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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
34,900 | alaya::SQ4SpaceTest_InsertAndRemove_Test::TestBody() | AlayaLite/tests/space/sq4_space_test.cpp | TEST_F(SQ4SpaceTest, InsertAndRemove) {
float vec[4] = {1.0, 2.0, 3.0, 4.0};
uint32_t id = space_->insert(vec);
EXPECT_GE(id, 0);
EXPECT_EQ(space_->get_data_num(), 1);
space_->remove(id);
EXPECT_EQ(space_->get_data_num(), 1); // remove 只是标记删除
} | O0 | cpp | alaya::SQ4SpaceTest_InsertAndRemove_Test::TestBody():
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movaps 0xeadbd(%rip), %xmm0 # 0x116370
movaps %xmm0, 0xf0(%rsp)
addq $0x10, %rdi
callq 0x2cb70
movq %rax, %rdi
leaq 0xf0(%rsp), %rsi
callq 0x2cd90
movl %eax, 0xec(%rsp)
movl $0x0, 0xd4(%rsp)
leaq 0xe9d1d(%rip), %rsi # 0x11530a
leaq 0xf2d71(%rip), %rdx # 0x11e365
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x50(%rsp)
leaq 0xec(%rsp), %rcx
leaq 0xd4(%rsp), %r8
callq 0x2ce20
movq 0x50(%rsp), %rdi
callq 0x1e060
movb %al, 0x5f(%rsp)
jmp 0x2b626
movb 0x5f(%rsp), %al
testb $0x1, %al
jne 0x2b630
jmp 0x2b64e
jmp 0x2b712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b796
leaq 0xb8(%rsp), %rdi
callq 0xc8d80
jmp 0x2b65d
leaq 0xd8(%rsp), %rdi
callq 0x1e070
movq %rax, 0x40(%rsp)
jmp 0x2b671
movq 0x40(%rsp), %r8
leaq 0xea817(%rip), %rdx # 0x115e94
leaq 0xb0(%rsp), %rdi
movl $0x1, %esi
movl $0x4a, %ecx
callq 0xc4b10
jmp 0x2b696
leaq 0xb0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xc1250
jmp 0x2b6ad
leaq 0xb0(%rsp), %rdi
callq 0xc4ba0
leaq 0xb8(%rsp), %rdi
callq 0x1e080
jmp 0x2b712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0xc4ba0
leaq 0xb8(%rsp), %rdi
callq 0x1e080
jmp 0x2b796
leaq 0xd8(%rsp), %rdi
callq 0x1e090
movq 0x48(%rsp), %rdi
addq $0x10, %rdi
callq 0x2cb70
movq %rax, %rdi
callq 0x2cb90
movl %eax, 0x9c(%rsp)
movl $0x1, 0x98(%rsp)
leaq 0xea299(%rip), %rsi # 0x1159e7
leaq 0xf111a(%rip), %rdx # 0x11c86f
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x9c(%rsp), %rcx
leaq 0x98(%rsp), %r8
callq 0x264d0
movq 0x30(%rsp), %rdi
callq 0x1e060
movb %al, 0x3f(%rsp)
jmp 0x2b787
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x2b791
jmp 0x2b7c1
jmp 0x2b885
leaq 0xd8(%rsp), %rdi
callq 0x1e090
jmp 0x2ba05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b918
leaq 0x90(%rsp), %rdi
callq 0xc8d80
jmp 0x2b7d0
leaq 0xa0(%rsp), %rdi
callq 0x1e070
movq %rax, 0x28(%rsp)
jmp 0x2b7e4
movq 0x28(%rsp), %r8
leaq 0xea6a4(%rip), %rdx # 0x115e94
leaq 0x88(%rsp), %rdi
movl $0x1, %esi
movl $0x4b, %ecx
callq 0xc4b10
jmp 0x2b809
leaq 0x88(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xc1250
jmp 0x2b820
leaq 0x88(%rsp), %rdi
callq 0xc4ba0
leaq 0x90(%rsp), %rdi
callq 0x1e080
jmp 0x2b885
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b873
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xc4ba0
leaq 0x90(%rsp), %rdi
callq 0x1e080
jmp 0x2b918
leaq 0xa0(%rsp), %rdi
callq 0x1e090
movq 0x48(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x2cb70
movq %rax, %rdi
movl 0xec(%rsp), %esi
callq 0x2cea0
movq 0x10(%rsp), %rdi
callq 0x2cb70
movq %rax, %rdi
callq 0x2cb90
movl %eax, 0x74(%rsp)
movl $0x1, 0x70(%rsp)
leaq 0xea10e(%rip), %rsi # 0x1159e7
leaq 0xf0f8f(%rip), %rdx # 0x11c86f
leaq 0x78(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x74(%rsp), %rcx
leaq 0x70(%rsp), %r8
callq 0x264d0
movq 0x18(%rsp), %rdi
callq 0x1e060
movb %al, 0x27(%rsp)
jmp 0x2b909
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x2b913
jmp 0x2b943
jmp 0x2b9e9
leaq 0xa0(%rsp), %rdi
callq 0x1e090
jmp 0x2ba05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b9fb
leaq 0x68(%rsp), %rdi
callq 0xc8d80
jmp 0x2b94f
leaq 0x78(%rsp), %rdi
callq 0x1e070
movq %rax, 0x8(%rsp)
jmp 0x2b960
movq 0x8(%rsp), %r8
leaq 0xea528(%rip), %rdx # 0x115e94
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
movl $0x4e, %ecx
callq 0xc4b10
jmp 0x2b982
leaq 0x60(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xc1250
jmp 0x2b993
leaq 0x60(%rsp), %rdi
callq 0xc4ba0
leaq 0x68(%rsp), %rdi
callq 0x1e080
jmp 0x2b9e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x2b9dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xc4ba0
leaq 0x68(%rsp), %rdi
callq 0x1e080
jmp 0x2b9fb
leaq 0x78(%rsp), %rdi
callq 0x1e090
addq $0x108, %rsp # imm = 0x108
retq
leaq 0x78(%rsp), %rdi
callq 0x1e090
movq 0xc8(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
| _ZN5alaya33SQ4SpaceTest_InsertAndRemove_Test8TestBodyEv:
sub rsp, 108h
mov [rsp+108h+var_8], rdi
mov rdi, [rsp+108h+var_8]
mov [rsp+108h+var_C0], rdi; __int64
movaps xmm0, cs:xmmword_116370
movaps [rsp+108h+var_18], xmm0
add rdi, 10h
call _ZNKSt19__shared_ptr_accessIN5alaya8SQ4SpaceIffjNS0_17SequentialStorageIhjEEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
lea rsi, [rsp+108h+var_18]
call _ZN5alaya8SQ4SpaceIffjNS_17SequentialStorageIhjEEE6insertEPf; alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>::insert(float *)
mov [rsp+108h+var_1C], eax
mov [rsp+108h+var_34], 0
lea rsi, aBasicStringMCo+27h; "id"
lea rdx, aStaticCastSize+77h; "0"
lea rdi, [rsp+108h+var_30]
mov qword ptr [rsp+108h+var_B8], rdi; char
lea rcx, [rsp+108h+var_1C]
lea r8, [rsp+108h+var_34]
call _ZN7testing8internal11CmpHelperGEIjiEENS_15AssertionResultEPKcS4_RKT_RKT0_; testing::internal::CmpHelperGE<uint,int>(char const*,char const*,uint const&,int const&)
mov rdi, qword ptr [rsp+108h+var_B8]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+108h+var_A9], al
jmp short $+2
loc_2B626:
mov al, [rsp+108h+var_A9]
test al, 1
jnz short loc_2B630
jmp short loc_2B64E
loc_2B630:
jmp loc_2B712
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp loc_2B796
loc_2B64E:
lea rdi, [rsp+108h+var_50]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_2B65D:
lea rdi, [rsp+108h+var_30]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+108h+var_C8], rax; __int16
jmp short $+2
loc_2B671:
mov r8, qword ptr [rsp+108h+var_C8]; int
lea rdx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+108h+var_58]; int
mov esi, 1; int
mov ecx, 4Ah ; 'J'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_2B696:
lea rdi, [rsp+108h+var_58]; char
lea rsi, [rsp+108h+var_50]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_2B6AD:
lea rdi, [rsp+108h+var_58]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+108h+var_50]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_2B712
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp short loc_2B700
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
lea rdi, [rsp+arg_A8]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_2B700:
lea rdi, [rsp+arg_B0]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp loc_2B796
loc_2B712:
lea rdi, [rsp+108h+var_30]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
mov rdi, [rsp+108h+var_C0]
add rdi, 10h
call _ZNKSt19__shared_ptr_accessIN5alaya8SQ4SpaceIffjNS0_17SequentialStorageIhjEEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZN5alaya8SQ4SpaceIffjNS_17SequentialStorageIhjEEE12get_data_numEv; alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>::get_data_num(void)
loc_2B735:
mov [rsp+108h+var_6C], eax
mov [rsp+108h+var_70], 1
lea rsi, aSpaceGetDataNu; "space_->get_data_num()"
lea rdx, aFcntlPipeFd1FS+22h; "1"
lea rdi, [rsp+108h+var_68]
mov qword ptr [rsp+108h+var_D8], rdi; int
lea rcx, [rsp+108h+var_6C]
lea r8, [rsp+108h+var_70]
call _ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, qword ptr [rsp+108h+var_D8]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+108h+var_C9], al
jmp short $+2
loc_2B787:
mov al, [rsp+108h+var_C9]
test al, 1
jnz short loc_2B791
jmp short loc_2B7C1
loc_2B791:
jmp loc_2B885
loc_2B796:
lea rdi, [rsp+arg_D0]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
jmp loc_2BA05
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp loc_2B918
loc_2B7C1:
lea rdi, [rsp+108h+var_78]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_2B7D0:
lea rdi, [rsp+108h+var_68]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+108h+var_E0], rax; int
jmp short $+2
loc_2B7E4:
mov r8, qword ptr [rsp+108h+var_E0]; int
lea rdx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+108h+var_80]; int
mov esi, 1; int
mov ecx, 4Bh ; 'K'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_2B809:
lea rdi, [rsp+108h+var_80]; char
lea rsi, [rsp+108h+var_78]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
loc_2B81E:
jmp short $+2
loc_2B820:
lea rdi, [rsp+108h+var_80]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+108h+var_78]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_2B885
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp short loc_2B873
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
lea rdi, [rsp+arg_80]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_2B873:
lea rdi, [rsp+arg_88]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp loc_2B918
loc_2B885:
lea rdi, [rsp+108h+var_68]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
mov rdi, [rsp+108h+var_C0]
add rdi, 10h
mov [rsp+108h+var_F8], rdi; int
call _ZNKSt19__shared_ptr_accessIN5alaya8SQ4SpaceIffjNS0_17SequentialStorageIhjEEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov esi, [rsp+108h+var_1C]
call _ZN5alaya8SQ4SpaceIffjNS_17SequentialStorageIhjEEE6removeEj; alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>::remove(uint)
mov rdi, [rsp+108h+var_F8]
call _ZNKSt19__shared_ptr_accessIN5alaya8SQ4SpaceIffjNS0_17SequentialStorageIhjEEEELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZN5alaya8SQ4SpaceIffjNS_17SequentialStorageIhjEEE12get_data_numEv; alaya::SQ4Space<float,float,uint,alaya::SequentialStorage<uchar,uint>>::get_data_num(void)
mov [rsp+108h+var_94], eax
mov dword ptr [rsp+108h+var_98], 1; char
lea rsi, aSpaceGetDataNu; "space_->get_data_num()"
lea rdx, aFcntlPipeFd1FS+22h; "1"
lea rdi, [rsp+108h+var_90]
mov qword ptr [rsp+108h+var_F0], rdi; int
lea rcx, [rsp+108h+var_94]
lea r8, [rsp+108h+var_98]
call _ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, qword ptr [rsp+108h+var_F0]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+108h+var_E1], al
jmp short $+2
loc_2B909:
mov al, [rsp+108h+var_E1]
test al, 1
jnz short loc_2B913
jmp short loc_2B943
loc_2B913:
jmp loc_2B9E9
loc_2B918:
lea rdi, [rsp+arg_98]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
jmp loc_2BA05
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp loc_2B9FB
loc_2B943:
lea rdi, [rsp+108h+var_A0]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_2B94F:
lea rdi, [rsp+108h+var_90]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+108h+var_100], rax; int
jmp short $+2
loc_2B960:
mov r8, qword ptr [rsp+108h+var_100]; int
lea rdx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+108h+var_A8]; int
mov esi, 1; int
mov ecx, 4Eh ; 'N'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_2B982:
lea rdi, [rsp+108h+var_A8]; char
lea rsi, [rsp+108h+var_A0]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_2B993:
lea rdi, [rsp+108h+var_A8]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+108h+var_A0]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_2B9E9
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
jmp short loc_2B9DD
mov rcx, rax
mov eax, edx
mov [rsp+arg_C0], rcx
mov [rsp+arg_BC], eax
lea rdi, [rsp+arg_58]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_2B9DD:
lea rdi, [rsp+arg_60]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_2B9FB
loc_2B9E9:
lea rdi, [rsp+108h+var_90]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
add rsp, 108h
retn
loc_2B9FB:
lea rdi, [rsp+arg_70]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
loc_2BA05:
mov rdi, [rsp+arg_C0]
call __Unwind_Resume
| void alaya::SQ4SpaceTest_InsertAndRemove_Test::TestBody(alaya::SQ4SpaceTest_InsertAndRemove_Test *this)
{
long long v1; // rax
int v2; // r9d
long long v3; // rax
int v4; // r9d
long long v5; // rax
long long v6; // rax
int v7; // r9d
void *v8; // [rsp+0h] [rbp-108h]
int v9; // [rsp+0h] [rbp-108h]
int v10; // [rsp+0h] [rbp-108h]
int v11; // [rsp+0h] [rbp-108h]
int v12; // [rsp+8h] [rbp-100h]
int v13; // [rsp+8h] [rbp-100h]
int v14; // [rsp+8h] [rbp-100h]
int v15; // [rsp+8h] [rbp-100h]
int v16; // [rsp+8h] [rbp-100h]
long long v17; // [rsp+10h] [rbp-F8h]
int v18; // [rsp+10h] [rbp-F8h]
int v19; // [rsp+10h] [rbp-F8h]
int v20; // [rsp+10h] [rbp-F8h]
int v21; // [rsp+18h] [rbp-F0h]
int v22; // [rsp+20h] [rbp-E8h]
int v23; // [rsp+28h] [rbp-E0h]
int v24; // [rsp+28h] [rbp-E0h]
int v25; // [rsp+30h] [rbp-D8h]
int *v26; // [rsp+30h] [rbp-D8h]
int v27; // [rsp+38h] [rbp-D0h]
__int16 v28; // [rsp+40h] [rbp-C8h]
int v29; // [rsp+40h] [rbp-C8h]
alaya::SQ4SpaceTest_InsertAndRemove_Test *v30; // [rsp+48h] [rbp-C0h]
char *v31; // [rsp+50h] [rbp-B8h]
int v32; // [rsp+58h] [rbp-B0h]
char v33[4]; // [rsp+60h] [rbp-A8h] BYREF
int v34; // [rsp+68h] [rbp-A0h] BYREF
char v35[4]; // [rsp+70h] [rbp-98h] BYREF
int v36; // [rsp+74h] [rbp-94h] BYREF
_BYTE v37[16]; // [rsp+78h] [rbp-90h] BYREF
char v38[4]; // [rsp+88h] [rbp-80h] BYREF
int v39; // [rsp+90h] [rbp-78h] BYREF
int v40; // [rsp+98h] [rbp-70h] BYREF
int data_num; // [rsp+9Ch] [rbp-6Ch] BYREF
_BYTE v42[16]; // [rsp+A0h] [rbp-68h] BYREF
char v43[4]; // [rsp+B0h] [rbp-58h] BYREF
int v44[7]; // [rsp+B8h] [rbp-50h] BYREF
int v45; // [rsp+D4h] [rbp-34h] BYREF
char v46[20]; // [rsp+D8h] [rbp-30h] BYREF
unsigned int v47; // [rsp+ECh] [rbp-1Ch] BYREF
__int128 v48; // [rsp+F0h] [rbp-18h] BYREF
long long v49; // [rsp+100h] [rbp-8h]
v49 = (long long)this;
v30 = this;
v48 = *(_OWORD *)xmmword_116370;
v1 = std::__shared_ptr_access<alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)this + 16);
v47 = alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>::insert(v1, &v48);
v45 = 0;
v31 = v46;
testing::internal::CmpHelperGE<unsigned int,int>(v46, "id", "0", &v47, &v45);
if ( (testing::AssertionResult::operator bool(v46) & 1) == 0 )
{
testing::Message::Message((testing::Message *)v44);
v29 = testing::AssertionResult::failure_message((testing::AssertionResult *)v46);
testing::internal::AssertHelper::AssertHelper(
(int)v43,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",
74,
v29,
v2,
v8,
v12,
v17);
testing::internal::AssertHelper::operator=(
(char)v43,
(int)v44,
v9,
v13,
v18,
v21,
v22,
v23,
v25,
v27,
v29,
(long long)this,
(char)v46,
v32,
*(int *)v33,
v34,
v35[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v43);
testing::Message::~Message((testing::Message *)v44);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v46);
v3 = std::__shared_ptr_access<alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)v30 + 16);
data_num = alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>::get_data_num(v3);
v40 = 1;
v26 = (int *)v42;
ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
(long long)v42,
(long long)"space_->get_data_num()",
(long long)"1",
(long long)&data_num,
(long long)&v40);
if ( (testing::AssertionResult::operator bool(v42) & 1) == 0 )
{
testing::Message::Message((testing::Message *)&v39);
v24 = testing::AssertionResult::failure_message((testing::AssertionResult *)v42);
testing::internal::AssertHelper::AssertHelper(
(int)v38,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",
75,
v24,
v4,
v8,
v12,
v17);
testing::internal::AssertHelper::operator=(
(char)v38,
(int)&v39,
v10,
v14,
v19,
v21,
v22,
v24,
(int)v42,
v27,
v28,
(long long)v30,
(char)v31,
v32,
*(int *)v33,
v34,
v35[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v38);
testing::Message::~Message((testing::Message *)&v39);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v42);
v5 = std::__shared_ptr_access<alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)v30 + 16);
alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>::remove(v5, v47);
v6 = std::__shared_ptr_access<alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((char *)v30 + 16);
v36 = alaya::SQ4Space<float,float,unsigned int,alaya::SequentialStorage<unsigned char,unsigned int>>::get_data_num(v6);
*(_DWORD *)v35 = 1;
ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
(long long)v37,
(long long)"space_->get_data_num()",
(long long)"1",
(long long)&v36,
(long long)v35);
if ( (testing::AssertionResult::operator bool(v37) & 1) == 0 )
{
testing::Message::Message((testing::Message *)&v34);
v15 = testing::AssertionResult::failure_message((testing::AssertionResult *)v37);
testing::internal::AssertHelper::AssertHelper(
(int)v33,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",
78,
v15,
v7,
v8,
v15,
(long long)v30 + 16);
testing::internal::AssertHelper::operator=(
(char)v33,
(int)&v34,
v11,
v16,
v20,
(int)v37,
v22,
v23,
(int)v26,
v27,
v28,
(long long)v30,
(char)v31,
v32,
*(int *)v33,
v34,
v35[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v33);
testing::Message::~Message((testing::Message *)&v34);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v37);
}
| TestBody:
SUB RSP,0x108
MOV qword ptr [RSP + 0x100],RDI
MOV RDI,qword ptr [RSP + 0x100]
MOV qword ptr [RSP + 0x48],RDI
MOVAPS XMM0,xmmword ptr [0x00216370]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
ADD RDI,0x10
CALL 0x0012cb70
MOV RDI,RAX
LEA RSI,[RSP + 0xf0]
CALL 0x0012cd90
MOV dword ptr [RSP + 0xec],EAX
MOV dword ptr [RSP + 0xd4],0x0
LEA RSI,[0x21530a]
LEA RDX,[0x21e365]
LEA RDI,[RSP + 0xd8]
MOV qword ptr [RSP + 0x50],RDI
LEA RCX,[RSP + 0xec]
LEA R8,[RSP + 0xd4]
CALL 0x0012ce20
MOV RDI,qword ptr [RSP + 0x50]
LAB_0012b61b:
CALL 0x0011e060
MOV byte ptr [RSP + 0x5f],AL
JMP 0x0012b626
LAB_0012b626:
MOV AL,byte ptr [RSP + 0x5f]
TEST AL,0x1
JNZ 0x0012b630
JMP 0x0012b64e
LAB_0012b630:
JMP 0x0012b712
LAB_0012b64e:
LEA RDI,[RSP + 0xb8]
CALL 0x001c8d80
JMP 0x0012b65d
LAB_0012b65d:
LEA RDI,[RSP + 0xd8]
CALL 0x0011e070
MOV qword ptr [RSP + 0x40],RAX
JMP 0x0012b671
LAB_0012b671:
MOV R8,qword ptr [RSP + 0x40]
LEA RDX,[0x215e94]
LEA RDI,[RSP + 0xb0]
MOV ESI,0x1
MOV ECX,0x4a
CALL 0x001c4b10
JMP 0x0012b696
LAB_0012b696:
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0xb8]
CALL 0x001c1250
LAB_0012b6ab:
JMP 0x0012b6ad
LAB_0012b6ad:
LEA RDI,[RSP + 0xb0]
CALL 0x001c4ba0
LEA RDI,[RSP + 0xb8]
CALL 0x0011e080
JMP 0x0012b712
LAB_0012b712:
LEA RDI,[RSP + 0xd8]
CALL 0x0011e090
MOV RDI,qword ptr [RSP + 0x48]
ADD RDI,0x10
CALL 0x0012cb70
MOV RDI,RAX
CALL 0x0012cb90
MOV dword ptr [RSP + 0x9c],EAX
MOV dword ptr [RSP + 0x98],0x1
LEA RSI,[0x2159e7]
LEA RDX,[0x21c86f]
LEA RDI,[RSP + 0xa0]
MOV qword ptr [RSP + 0x30],RDI
LEA RCX,[RSP + 0x9c]
LEA R8,[RSP + 0x98]
CALL 0x001264d0
MOV RDI,qword ptr [RSP + 0x30]
LAB_0012b77c:
CALL 0x0011e060
MOV byte ptr [RSP + 0x3f],AL
JMP 0x0012b787
LAB_0012b787:
MOV AL,byte ptr [RSP + 0x3f]
TEST AL,0x1
JNZ 0x0012b791
JMP 0x0012b7c1
LAB_0012b791:
JMP 0x0012b885
LAB_0012b7c1:
LEA RDI,[RSP + 0x90]
CALL 0x001c8d80
JMP 0x0012b7d0
LAB_0012b7d0:
LEA RDI,[RSP + 0xa0]
CALL 0x0011e070
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0012b7e4
LAB_0012b7e4:
MOV R8,qword ptr [RSP + 0x28]
LEA RDX,[0x215e94]
LEA RDI,[RSP + 0x88]
MOV ESI,0x1
MOV ECX,0x4b
CALL 0x001c4b10
JMP 0x0012b809
LAB_0012b809:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x90]
CALL 0x001c1250
LAB_0012b81e:
JMP 0x0012b820
LAB_0012b820:
LEA RDI,[RSP + 0x88]
CALL 0x001c4ba0
LEA RDI,[RSP + 0x90]
CALL 0x0011e080
JMP 0x0012b885
LAB_0012b885:
LEA RDI,[RSP + 0xa0]
CALL 0x0011e090
MOV RDI,qword ptr [RSP + 0x48]
ADD RDI,0x10
MOV qword ptr [RSP + 0x10],RDI
CALL 0x0012cb70
MOV RDI,RAX
MOV ESI,dword ptr [RSP + 0xec]
CALL 0x0012cea0
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0012cb70
MOV RDI,RAX
CALL 0x0012cb90
MOV dword ptr [RSP + 0x74],EAX
MOV dword ptr [RSP + 0x70],0x1
LEA RSI,[0x2159e7]
LEA RDX,[0x21c86f]
LEA RDI,[RSP + 0x78]
MOV qword ptr [RSP + 0x18],RDI
LEA RCX,[RSP + 0x74]
LEA R8,[RSP + 0x70]
CALL 0x001264d0
MOV RDI,qword ptr [RSP + 0x18]
LAB_0012b8fe:
CALL 0x0011e060
MOV byte ptr [RSP + 0x27],AL
JMP 0x0012b909
LAB_0012b909:
MOV AL,byte ptr [RSP + 0x27]
TEST AL,0x1
JNZ 0x0012b913
JMP 0x0012b943
LAB_0012b913:
JMP 0x0012b9e9
LAB_0012b943:
LEA RDI,[RSP + 0x68]
CALL 0x001c8d80
JMP 0x0012b94f
LAB_0012b94f:
LEA RDI,[RSP + 0x78]
CALL 0x0011e070
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0012b960
LAB_0012b960:
MOV R8,qword ptr [RSP + 0x8]
LEA RDX,[0x215e94]
LEA RDI,[RSP + 0x60]
MOV ESI,0x1
MOV ECX,0x4e
CALL 0x001c4b10
JMP 0x0012b982
LAB_0012b982:
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x68]
CALL 0x001c1250
LAB_0012b991:
JMP 0x0012b993
LAB_0012b993:
LEA RDI,[RSP + 0x60]
CALL 0x001c4ba0
LEA RDI,[RSP + 0x68]
CALL 0x0011e080
JMP 0x0012b9e9
LAB_0012b9e9:
LEA RDI,[RSP + 0x78]
CALL 0x0011e090
ADD RSP,0x108
RET
|
/* alaya::SQ4SpaceTest_InsertAndRemove_Test::TestBody() */
void __thiscall
alaya::SQ4SpaceTest_InsertAndRemove_Test::TestBody(SQ4SpaceTest_InsertAndRemove_Test *this)
{
SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>> *pSVar1;
int8 uVar2;
bool bVar3;
AssertHelper local_a8 [8];
Message local_a0 [8];
int4 local_98;
int4 local_94;
AssertionResult local_90 [16];
AssertHelper local_80 [8];
Message local_78 [8];
int4 local_70;
int4 local_6c;
AssertionResult local_68 [16];
AssertHelper local_58 [8];
Message local_50 [28];
int local_34;
internal local_30 [20];
uint local_1c;
int8 local_18;
int8 uStack_10;
SQ4SpaceTest_InsertAndRemove_Test *local_8;
local_18 = DAT_00216370;
uStack_10 = DAT_00216378;
local_8 = this;
pSVar1 = (SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
*)std::
__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
local_1c = SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
::insert(pSVar1,(float *)&local_18);
local_34 = 0;
testing::internal::CmpHelperGE<unsigned_int,int>(local_30,"id","0",&local_1c,&local_34);
/* try { // try from 0012b61b to 0012b65a has its CatchHandler @ 0012b635 */
bVar3 = testing::AssertionResult::operator_cast_to_bool((AssertionResult *)local_30);
if (!bVar3) {
testing::Message::Message(local_50);
/* try { // try from 0012b65d to 0012b693 has its CatchHandler @ 0012b6c9 */
uVar2 = testing::AssertionResult::failure_message((AssertionResult *)local_30);
testing::internal::AssertHelper::AssertHelper
(local_58,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",0x4a,
uVar2);
/* try { // try from 0012b696 to 0012b6aa has its CatchHandler @ 0012b6df */
testing::internal::AssertHelper::operator=(local_58,local_50);
testing::internal::AssertHelper::~AssertHelper(local_58);
testing::Message::~Message(local_50);
}
testing::AssertionResult::~AssertionResult((AssertionResult *)local_30);
pSVar1 = (SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
*)std::
__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
local_6c = SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
::get_data_num(pSVar1);
local_70 = 1;
_ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_68,"space_->get_data_num()","1",&local_6c,&local_70);
/* try { // try from 0012b77c to 0012b7cd has its CatchHandler @ 0012b7a8 */
bVar3 = testing::AssertionResult::operator_cast_to_bool(local_68);
if (!bVar3) {
testing::Message::Message(local_78);
/* try { // try from 0012b7d0 to 0012b806 has its CatchHandler @ 0012b83c */
uVar2 = testing::AssertionResult::failure_message(local_68);
testing::internal::AssertHelper::AssertHelper
(local_80,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",0x4b,
uVar2);
/* try { // try from 0012b809 to 0012b81d has its CatchHandler @ 0012b852 */
testing::internal::AssertHelper::operator=(local_80,local_78);
testing::internal::AssertHelper::~AssertHelper(local_80);
testing::Message::~Message(local_78);
}
testing::AssertionResult::~AssertionResult(local_68);
pSVar1 = (SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
*)std::
__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>::remove
(pSVar1,local_1c);
pSVar1 = (SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
*)std::
__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<alaya::SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>,(__gnu_cxx::_Lock_policy)2,false,false>
*)(this + 0x10));
local_94 = SQ4Space<float,float,unsigned_int,alaya::SequentialStorage<unsigned_char,unsigned_int>>
::get_data_num(pSVar1);
local_98 = 1;
_ZN7testing8internal8EqHelper7CompareIjiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_90,"space_->get_data_num()","1",&local_94,&local_98);
/* try { // try from 0012b8fe to 0012b94c has its CatchHandler @ 0012b92a */
bVar3 = testing::AssertionResult::operator_cast_to_bool(local_90);
if (!bVar3) {
testing::Message::Message(local_a0);
/* try { // try from 0012b94f to 0012b97f has its CatchHandler @ 0012b9a9 */
uVar2 = testing::AssertionResult::failure_message(local_90);
testing::internal::AssertHelper::AssertHelper
(local_a8,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/space/sq4_space_test.cpp",0x4e,
uVar2);
/* try { // try from 0012b982 to 0012b990 has its CatchHandler @ 0012b9bf */
testing::internal::AssertHelper::operator=(local_a8,local_a0);
testing::internal::AssertHelper::~AssertHelper(local_a8);
testing::Message::~Message(local_a0);
}
testing::AssertionResult::~AssertionResult(local_90);
return;
}
| |
34,901 | my_multi_malloc_large | eloqsql/mysys/mulalloc.c | void *my_multi_malloc_large(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
ulonglong tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,ulonglong);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, (size_t) tot_length, myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,ulonglong);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
} | O0 | c | my_multi_malloc_large:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0xeef11
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0xeef9b
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0xeefb8
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xef053
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0xef00b
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0xef028
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xeef60
leaq -0x30(%rbp), %rax
movl -0xc(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf99f0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xef080
jmp 0xef073
movq $0x0, -0x8(%rbp)
jmp 0xef1b6
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0xef0e7
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0xef104
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xef1aa
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0xef162
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0xef17f
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xef0ac
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_multi_malloc_large:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_EEF11
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_EEF11:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov [rbp+var_50], 0
loc_EEF60:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_EEF9B
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_EEFB8
loc_EEF9B:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_EEFB8:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_EF053
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_EF00B
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_EF028
loc_EF00B:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_EF028:
mov rax, [rbp+var_140]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_EEF60
loc_EF053:
lea rax, [rbp+var_30]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_EF080
jmp short $+2
loc_EF073:
mov [rbp+var_8], 0
jmp loc_EF1B6
loc_EF080:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_EF0AC:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_EF0E7
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_EF104
loc_EF0E7:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_EF104:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_EF1AA
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_EF162
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_EF17F
loc_EF162:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_EF17F:
mov rax, [rbp+var_170]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_EF0AC
loc_EF1AA:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_EF1B6:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| long long my_multi_malloc_large(unsigned int a1, long long a2, ...)
{
_QWORD *overflow_arg_area; // rax
_QWORD *v3; // rax
_QWORD *v4; // rax
_QWORD *v5; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v9; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
long long v11; // [rsp+158h] [rbp-18h]
unsigned int v12; // [rsp+164h] [rbp-Ch]
va_start(va, a2);
v12 = a1;
v11 = a2;
for ( i = 0LL; ; i += (*v3 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v3 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
v9 = my_malloc(v12, i, v11);
if ( !v9 )
return 0LL;
va_end(va);
va_start(va, a2);
for ( j = v9; ; j += (*v5 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v4 )
break;
*(_QWORD *)*v4 = j;
if ( va[0].gp_offset > 0x28 )
{
v5 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v5 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
return v9;
}
| my_multi_malloc_large:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x001eef11
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_001eef11:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV qword ptr [RBP + -0x50],0x0
LAB_001eef60:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x001eef9b
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x001eefb8
LAB_001eef9b:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_001eefb8:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ef053
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x001ef00b
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x001ef028
LAB_001ef00b:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_001ef028:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001eef60
LAB_001ef053:
LEA RAX,[RBP + -0x30]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001f99f0
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001ef080
JMP 0x001ef073
LAB_001ef073:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001ef1b6
LAB_001ef080:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ef0ac:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x001ef0e7
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x001ef104
LAB_001ef0e7:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_001ef104:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ef1aa
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x001ef162
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x001ef17f
LAB_001ef162:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_001ef17f:
MOV RAX,qword ptr [RBP + -0x170]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ef0ac
LAB_001ef1aa:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001ef1b6:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long my_multi_malloc_large
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long *local_178;
long *local_160;
long *local_148;
long *local_130;
long local_118 [4];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
long local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
long *local_30;
long *local_28;
int8 local_20;
int4 local_14;
long local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (long *)&stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 1;
}
local_40 = *local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 1;
}
local_60 = *local_148;
local_58 = (local_60 + 7U & 0xfffffffffffffff8) + local_58;
}
local_118[2] = param_11;
local_118[3] = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_20 = param_10;
local_14 = param_9;
local_10 = my_malloc(param_9,local_58,param_10);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (long *)&stack0x00000008;
local_38 = 0x10;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 1;
}
if ((long *)*local_160 == (long *)0x0) break;
*(long *)*local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 1;
}
local_50 = (*local_178 + 7U & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
| |
34,902 | pow5mult | eloqsql/libmariadb/libmariadb/ma_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 0x58603
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1d9dcf(%rip), %rax # 0x2323c0
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x58d40
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x5861e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x58714
leaq 0x1d9dab(%rip), %rax # 0x2323d0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5865e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x58720
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x58970
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x58670
jmp 0x586f8
cmpb $0x0, -0x3d(%rbp)
je 0x586a2
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x58720
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x58970
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x586f3
leaq 0x1d9d27(%rip), %rax # 0x2323d0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x586c3
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x586f1
leaq 0x1d9d06(%rip), %rax # 0x2323d0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x586ef
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x58720
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x586f1
jmp 0x586f3
jmp 0x58629
cmpq $0x0, -0x38(%rbp)
je 0x5870c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x58970
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_58603
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_58603:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_5861E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_58714
loc_5861E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_58629:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_5865E
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_5865E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_58670
jmp loc_586F8
loc_58670:
cmp [rbp+var_3D], 0
jz short loc_586A2
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_586F3
loc_586A2:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_586C3
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_586F1
loc_586C3:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_586EF
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_586EF:
jmp short $+2
loc_586F1:
jmp short $+2
loc_586F3:
jmp loc_58629
loc_586F8:
cmp [rbp+var_38], 0
jz short loc_5870C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_5870C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_58714:
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 0x00158603
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x3323c0]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x00158d40
MOV qword ptr [RBP + -0x10],RAX
LAB_00158603:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0015861e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00158714
LAB_0015861e:
LEA RAX,[0x3323d0]
MOV qword ptr [RBP + -0x30],RAX
LAB_00158629:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0015865e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00158720
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00158970
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0015865e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00158670
JMP 0x001586f8
LAB_00158670:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x001586a2
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00158720
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00158970
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001586f3
LAB_001586a2:
LEA RAX,[0x3323d0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x001586c3
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001586f1
LAB_001586c3:
LEA RAX,[0x3323d0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x001586ef
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00158720
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_001586ef:
JMP 0x001586f1
LAB_001586f1:
JMP 0x001586f3
LAB_001586f3:
JMP 0x00158629
LAB_001586f8:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0015870c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00158970
LAB_0015870c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00158714:
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 *)0x332460) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x332460) {
local_38 = (int1 *)mult(0x332460,0x332460,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
34,903 | my_wc_mb_euc_jp | eloqsql/strings/ctype-ujis.c | static int
my_wc_mb_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjp[wc])) /* JIS-X-0208 */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjp[wc])) /* JIS-X-0212 */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_euc_jp:
cmpl $0x7f, %esi
jg 0xd075e
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xd0793
movb %sil, (%rdx)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0xd0793
leaq 0x24e8e0(%rip), %rdi # 0x31f050
movzwl (%rdi,%rsi,2), %edi
testw %di, %di
je 0xd0794
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0xd0793
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x26e8b0(%rip), %rdi # 0x33f050
movzwl (%rdi,%rsi,2), %ebx
testw %bx, %bx
je 0xd07c7
leaq 0x3(%rdx), %rsi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rsi
ja 0xd07f2
movb $-0x71, (%rdx)
movb %bh, 0x1(%rdx)
movb %bl, 0x2(%rdx)
movl $0x3, %eax
jmp 0xd07f2
leaq -0xff61(%rsi), %rdi
cmpq $0x3e, %rdi
ja 0xd07f2
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xd07f2
movb $-0x72, (%rdx)
addb $0x40, %sil
movb %sil, 0x1(%rdx)
movl $0x2, %eax
popq %rbx
popq %rbp
retq
| my_wc_mb_euc_jp:
cmp esi, 7Fh
jg short loc_D075E
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_D0793
mov [rdx], sil
mov eax, 1
retn
loc_D075E:
xor eax, eax
cmp rsi, 0FFFFh
ja short locret_D0793
lea rdi, unicode_to_jisx0208_eucjp
movzx edi, word ptr [rdi+rsi*2]
test di, di
jz short loc_D0794
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short locret_D0793
rol di, 8
mov [rdx], di
mov eax, 2
locret_D0793:
retn
loc_D0794:
push rbp
mov rbp, rsp
push rbx
lea rdi, unicode_to_jisx0212_eucjp
movzx ebx, word ptr [rdi+rsi*2]
test bx, bx
jz short loc_D07C7
lea rsi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rsi, rcx
ja short loc_D07F2
mov byte ptr [rdx], 8Fh
mov [rdx+1], bh
mov [rdx+2], bl
mov eax, 3
jmp short loc_D07F2
loc_D07C7:
lea rdi, [rsi-0FF61h]
cmp rdi, 3Eh ; '>'
ja short loc_D07F2
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_D07F2
mov byte ptr [rdx], 8Eh
add sil, 40h ; '@'
mov [rdx+1], sil
mov eax, 2
loc_D07F2:
pop rbx
pop rbp
retn
| long long my_wc_mb_euc_jp(long long a1, unsigned long long a2, unsigned long long a3, unsigned long long a4)
{
long long result; // rax
__int16 v5; // di
__int16 v6; // bx
if ( (int)a2 > 127 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjp[a2];
if ( v5 )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
v6 = unicode_to_jisx0212_eucjp[a2];
if ( v6 )
{
result = 4294967193LL;
if ( a3 + 3 <= a4 )
{
*(_BYTE *)a3 = -113;
*(_BYTE *)(a3 + 1) = HIBYTE(v6);
*(_BYTE *)(a3 + 2) = v6;
return 3LL;
}
}
else if ( a2 - 65377 <= 0x3E )
{
result = 4294967194LL;
if ( a3 + 2 <= a4 )
{
*(_BYTE *)a3 = -114;
*(_BYTE *)(a3 + 1) = a2 + 64;
return 2LL;
}
}
}
}
}
else
{
result = 4294967195LL;
if ( a3 < a4 )
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_euc_jp:
CMP ESI,0x7f
JG 0x001d075e
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001d0793
MOV byte ptr [RDX],SIL
MOV EAX,0x1
RET
LAB_001d075e:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001d0793
LEA RDI,[0x41f050]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST DI,DI
JZ 0x001d0794
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x001d0793
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_001d0793:
RET
LAB_001d0794:
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDI,[0x43f050]
MOVZX EBX,word ptr [RDI + RSI*0x2]
TEST BX,BX
JZ 0x001d07c7
LEA RSI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RSI,RCX
JA 0x001d07f2
MOV byte ptr [RDX],0x8f
MOV byte ptr [RDX + 0x1],BH
MOV byte ptr [RDX + 0x2],BL
MOV EAX,0x3
JMP 0x001d07f2
LAB_001d07c7:
LEA RDI,[RSI + -0xff61]
CMP RDI,0x3e
JA 0x001d07f2
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001d07f2
MOV byte ptr [RDX],0x8e
ADD SIL,0x40
MOV byte ptr [RDX + 0x1],SIL
MOV EAX,0x2
LAB_001d07f2:
POP RBX
POP RBP
RET
|
int8 my_wc_mb_euc_jp(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
short sVar2;
int8 uVar3;
if ((int)param_2 < 0x80) {
uVar3 = 0xffffff9b;
if (param_3 < param_4) {
*(char *)param_3 = (char)param_2;
return 1;
}
}
else {
uVar3 = 0;
if (param_2 < 0x10000) {
uVar1 = *(ushort *)(unicode_to_jisx0208_eucjp + param_2 * 2);
if (uVar1 == 0) {
sVar2 = *(short *)(unicode_to_jisx0212_eucjp + param_2 * 2);
if (sVar2 == 0) {
if ((param_2 - 0xff61 < 0x3f) && (uVar3 = 0xffffff9a, param_3 + 1 <= param_4)) {
*(char *)param_3 = -0x72;
*(char *)((long)param_3 + 1) = (char)param_2 + '@';
uVar3 = 2;
}
}
else {
uVar3 = 0xffffff99;
if ((ushort *)((long)param_3 + 3) <= param_4) {
*(char *)param_3 = -0x71;
*(char *)((long)param_3 + 1) = (char)((ushort)sVar2 >> 8);
*(char *)(param_3 + 1) = (char)sVar2;
uVar3 = 3;
}
}
return uVar3;
}
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar3 = 2;
}
}
}
return uVar3;
}
| |
34,904 | string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | llama.cpp/common/common.cpp | std::string string_repeat(const std::string & str, size_t n) {
if (n == 0) {
return "";
}
std::string result;
result.reserve(str.length() * n);
for (size_t i = 0; i < n; ++i) {
result += str;
}
return result;
} | O3 | cpp | string_repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
testq %rdx, %rdx
je 0x54114
movq %rdx, %r14
movq %rsi, %r15
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsi), %rsi
imulq %rdx, %rsi
movq %rbx, %rdi
callq 0x17920
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x17360
decq %r14
jne 0x540fe
jmp 0x54126
leaq 0x7b31(%rip), %rdx # 0x5bc4c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2fb78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x54137
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5414e
movq (%r12), %rsi
incq %rsi
callq 0x17100
movq %r14, %rdi
callq 0x17710
| _Z13string_repeatRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
test rdx, rdx
jz short loc_54114
mov r14, rdx
mov r15, rsi
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, [rsi+8]
imul rsi, rdx
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
loc_540FE:
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
dec r14
jnz short loc_540FE
jmp short loc_54126
loc_54114:
lea rdx, aNoteDebugGramm+0CAh; ""
mov rdi, rbx
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)
loc_54126:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_54137:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_5414E
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5414E:
mov rdi, r14
call __Unwind_Resume
| long long string_repeat(long long a1, _QWORD *a2, long long a3)
{
long long v3; // r14
*(_QWORD *)a1 = a1 + 16;
if ( a3 )
{
v3 = a3;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
std::string::reserve(a1, a3 * a2[1]);
do
{
std::string::append(a1, *a2, a2[1]);
--v3;
}
while ( v3 );
}
else
{
std::string::_M_construct<char const*>(a1, "", (long long)"");
}
return a1;
}
| string_repeat:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
TEST RDX,RDX
JZ 0x00154114
MOV R14,RDX
MOV R15,RSI
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
IMUL RSI,RDX
LAB_001540f6:
MOV RDI,RBX
CALL 0x00117920
LAB_001540fe:
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_00154105:
MOV RDI,RBX
CALL 0x00117360
LAB_0015410d:
DEC R14
JNZ 0x001540fe
JMP 0x00154126
LAB_00154114:
LEA RDX,[0x15bc4c]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x0012fb78
LAB_00154126:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* string_repeat(std::__cxx11::string const&, unsigned long) */
string * string_repeat(string *param_1,ulong param_2)
{
long in_RDX;
*(string **)param_1 = param_1 + 0x10;
if (in_RDX == 0) {
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
else {
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
/* try { // try from 001540f6 to 001540fd has its CatchHandler @ 00154135 */
std::__cxx11::string::reserve((ulong)param_1);
do {
/* try { // try from 00154105 to 0015410c has its CatchHandler @ 00154137 */
std::__cxx11::string::append((char *)param_1,*(ulong *)param_2);
in_RDX = in_RDX + -1;
} while (in_RDX != 0);
}
return param_1;
}
| |
34,905 | fill_uchar | eloqsql/strings/ctype.c | static int fill_uchar(uchar *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uchar) strtoul(b,NULL,16);
}
return 0;
} | O3 | c | fill_uchar:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
testq %rcx, %rcx
jle 0xdceb4
movq %rcx, %rbx
movq %rdx, %r12
addq %rdx, %rbx
movl %esi, %eax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
leaq 0xf74d(%rip), %r15 # 0xec58e
movq %r12, %r13
movsbl (%r13), %esi
movl $0x5, %edx
movq %r15, %rdi
callq 0x2a380
testq %rax, %rax
je 0xdce63
incq %r13
cmpq %rbx, %r13
jb 0xdce44
cmpq %rbx, %r13
jae 0xdceb4
movq %r13, %r12
movsbl (%r12), %esi
movl $0x5, %edx
movq %r15, %rdi
callq 0x2a380
testq %rax, %rax
jne 0xdce8a
incq %r12
cmpq %rbx, %r12
jb 0xdce6b
cmpq %r13, %r12
je 0xdceb4
cmpq -0x30(%rbp), %r14
ja 0xdceb4
movq %r13, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2a090
movq -0x38(%rbp), %rcx
movb %al, (%rcx,%r14)
incq %r14
cmpq %rbx, %r12
jb 0xdce41
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| fill_uchar:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], rdi
test rcx, rcx
jle loc_DCEB4
mov rbx, rcx
mov r12, rdx
add rbx, rdx
mov eax, esi
mov [rbp+var_30], rax
xor r14d, r14d
lea r15, asc_EC58E; " \t\r\n"
loc_DCE41:
mov r13, r12
loc_DCE44:
movsx esi, byte ptr [r13+0]
mov edx, 5
mov rdi, r15
call _memchr
test rax, rax
jz short loc_DCE63
inc r13
cmp r13, rbx
jb short loc_DCE44
loc_DCE63:
cmp r13, rbx
jnb short loc_DCEB4
mov r12, r13
loc_DCE6B:
movsx esi, byte ptr [r12]
mov edx, 5
mov rdi, r15
call _memchr
test rax, rax
jnz short loc_DCE8A
inc r12
cmp r12, rbx
jb short loc_DCE6B
loc_DCE8A:
cmp r12, r13
jz short loc_DCEB4
cmp r14, [rbp+var_30]
ja short loc_DCEB4
mov rdi, r13
xor esi, esi
mov edx, 10h
call ___isoc23_strtoul
mov rcx, [rbp+var_38]
mov [rcx+r14], al
inc r14
cmp r12, rbx
jb short loc_DCE41
loc_DCEB4:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void fill_uchar(long long a1, unsigned int a2, char *a3, long long a4)
{
char *v4; // r12
unsigned long long v5; // rbx
unsigned long long v6; // r14
char *v7; // r13
if ( a4 > 0 )
{
v4 = a3;
v5 = (unsigned long long)&a3[a4];
v6 = 0LL;
do
{
v7 = v4;
do
{
if ( !memchr(" \t\r\n", (unsigned int)*v7, 5LL) )
break;
++v7;
}
while ( (unsigned long long)v7 < v5 );
if ( (unsigned long long)v7 >= v5 )
break;
v4 = v7;
do
{
if ( memchr(" \t\r\n", (unsigned int)*v4, 5LL) )
break;
++v4;
}
while ( (unsigned long long)v4 < v5 );
if ( v4 == v7 )
break;
if ( v6 > a2 )
break;
*(_BYTE *)(a1 + v6++) = __isoc23_strtoul(v7, 0LL, 16LL);
}
while ( (unsigned long long)v4 < v5 );
}
}
| fill_uchar:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],RDI
TEST RCX,RCX
JLE 0x001dceb4
MOV RBX,RCX
MOV R12,RDX
ADD RBX,RDX
MOV EAX,ESI
MOV qword ptr [RBP + -0x30],RAX
XOR R14D,R14D
LEA R15,[0x1ec58e]
LAB_001dce41:
MOV R13,R12
LAB_001dce44:
MOVSX ESI,byte ptr [R13]
MOV EDX,0x5
MOV RDI,R15
CALL 0x0012a380
TEST RAX,RAX
JZ 0x001dce63
INC R13
CMP R13,RBX
JC 0x001dce44
LAB_001dce63:
CMP R13,RBX
JNC 0x001dceb4
MOV R12,R13
LAB_001dce6b:
MOVSX ESI,byte ptr [R12]
MOV EDX,0x5
MOV RDI,R15
CALL 0x0012a380
TEST RAX,RAX
JNZ 0x001dce8a
INC R12
CMP R12,RBX
JC 0x001dce6b
LAB_001dce8a:
CMP R12,R13
JZ 0x001dceb4
CMP R14,qword ptr [RBP + -0x30]
JA 0x001dceb4
MOV RDI,R13
XOR ESI,ESI
MOV EDX,0x10
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RCX + R14*0x1],AL
INC R14
CMP R12,RBX
JC 0x001dce41
LAB_001dceb4:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void fill_uchar(long param_1,ulong param_2,char *param_3,long param_4)
{
int1 uVar1;
void *pvVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
if (param_4 < 1) {
return;
}
pcVar3 = param_3 + param_4;
uVar5 = 0;
LAB_001dce44:
do {
pvVar2 = memchr(&DAT_001ec58e,(int)*param_3,5);
pcVar4 = param_3;
if (pvVar2 != (void *)0x0) {
param_3 = param_3 + 1;
pcVar4 = param_3;
if (param_3 < pcVar3) goto LAB_001dce44;
}
param_3 = pcVar4;
if (pcVar3 <= pcVar4) {
return;
}
do {
pvVar2 = memchr(&DAT_001ec58e,(int)*param_3,5);
if (pvVar2 != (void *)0x0) break;
param_3 = param_3 + 1;
} while (param_3 < pcVar3);
if (param_3 == pcVar4) {
return;
}
if ((param_2 & 0xffffffff) < uVar5) {
return;
}
uVar1 = __isoc23_strtoul(pcVar4,0,0x10);
*(int1 *)(param_1 + uVar5) = uVar1;
uVar5 = uVar5 + 1;
if (pcVar3 <= param_3) {
return;
}
} while( true );
}
| |
34,906 | stbi__gif_parse_colortable | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
pal[i][3] = transp == i ? 0 : 255;
}
} | O3 | c | stbi__gif_parse_colortable:
testl %edx, %edx
jle 0x36b6f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x35752
movb %al, 0x2(%rbx,%r13,4)
movq %r14, %rdi
callq 0x35752
movb %al, 0x1(%rbx,%r13,4)
movq %r14, %rdi
callq 0x35752
movb %al, (%rbx,%r13,4)
cmpq %r13, %r15
setne %al
negb %al
movb %al, 0x3(%rbx,%r13,4)
incq %r13
cmpq %r13, %r12
jne 0x36b2b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| stbi__gif_parse_colortable:
test edx, edx
jle short locret_36B6F
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, rdi
mov r15d, ecx
mov r12d, edx
xor r13d, r13d
loc_36B2B:
mov rdi, r14
call stbi__get8
mov [rbx+r13*4+2], al
mov rdi, r14
call stbi__get8
mov [rbx+r13*4+1], al
mov rdi, r14
call stbi__get8
mov [rbx+r13*4], al
cmp r15, r13
setnz al
neg al
mov [rbx+r13*4+3], al
inc r13
cmp r12, r13
jnz short loc_36B2B
pop rbx
pop r12
pop r13
pop r14
pop r15
locret_36B6F:
retn
| void stbi__gif_parse_colortable(long long a1, long long a2, int a3, unsigned int a4)
{
long long v4; // r15
long long v5; // r12
long long i; // r13
if ( a3 > 0 )
{
v4 = a4;
v5 = (unsigned int)a3;
for ( i = 0LL; i != v5; ++i )
{
*(_BYTE *)(a2 + 4 * i + 2) = stbi__get8(a1);
*(_BYTE *)(a2 + 4 * i + 1) = stbi__get8(a1);
*(_BYTE *)(a2 + 4 * i) = stbi__get8(a1);
*(_BYTE *)(a2 + 4 * i + 3) = -(v4 != i);
}
}
}
| stbi__gif_parse_colortable:
TEST EDX,EDX
JLE 0x00136b6f
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV R15D,ECX
MOV R12D,EDX
XOR R13D,R13D
LAB_00136b2b:
MOV RDI,R14
CALL 0x00135752
MOV byte ptr [RBX + R13*0x4 + 0x2],AL
MOV RDI,R14
CALL 0x00135752
MOV byte ptr [RBX + R13*0x4 + 0x1],AL
MOV RDI,R14
CALL 0x00135752
MOV byte ptr [RBX + R13*0x4],AL
CMP R15,R13
SETNZ AL
NEG AL
MOV byte ptr [RBX + R13*0x4 + 0x3],AL
INC R13
CMP R12,R13
JNZ 0x00136b2b
POP RBX
POP R12
POP R13
POP R14
POP R15
LAB_00136b6f:
RET
|
void stbi__gif_parse_colortable(int8 param_1,long param_2,uint param_3,uint param_4)
{
int1 uVar1;
ulong uVar2;
if (0 < (int)param_3) {
uVar2 = 0;
do {
uVar1 = stbi__get8(param_1);
*(int1 *)(param_2 + 2 + uVar2 * 4) = uVar1;
uVar1 = stbi__get8(param_1);
*(int1 *)(param_2 + 1 + uVar2 * 4) = uVar1;
uVar1 = stbi__get8(param_1);
*(int1 *)(param_2 + uVar2 * 4) = uVar1;
*(char *)(param_2 + 3 + uVar2 * 4) = -(param_4 != uVar2);
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
return;
}
| |
34,907 | my_hash_sort_utf8mb4 | eloqsql/strings/ctype-utf8.c | static void
my_hash_sort_utf8mb4(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb4_nopad(cs, s, e - s, nr1, nr2);
} | O3 | c | my_hash_sort_utf8mb4:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0xcf96b
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0xcf96b
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0xcf990
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0xcf953
jmp 0xcf96e
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0xcf98a
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0xcf974
popq %rbp
jmp 0xcfc14
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0xcf96e
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0xcf96e
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0xcf9a7
jmp 0xcf96e
| my_hash_sort_utf8mb4:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_CF96B
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_CF96B
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_CF953:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_CF990
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_CF953
jmp short loc_CF96E
loc_CF96B:
mov rax, r10
loc_CF96E:
mov r9, rax
sub r9, rsi
loc_CF974:
mov rdx, r9
cmp rax, rsi
jbe short loc_CF98A
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_CF974
loc_CF98A:
pop rbp
jmp my_hash_sort_utf8mb4_nopad
loc_CF990:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_CF96E
mov r9, rax
loc_CF9A7:
mov rax, r9
cmp r9, rdx
jbe short loc_CF96E
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_CF9A7
jmp short loc_CF96E
| long long my_hash_sort_utf8mb4(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb4_nopad(a1, a2, v11, a4, a5, v10);
}
| my_hash_sort_utf8mb4:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001cf96b
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x001cf96b
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001cf953:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x001cf990
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x001cf953
JMP 0x001cf96e
LAB_001cf96b:
MOV RAX,R10
LAB_001cf96e:
MOV R9,RAX
SUB R9,RSI
LAB_001cf974:
MOV RDX,R9
CMP RAX,RSI
JBE 0x001cf98a
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x001cf974
LAB_001cf98a:
POP RBP
JMP 0x001cfc14
LAB_001cf990:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x001cf96e
MOV R9,RAX
LAB_001cf9a7:
MOV RAX,R9
CMP R9,RDX
JBE 0x001cf96e
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x001cf9a7
JMP 0x001cf96e
|
void my_hash_sort_utf8mb4(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_001cf9a7;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_001cf974;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_001cf9a7:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_001cf974:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb4_nopad();
return;
}
| |
34,908 | minja::Value::get(minja::Value const&) | llama.cpp/common/minja/minja.hpp | Value get(const Value& key) {
if (array_) {
if (!key.is_number_integer()) {
return Value();
}
auto index = key.get<int>();
return array_->at(index < 0 ? array_->size() + index : index);
} else if (object_) {
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
auto it = object_->find(key.primitive_);
if (it == object_->end()) return Value();
return it->second;
}
return Value();
} | O3 | cpp | minja::Value::get(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0xca9e8
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x2, %al
jae 0xcaa96
movq %r15, %rdi
callq 0xbfd7a
movq 0x10(%r14), %rcx
testl %eax, %eax
js 0xcaa45
movl %eax, %eax
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
jmp 0xcaa66
movq 0x20(%r14), %r13
testq %r13, %r13
je 0xcaa96
cmpq $0x0, 0x10(%r15)
jne 0xcaaf5
cmpq $0x0, 0x20(%r15)
jne 0xcaaf5
cmpq $0x0, 0x30(%r15)
jne 0xcaaf5
movq (%r13), %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
je 0xcaa83
addq $0x40, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xbbab0
testb %al, %al
jne 0xcaa78
addq $0x60, %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
jne 0xcaa27
jmp 0xcaa7b
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cltq
addq %rdx, %rax
cmpq %rax, %rdx
jbe 0xcaae4
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rsi
jmp 0xcaa8c
movq %r12, %rsi
movq 0x20(%r14), %rax
movq 0x8(%rax), %r12
cmpq %r12, %rsi
je 0xcaa96
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xbd2ac
jmp 0xcaad2
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x84776
movq %r14, %rdi
movl $0x1, %esi
callq 0x84776
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56a9a(%rip), %rdi # 0x121585
movq %rax, %rsi
xorl %eax, %eax
callq 0x21090
movl $0x10, %edi
callq 0x21630
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb571c
leaq 0x56bb0(%rip), %rsi # 0x1216cd
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xaefbc
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21450
xorl %ebp, %ebp
movq 0x9a47b(%rip), %rsi # 0x164fc0
movq 0x9a42c(%rip), %rdx # 0x164f78
movq %rbx, %rdi
callq 0x21a50
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcab72
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21170
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcab8d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21170
testb %bpl, %bpl
jne 0xcabb7
jmp 0xcabbf
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcabb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21170
jmp 0xcabb7
movq %rax, %r14
movq %rbx, %rdi
callq 0x21ef0
movq %r14, %rdi
callq 0x21af0
nop
| _ZN5minja5Value3getERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+10h], 0
jz short loc_CA9E8
mov al, [r15+40h]
add al, 0FBh
cmp al, 2
jnb loc_CAA96
mov rdi, r15
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
mov rcx, [r14+10h]
test eax, eax
js short loc_CAA45
mov eax, eax
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
jmp short loc_CAA66
loc_CA9E8:
mov r13, [r14+20h]
test r13, r13
jz loc_CAA96
cmp qword ptr [r15+10h], 0
jnz loc_CAAF5
cmp qword ptr [r15+20h], 0
jnz loc_CAAF5
cmp qword ptr [r15+30h], 0
jnz loc_CAAF5
mov r12, [r13+0]
mov rsi, [r13+8]
cmp r12, rsi
jz short loc_CAA83
add r15, 40h ; '@'
loc_CAA27:
mov rdi, r12
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> 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&)
test al, al
jnz short loc_CAA78
add r12, 60h ; '`'
mov rsi, [r13+8]
cmp r12, rsi
jnz short loc_CAA27
jmp short loc_CAA7B
loc_CAA45:
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cdqe
add rax, rdx
loc_CAA66:
cmp rdx, rax
jbe short loc_CAAE4
lea rax, [rax+rax*4]
shl rax, 4
add rsi, rax
jmp short loc_CAA8C
loc_CAA78:
mov rsi, r12
loc_CAA7B:
mov rax, [r14+20h]
mov r12, [rax+8]
loc_CAA83:
cmp rsi, r12
jz short loc_CAA96
add rsi, 10h; minja::Value *
loc_CAA8C:
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
jmp short loc_CAAD2
loc_CAA96:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 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
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_CAAD2:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CAAE4:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rsi, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_CAAF5:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CAB72
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CAB72:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CAB8D
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CAB8D:
test bpl, bpl
jnz short loc_CABB7
jmp short loc_CABBF
mov r14, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CABB7
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CABB7
mov r14, rax
loc_CABB7:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_CABBF:
mov rdi, r14
call __Unwind_Resume
| minja::Value * minja::Value::get(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
unsigned long long v5; // rax
long long *v6; // rcx
long long v7; // rsi
unsigned long long v8; // rdx
unsigned __int8 **v9; // r13
unsigned __int8 *v10; // r12
unsigned __int8 *v11; // rsi
unsigned __int8 *v12; // r15
const minja::Value *v13; // rsi
void *exception; // rbx
_BYTE v16[16]; // [rsp+8h] [rbp-70h] BYREF
_QWORD v17[2]; // [rsp+28h] [rbp-50h] BYREF
if ( *((_QWORD *)a2 + 2) )
{
if ( (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) < 2u )
{
LODWORD(v5) = minja::Value::get<int>((_QWORD *)a3);
v6 = (long long *)*((_QWORD *)a2 + 2);
if ( (v5 & 0x80000000) != 0LL )
{
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
v5 = v8 + (int)v5;
}
else
{
v5 = (unsigned int)v5;
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
}
if ( v8 <= v5 )
std::__throw_out_of_range_fmt(
"vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
v5,
v8);
v13 = (const minja::Value *)(80 * v5 + v7);
goto LABEL_21;
}
LABEL_22:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 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 *)this + 64);
return this;
}
v9 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v9 )
goto LABEL_22;
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v16, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>(v17, (long long)"Unashable type: ", (long long)v16);
std::runtime_error::runtime_error(exception, v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v10 = *v9;
v11 = v9[1];
if ( *v9 != v11 )
{
v12 = (unsigned __int8 *)(a3 + 64);
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v10, v12, a4) )
{
v10 += 96;
v11 = v9[1];
if ( v10 == v11 )
goto LABEL_18;
}
v11 = v10;
LABEL_18:
v10 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
}
if ( v11 == v10 )
goto LABEL_22;
v13 = (const minja::Value *)(v11 + 16);
LABEL_21:
minja::Value::Value(this, v13);
return this;
}
| get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x10],0x0
JZ 0x001ca9e8
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JNC 0x001caa96
MOV RDI,R15
CALL 0x001bfd7a
MOV RCX,qword ptr [R14 + 0x10]
TEST EAX,EAX
JS 0x001caa45
MOV EAX,EAX
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
JMP 0x001caa66
LAB_001ca9e8:
MOV R13,qword ptr [R14 + 0x20]
TEST R13,R13
JZ 0x001caa96
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x001caaf5
CMP qword ptr [R15 + 0x20],0x0
JNZ 0x001caaf5
CMP qword ptr [R15 + 0x30],0x0
JNZ 0x001caaf5
MOV R12,qword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JZ 0x001caa83
ADD R15,0x40
LAB_001caa27:
MOV RDI,R12
MOV RSI,R15
CALL 0x001bbab0
TEST AL,AL
JNZ 0x001caa78
ADD R12,0x60
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JNZ 0x001caa27
JMP 0x001caa7b
LAB_001caa45:
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CDQE
ADD RAX,RDX
LAB_001caa66:
CMP RDX,RAX
JBE 0x001caae4
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD RSI,RAX
JMP 0x001caa8c
LAB_001caa78:
MOV RSI,R12
LAB_001caa7b:
MOV RAX,qword ptr [R14 + 0x20]
MOV R12,qword ptr [RAX + 0x8]
LAB_001caa83:
CMP RSI,R12
JZ 0x001caa96
ADD RSI,0x10
LAB_001caa8c:
MOV RDI,RBX
CALL 0x001bd2ac
JMP 0x001caad2
LAB_001caa96:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184776
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184776
LAB_001caad2:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001caae4:
LEA RDI,[0x221585]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x00121090
LAB_001caaf5:
MOV EDI,0x10
CALL 0x00121630
MOV RBX,RAX
LAB_001cab02:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b571c
LAB_001cab16:
LEA RSI,[0x2216cd]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001aefbc
MOV BPL,0x1
LAB_001cab2f:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00121450
XOR EBP,EBP
MOV RSI,qword ptr [0x00264fc0]
MOV RDX,qword ptr [0x00264f78]
MOV RDI,RBX
CALL 0x00121a50
|
/* minja::Value::get(minja::Value const&) */
Value * minja::Value::get(Value *param_1)
{
long *plVar1;
char cVar2;
uint uVar3;
ulong uVar4;
runtime_error *this;
Value *in_RDX;
ulong uVar5;
long in_RSI;
long lVar6;
Value *pVVar7;
basic_json *pbVar8;
bool bVar9;
basic_json *pbVar10;
int1 local_70 [32];
string local_50 [32];
if (*(long *)(in_RSI + 0x10) == 0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 != (long *)0x0) {
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) goto LAB_001caaf5;
pbVar10 = (basic_json *)*plVar1;
pbVar8 = (basic_json *)plVar1[1];
if (pbVar10 != pbVar8) {
do {
pbVar8 = pbVar10;
cVar2 = nlohmann::json_abi_v3_11_3::operator==(pbVar8,(basic_json *)(in_RDX + 0x40));
if (cVar2 != '\0') break;
pbVar10 = pbVar8 + 0x60;
pbVar8 = (basic_json *)plVar1[1];
} while (pbVar10 != pbVar8);
pbVar10 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
}
if (pbVar8 != pbVar10) {
pVVar7 = (Value *)(pbVar8 + 0x10);
goto LAB_001caa8c;
}
}
}
else if ((byte)((char)in_RDX[0x40] - 5U) < 2) {
uVar3 = get<int>(in_RDX);
plVar1 = *(long **)(in_RSI + 0x10);
if ((int)uVar3 < 0) {
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
uVar4 = (long)(int)uVar3 + uVar5;
}
else {
uVar4 = (ulong)uVar3;
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
}
if (uVar4 < uVar5) {
pVVar7 = (Value *)(lVar6 + uVar4 * 0x50);
LAB_001caa8c:
Value(param_1,pVVar7);
return param_1;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",uVar4);
LAB_001caaf5:
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001cab02 to 001cab15 has its CatchHandler @ 001cabb4 */
dump_abi_cxx11_((int)local_70,SUB81(in_RSI,0));
/* try { // try from 001cab16 to 001cab2b has its CatchHandler @ 001cab94 */
std::operator+((char *)local_50,(string *)"Unashable type: ");
/* try { // try from 001cab2f to 001cab53 has its CatchHandler @ 001cab54 */
std::runtime_error::runtime_error(this,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00264fc0,PTR__runtime_error_00264f78);
}
bVar9 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (Value)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar9);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar9);
return param_1;
}
| |
34,909 | my_hash_sort_8bit_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
/*
Remove trailing spaces. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *end= skip_trailing_space(key, len);
my_hash_sort_bin(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_8bit_bin:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0xcc150
movq %r9, %rdi
andq $-0x4, %rdi
cmpq %rsi, %rdi
jbe 0xcc150
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r9, %rax
movb -0x1(%r9), %r10b
cmpq %rdi, %r9
jbe 0xcc1b0
leaq -0x1(%rax), %r9
cmpb $0x20, %r10b
je 0xcc138
jmp 0xcc153
movq %r9, %rax
movq %rax, %rdi
subq %rsi, %rdi
movq %rax, %rdx
movq %rdi, %r9
cmpq %rsi, %rax
jbe 0xcc172
leaq -0x1(%rdx), %rax
leaq -0x1(%r9), %rdi
cmpb $0x20, -0x1(%rdx)
je 0xcc159
movq (%rcx), %rax
movq (%r8), %rdi
testq %r9, %r9
jle 0xcc1a8
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0xcc17d
movq %rax, (%rcx)
movq %rdi, (%r8)
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdi, %rdx
setae %dil
orb %r9b, %dil
jne 0xcc153
movq %rax, %rdi
movq %rdi, %rax
cmpq %rdx, %rdi
jbe 0xcc153
leaq -0x4(%rax), %rdi
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0xcc1c7
jmp 0xcc153
| my_hash_sort_8bit_bin:
push rbp
mov rbp, rsp
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_CC150
mov rdi, r9
and rdi, 0FFFFFFFFFFFFFFFCh
cmp rdi, rsi
jbe short loc_CC150
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_CC138:
mov rax, r9
mov r10b, [r9-1]
cmp r9, rdi
jbe short loc_CC1B0
lea r9, [rax-1]
cmp r10b, 20h ; ' '
jz short loc_CC138
jmp short loc_CC153
loc_CC150:
mov rax, r9
loc_CC153:
mov rdi, rax
sub rdi, rsi
loc_CC159:
mov rdx, rax
mov r9, rdi
cmp rax, rsi
jbe short loc_CC172
lea rax, [rdx-1]
lea rdi, [r9-1]
cmp byte ptr [rdx-1], 20h ; ' '
jz short loc_CC159
loc_CC172:
mov rax, [rcx]
mov rdi, [r8]
test r9, r9
jle short loc_CC1A8
loc_CC17D:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_CC17D
loc_CC1A8:
mov [rcx], rax
mov [r8], rdi
pop rbp
retn
loc_CC1B0:
cmp r10b, 20h ; ' '
setnz r9b
cmp rdx, rdi
setnb dil
or dil, r9b
jnz short loc_CC153
mov rdi, rax
loc_CC1C7:
mov rax, rdi
cmp rdi, rdx
jbe short loc_CC153
lea rdi, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_CC1C7
jmp loc_CC153
| long long my_hash_sort_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdi
unsigned long long v7; // rdx
unsigned __int8 *v8; // rax
char v9; // r10
long long v10; // rdi
unsigned long long v11; // rdx
long long v12; // r9
long long result; // rax
long long v14; // rdi
unsigned long long v15; // rdi
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = &a2[a3];
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = (unsigned __int8 *)v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v15 = v5;
do
{
v8 = (unsigned __int8 *)v15;
if ( v15 <= v7 )
break;
v15 -= 4LL;
}
while ( *((_DWORD *)v8 - 1) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = (unsigned long long)v8;
v12 = v10;
if ( v8 <= a2 )
break;
--v8;
--v10;
}
while ( *(_BYTE *)(v11 - 1) == 32 );
result = *a4;
v14 = *a5;
if ( v12 > 0 )
{
do
{
result ^= (v14 + (result & 0x3F)) * *a2 + (result << 8);
v14 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v11 );
}
*a4 = result;
*a5 = v14;
return result;
}
| my_hash_sort_8bit_bin:
PUSH RBP
MOV RBP,RSP
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001cc150
MOV RDI,R9
AND RDI,-0x4
CMP RDI,RSI
JBE 0x001cc150
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001cc138:
MOV RAX,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDI
JBE 0x001cc1b0
LEA R9,[RAX + -0x1]
CMP R10B,0x20
JZ 0x001cc138
JMP 0x001cc153
LAB_001cc150:
MOV RAX,R9
LAB_001cc153:
MOV RDI,RAX
SUB RDI,RSI
LAB_001cc159:
MOV RDX,RAX
MOV R9,RDI
CMP RAX,RSI
JBE 0x001cc172
LEA RAX,[RDX + -0x1]
LEA RDI,[R9 + -0x1]
CMP byte ptr [RDX + -0x1],0x20
JZ 0x001cc159
LAB_001cc172:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST R9,R9
JLE 0x001cc1a8
LAB_001cc17d:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x001cc17d
LAB_001cc1a8:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
POP RBP
RET
LAB_001cc1b0:
CMP R10B,0x20
SETNZ R9B
CMP RDX,RDI
SETNC DIL
OR DIL,R9B
JNZ 0x001cc153
MOV RDI,RAX
LAB_001cc1c7:
MOV RAX,RDI
CMP RDI,RDX
JBE 0x001cc153
LEA RDI,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x001cc1c7
JMP 0x001cc153
|
void my_hash_sort_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
long lVar6;
pbVar2 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar2 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar2;
do {
pbVar2 = pbVar1;
if (pbVar2 <= pbVar4) {
pbVar1 = pbVar2;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar2[-1] == 0x20)
goto LAB_001cc1c7;
break;
}
pbVar1 = pbVar2 + -1;
} while (pbVar2[-1] == 0x20);
}
goto LAB_001cc153;
while (pbVar1 = pbVar2 + -4, *(int *)(pbVar2 + -4) == 0x20202020) {
LAB_001cc1c7:
pbVar2 = pbVar1;
if (pbVar2 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_001cc153:
lVar6 = (long)pbVar2 - (long)param_2;
do {
lVar5 = lVar6;
pbVar4 = pbVar2;
if (pbVar4 <= param_2) break;
pbVar2 = pbVar4 + -1;
lVar6 = lVar5 + -1;
} while (pbVar4[-1] == 0x20);
uVar3 = *param_4;
lVar6 = *param_5;
if (0 < lVar5) {
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar4);
}
*param_4 = uVar3;
*param_5 = lVar6;
return;
}
| |
34,910 | my_charset_get_by_name | eloqsql/mysys/charset.c | CHARSET_INFO *
my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *cs_name, uint cs_flags, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
DBUG_ENTER("get_charset_by_csname");
DBUG_PRINT("enter",("name: '%s'", cs_name));
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_charset_number(cs_name, cs_flags, flags);
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_CHARSET, MYF(ME_BELL), cs_name, index_file);
}
DBUG_RETURN(cs);
} | O3 | c | my_charset_get_by_name:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq 0xba8d16(%rip), %rdi # 0xc5af30
leaq -0x9ae(%rip), %rsi # 0xb1873
callq 0x2b250
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0xb1a5e
testl %eax, %eax
je 0xb224a
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xb1d02
movq %rax, %r14
jmp 0xb224d
xorl %r14d, %r14d
testq %r14, %r14
setne %al
testb $0x10, %r15b
sete %cl
orb %al, %cl
jne 0xb2297
leaq -0x240(%rbp), %r15
movq %r15, %rdi
callq 0xb1633
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movl $0x4, %esi
movl $0x16, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xbf527
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0xb22b9
movq %r14, %rax
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2b280
| my_charset_get_by_name:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 220h
mov r15, rcx
mov r12d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
mov esi, r12d
mov rdx, r15
call get_charset_number
test eax, eax
jz short loc_B224A
mov rdi, r14
mov esi, eax
mov rdx, r15
call get_internal_charset
mov r14, rax
jmp short loc_B224D
loc_B224A:
xor r14d, r14d
loc_B224D:
test r14, r14
setnz al
test r15b, 10h
setz cl
or cl, al
jnz short loc_B2297
lea r15, [rbp+var_240]
mov rdi, r15
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov esi, 4
mov edi, 16h
mov rdx, rbx
mov rcx, r15
xor eax, eax
call my_error
loc_B2297:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_B22B9
mov rax, r14
add rsp, 220h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B22B9:
call ___stack_chk_fail
| long long my_charset_get_by_name(long long a1, long long a2, unsigned int a3, long long a4)
{
unsigned int charset_number; // eax
long long internal_charset; // r14
int v8; // r8d
int v9; // r9d
_BYTE v11[536]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+218h] [rbp-28h]
v12 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
charset_number = get_charset_number(a2, a3, a4);
if ( charset_number )
internal_charset = get_internal_charset(a1, charset_number, a4);
else
internal_charset = 0LL;
if ( internal_charset == 0 && (a4 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v11), "Index.xml");
my_error(22, 4, a2, (unsigned int)v11, v8, v9);
}
return internal_charset;
}
| my_charset_get_by_name:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x220
MOV R15,RCX
MOV R12D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[0xd5af30]
LEA RSI,[0x1b1873]
CALL 0x0012b250
MOV RDI,RBX
MOV ESI,R12D
MOV RDX,R15
CALL 0x001b1a5e
TEST EAX,EAX
JZ 0x001b224a
MOV RDI,R14
MOV ESI,EAX
MOV RDX,R15
CALL 0x001b1d02
MOV R14,RAX
JMP 0x001b224d
LAB_001b224a:
XOR R14D,R14D
LAB_001b224d:
TEST R14,R14
SETNZ AL
TEST R15B,0x10
SETZ CL
OR CL,AL
JNZ 0x001b2297
LEA R15,[RBP + -0x240]
MOV RDI,R15
CALL 0x001b1633
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV ESI,0x4
MOV EDI,0x16
MOV RDX,RBX
MOV RCX,R15
XOR EAX,EAX
CALL 0x001bf527
LAB_001b2297:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001b22b9
MOV RAX,R14
ADD RSP,0x220
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b22b9:
CALL 0x0012b280
|
long my_charset_get_by_name(int8 param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_248 [536];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_charset_number(param_2,param_3,param_4);
if (iVar1 == 0) {
lVar2 = 0;
}
else {
lVar2 = get_internal_charset(param_1,iVar1,param_4);
}
if ((param_4 & 0x10) != 0 && lVar2 == 0) {
puVar3 = (int8 *)get_charsets_dir(local_248);
*puVar3 = 0x6d782e7865646e49;
*(int2 *)(puVar3 + 1) = 0x6c;
my_error(0x16,4,param_2,local_248);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return lVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,911 | maria_page_crc_check_data | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_check_data(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
if (res)
{
return 1;
}
return (maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_NORMAL_PAGE,
share->block_size - CRC_SIZE));
} | O3 | c | maria_page_crc_check_data:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
je 0x8d91f
movb $0x1, %al
popq %rbp
retq
movq 0x10(%rsi), %rdx
movl 0x8(%rsi), %eax
movq (%rsi), %rdi
movl 0x7bc(%rdx), %r8d
addl $-0x4, %r8d
movq %rax, %rsi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
popq %rbp
jmp 0x8d80c
| maria_page_crc_check_data:
push rbp
mov rbp, rsp
test edi, edi
jz short loc_8D91F
mov al, 1
pop rbp
retn
loc_8D91F:
mov rdx, [rsi+10h]
mov eax, [rsi+8]
mov rdi, [rsi]
mov r8d, [rdx+7BCh]
add r8d, 0FFFFFFFCh
mov rsi, rax
mov ecx, 0FFFFFFFFh
pop rbp
jmp maria_page_crc_check
| char maria_page_crc_check_data(int a1, long long a2)
{
if ( a1 )
return 1;
else
return maria_page_crc_check(
*(_QWORD *)a2,
*(_DWORD *)(a2 + 8),
*(_QWORD *)(a2 + 16),
-1,
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 1980LL) - 4);
}
| maria_page_crc_check_data:
PUSH RBP
MOV RBP,RSP
TEST EDI,EDI
JZ 0x0018d91f
MOV AL,0x1
POP RBP
RET
LAB_0018d91f:
MOV RDX,qword ptr [RSI + 0x10]
MOV EAX,dword ptr [RSI + 0x8]
MOV RDI,qword ptr [RSI]
MOV R8D,dword ptr [RDX + 0x7bc]
ADD R8D,-0x4
MOV RSI,RAX
MOV ECX,0xffffffff
POP RBP
JMP 0x0018d80c
|
int8 maria_page_crc_check_data(int param_1,int8 *param_2)
{
int8 uVar1;
if (param_1 != 0) {
return 1;
}
uVar1 = maria_page_crc_check
(*param_2,*(int4 *)(param_2 + 1),param_2[2],0xffffffff,
*(int *)(param_2[2] + 0x7bc) + -4);
return uVar1;
}
| |
34,912 | my_chsize | eloqsql/mysys/my_chsize.c | int my_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
{
my_off_t oldsize;
uchar buff[IO_SIZE];
DBUG_ENTER("my_chsize");
DBUG_PRINT("my",("fd: %d length: %lu MyFlags: %lu",fd,(ulong) newlength,
MyFlags));
if ((oldsize= my_seek(fd, 0L, MY_SEEK_END, MYF(MY_WME+MY_FAE))) == newlength)
DBUG_RETURN(0);
DBUG_PRINT("info",("old_size: %ld", (ulong) oldsize));
if (oldsize > newlength)
{
#ifdef _WIN32
if (my_win_chsize(fd, newlength))
{
my_errno= errno;
goto err;
}
DBUG_RETURN(0);
#elif defined(HAVE_FTRUNCATE)
if (ftruncate(fd, (off_t) newlength))
{
my_errno= errno;
goto err;
}
DBUG_RETURN(0);
#else
/*
Fill space between requested length and true length with 'filler'
We should never come here on any modern machine
*/
if (my_seek(fd, newlength, MY_SEEK_SET, MYF(MY_WME+MY_FAE))
== MY_FILEPOS_ERROR)
{
goto err;
}
swap_variables(my_off_t, newlength, oldsize);
#endif
}
/* Full file with 'filler' until it's as big as requested */
bfill(buff, IO_SIZE, filler);
while (newlength-oldsize > IO_SIZE)
{
if (my_write(fd, buff, IO_SIZE, MYF(MY_NABP)))
goto err;
oldsize+= IO_SIZE;
}
if (my_write(fd,buff,(size_t) (newlength-oldsize), MYF(MY_NABP)))
goto err;
DBUG_RETURN(0);
err:
DBUG_PRINT("error", ("errno: %d", errno));
if (MyFlags & MY_WME)
my_error(EE_CANT_CHSIZE, MYF(ME_BELL), my_errno);
DBUG_RETURN(1);
} | O0 | c | my_chsize:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp # imm = 0x1040
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x1018(%rbp)
movq %rsi, -0x1020(%rbp)
movl %edx, -0x1024(%rbp)
movq %rcx, -0x1030(%rbp)
jmp 0xc11a54
movl -0x1018(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
movl $0x18, %ecx
callq 0xc1c570
movq %rax, -0x1038(%rbp)
cmpq -0x1020(%rbp), %rax
jne 0xc11a8e
jmp 0xc11a7f
movl $0x0, -0x1014(%rbp)
jmp 0xc11bc7
jmp 0xc11a90
jmp 0xc11a92
movq -0x1038(%rbp), %rax
cmpq -0x1020(%rbp), %rax
jbe 0xc11ae9
movl -0x1018(%rbp), %edi
movq -0x1020(%rbp), %rsi
callq 0x433f10
cmpl $0x0, %eax
je 0xc11ad8
callq 0x434a00
movl (%rax), %eax
movl %eax, -0x103c(%rbp)
callq 0xc1d990
movl -0x103c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xc11b8e
jmp 0xc11ada
movl $0x0, -0x1014(%rbp)
jmp 0xc11bc7
leaq -0x1010(%rbp), %rdi
movl -0x1024(%rbp), %eax
movl $0x1000, %edx # imm = 0x1000
movzbl %al, %esi
callq 0x433730
movq -0x1020(%rbp), %rax
subq -0x1038(%rbp), %rax
cmpq $0x1000, %rax # imm = 0x1000
jbe 0xc11b53
movl -0x1018(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx # imm = 0x1000
movl $0x4, %ecx
callq 0xc1e6e0
cmpq $0x0, %rax
je 0xc11b3d
jmp 0xc11b8e
movq -0x1038(%rbp), %rax
addq $0x1000, %rax # imm = 0x1000
movq %rax, -0x1038(%rbp)
jmp 0xc11b03
movl -0x1018(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movq -0x1020(%rbp), %rdx
subq -0x1038(%rbp), %rdx
movl $0x4, %ecx
callq 0xc1e6e0
cmpq $0x0, %rax
je 0xc11b80
jmp 0xc11b8e
jmp 0xc11b82
movl $0x0, -0x1014(%rbp)
jmp 0xc11bc7
jmp 0xc11b90
jmp 0xc11b92
movq -0x1030(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xc11bbb
callq 0xc1d990
movl (%rax), %edx
movl $0xe, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xc12a30
jmp 0xc11bbd
movl $0x1, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movl %eax, -0x1040(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc11bf4
movl -0x1040(%rbp), %eax
addq $0x1040, %rsp # imm = 0x1040
popq %rbp
retq
callq 0x433650
nopl (%rax)
| my_chsize:
push rbp
mov rbp, rsp
sub rsp, 1040h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1018], edi
mov [rbp+var_1020], rsi
mov [rbp+var_1024], edx
mov [rbp+var_1030], rcx
jmp short $+2
loc_C11A54:
mov edi, [rbp+var_1018]
xor eax, eax
mov esi, eax
mov edx, 2
mov ecx, 18h
call my_seek
mov [rbp+var_1038], rax
cmp rax, [rbp+var_1020]
jnz short loc_C11A8E
jmp short $+2
loc_C11A7F:
mov [rbp+var_1014], 0
jmp loc_C11BC7
loc_C11A8E:
jmp short $+2
loc_C11A90:
jmp short $+2
loc_C11A92:
mov rax, [rbp+var_1038]
cmp rax, [rbp+var_1020]
jbe short loc_C11AE9
mov edi, [rbp+var_1018]
mov rsi, [rbp+var_1020]
call _ftruncate64
cmp eax, 0
jz short loc_C11AD8
call ___errno_location
mov eax, [rax]
mov [rbp+var_103C], eax
call _my_thread_var
mov ecx, [rbp+var_103C]
mov [rax], ecx
jmp loc_C11B8E
loc_C11AD8:
jmp short $+2
loc_C11ADA:
mov [rbp+var_1014], 0
jmp loc_C11BC7
loc_C11AE9:
lea rdi, [rbp+var_1010]
mov eax, [rbp+var_1024]
mov edx, 1000h
movzx esi, al
call _memset
loc_C11B03:
mov rax, [rbp+var_1020]
sub rax, [rbp+var_1038]
cmp rax, 1000h
jbe short loc_C11B53
mov edi, [rbp+var_1018]
lea rsi, [rbp+var_1010]
mov edx, 1000h
mov ecx, 4
call my_write
cmp rax, 0
jz short loc_C11B3D
jmp short loc_C11B8E
loc_C11B3D:
mov rax, [rbp+var_1038]
add rax, 1000h
mov [rbp+var_1038], rax
jmp short loc_C11B03
loc_C11B53:
mov edi, [rbp+var_1018]
lea rsi, [rbp+var_1010]
mov rdx, [rbp+var_1020]
sub rdx, [rbp+var_1038]
mov ecx, 4
call my_write
cmp rax, 0
jz short loc_C11B80
jmp short loc_C11B8E
loc_C11B80:
jmp short $+2
loc_C11B82:
mov [rbp+var_1014], 0
jmp short loc_C11BC7
loc_C11B8E:
jmp short $+2
loc_C11B90:
jmp short $+2
loc_C11B92:
mov rax, [rbp+var_1030]
and rax, 10h
cmp rax, 0
jz short loc_C11BBB
call _my_thread_var
mov edx, [rax]
mov edi, 0Eh
mov esi, 4
mov al, 0
call my_error
loc_C11BBB:
jmp short $+2
loc_C11BBD:
mov [rbp+var_1014], 1
loc_C11BC7:
mov eax, [rbp+var_1014]
mov [rbp+var_1040], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C11BF4
mov eax, [rbp+var_1040]
add rsp, 1040h
pop rbp
retn
loc_C11BF4:
call ___stack_chk_fail
| long long my_chsize(long long a1, const char *a2, unsigned __int8 a3, char a4)
{
_DWORD *v4; // rax
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v9; // [rsp+4h] [rbp-103Ch]
unsigned long long v10; // [rsp+8h] [rbp-1038h]
const char *v13; // [rsp+20h] [rbp-1020h]
unsigned int v14; // [rsp+28h] [rbp-1018h]
_BYTE v16[4104]; // [rsp+30h] [rbp-1010h] BYREF
unsigned long long v17; // [rsp+1038h] [rbp-8h]
v17 = __readfsqword(0x28u);
v14 = a1;
v13 = a2;
v10 = my_seek((unsigned int)a1, 0LL, 2LL, 24LL);
if ( (const char *)v10 == a2 )
{
return 0;
}
else
{
if ( v10 <= (unsigned long long)a2 )
{
memset(v16, a3);
while ( (unsigned long long)&v13[-v10] > 0x1000 )
{
a1 = v14;
a2 = v16;
if ( my_write(v14, v16, 4096LL, 4LL) )
goto LABEL_13;
v10 += 4096LL;
}
a1 = v14;
a2 = v16;
if ( !my_write(v14, v16, &v13[-v10], 4LL) )
return 0;
}
else
{
a1 = (unsigned int)a1;
if ( !(unsigned int)ftruncate64((unsigned int)a1, a2) )
return 0;
v9 = *(_DWORD *)__errno_location((unsigned int)a1, a2);
*(_DWORD *)my_thread_var((unsigned int)a1, a2) = v9;
}
LABEL_13:
if ( (a4 & 0x10) != 0 )
{
v4 = (_DWORD *)my_thread_var(a1, a2);
my_error(14, 4, *v4, v5, v6, v7);
}
return 1;
}
}
| inline_mysql_cond_wait:
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 dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x10]
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 0x00c11a74
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x00d1e440
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00c11a84
LAB_00c11a74:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00533c70
MOV dword ptr [RBP + -0x4],EAX
LAB_00c11a84:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int inline_mysql_cond_wait
(pthread_cond_t *param_1,pthread_mutex_t *param_2,int8 param_3,
int4 param_4)
{
int local_c;
if (param_1[1].__align == 0) {
local_c = pthread_cond_wait(param_1,param_2);
}
else {
local_c = psi_cond_wait(param_1,param_2,param_3,param_4);
}
return local_c;
}
| |
34,913 | Warning_info::remove_marked_sql_conditions() | eloqsql/sql/sql_error.cc | void Warning_info::remove_marked_sql_conditions()
{
List_iterator_fast<Sql_condition> it(m_marked_sql_conditions);
Sql_condition *cond;
while ((cond= it++))
{
m_warn_list.remove(cond);
m_warn_count[cond->get_level()]--;
m_current_statement_warn_count--;
if (cond == m_error_condition)
m_error_condition= NULL;
}
m_marked_sql_conditions.empty();
} | O0 | cpp | Warning_info::remove_marked_sql_conditions():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x98, %rsi
leaq -0x28(%rbp), %rdi
callq 0x56cee0
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x56cf10
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x56be45
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq -0x30(%rbp), %rsi
callq 0x56cf30
movq -0x30(%rbp), %rdi
callq 0x4eb4a0
movq -0x38(%rbp), %rcx
movl %eax, %eax
movl 0x58(%rcx,%rax,4), %edx
addl $-0x1, %edx
movl %edx, 0x58(%rcx,%rax,4)
movl 0x64(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x64(%rcx)
movq -0x30(%rbp), %rax
cmpq 0x78(%rcx), %rax
jne 0x56be43
movq -0x38(%rbp), %rax
movq $0x0, 0x78(%rax)
jmp 0x56bde4
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x49e4a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN12Warning_info28remove_marked_sql_conditionsEv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov rsi, [rbp+var_8]
mov [rbp+var_38], rsi
add rsi, 98h
lea rdi, [rbp+var_28]
call _ZN18List_iterator_fastI13Sql_conditionEC2ER4ListIS0_E; List_iterator_fast<Sql_condition>::List_iterator_fast(List<Sql_condition> &)
loc_56BDE4:
lea rdi, [rbp+var_28]
xor esi, esi
call _ZN18List_iterator_fastI13Sql_conditionEppEi; List_iterator_fast<Sql_condition>::operator++(int)
mov [rbp+var_30], rax
cmp rax, 0
jz short loc_56BE45
mov rdi, [rbp+var_38]
add rdi, 40h ; '@'
mov rsi, [rbp+var_30]
call _ZN8I_P_ListI13Sql_condition16I_P_List_adapterIS0_XadL_ZNS0_10next_in_wiEEEXadL_ZNS0_10prev_in_wiEEEE16I_P_List_counter23I_P_List_fast_push_backIS0_EE6removeEPS0_; I_P_List<Sql_condition,I_P_List_adapter<Sql_condition,&Sql_condition::next_in_wi,&Sql_condition::prev_in_wi>,I_P_List_counter,I_P_List_fast_push_back<Sql_condition>>::remove(Sql_condition*)
mov rdi, [rbp+var_30]; this
call _ZNK21Sql_state_errno_level9get_levelEv; Sql_state_errno_level::get_level(void)
mov rcx, [rbp+var_38]
mov eax, eax
mov edx, [rcx+rax*4+58h]
add edx, 0FFFFFFFFh
mov [rcx+rax*4+58h], edx
mov eax, [rcx+64h]
add eax, 0FFFFFFFFh
mov [rcx+64h], eax
mov rax, [rbp+var_30]
cmp rax, [rcx+78h]
jnz short loc_56BE43
mov rax, [rbp+var_38]
mov qword ptr [rax+78h], 0
loc_56BE43:
jmp short loc_56BDE4
loc_56BE45:
mov rdi, [rbp+var_38]
add rdi, 98h; this
call _ZN9base_list5emptyEv; base_list::empty(void)
add rsp, 40h
pop rbp
retn
| base_list * Warning_info::remove_marked_sql_conditions(Warning_info *this)
{
unsigned int level; // eax
Sql_state_errno_level *v3; // [rsp+10h] [rbp-30h]
_BYTE v4[32]; // [rsp+18h] [rbp-28h] BYREF
Warning_info *v5; // [rsp+38h] [rbp-8h]
v5 = this;
List_iterator_fast<Sql_condition>::List_iterator_fast(v4, (char *)this + 152);
while ( 1 )
{
v3 = (Sql_state_errno_level *)List_iterator_fast<Sql_condition>::operator++(v4, 0LL);
if ( !v3 )
break;
I_P_List<Sql_condition,I_P_List_adapter<Sql_condition,&Sql_condition::next_in_wi,&Sql_condition::prev_in_wi>,I_P_List_counter,I_P_List_fast_push_back<Sql_condition>>::remove(
(char *)this + 64,
v3);
level = Sql_state_errno_level::get_level(v3);
--*((_DWORD *)this + level + 22);
--*((_DWORD *)this + 25);
if ( v3 == *((Sql_state_errno_level **)this + 15) )
*((_QWORD *)this + 15) = 0LL;
}
return base_list::empty((Warning_info *)((char *)this + 152));
}
| __cxx_global_var_init.8:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x16efc58]
MOV ESI,0x1800000
CALL 0x0058cc10
POP RBP
RET
|
void __cxx_global_var_init_8(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_NO_ZEROS,0x1800000);
return;
}
| |
34,914 | ACT_conf_recover | xtate/src/xcmd.c | static ActRes ACT_conf_recover(void *conf) {
XConf *xconf = conf;
int err = xconf_read_conf(xconf, XCONF_DFT_RECOVER_FILENAME);
if (err) {
LOG(LEVEL_ERROR, "failed to read configuration from %s.\n",
XCONF_DFT_RECOVER_FILENAME);
} else {
LOG(LEVEL_HINT, "read and load configuration successfully!\n");
}
return ActRes_Next;
} | O3 | c | ACT_conf_recover:
pushq %rax
leaq 0x1e961(%rip), %rsi # 0x75de9
callq 0x5b99e
testl %eax, %eax
je 0x574ad
leaq 0x1f141(%rip), %rsi # 0x765d9
leaq 0x1e94a(%rip), %rdx # 0x75de9
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x536da
jmp 0x574c0
leaq 0x1f14c(%rip), %rsi # 0x76600
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
xorl %eax, %eax
callq 0x536da
xorl %eax, %eax
popq %rcx
retq
| ACT_conf_recover:
push rax
lea rsi, aRecoverConf; "recover.conf"
call xconf_read_conf
test eax, eax
jz short loc_574AD
lea rsi, aFailedToReadCo; "failed to read configuration from %s.\n"
lea rdx, aRecoverConf; "recover.conf"
mov edi, 0FFFFFFFFh
xor eax, eax
call LOG
jmp short loc_574C0
loc_574AD:
lea rsi, aReadAndLoadCon; "read and load configuration successfull"...
mov edi, 0FFFFFFFEh
xor eax, eax
call LOG
loc_574C0:
xor eax, eax
pop rcx
retn
| long long ACT_conf_recover(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
char v9; // al
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
char v17; // [rsp-8h] [rbp-8h]
v17 = v9;
if ( (unsigned int)xconf_read_conf(a1, "recover.conf") )
LOG(
-1,
(long long)"failed to read configuration from %s.\n",
(long long)"recover.conf",
v11,
v12,
v13,
a2,
a3,
a4,
a5,
v14,
v15,
a8,
a9,
v17);
else
LOG(
-2,
(long long)"read and load configuration successfully!\n",
v10,
v11,
v12,
v13,
a2,
a3,
a4,
a5,
v14,
v15,
a8,
a9,
v17);
return 0LL;
}
| ACT_conf_recover:
PUSH RAX
LEA RSI,[0x175de9]
CALL 0x0015b99e
TEST EAX,EAX
JZ 0x001574ad
LEA RSI,[0x1765d9]
LEA RDX,[0x175de9]
MOV EDI,0xffffffff
XOR EAX,EAX
CALL 0x001536da
JMP 0x001574c0
LAB_001574ad:
LEA RSI,[0x176600]
MOV EDI,0xfffffffe
XOR EAX,EAX
CALL 0x001536da
LAB_001574c0:
XOR EAX,EAX
POP RCX
RET
|
int8 ACT_conf_recover(int8 param_1)
{
int iVar1;
iVar1 = xconf_read_conf(param_1,"recover.conf");
if (iVar1 == 0) {
LOG(0xfffffffe,"read and load configuration successfully!\n");
}
else {
LOG(0xffffffff,"failed to read configuration from %s.\n","recover.conf");
}
return 0;
}
| |
34,915 | js_string_memcmp | bluesky950520[P]quickjs/quickjs.c | static int js_string_memcmp(const JSString *p1, const JSString *p2, int len)
{
int res;
if (likely(!p1->is_wide_char)) {
if (likely(!p2->is_wide_char))
res = memcmp(p1->u.str8, p2->u.str8, len);
else
res = -memcmp16_8(p2->u.str16, p1->u.str8, len);
} else {
if (!p2->is_wide_char)
res = memcmp16_8(p1->u.str16, p2->u.str8, len);
else
res = memcmp16(p1->u.str16, p2->u.str16, len);
}
return res;
} | O1 | c | js_string_memcmp:
testb $-0x80, 0x7(%rdi)
movq 0x4(%rsi), %rax
jne 0x3af9d
testl %eax, %eax
js 0x3afc3
addq $0x18, %rdi
addq $0x18, %rsi
movslq %edx, %rdx
jmp 0xe470
testl %eax, %eax
js 0x3afe8
testl %edx, %edx
jle 0x3b008
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rdi,%rdx,2), %eax
movzbl 0x18(%rsi,%rdx), %r8d
subl %r8d, %eax
jne 0x3b00a
incq %rdx
cmpq %rdx, %rcx
jne 0x3afa9
jmp 0x3b008
testl %edx, %edx
jle 0x3afe3
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rsi,%rdx,2), %eax
movzbl 0x18(%rdi,%rdx), %r8d
subl %r8d, %eax
jne 0x3afe5
incq %rdx
cmpq %rdx, %rcx
jne 0x3afcb
xorl %eax, %eax
negl %eax
retq
testl %edx, %edx
jle 0x3b008
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rdi,%rdx,2), %eax
movzwl 0x18(%rsi,%rdx,2), %r8d
subl %r8d, %eax
jne 0x3b00a
incq %rdx
cmpq %rdx, %rcx
jne 0x3aff0
xorl %eax, %eax
retq
| js_string_memcmp:
test byte ptr [rdi+7], 80h
mov rax, [rsi+4]
jnz short loc_3AF9D
test eax, eax
js short loc_3AFC3
add rdi, 18h
add rsi, 18h
movsxd rdx, edx
jmp _memcmp
loc_3AF9D:
test eax, eax
js short loc_3AFE8
test edx, edx
jle short loc_3B008
mov ecx, edx
xor edx, edx
loc_3AFA9:
movzx eax, word ptr [rdi+rdx*2+18h]
movzx r8d, byte ptr [rsi+rdx+18h]
sub eax, r8d
jnz short locret_3B00A
inc rdx
cmp rcx, rdx
jnz short loc_3AFA9
jmp short loc_3B008
loc_3AFC3:
test edx, edx
jle short loc_3AFE3
mov ecx, edx
xor edx, edx
loc_3AFCB:
movzx eax, word ptr [rsi+rdx*2+18h]
movzx r8d, byte ptr [rdi+rdx+18h]
sub eax, r8d
jnz short loc_3AFE5
inc rdx
cmp rcx, rdx
jnz short loc_3AFCB
loc_3AFE3:
xor eax, eax
loc_3AFE5:
neg eax
retn
loc_3AFE8:
test edx, edx
jle short loc_3B008
mov ecx, edx
xor edx, edx
loc_3AFF0:
movzx eax, word ptr [rdi+rdx*2+18h]
movzx r8d, word ptr [rsi+rdx*2+18h]
sub eax, r8d
jnz short locret_3B00A
inc rdx
cmp rcx, rdx
jnz short loc_3AFF0
loc_3B008:
xor eax, eax
locret_3B00A:
retn
| long long js_string_memcmp(long long a1, long long a2, int a3)
{
long long v3; // rax
long long result; // rax
long long v5; // rcx
long long v6; // rdx
long long v7; // rcx
long long v8; // rdx
int v9; // eax
long long v10; // rcx
long long v11; // rdx
v3 = *(_QWORD *)(a2 + 4);
if ( *(char *)(a1 + 7) >= 0 )
{
if ( (int)v3 >= 0 )
return memcmp(a1 + 24, a2 + 24, a3);
if ( a3 <= 0 )
{
LABEL_14:
v9 = 0;
}
else
{
v7 = (unsigned int)a3;
v8 = 0LL;
while ( 1 )
{
v9 = *(unsigned __int16 *)(a2 + 2 * v8 + 24) - *(unsigned __int8 *)(a1 + v8 + 24);
if ( v9 )
break;
if ( v7 == ++v8 )
goto LABEL_14;
}
}
return (unsigned int)-v9;
}
if ( (int)v3 >= 0 )
{
if ( a3 > 0 )
{
v5 = (unsigned int)a3;
v6 = 0LL;
while ( 1 )
{
result = *(unsigned __int16 *)(a1 + 2 * v6 + 24) - (unsigned int)*(unsigned __int8 *)(a2 + v6 + 24);
if ( (_DWORD)result )
break;
if ( v5 == ++v6 )
return 0LL;
}
return result;
}
return 0LL;
}
if ( a3 <= 0 )
return 0LL;
v10 = (unsigned int)a3;
v11 = 0LL;
while ( 1 )
{
result = *(unsigned __int16 *)(a1 + 2 * v11 + 24) - (unsigned int)*(unsigned __int16 *)(a2 + 2 * v11 + 24);
if ( (_DWORD)result )
break;
if ( v10 == ++v11 )
return 0LL;
}
return result;
}
| js_string_memcmp:
TEST byte ptr [RDI + 0x7],0x80
MOV RAX,qword ptr [RSI + 0x4]
JNZ 0x0013af9d
TEST EAX,EAX
JS 0x0013afc3
ADD RDI,0x18
ADD RSI,0x18
MOVSXD RDX,EDX
JMP 0x0010e470
LAB_0013af9d:
TEST EAX,EAX
JS 0x0013afe8
TEST EDX,EDX
JLE 0x0013b008
MOV ECX,EDX
XOR EDX,EDX
LAB_0013afa9:
MOVZX EAX,word ptr [RDI + RDX*0x2 + 0x18]
MOVZX R8D,byte ptr [RSI + RDX*0x1 + 0x18]
SUB EAX,R8D
JNZ 0x0013b00a
INC RDX
CMP RCX,RDX
JNZ 0x0013afa9
JMP 0x0013b008
LAB_0013afc3:
TEST EDX,EDX
JLE 0x0013afe3
MOV ECX,EDX
XOR EDX,EDX
LAB_0013afcb:
MOVZX EAX,word ptr [RSI + RDX*0x2 + 0x18]
MOVZX R8D,byte ptr [RDI + RDX*0x1 + 0x18]
SUB EAX,R8D
JNZ 0x0013afe5
INC RDX
CMP RCX,RDX
JNZ 0x0013afcb
LAB_0013afe3:
XOR EAX,EAX
LAB_0013afe5:
NEG EAX
RET
LAB_0013afe8:
TEST EDX,EDX
JLE 0x0013b008
MOV ECX,EDX
XOR EDX,EDX
LAB_0013aff0:
MOVZX EAX,word ptr [RDI + RDX*0x2 + 0x18]
MOVZX R8D,word ptr [RSI + RDX*0x2 + 0x18]
SUB EAX,R8D
JNZ 0x0013b00a
INC RDX
CMP RCX,RDX
JNZ 0x0013aff0
LAB_0013b008:
XOR EAX,EAX
LAB_0013b00a:
RET
|
int js_string_memcmp(long param_1,long param_2,uint param_3)
{
int iVar1;
ulong uVar2;
iVar1 = (int)*(int8 *)(param_2 + 4);
if ((*(byte *)(param_1 + 7) & 0x80) != 0) {
if (iVar1 < 0) {
if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_1 + 0x18 + uVar2 * 2) -
(uint)*(ushort *)(param_2 + 0x18 + uVar2 * 2);
if (iVar1 != 0) {
return iVar1;
}
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
}
else if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_1 + 0x18 + uVar2 * 2) -
(uint)*(byte *)(param_2 + 0x18 + uVar2);
if (iVar1 != 0) {
return iVar1;
}
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
return 0;
}
if (-1 < iVar1) {
iVar1 = memcmp((void *)(param_1 + 0x18),(void *)(param_2 + 0x18),(long)(int)param_3);
return iVar1;
}
if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_2 + 0x18 + uVar2 * 2) -
(uint)*(byte *)(param_1 + 0x18 + uVar2);
if (iVar1 != 0) goto LAB_0013afe5;
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
iVar1 = 0;
LAB_0013afe5:
return -iVar1;
}
| |
34,916 | js_string_memcmp | bluesky950520[P]quickjs/quickjs.c | static int js_string_memcmp(const JSString *p1, const JSString *p2, int len)
{
int res;
if (likely(!p1->is_wide_char)) {
if (likely(!p2->is_wide_char))
res = memcmp(p1->u.str8, p2->u.str8, len);
else
res = -memcmp16_8(p2->u.str16, p1->u.str8, len);
} else {
if (!p2->is_wide_char)
res = memcmp16_8(p1->u.str16, p2->u.str8, len);
else
res = memcmp16(p1->u.str16, p2->u.str16, len);
}
return res;
} | O2 | c | js_string_memcmp:
movq %rdi, %rcx
testb $-0x80, 0x7(%rdi)
movq 0x4(%rsi), %rax
jne 0x33e40
testl %eax, %eax
js 0x33e51
addq $0x18, %rcx
addq $0x18, %rsi
movslq %edx, %rdx
movq %rcx, %rdi
jmp 0xe480
addq $0x18, %rcx
addq $0x18, %rsi
testl %eax, %eax
js 0x33e6c
movq %rcx, %rdi
jmp 0x33e8d
pushq %rax
addq $0x18, %rsi
addq $0x18, %rcx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x33e8d
negl %eax
addq $0x8, %rsp
retq
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
cmpq %rdi, %rdx
je 0x33e8a
movzwl (%rcx,%rdi,2), %eax
movzwl (%rsi,%rdi,2), %r8d
incq %rdi
subl %r8d, %eax
je 0x33e73
retq
xorl %eax, %eax
retq
| js_string_memcmp:
mov rcx, rdi
test byte ptr [rdi+7], 80h
mov rax, [rsi+4]
jnz short loc_33E40
test eax, eax
js short loc_33E51
add rcx, 18h
add rsi, 18h
movsxd rdx, edx
mov rdi, rcx
jmp _memcmp
loc_33E40:
add rcx, 18h
add rsi, 18h
test eax, eax
js short loc_33E6C
mov rdi, rcx
jmp short memcmp16_8
loc_33E51:
push rax
add rsi, 18h
add rcx, 18h
mov rdi, rsi
mov rsi, rcx
call memcmp16_8
neg eax
add rsp, 8
retn
loc_33E6C:
xor edi, edi
test edx, edx
cmovle edx, edi
loc_33E73:
cmp rdx, rdi
jz short loc_33E8A
movzx eax, word ptr [rcx+rdi*2]
movzx r8d, word ptr [rsi+rdi*2]
inc rdi
sub eax, r8d
jz short loc_33E73
retn
loc_33E8A:
xor eax, eax
retn
| long long js_string_memcmp(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long result; // rax
long long v5; // rcx
long long v6; // rsi
long long v7; // rdi
int v8; // eax
int v9; // r8d
v3 = *(_QWORD *)(a2 + 4);
if ( *(char *)(a1 + 7) < 0 )
{
v5 = a1 + 24;
v6 = a2 + 24;
if ( (int)v3 < 0 )
{
v7 = 0LL;
if ( (int)a3 <= 0 )
a3 = 0LL;
while ( a3 != v7 )
{
v8 = *(unsigned __int16 *)(v5 + 2 * v7);
v9 = *(unsigned __int16 *)(v6 + 2 * v7++);
result = (unsigned int)(v8 - v9);
if ( (_DWORD)result )
return result;
}
return 0LL;
}
else
{
return memcmp16_8(v5, v6);
}
}
else if ( (int)v3 < 0 )
{
return (unsigned int)-memcmp16_8(a2 + 24, a1 + 24);
}
else
{
return memcmp(a1 + 24, a2 + 24, (int)a3);
}
}
| js_string_memcmp:
MOV RCX,RDI
TEST byte ptr [RDI + 0x7],0x80
MOV RAX,qword ptr [RSI + 0x4]
JNZ 0x00133e40
TEST EAX,EAX
JS 0x00133e51
ADD RCX,0x18
ADD RSI,0x18
MOVSXD RDX,EDX
MOV RDI,RCX
JMP 0x0010e480
LAB_00133e40:
ADD RCX,0x18
ADD RSI,0x18
TEST EAX,EAX
JS 0x00133e6c
MOV RDI,RCX
JMP 0x00133e8d
LAB_00133e51:
PUSH RAX
ADD RSI,0x18
ADD RCX,0x18
MOV RDI,RSI
MOV RSI,RCX
CALL 0x00133e8d
NEG EAX
ADD RSP,0x8
RET
LAB_00133e6c:
XOR EDI,EDI
TEST EDX,EDX
CMOVLE EDX,EDI
LAB_00133e73:
CMP RDX,RDI
JZ 0x00133e8a
MOVZX EAX,word ptr [RCX + RDI*0x2]
MOVZX R8D,word ptr [RSI + RDI*0x2]
INC RDI
SUB EAX,R8D
JZ 0x00133e73
RET
LAB_00133e8a:
XOR EAX,EAX
RET
|
int js_string_memcmp(long param_1,long param_2,uint param_3)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
iVar3 = (int)*(int8 *)(param_2 + 4);
if ((*(byte *)(param_1 + 7) & 0x80) != 0) {
if (-1 < iVar3) {
iVar3 = memcmp16_8(param_1 + 0x18);
return iVar3;
}
uVar5 = 0;
uVar4 = (ulong)param_3;
if ((int)param_3 < 1) {
uVar4 = uVar5;
}
do {
if (uVar4 == uVar5) {
return 0;
}
lVar1 = uVar5 * 2;
lVar2 = uVar5 * 2;
uVar5 = uVar5 + 1;
iVar3 = (uint)*(ushort *)(param_1 + 0x18 + lVar1) - (uint)*(ushort *)(param_2 + 0x18 + lVar2);
} while (iVar3 == 0);
return iVar3;
}
if (-1 < iVar3) {
iVar3 = memcmp((void *)(param_1 + 0x18),(void *)(param_2 + 0x18),(long)(int)param_3);
return iVar3;
}
iVar3 = memcmp16_8(param_2 + 0x18,param_1 + 0x18);
return -iVar3;
}
| |
34,917 | js_string_memcmp | bluesky950520[P]quickjs/quickjs.c | static int js_string_memcmp(const JSString *p1, const JSString *p2, int len)
{
int res;
if (likely(!p1->is_wide_char)) {
if (likely(!p2->is_wide_char))
res = memcmp(p1->u.str8, p2->u.str8, len);
else
res = -memcmp16_8(p2->u.str16, p1->u.str8, len);
} else {
if (!p2->is_wide_char)
res = memcmp16_8(p1->u.str16, p2->u.str8, len);
else
res = memcmp16(p1->u.str16, p2->u.str16, len);
}
return res;
} | O3 | c | js_string_memcmp:
testb $-0x80, 0x7(%rdi)
movq 0x4(%rsi), %rax
jne 0x3c632
testl %eax, %eax
js 0x3c658
addq $0x18, %rdi
addq $0x18, %rsi
movslq %edx, %rdx
jmp 0xe470
testl %eax, %eax
js 0x3c67d
testl %edx, %edx
jle 0x3c69d
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rdi,%rdx,2), %eax
movzbl 0x18(%rsi,%rdx), %r8d
subl %r8d, %eax
jne 0x3c69f
incq %rdx
cmpq %rdx, %rcx
jne 0x3c63e
jmp 0x3c69d
testl %edx, %edx
jle 0x3c678
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rsi,%rdx,2), %eax
movzbl 0x18(%rdi,%rdx), %r8d
subl %r8d, %eax
jne 0x3c67a
incq %rdx
cmpq %rdx, %rcx
jne 0x3c660
xorl %eax, %eax
negl %eax
retq
testl %edx, %edx
jle 0x3c69d
movl %edx, %ecx
xorl %edx, %edx
movzwl 0x18(%rdi,%rdx,2), %eax
movzwl 0x18(%rsi,%rdx,2), %r8d
subl %r8d, %eax
jne 0x3c69f
incq %rdx
cmpq %rdx, %rcx
jne 0x3c685
xorl %eax, %eax
retq
| js_string_memcmp:
test byte ptr [rdi+7], 80h
mov rax, [rsi+4]
jnz short loc_3C632
test eax, eax
js short loc_3C658
add rdi, 18h
add rsi, 18h
movsxd rdx, edx
jmp _memcmp
loc_3C632:
test eax, eax
js short loc_3C67D
test edx, edx
jle short loc_3C69D
mov ecx, edx
xor edx, edx
loc_3C63E:
movzx eax, word ptr [rdi+rdx*2+18h]
movzx r8d, byte ptr [rsi+rdx+18h]
sub eax, r8d
jnz short locret_3C69F
inc rdx
cmp rcx, rdx
jnz short loc_3C63E
jmp short loc_3C69D
loc_3C658:
test edx, edx
jle short loc_3C678
mov ecx, edx
xor edx, edx
loc_3C660:
movzx eax, word ptr [rsi+rdx*2+18h]
movzx r8d, byte ptr [rdi+rdx+18h]
sub eax, r8d
jnz short loc_3C67A
inc rdx
cmp rcx, rdx
jnz short loc_3C660
loc_3C678:
xor eax, eax
loc_3C67A:
neg eax
retn
loc_3C67D:
test edx, edx
jle short loc_3C69D
mov ecx, edx
xor edx, edx
loc_3C685:
movzx eax, word ptr [rdi+rdx*2+18h]
movzx r8d, word ptr [rsi+rdx*2+18h]
sub eax, r8d
jnz short locret_3C69F
inc rdx
cmp rcx, rdx
jnz short loc_3C685
loc_3C69D:
xor eax, eax
locret_3C69F:
retn
| long long js_string_memcmp(long long a1, long long a2, int a3)
{
long long v3; // rax
long long result; // rax
long long v5; // rcx
long long v6; // rdx
long long v7; // rcx
long long v8; // rdx
int v9; // eax
long long v10; // rcx
long long v11; // rdx
v3 = *(_QWORD *)(a2 + 4);
if ( *(char *)(a1 + 7) >= 0 )
{
if ( (int)v3 >= 0 )
return memcmp(a1 + 24, a2 + 24, a3);
if ( a3 <= 0 )
{
LABEL_14:
v9 = 0;
}
else
{
v7 = (unsigned int)a3;
v8 = 0LL;
while ( 1 )
{
v9 = *(unsigned __int16 *)(a2 + 2 * v8 + 24) - *(unsigned __int8 *)(a1 + v8 + 24);
if ( v9 )
break;
if ( v7 == ++v8 )
goto LABEL_14;
}
}
return (unsigned int)-v9;
}
if ( (int)v3 >= 0 )
{
if ( a3 > 0 )
{
v5 = (unsigned int)a3;
v6 = 0LL;
while ( 1 )
{
result = *(unsigned __int16 *)(a1 + 2 * v6 + 24) - (unsigned int)*(unsigned __int8 *)(a2 + v6 + 24);
if ( (_DWORD)result )
break;
if ( v5 == ++v6 )
return 0LL;
}
return result;
}
return 0LL;
}
if ( a3 <= 0 )
return 0LL;
v10 = (unsigned int)a3;
v11 = 0LL;
while ( 1 )
{
result = *(unsigned __int16 *)(a1 + 2 * v11 + 24) - (unsigned int)*(unsigned __int16 *)(a2 + 2 * v11 + 24);
if ( (_DWORD)result )
break;
if ( v10 == ++v11 )
return 0LL;
}
return result;
}
| js_string_memcmp:
TEST byte ptr [RDI + 0x7],0x80
MOV RAX,qword ptr [RSI + 0x4]
JNZ 0x0013c632
TEST EAX,EAX
JS 0x0013c658
ADD RDI,0x18
ADD RSI,0x18
MOVSXD RDX,EDX
JMP 0x0010e470
LAB_0013c632:
TEST EAX,EAX
JS 0x0013c67d
TEST EDX,EDX
JLE 0x0013c69d
MOV ECX,EDX
XOR EDX,EDX
LAB_0013c63e:
MOVZX EAX,word ptr [RDI + RDX*0x2 + 0x18]
MOVZX R8D,byte ptr [RSI + RDX*0x1 + 0x18]
SUB EAX,R8D
JNZ 0x0013c69f
INC RDX
CMP RCX,RDX
JNZ 0x0013c63e
JMP 0x0013c69d
LAB_0013c658:
TEST EDX,EDX
JLE 0x0013c678
MOV ECX,EDX
XOR EDX,EDX
LAB_0013c660:
MOVZX EAX,word ptr [RSI + RDX*0x2 + 0x18]
MOVZX R8D,byte ptr [RDI + RDX*0x1 + 0x18]
SUB EAX,R8D
JNZ 0x0013c67a
INC RDX
CMP RCX,RDX
JNZ 0x0013c660
LAB_0013c678:
XOR EAX,EAX
LAB_0013c67a:
NEG EAX
RET
LAB_0013c67d:
TEST EDX,EDX
JLE 0x0013c69d
MOV ECX,EDX
XOR EDX,EDX
LAB_0013c685:
MOVZX EAX,word ptr [RDI + RDX*0x2 + 0x18]
MOVZX R8D,word ptr [RSI + RDX*0x2 + 0x18]
SUB EAX,R8D
JNZ 0x0013c69f
INC RDX
CMP RCX,RDX
JNZ 0x0013c685
LAB_0013c69d:
XOR EAX,EAX
LAB_0013c69f:
RET
|
int js_string_memcmp(long param_1,long param_2,uint param_3)
{
int iVar1;
ulong uVar2;
iVar1 = (int)*(int8 *)(param_2 + 4);
if ((*(byte *)(param_1 + 7) & 0x80) != 0) {
if (iVar1 < 0) {
if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_1 + 0x18 + uVar2 * 2) -
(uint)*(ushort *)(param_2 + 0x18 + uVar2 * 2);
if (iVar1 != 0) {
return iVar1;
}
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
}
else if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_1 + 0x18 + uVar2 * 2) -
(uint)*(byte *)(param_2 + 0x18 + uVar2);
if (iVar1 != 0) {
return iVar1;
}
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
return 0;
}
if (-1 < iVar1) {
iVar1 = memcmp((void *)(param_1 + 0x18),(void *)(param_2 + 0x18),(long)(int)param_3);
return iVar1;
}
if (0 < (int)param_3) {
uVar2 = 0;
do {
iVar1 = (uint)*(ushort *)(param_2 + 0x18 + uVar2 * 2) -
(uint)*(byte *)(param_1 + 0x18 + uVar2);
if (iVar1 != 0) goto LAB_0013c67a;
uVar2 = uVar2 + 1;
} while (param_3 != uVar2);
}
iVar1 = 0;
LAB_0013c67a:
return -iVar1;
}
| |
34,918 | stbi__refill_buffer(stbi__context*) | llama.cpp/examples/llava/../../common/stb_image.h | static void stbi__refill_buffer(stbi__context *s)
{
int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
if (n == 0) {
// at end of file, treat same as if from memory, but need to handle case
// where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
s->read_from_callbacks = 0;
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start+1;
*s->img_buffer = 0;
} else {
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start + n;
}
} | O3 | c | stbi__refill_buffer(stbi__context*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq *0x10(%rbx)
movl 0xc0(%rbx), %ecx
subl 0xd0(%rbx), %ecx
addl %ecx, 0xb8(%rbx)
testl %eax, %eax
je 0x2f0de
cltq
addq %r14, %rax
jmp 0x2f0ed
movl $0x0, 0x30(%rbx)
leaq 0x39(%rbx), %rax
movb $0x0, 0x38(%rbx)
movq %r14, 0xc0(%rbx)
movq %rax, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZL19stbi__refill_bufferP13stbi__context:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+28h]
lea r14, [rbx+38h]
mov edx, [rbx+34h]
mov rsi, r14
call qword ptr [rbx+10h]
mov ecx, [rbx+0C0h]
sub ecx, [rbx+0D0h]
add [rbx+0B8h], ecx
test eax, eax
jz short loc_2F0DE
cdqe
add rax, r14
jmp short loc_2F0ED
loc_2F0DE:
mov dword ptr [rbx+30h], 0
lea rax, [rbx+39h]
mov byte ptr [rbx+38h], 0
loc_2F0ED:
mov [rbx+0C0h], r14
mov [rbx+0C8h], rax
add rsp, 8
pop rbx
pop r14
retn
| long long stbi__refill_buffer(long long a1)
{
long long v1; // r14
int v2; // eax
long long result; // rax
v1 = a1 + 56;
v2 = (*(long long ( **)(_QWORD, long long, _QWORD))(a1 + 16))(
*(_QWORD *)(a1 + 40),
a1 + 56,
*(unsigned int *)(a1 + 52));
*(_DWORD *)(a1 + 184) += *(_DWORD *)(a1 + 192) - *(_DWORD *)(a1 + 208);
if ( v2 )
{
result = v1 + v2;
}
else
{
*(_DWORD *)(a1 + 48) = 0;
result = a1 + 57;
*(_BYTE *)(a1 + 56) = 0;
}
*(_QWORD *)(a1 + 192) = v1;
*(_QWORD *)(a1 + 200) = result;
return result;
}
| stbi__refill_buffer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x28]
LEA R14,[RBX + 0x38]
MOV EDX,dword ptr [RBX + 0x34]
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RBX + 0xc0]
SUB ECX,dword ptr [RBX + 0xd0]
ADD dword ptr [RBX + 0xb8],ECX
TEST EAX,EAX
JZ 0x0012f0de
CDQE
ADD RAX,R14
JMP 0x0012f0ed
LAB_0012f0de:
MOV dword ptr [RBX + 0x30],0x0
LEA RAX,[RBX + 0x39]
MOV byte ptr [RBX + 0x38],0x0
LAB_0012f0ed:
MOV qword ptr [RBX + 0xc0],R14
MOV qword ptr [RBX + 0xc8],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* stbi__refill_buffer(stbi__context*) */
void stbi__refill_buffer(stbi__context *param_1)
{
stbi__context *psVar1;
int iVar2;
stbi__context *psVar3;
psVar1 = param_1 + 0x38;
iVar2 = (**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x28),psVar1,*(int4 *)(param_1 + 0x34));
*(int *)(param_1 + 0xb8) =
*(int *)(param_1 + 0xb8) + (*(int *)(param_1 + 0xc0) - *(int *)(param_1 + 0xd0));
if (iVar2 == 0) {
*(int4 *)(param_1 + 0x30) = 0;
psVar3 = param_1 + 0x39;
param_1[0x38] = (stbi__context)0x0;
}
else {
psVar3 = psVar1 + iVar2;
}
*(stbi__context **)(param_1 + 0xc0) = psVar1;
*(stbi__context **)(param_1 + 200) = psVar3;
return;
}
| |
34,919 | my_thread_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_init(void)
{
struct st_my_thread_var *tmp;
my_bool error=0;
if (!my_thread_global_init_done)
return 1; /* cannot proceed with uninitialized library */
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init(): pthread_self: %p\n", pthread_self());
#endif
if (my_thread_var)
{
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
(long) pthread_self());
#endif
goto end;
}
#ifdef _MSC_VER
install_sigabrt_handler();
#endif
if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
{
error= 1;
goto end;
}
set_mysys_var(tmp);
tmp->pthread_self= pthread_self();
my_thread_init_thr_mutex(tmp);
tmp->stack_ends_here= (char*)&tmp +
STACK_DIRECTION * (long)my_thread_stack_size;
mysql_mutex_lock(&THR_LOCK_threads);
tmp->id= tmp->dbug_id= ++thread_id;
++THR_thread_count;
mysql_mutex_unlock(&THR_LOCK_threads);
tmp->init= 1;
#ifndef DBUG_OFF
/* Generate unique name for thread */
(void) my_thread_name();
#endif
end:
return error;
} | O0 | c | my_thread_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x11(%rbp)
cmpb $0x0, 0x3769dd(%rip) # 0x3f8e90
jne 0x824be
movb $0x1, -0x1(%rbp)
jmp 0x825a7
callq 0x82360
cmpq $0x0, %rax
je 0x824ce
jmp 0x825a1
movl $0x1, %edi
movl $0xf0, %esi
callq 0x28240
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x824f0
movb $0x1, -0x11(%rbp)
jmp 0x825a1
movq -0x10(%rbp), %rdi
callq 0x82810
callq 0x282f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x10(%rbp), %rdi
callq 0x823b0
leaq 0x1b6244(%rip), %rax # 0x238760
movq (%rax), %rax
shlq $0x0, %rax
leaq -0x10(%rbp), %rcx
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
leaq 0x37688c(%rip), %rdi # 0x3f8dc8
leaq 0x57a9e(%rip), %rsi # 0xd9fe1
movl $0x12e, %edx # imm = 0x12E
callq 0x826c0
movq 0x376944(%rip), %rcx # 0x3f8e98
addq $0x1, %rcx
movq %rcx, 0x376939(%rip) # 0x3f8e98
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
leaq 0x37664c(%rip), %rax # 0x3f8bc8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x376640(%rip), %rax # 0x3f8bc8
movl %ecx, (%rax)
leaq 0x376837(%rip), %rdi # 0x3f8dc8
callq 0x827b0
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| my_thread_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_11], 0
cmp cs:my_thread_global_init_done, 0
jnz short loc_824BE
mov [rbp+var_1], 1
jmp loc_825A7
loc_824BE:
call _my_thread_var
cmp rax, 0
jz short loc_824CE
jmp loc_825A1
loc_824CE:
mov edi, 1
mov esi, 0F0h
call _calloc
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_824F0
mov [rbp+var_11], 1
jmp loc_825A1
loc_824F0:
mov rdi, [rbp+var_10]
call set_mysys_var
call _pthread_self
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+0C8h], rcx
mov rdi, [rbp+var_10]
call my_thread_init_thr_mutex
lea rax, my_thread_stack_size
mov rax, [rax]
shl rax, 0
lea rcx, [rbp+var_10]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+0B8h], rcx
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12Eh
call inline_mysql_mutex_lock_10
mov rcx, cs:thread_id
add rcx, 1
mov cs:thread_id, rcx
mov rax, [rbp+var_10]
mov [rax+0D8h], rcx
mov rax, [rbp+var_10]
mov [rax+0D0h], rcx
lea rax, THR_thread_count
mov ecx, [rax]
add ecx, 1
lea rax, THR_thread_count
mov [rax], ecx
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock_10
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
loc_825A1:
mov al, [rbp+var_11]
mov [rbp+var_1], al
loc_825A7:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_thread_init(long long a1, const char *a2)
{
long long v2; // rcx
char v4; // [rsp+Fh] [rbp-11h]
long long v5; // [rsp+10h] [rbp-10h] BYREF
v4 = 0;
if ( !my_thread_global_init_done )
return 1;
if ( !my_thread_var(a1, a2) )
{
v5 = calloc(1LL, 240LL);
if ( v5 )
{
set_mysys_var(v5);
*(_QWORD *)(v5 + 200) = pthread_self();
my_thread_init_thr_mutex(v5);
*(_QWORD *)(v5 + 184) = (char *)&v5 + (_QWORD)my_thread_stack_size;
inline_mysql_mutex_lock_10(
&THR_LOCK_threads,
"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
302LL);
v2 = thread_id + 1;
thread_id = v2;
*(_QWORD *)(v5 + 216) = v2;
*(_QWORD *)(v5 + 208) = v2;
++THR_thread_count;
inline_mysql_mutex_unlock_10(&THR_LOCK_threads);
*(_BYTE *)(v5 + 232) = 1;
}
else
{
return 1;
}
}
return v4;
}
| my_thread_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV byte ptr [RBP + -0x11],0x0
CMP byte ptr [0x004f8e90],0x0
JNZ 0x001824be
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001825a7
LAB_001824be:
CALL 0x00182360
CMP RAX,0x0
JZ 0x001824ce
JMP 0x001825a1
LAB_001824ce:
MOV EDI,0x1
MOV ESI,0xf0
CALL 0x00128240
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x001824f0
MOV byte ptr [RBP + -0x11],0x1
JMP 0x001825a1
LAB_001824f0:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00182810
CALL 0x001282f0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001823b0
LEA RAX,[0x338760]
MOV RAX,qword ptr [RAX]
SHL RAX,0x0
LEA RCX,[RBP + -0x10]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xb8],RCX
LEA RDI,[0x4f8dc8]
LEA RSI,[0x1d9fe1]
MOV EDX,0x12e
CALL 0x001826c0
MOV RCX,qword ptr [0x004f8e98]
ADD RCX,0x1
MOV qword ptr [0x004f8e98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd0],RCX
LEA RAX,[0x4f8bc8]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x4f8bc8]
MOV dword ptr [RAX],ECX
LEA RDI,[0x4f8dc8]
CALL 0x001827b0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
LAB_001825a1:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
LAB_001825a7:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_thread_init(void)
{
long lVar1;
pthread_t pVar2;
int1 local_19;
void *local_18;
int1 local_9;
local_19 = 0;
if (my_thread_global_init_done == '\0') {
local_9 = 1;
}
else {
lVar1 = _my_thread_var();
if (lVar1 == 0) {
local_18 = calloc(1,0xf0);
if (local_18 == (void *)0x0) {
local_19 = 1;
}
else {
set_mysys_var(local_18);
pVar2 = pthread_self();
*(pthread_t *)((long)local_18 + 200) = pVar2;
my_thread_init_thr_mutex(local_18);
*(long *)((long)local_18 + 0xb8) = (long)&local_18 + my_thread_stack_size;
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x12e);
lVar1 = thread_id + 1;
thread_id = lVar1;
*(long *)((long)local_18 + 0xd8) = lVar1;
*(long *)((long)local_18 + 0xd0) = lVar1;
THR_thread_count = THR_thread_count + 1;
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)local_18 + 0xe8) = 1;
}
}
local_9 = local_19;
}
return local_9;
}
| |
34,920 | GL_MeshingTask::process() | untodesu[P]voxelius/game/client/chunk_mesher.cc | void GL_MeshingTask::process(void)
{
m_quads_b.resize(voxel_atlas::plane_count());
m_quads_s.resize(voxel_atlas::plane_count());
const auto &voxels = m_cache.at(CPOS_ITSELF);
for(std::size_t i = 0; i < CHUNK_VOLUME; ++i) {
if(m_status == task_status::CANCELLED) {
m_quads_b.clear();
m_quads_s.clear();
return;
}
const auto voxel = voxels[i];
const auto lpos = coord::to_local(i);
const auto info = voxel_registry::find(voxel);
if(info == nullptr) {
// Either a NULL_VOXEL_ID or something went
// horribly wrong and we don't what this is
continue;
}
voxel_vis vis = 0;
if(vis_test(voxel, info, lpos + DIR_NORTH<local_pos::value_type>))
vis |= VIS_NORTH;
if(vis_test(voxel, info, lpos + DIR_SOUTH<local_pos::value_type>))
vis |= VIS_SOUTH;
if(vis_test(voxel, info, lpos + DIR_EAST<local_pos::value_type>))
vis |= VIS_EAST;
if(vis_test(voxel, info, lpos + DIR_WEST<local_pos::value_type>))
vis |= VIS_WEST;
if(vis_test(voxel, info, lpos + DIR_UP<local_pos::value_type>))
vis |= VIS_UP;
if(vis_test(voxel, info, lpos + DIR_DOWN<local_pos::value_type>))
vis |= VIS_DOWN;
const auto vpos = coord::to_voxel(m_cpos, lpos);
const auto entropy_src = vpos[0] * vpos[1] * vpos[2];
const auto entropy = crc64::get(&entropy_src, sizeof(entropy_src));
// FIXME: handle different voxel types
make_cube(voxel, info, lpos, vis, entropy);
}
} | O3 | cpp | GL_MeshingTask::process():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq 0xe020(%rdi), %rbx
callq 0x714e8
movq %rbx, 0x50(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3af96
movq %r14, %rbp
leaq 0xe038(%r14), %rbx
callq 0x714e8
movq %rbx, 0x48(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3af96
xorl %r15d, %r15d
movq %r14, 0x20(%rsp)
movl 0x8(%rbp), %eax
cmpl $0x4, %eax
je 0x39f74
movzwl 0x20(%rbp,%r15,2), %eax
movl %r15d, %r14d
andl $0xf, %r14d
movl %r15d, %r13d
shrl $0x4, %r13d
andl $0xf, %r13d
movq %r13, %rcx
shlq $0x20, %rcx
movl %r15d, %r12d
shll $0x8, %r12d
andl $0xf0000, %r12d # imm = 0xF0000
addq %r14, %rcx
orq %r12, %rcx
movw %r13w, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movzwl %ax, %ebx
movl %ebx, %edi
callq 0x839aa
testq %rax, %rax
je 0x39f62
movq %rax, %rcx
movl %r12d, %eax
shrl $0x10, %eax
movq %rax, 0x60(%rsp)
movzwl %r13w, %edx
leal 0x1(%rdx), %eax
movl %ebx, %esi
movq %rdx, %rbx
movq %rdx, 0x40(%rsp)
movw %ax, 0xc(%rsp)
shlq $0x20, %rax
orq %r12, %rax
movzwl %r14w, %edx
movq %rdx, 0x28(%rsp)
orq %rdx, %rax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movl %esi, %r14d
movl %esi, 0x14(%rsp)
movq %rcx, 0x30(%rsp)
movq %rcx, %rdx
leaq 0x8(%rsp), %rcx
callq 0x39f9e
movb %al, 0x18(%rsp)
leal -0x1(%rbx), %eax
movw %ax, 0xc(%rsp)
shlq $0x20, %rax
orq %r12, %rax
movq 0x28(%rsp), %rbx
orq %rbx, %rax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movl %r14d, %esi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x39f9e
movzbl 0x18(%rsp), %ecx
leal 0x2(%rcx), %r14d
testb %al, %al
cmovel %ecx, %r14d
leal -0x1(%rbx), %eax
movq 0x40(%rsp), %rcx
shlq $0x20, %rcx
movq %rcx, 0x18(%rsp)
movq %r12, %rbx
orq %rcx, %rbx
movl $0xffff, %ecx # imm = 0xFFFF
andl %ecx, %eax
orq %rbx, %rax
movw %r13w, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movq %r15, 0x58(%rsp)
movl 0x14(%rsp), %r15d
movl %r15d, %esi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x39f9e
leal 0x4(%r14), %ebp
testb %al, %al
cmovel %r14d, %ebp
movq 0x28(%rsp), %rax
incl %eax
orq %rbx, %rax
movw %r13w, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl %r15d, %esi
movq 0x58(%rsp), %r15
movq 0x30(%rsp), %r14
movq %r14, %rdx
leaq 0x8(%rsp), %rcx
callq 0x39f9e
leal 0x8(%rbp), %ebx
testb %al, %al
cmovel %ebp, %ebx
andl $0xf0000, %r12d # imm = 0xF0000
leal 0x10000(%r12), %eax
addq 0x18(%rsp), %rax
addq 0x28(%rsp), %rax
movw %r13w, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %r14, %rdx
leaq 0x8(%rsp), %rcx
callq 0x39f9e
movl %ebx, %ebp
orl $0x10, %ebp
testb %al, %al
cmovel %ebx, %ebp
addl $0xffff0000, %r12d # imm = 0xFFFF0000
addq 0x18(%rsp), %r12
addq 0x28(%rsp), %r12
movw %r13w, 0xc(%rsp)
movl %r12d, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %r14, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rcx
callq 0x39f9e
movl %ebp, %ebx
orl $0x20, %ebx
testb %al, %al
cmovel %ebp, %ebx
movq 0x20(%rsp), %r13
movl %r15d, %eax
andl $0xf, %eax
movslq 0xe054(%r13), %rcx
shlq $0x4, %rcx
orq %rax, %rcx
movslq 0xe058(%r13), %rax
shlq $0x4, %rax
addq 0x60(%rsp), %rax
imulq %rcx, %rax
movslq 0xe05c(%r13), %rcx
shlq $0x4, %rcx
addq 0x40(%rsp), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%rsp)
movl $0x8, %esi
movq %r12, %rdi
xorl %edx, %edx
callq 0x12eb90
movl $0xffff, %ecx # imm = 0xFFFF
andl %ecx, %ebx
movq %r13, %rbp
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
leaq 0x38(%rsp), %rcx
movl %ebx, %r8d
movq %rax, %r9
callq 0x3a08e
incq %r15
cmpq $0x1000, %r15 # imm = 0x1000
jne 0x39ce4
jmp 0x39f8e
movq 0x50(%rsp), %rdi
movq (%rdi), %rsi
callq 0x3d2d2
movq 0x48(%rsp), %rdi
movq (%rdi), %rsi
callq 0x3d2d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN14GL_MeshingTask7processEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdi
lea rbx, [rdi+0E020h]
call _ZN11voxel_atlas11plane_countEv; voxel_atlas::plane_count(void)
mov [rsp+98h+var_48], rbx
mov rdi, rbx; this
mov rsi, rax
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE6resizeEm; std::vector<std::vector<std::array<uint,2ul>>>::resize(ulong)
mov rbp, r14
lea rbx, [r14+0E038h]
call _ZN11voxel_atlas11plane_countEv; voxel_atlas::plane_count(void)
mov [rsp+98h+var_50], rbx
mov rdi, rbx
mov rsi, rax; unsigned __int16
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE6resizeEm; std::vector<std::vector<std::array<uint,2ul>>>::resize(ulong)
xor r15d, r15d
mov [rsp+98h+var_78], r14
loc_39CE4:
mov eax, [rbp+8]
cmp eax, 4
jz loc_39F74
movzx eax, word ptr [rbp+r15*2+20h]
mov r14d, r15d
and r14d, 0Fh
mov r13d, r15d
shr r13d, 4
and r13d, 0Fh
mov rcx, r13
shl rcx, 20h
mov r12d, r15d
shl r12d, 8
and r12d, 0F0000h
add rcx, r14
or rcx, r12
mov [rsp+98h+var_5C], r13w
mov [rsp+98h+var_60], ecx
movzx ebx, ax
mov edi, ebx; this
call _ZN14voxel_registry4findEt; voxel_registry::find(ushort)
test rax, rax
jz loc_39F62
mov rcx, rax
mov eax, r12d
shr eax, 10h
mov [rsp+98h+var_38], rax
movzx edx, r13w
lea eax, [rdx+1]
mov esi, ebx
mov rbx, rdx
mov [rsp+98h+var_58], rdx
mov word ptr [rsp+98h+var_90+4], ax
shl rax, 20h
or rax, r12
movzx edx, r14w
mov [rsp+98h+var_70], rdx
or rax, rdx
mov dword ptr [rsp+98h+var_90], eax
mov rdi, rbp
mov r14d, esi
mov [rsp+98h+var_84], esi
mov [rsp+98h+var_68], rcx
mov rdx, rcx
lea rcx, [rsp+98h+var_90]
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
mov byte ptr [rsp+98h+var_80], al
lea eax, [rbx-1]
mov word ptr [rsp+98h+var_90+4], ax
shl rax, 20h
or rax, r12
mov rbx, [rsp+98h+var_70]
or rax, rbx
mov dword ptr [rsp+98h+var_90], eax
mov rdi, rbp
mov esi, r14d
mov rdx, [rsp+98h+var_68]
lea rcx, [rsp+98h+var_90]
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
movzx ecx, byte ptr [rsp+98h+var_80]
lea r14d, [rcx+2]
test al, al
cmovz r14d, ecx
lea eax, [rbx-1]
mov rcx, [rsp+98h+var_58]
shl rcx, 20h
mov [rsp+98h+var_80], rcx
mov rbx, r12
or rbx, rcx
mov ecx, 0FFFFh
and eax, ecx
or rax, rbx
mov word ptr [rsp+98h+var_90+4], r13w
mov dword ptr [rsp+98h+var_90], eax
mov rdi, rbp
mov [rsp+98h+var_40], r15
mov r15d, [rsp+98h+var_84]
mov esi, r15d
mov rdx, [rsp+98h+var_68]
lea rcx, [rsp+98h+var_90]
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
lea ebp, [r14+4]
test al, al
cmovz ebp, r14d
mov rax, [rsp+98h+var_70]
inc eax
or rax, rbx
mov word ptr [rsp+98h+var_90+4], r13w
mov dword ptr [rsp+98h+var_90], eax
mov rdi, [rsp+98h+var_78]
mov esi, r15d
mov r15, [rsp+98h+var_40]
mov r14, [rsp+98h+var_68]
mov rdx, r14
lea rcx, [rsp+98h+var_90]
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
lea ebx, [rbp+8]
test al, al
cmovz ebx, ebp
and r12d, 0F0000h
lea eax, [r12+10000h]
add rax, [rsp+98h+var_80]
add rax, [rsp+98h+var_70]
mov word ptr [rsp+98h+var_90+4], r13w
mov dword ptr [rsp+98h+var_90], eax
mov rdi, [rsp+98h+var_78]
mov esi, [rsp+98h+var_84]
mov rdx, r14
lea rcx, [rsp+98h+var_90]
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
mov ebp, ebx
or ebp, 10h
test al, al
cmovz ebp, ebx
add r12d, 0FFFF0000h
add r12, [rsp+98h+var_80]
add r12, [rsp+98h+var_70]
mov word ptr [rsp+98h+var_90+4], r13w
mov dword ptr [rsp+98h+var_90], r12d
mov rdi, [rsp+98h+var_78]
mov esi, [rsp+98h+var_84]
mov rdx, r14
lea r12, [rsp+98h+var_90]
mov rcx, r12
call _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE; GL_MeshingTask::vis_test(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&)
mov ebx, ebp
or ebx, 20h
test al, al
cmovz ebx, ebp
mov r13, [rsp+98h+var_78]
mov eax, r15d
and eax, 0Fh
movsxd rcx, dword ptr [r13+0E054h]
shl rcx, 4
or rcx, rax
movsxd rax, dword ptr [r13+0E058h]
shl rax, 4
add rax, [rsp+98h+var_38]
imul rax, rcx
movsxd rcx, dword ptr [r13+0E05Ch]
shl rcx, 4
add rcx, [rsp+98h+var_58]
imul rcx, rax; unsigned __int64
mov [rsp+98h+var_90], rcx
mov esi, offset byte_8; void *
mov rdi, r12; this
xor edx, edx; unsigned __int64
call _ZN5crc643getEPKvmm; crc64::get(void const*,ulong,ulong)
mov ecx, 0FFFFh
and ebx, ecx
mov rbp, r13
mov rdi, r13
xor esi, esi
mov rdx, r14
lea rcx, [rsp+98h+var_60]
mov r8d, ebx
mov r9, rax
call _ZN14GL_MeshingTask9make_cubeEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEEtm; GL_MeshingTask::make_cube(ushort,VoxelInfo const*,glm::vec<3,short,(glm::qualifier)0> const&,ushort,ulong)
loc_39F62:
inc r15
cmp r15, 1000h
jnz loc_39CE4
jmp short loc_39F8E
loc_39F74:
mov rdi, [rsp+98h+var_48]
mov rsi, [rdi]
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE15_M_erase_at_endEPS3_; std::vector<std::vector<std::array<uint,2ul>>>::_M_erase_at_end(std::vector<std::array<uint,2ul>>*)
mov rdi, [rsp+98h+var_50]
mov rsi, [rdi]
call _ZNSt6vectorIS_ISt5arrayIjLm2EESaIS1_EESaIS3_EE15_M_erase_at_endEPS3_; std::vector<std::vector<std::array<uint,2ul>>>::_M_erase_at_end(std::vector<std::array<uint,2ul>>*)
loc_39F8E:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long GL_MeshingTask::process(GL_MeshingTask *this)
{
long long v2; // rax
voxel_atlas *v3; // rdi
GL_MeshingTask *v4; // rbp
long long v5; // rsi
long long v6; // r15
unsigned __int16 v7; // ax
__int16 v8; // r13
unsigned int v9; // r12d
unsigned int v10; // ebx
long long result; // rax
unsigned int v12; // esi
__int16 v13; // bx
char v14; // al
unsigned __int16 v15; // r14
unsigned int v16; // r15d
char v17; // al
unsigned __int16 v18; // bp
long long v19; // rsi
long long v20; // r14
unsigned __int16 v21; // bx
int v22; // r12d
unsigned __int16 v23; // bp
unsigned __int16 v24; // bx
int *v25; // r13
long long v26; // rax
unsigned long long v27; // [rsp+8h] [rbp-90h] BYREF
unsigned int v28; // [rsp+14h] [rbp-84h]
long long v29; // [rsp+18h] [rbp-80h]
int *v30; // [rsp+20h] [rbp-78h]
long long v31; // [rsp+28h] [rbp-70h]
long long v32; // [rsp+30h] [rbp-68h]
int v33; // [rsp+38h] [rbp-60h] BYREF
__int16 v34; // [rsp+3Ch] [rbp-5Ch]
long long v35; // [rsp+40h] [rbp-58h]
_QWORD *v36; // [rsp+48h] [rbp-50h]
_QWORD *v37; // [rsp+50h] [rbp-48h]
long long v38; // [rsp+58h] [rbp-40h]
long long v39; // [rsp+60h] [rbp-38h]
v2 = voxel_atlas::plane_count(this);
v37 = (_QWORD *)((char *)this + 57376);
v3 = (GL_MeshingTask *)((char *)this + 57376);
std::vector<std::vector<std::array<unsigned int,2ul>>>::resize(v3, v2);
v4 = this;
v36 = (_QWORD *)((char *)this + 57400);
v5 = voxel_atlas::plane_count(v3);
std::vector<std::vector<std::array<unsigned int,2ul>>>::resize((char *)this + 57400, v5);
v6 = 0LL;
v30 = (int *)this;
while ( *((_DWORD *)v4 + 2) != 4 )
{
v7 = *((_WORD *)v4 + v6 + 16);
v8 = (unsigned __int8)v6 >> 4;
v9 = ((_DWORD)v6 << 8) & 0xF0000;
v34 = (unsigned __int8)v8;
v33 = v9 | v6 & 0xF;
v10 = v7;
result = voxel_registry::find((voxel_registry *)v7, v5);
if ( result )
{
v39 = HIWORD(v9);
v12 = v10;
v35 = (unsigned __int8)v6 >> 4;
WORD2(v27) = v8 + 1;
v31 = v6 & 0xF;
LODWORD(v27) = v6 & 0xF | v9;
v28 = v10;
v32 = result;
LOBYTE(v29) = GL_MeshingTask::vis_test(v4, v10, result, &v27);
WORD2(v27) = ((unsigned __int8)v6 >> 4) - 1;
v13 = v31;
LODWORD(v27) = v31 | v9;
v14 = GL_MeshingTask::vis_test(v4, v12, v32, &v27);
v15 = (unsigned __int8)v29 + 2;
if ( !v14 )
v15 = (unsigned __int8)v29;
v29 = v35 << 32;
WORD2(v27) = (unsigned __int8)v6 >> 4;
LODWORD(v27) = v9 | (unsigned __int16)(v13 - 1);
v38 = v6;
v16 = v28;
v17 = GL_MeshingTask::vis_test(v4, v28, v32, &v27);
v18 = v15 + 4;
if ( !v17 )
v18 = v15;
WORD2(v27) = v8;
LODWORD(v27) = v9 | (v31 + 1);
v19 = v16;
v6 = v38;
v20 = v32;
v21 = v18 + 8;
if ( !(unsigned __int8)GL_MeshingTask::vis_test(v30, v19, v32, &v27) )
v21 = v18;
v22 = v9 & 0xF0000;
WORD2(v27) = v8;
LODWORD(v27) = v31 + v29 + v22 + 0x10000;
v23 = v21 | 0x10;
if ( !(unsigned __int8)GL_MeshingTask::vis_test(v30, v28, v20, &v27) )
v23 = v21;
WORD2(v27) = v8;
LODWORD(v27) = v31 + v29 + v22 - 0x10000;
v24 = v23 | 0x20;
if ( !(unsigned __int8)GL_MeshingTask::vis_test(v30, v28, v20, &v27) )
v24 = v23;
v25 = v30;
v27 = (v6 & 0xF | (16LL * v30[14357])) * (v39 + 16LL * v30[14358]) * (v35 + 16LL * v30[14359]);
v26 = crc64::get((crc64 *)&v27, &byte_8, 0LL, v27);
v4 = (GL_MeshingTask *)v25;
LOWORD(v5) = 0;
result = GL_MeshingTask::make_cube(v25, 0LL, v20, &v33, v24, v26);
}
if ( ++v6 == 4096 )
return result;
}
std::vector<std::vector<std::array<unsigned int,2ul>>>::_M_erase_at_end(v37, *v37);
return std::vector<std::vector<std::array<unsigned int,2ul>>>::_M_erase_at_end(v36, *v36);
}
| process:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
LEA RBX,[RDI + 0xe020]
CALL 0x001714e8
MOV qword ptr [RSP + 0x50],RBX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0013af96
MOV RBP,R14
LEA RBX,[R14 + 0xe038]
CALL 0x001714e8
MOV qword ptr [RSP + 0x48],RBX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0013af96
XOR R15D,R15D
MOV qword ptr [RSP + 0x20],R14
LAB_00139ce4:
MOV EAX,dword ptr [RBP + 0x8]
CMP EAX,0x4
JZ 0x00139f74
MOVZX EAX,word ptr [RBP + R15*0x2 + 0x20]
MOV R14D,R15D
AND R14D,0xf
MOV R13D,R15D
SHR R13D,0x4
AND R13D,0xf
MOV RCX,R13
SHL RCX,0x20
MOV R12D,R15D
SHL R12D,0x8
AND R12D,0xf0000
ADD RCX,R14
OR RCX,R12
MOV word ptr [RSP + 0x3c],R13W
MOV dword ptr [RSP + 0x38],ECX
MOVZX EBX,AX
MOV EDI,EBX
CALL 0x001839aa
TEST RAX,RAX
JZ 0x00139f62
MOV RCX,RAX
MOV EAX,R12D
SHR EAX,0x10
MOV qword ptr [RSP + 0x60],RAX
MOVZX EDX,R13W
LEA EAX,[RDX + 0x1]
MOV ESI,EBX
MOV RBX,RDX
MOV qword ptr [RSP + 0x40],RDX
MOV word ptr [RSP + 0xc],AX
SHL RAX,0x20
OR RAX,R12
MOVZX EDX,R14W
MOV qword ptr [RSP + 0x28],RDX
OR RAX,RDX
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,RBP
MOV R14D,ESI
MOV dword ptr [RSP + 0x14],ESI
MOV qword ptr [RSP + 0x30],RCX
MOV RDX,RCX
LEA RCX,[RSP + 0x8]
CALL 0x00139f9e
MOV byte ptr [RSP + 0x18],AL
LEA EAX,[RBX + -0x1]
MOV word ptr [RSP + 0xc],AX
SHL RAX,0x20
OR RAX,R12
MOV RBX,qword ptr [RSP + 0x28]
OR RAX,RBX
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,RBP
MOV ESI,R14D
MOV RDX,qword ptr [RSP + 0x30]
LEA RCX,[RSP + 0x8]
CALL 0x00139f9e
MOVZX ECX,byte ptr [RSP + 0x18]
LEA R14D,[RCX + 0x2]
TEST AL,AL
CMOVZ R14D,ECX
LEA EAX,[RBX + -0x1]
MOV RCX,qword ptr [RSP + 0x40]
SHL RCX,0x20
MOV qword ptr [RSP + 0x18],RCX
MOV RBX,R12
OR RBX,RCX
MOV ECX,0xffff
AND EAX,ECX
OR RAX,RBX
MOV word ptr [RSP + 0xc],R13W
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,RBP
MOV qword ptr [RSP + 0x58],R15
MOV R15D,dword ptr [RSP + 0x14]
MOV ESI,R15D
MOV RDX,qword ptr [RSP + 0x30]
LEA RCX,[RSP + 0x8]
CALL 0x00139f9e
LEA EBP,[R14 + 0x4]
TEST AL,AL
CMOVZ EBP,R14D
MOV RAX,qword ptr [RSP + 0x28]
INC EAX
OR RAX,RBX
MOV word ptr [RSP + 0xc],R13W
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,R15D
MOV R15,qword ptr [RSP + 0x58]
MOV R14,qword ptr [RSP + 0x30]
MOV RDX,R14
LEA RCX,[RSP + 0x8]
CALL 0x00139f9e
LEA EBX,[RBP + 0x8]
TEST AL,AL
CMOVZ EBX,EBP
AND R12D,0xf0000
LEA EAX,[R12 + 0x10000]
ADD RAX,qword ptr [RSP + 0x18]
ADD RAX,qword ptr [RSP + 0x28]
MOV word ptr [RSP + 0xc],R13W
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x14]
MOV RDX,R14
LEA RCX,[RSP + 0x8]
CALL 0x00139f9e
MOV EBP,EBX
OR EBP,0x10
TEST AL,AL
CMOVZ EBP,EBX
ADD R12D,0xffff0000
ADD R12,qword ptr [RSP + 0x18]
ADD R12,qword ptr [RSP + 0x28]
MOV word ptr [RSP + 0xc],R13W
MOV dword ptr [RSP + 0x8],R12D
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x14]
MOV RDX,R14
LEA R12,[RSP + 0x8]
MOV RCX,R12
CALL 0x00139f9e
MOV EBX,EBP
OR EBX,0x20
TEST AL,AL
CMOVZ EBX,EBP
MOV R13,qword ptr [RSP + 0x20]
MOV EAX,R15D
AND EAX,0xf
MOVSXD RCX,dword ptr [R13 + 0xe054]
SHL RCX,0x4
OR RCX,RAX
MOVSXD RAX,dword ptr [R13 + 0xe058]
SHL RAX,0x4
ADD RAX,qword ptr [RSP + 0x60]
IMUL RAX,RCX
MOVSXD RCX,dword ptr [R13 + 0xe05c]
SHL RCX,0x4
ADD RCX,qword ptr [RSP + 0x40]
IMUL RCX,RAX
MOV qword ptr [RSP + 0x8],RCX
MOV ESI,0x8
MOV RDI,R12
XOR EDX,EDX
CALL 0x0022eb90
MOV ECX,0xffff
AND EBX,ECX
MOV RBP,R13
MOV RDI,R13
XOR ESI,ESI
MOV RDX,R14
LEA RCX,[RSP + 0x38]
MOV R8D,EBX
MOV R9,RAX
CALL 0x0013a08e
LAB_00139f62:
INC R15
CMP R15,0x1000
JNZ 0x00139ce4
JMP 0x00139f8e
LAB_00139f74:
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RDI]
CALL 0x0013d2d2
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RDI]
CALL 0x0013d2d2
LAB_00139f8e:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* GL_MeshingTask::process() */
void __thiscall GL_MeshingTask::process(GL_MeshingTask *this)
{
ushort uVar1;
int1 uVar2;
char cVar3;
ulong uVar4;
VoxelInfo *pVVar5;
ulong uVar6;
ushort uVar7;
ushort uVar8;
uint uVar9;
short sVar10;
uint uVar11;
uint uVar12;
int8 local_90;
uint local_84;
long local_80;
GL_MeshingTask *local_78;
ulong local_70;
VoxelInfo *local_68;
uint local_60;
short local_5c;
ulong local_58;
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*local_50;
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*local_48;
ulong local_40;
ulong local_38;
uVar4 = voxel_atlas::plane_count();
local_48 = (vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe020);
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::resize((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe020),uVar4);
uVar4 = voxel_atlas::plane_count();
local_50 = (vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe038);
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::resize((vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
*)(this + 0xe038),uVar4);
uVar4 = 0;
local_78 = this;
do {
if (*(int *)(this + 8) == 4) {
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::_M_erase_at_end(local_48,*(vector **)local_48);
std::
vector<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>,std::allocator<std::vector<std::array<unsigned_int,2ul>,std::allocator<std::array<unsigned_int,2ul>>>>>
::_M_erase_at_end(local_50,*(vector **)local_50);
return;
}
uVar1 = *(ushort *)(this + uVar4 * 2 + 0x20);
uVar12 = (uint)uVar4 & 0xf;
uVar11 = (uint)(uVar4 >> 4) & 0xf;
uVar9 = ((uint)uVar4 & 0xf00) * 0x100;
local_60 = uVar12 | uVar9;
sVar10 = (short)uVar11;
local_5c = sVar10;
pVVar5 = (VoxelInfo *)voxel_registry::find(uVar1);
if (pVVar5 != (VoxelInfo *)0x0) {
local_38 = (ulong)(uVar9 >> 0x10);
local_58 = (ulong)uVar11;
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10 + 1),uVar9 | uVar12);
local_84 = (uint)uVar1;
local_70 = (ulong)uVar12;
local_68 = pVVar5;
uVar2 = vis_test(this,uVar1,pVVar5,(vec *)&local_90);
local_80 = CONCAT71(local_80._1_7_,uVar2);
uVar11 = (uint)local_70;
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10 + -1),uVar9 | uVar11);
cVar3 = vis_test(this,uVar1,local_68,(vec *)&local_90);
uVar1 = (byte)local_80 + 2;
if (cVar3 == '\0') {
uVar1 = (ushort)(byte)local_80;
}
local_80 = local_58 << 0x20;
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10),uVar11 - 1 & 0xffff | uVar9);
uVar8 = (ushort)local_84;
local_40 = uVar4;
cVar3 = vis_test(this,uVar8,local_68,(vec *)&local_90);
uVar4 = local_40;
pVVar5 = local_68;
uVar7 = uVar1 + 4;
if (cVar3 == '\0') {
uVar7 = uVar1;
}
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10),(int)local_70 + 1U | uVar9);
cVar3 = vis_test(local_78,uVar8,local_68,(vec *)&local_90);
uVar1 = uVar7 + 8;
if (cVar3 == '\0') {
uVar1 = uVar7;
}
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10),
uVar9 + 0x10000 + (int)local_80 + (int)local_70);
cVar3 = vis_test(local_78,(ushort)local_84,pVVar5,(vec *)&local_90);
uVar7 = uVar1 | 0x10;
if (cVar3 == '\0') {
uVar7 = uVar1;
}
local_90 = CONCAT44(CONCAT22(local_90._6_2_,sVar10),
(uVar9 - 0x10000) + (int)local_80 + (int)local_70);
cVar3 = vis_test(local_78,(ushort)local_84,pVVar5,(vec *)&local_90);
this = local_78;
uVar1 = uVar7 | 0x20;
if (cVar3 == '\0') {
uVar1 = uVar7;
}
local_90 = ((long)*(int *)(local_78 + 0xe05c) * 0x10 + local_58) *
((long)*(int *)(local_78 + 0xe058) * 0x10 + local_38) *
((long)*(int *)(local_78 + 0xe054) << 4 | (ulong)((uint)uVar4 & 0xf));
uVar6 = crc64::get((vec *)&local_90,8,0);
make_cube(this,0,pVVar5,(vec *)&local_60,uVar1,uVar6);
}
uVar4 = uVar4 + 1;
} while (uVar4 != 0x1000);
return;
}
| |
34,921 | my_fill_mb2 | eloqsql/strings/ctype-ucs2.c | static void
my_fill_mb2(CHARSET_INFO *cs, char *s, size_t slen, int fill)
{
char buf[10], *last;
size_t buflen, remainder;
DBUG_ASSERT((slen % 2) == 0);
buflen= my_ci_wc_mb(cs, (my_wc_t) fill, (uchar*) buf,
(uchar*) buf + sizeof(buf));
DBUG_ASSERT(buflen > 0);
/*
"last" in the last position where a sequence of "buflen" bytes can start.
*/
for (last= s + slen - buflen; s <= last; s+= buflen)
{
/* Enough space for the character */
memcpy(s, buf, buflen);
}
/*
If there are some more space which is not enough
for the whole multibyte character, then add trailing zeros.
*/
if ((remainder= last + buflen - s) > 0)
bzero(s, (size_t) remainder);
} | O0 | c | my_fill_mb2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
jmp 0x90476
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
leaq -0x12(%rbp), %rdx
leaq -0x12(%rbp), %rcx
addq $0xa, %rcx
callq *%rax
cltq
movq %rax, -0x48(%rbp)
jmp 0x904a3
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
xorl %ecx, %ecx
subq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x904e1
movq -0x28(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x26280
movq -0x48(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x904b8
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jbe 0x90509
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0x261c0
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x90521
addq $0x50, %rsp
popq %rbp
retq
callq 0x26370
nopw %cs:(%rax,%rax)
| my_fill_mb2:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
jmp short $+2
loc_90476:
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_20]
movsxd rsi, [rbp+var_34]
lea rdx, [rbp+var_12]
lea rcx, [rbp+var_12]
add rcx, 0Ah
call rax
cdqe
mov [rbp+var_48], rax
jmp short $+2
loc_904A3:
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
xor ecx, ecx
sub rcx, [rbp+var_48]
add rax, rcx
mov [rbp+var_40], rax
loc_904B8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
ja short loc_904E1
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_12]
mov rdx, [rbp+var_48]
call _memcpy
mov rax, [rbp+var_48]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
jmp short loc_904B8
loc_904E1:
mov rax, [rbp+var_40]
add rax, [rbp+var_48]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_50], rax
cmp rax, 0
jbe short loc_90509
mov rdi, [rbp+var_28]
mov rdx, [rbp+var_50]
xor esi, esi
call _memset
loc_90509:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_90521
add rsp, 50h
pop rbp
retn
loc_90521:
call ___stack_chk_fail
| unsigned long long my_fill_mb2(long long a1, unsigned long long a2, long long a3, int a4)
{
long long i; // [rsp+8h] [rbp-48h]
unsigned long long v7; // [rsp+28h] [rbp-28h]
_BYTE v8[10]; // [rsp+3Eh] [rbp-12h] BYREF
unsigned long long v9; // [rsp+48h] [rbp-8h] BYREF
v9 = __readfsqword(0x28u);
v7 = a2;
for ( i = (*(int ( **)(long long, _QWORD, _BYTE *, unsigned long long *))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
a4,
v8,
&v9); v7 <= a3 + a2 - i; v7 += i )
memcpy(v7, v8, i);
if ( a3 + a2 != v7 )
memset(v7, 0LL, a3 + a2 - v7);
return __readfsqword(0x28u);
}
| my_fill_mb2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
JMP 0x00190476
LAB_00190476:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x20]
MOVSXD RSI,dword ptr [RBP + -0x34]
LEA RDX,[RBP + -0x12]
LEA RCX,[RBP + -0x12]
ADD RCX,0xa
CALL RAX
CDQE
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001904a3
LAB_001904a3:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001904b8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x001904e1
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x12]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00126280
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001904b8
LAB_001904e1:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JBE 0x00190509
MOV RDI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x50]
XOR ESI,ESI
CALL 0x001261c0
LAB_00190509:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00190521
ADD RSP,0x50
POP RBP
RET
LAB_00190521:
CALL 0x00126370
|
void my_fill_mb2(long param_1,void *param_2,long param_3,int param_4)
{
int iVar1;
size_t sVar2;
void *pvVar3;
long in_FS_OFFSET;
void *local_30;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))(param_1,(long)param_4,local_1a);
sVar2 = (size_t)iVar1;
pvVar3 = (void *)((long)param_2 + (param_3 - sVar2));
for (local_30 = param_2; local_30 <= pvVar3; local_30 = (void *)(sVar2 + (long)local_30)) {
memcpy(local_30,local_1a,sVar2);
}
sVar2 = (long)pvVar3 + (sVar2 - (long)local_30);
if (sVar2 != 0) {
memset(local_30,0,sVar2);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,922 | my_strnxfrm_czech | eloqsql/strings/ctype-czech.c | static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
} | O0 | c | my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %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)
movl $0x0, -0x4c(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x10(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x88b68
movl 0x10(%rbp), %eax
orl $0xf, %eax
movl %eax, 0x10(%rbp)
jmp 0x88b6a
movl -0x4c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl 0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x88bdd
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x4c(%rbp)
je 0x88bd8
movl -0x4c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4c(%rbp)
cmpl $0x0, %eax
jne 0x88bbb
movq -0x48(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x88bc6
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x88e37
movslq -0x4c(%rbp), %rcx
leaq 0x19f7a8(%rip), %rax # 0x228390
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x88c11
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x88b7a
cmpl $0x2, -0x34(%rbp)
jne 0x88d1d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x99(%rbp)
jge 0x88c70
movslq -0x4c(%rbp), %rcx
leaq 0x19f73b(%rip), %rax # 0x228390
movq (%rax,%rcx,8), %rax
movq -0x70(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
sete %al
movb %al, -0x99(%rbp)
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x88c7c
jmp 0x88c8a
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x88c2b
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x88ca9
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jg 0x88cce
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x88cce
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x88cea
jmp 0x88b7a
cmpl $0x1, -0x4c(%rbp)
jle 0x88cf5
jmp 0x88e37
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x88e37
cmpl $0xff, -0x34(%rbp)
jne 0x88e2b
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x88e29
movslq -0x74(%rbp), %rcx
leaq 0x19f66a(%rip), %rax # 0x2283b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x88dd6
movq -0x88(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x88db1
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
movq -0x80(%rbp), %rcx
movslq -0x8c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x88db3
jmp 0x88dd6
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x88d69
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x88e19
movslq -0x74(%rbp), %rcx
leaq 0x19f5be(%rip), %rax # 0x2283b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x4c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x88e29
jmp 0x88e1b
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x88d31
jmp 0x88e2b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x88e64
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x88e62
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x88e64
jmp 0x88e66
cmpl $0x0, -0x34(%rbp)
jne 0x88b6a
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x88ea9
movq -0x18(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x88ea9
movq -0x10(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x58(%rbp), %rdx
movl $0x20, %esi
callq 0x362e0
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strnxfrm_czech:
push rbp
mov rbp, rsp
sub rsp, 0A0h
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 [rbp+var_4C], 0
mov [rbp+var_58], 0
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov eax, [rbp+arg_0]
and eax, 0Fh
cmp eax, 0
jnz short loc_88B68
mov eax, [rbp+arg_0]
or eax, 0Fh
mov [rbp+arg_0], eax
loc_88B68:
jmp short $+2
loc_88B6A:
mov ecx, [rbp+var_4C]
mov eax, 1
shl eax, cl
and eax, [rbp+arg_0]
mov [rbp+var_5C], eax
loc_88B7A:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_88BDD
mov [rbp+var_34], 0
cmp [rbp+var_4C], 3
jz short loc_88BD8
mov eax, [rbp+var_4C]
mov ecx, eax
add ecx, 1
mov [rbp+var_4C], ecx
cmp eax, 0
jnz short loc_88BBB
mov rax, [rbp+var_48]
mov [rbp+var_98], rax
jmp short loc_88BC6
loc_88BBB:
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
loc_88BC6:
mov rax, [rbp+var_98]
mov [rbp+var_40], rax
mov [rbp+var_34], 1
loc_88BD8:
jmp loc_88E37
loc_88BDD:
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jnz short loc_88C11
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_88B7A
loc_88C11:
cmp [rbp+var_34], 2
jnz loc_88D1D
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
mov [rbp+var_70], rax
loc_88C2B:
mov rcx, [rbp+var_70]
mov rax, [rbp+var_28]
sub rcx, rax
mov rax, [rbp+var_30]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_99], al
jge short loc_88C70
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_70]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
cmp eax, 2
setz al
mov [rbp+var_99], al
loc_88C70:
mov al, [rbp+var_99]
test al, 1
jnz short loc_88C7C
jmp short loc_88C8A
loc_88C7C:
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_88C2B
loc_88C8A:
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_88CA9
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_88CA9:
cmp [rbp+var_4C], 2
jg short loc_88CCE
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_88CCE
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_88CCE:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_88CEA
jmp loc_88B7A
loc_88CEA:
cmp [rbp+var_4C], 1
jle short loc_88CF5
jmp loc_88E37
loc_88CF5:
mov rax, [rbp+var_40]
mov [rbp+var_68], rax
mov eax, 1
sub eax, [rbp+var_4C]
mov [rbp+var_4C], eax
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
mov rax, [rbp+var_68]
mov [rbp+var_48], rax
jmp loc_88E37
loc_88D1D:
cmp [rbp+var_34], 0FFh
jnz loc_88E2B
mov [rbp+var_74], 0
loc_88D31:
cmp [rbp+var_74], 50h ; 'P'
jge loc_88E29
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_40]
mov [rbp+var_88], rax
mov [rbp+var_8C], 0
loc_88D69:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jz short loc_88DD6
mov rax, [rbp+var_88]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_88DB1
mov rax, [rbp+var_88]
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movsxd rdx, [rbp+var_8C]
movsx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_88DB3
loc_88DB1:
jmp short loc_88DD6
loc_88DB3:
mov eax, [rbp+var_8C]
add eax, 1
mov [rbp+var_8C], eax
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_88D69
loc_88DD6:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jnz short loc_88E19
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
movsxd rcx, [rbp+var_4C]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
mov rax, [rbp+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rax
jmp short loc_88E29
loc_88E19:
jmp short $+2
loc_88E1B:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
jmp loc_88D31
loc_88E29:
jmp short $+2
loc_88E2B:
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
loc_88E37:
cmp [rbp+var_5C], 0
jz short loc_88E64
mov rax, [rbp+var_58]
cmp rax, [rbp+var_18]
jnb short loc_88E62
mov eax, [rbp+var_34]
mov dl, al
mov rax, [rbp+var_10]
mov rcx, [rbp+var_58]
mov rsi, rcx
add rsi, 1
mov [rbp+var_58], rsi
mov [rax+rcx], dl
loc_88E62:
jmp short $+2
loc_88E64:
jmp short $+2
loc_88E66:
cmp [rbp+var_34], 0
jnz loc_88B6A
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_88EA9
mov rax, [rbp+var_18]
cmp rax, [rbp+var_58]
jbe short loc_88EA9
mov rdi, [rbp+var_10]
add rdi, [rbp+var_58]
mov rdx, [rbp+var_18]
sub rdx, [rbp+var_58]
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
loc_88EA9:
mov rax, [rbp+var_58]
add rsp, 0A0h
pop rbp
retn
| unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
char *a5,
int a6,
int a7)
{
long long v8; // rcx
long long v9; // rcx
bool v11; // [rsp+7h] [rbp-99h]
char *v12; // [rsp+8h] [rbp-98h]
int k; // [rsp+14h] [rbp-8Ch]
char *v14; // [rsp+18h] [rbp-88h]
long long v15; // [rsp+20h] [rbp-80h]
int j; // [rsp+2Ch] [rbp-74h]
unsigned __int8 *i; // [rsp+30h] [rbp-70h]
char *v18; // [rsp+38h] [rbp-68h]
int v19; // [rsp+44h] [rbp-5Ch]
unsigned long long v20; // [rsp+48h] [rbp-58h]
int v21; // [rsp+54h] [rbp-4Ch]
char *v22; // [rsp+58h] [rbp-48h]
char *v23; // [rsp+60h] [rbp-40h]
int v24; // [rsp+6Ch] [rbp-34h]
v21 = 0;
v20 = 0LL;
v23 = a5;
v22 = a5;
if ( (a7 & 0xF) == 0 )
a7 |= 0xFu;
do
{
v19 = a7 & (1 << v21);
while ( 1 )
{
while ( 1 )
{
if ( v23 - a5 >= a6 )
{
v24 = 0;
if ( v21 != 3 )
{
if ( v21++ )
v12 = a5;
else
v12 = v22;
v23 = v12;
v24 = 1;
}
goto LABEL_40;
}
v8 = (unsigned __int8)*v23;
v24 = *((unsigned __int8 *)*(&CZ_SORT_TABLE + v21) + v8);
if ( *((_BYTE *)*(&CZ_SORT_TABLE + v21) + v8) )
break;
++v23;
}
if ( v24 != 2 )
break;
for ( i = (unsigned __int8 *)++v23; ; ++i )
{
v11 = 0;
if ( i - (unsigned __int8 *)a5 < a6 )
v11 = *((_BYTE *)*(&CZ_SORT_TABLE + v21) + *i) == 2;
if ( !v11 )
break;
}
if ( i - (unsigned __int8 *)a5 >= a6 )
v23 = (char *)i;
if ( v21 <= 2 && i - (unsigned __int8 *)a5 < a6 )
v23 = (char *)i;
if ( v23 - a5 < a6 )
{
if ( v21 <= 1 )
{
v18 = v23;
v21 = 1 - v21;
v23 = v22;
v22 = v18;
}
goto LABEL_40;
}
}
if ( v24 == 255 )
{
for ( j = 0; j < 80; ++j )
{
v15 = (long long)*(&doubles + 2 * j);
v14 = v23;
for ( k = 0; *(_BYTE *)(v15 + k) && v14 - a5 < a6 && *v14 == *(char *)(v15 + k); ++k )
++v14;
if ( !*(_BYTE *)(v15 + k) )
{
v24 = *((unsigned __int8 *)*(&doubles + 2 * j + 1) + v21);
v23 = v14 - 1;
break;
}
}
}
++v23;
LABEL_40:
if ( v19 && v20 < a3 )
{
v9 = v20++;
*(_BYTE *)(a2 + v9) = v24;
}
}
while ( v24 );
if ( (a7 & 0x80) != 0 && a3 > v20 )
{
memset(v20 + a2, 32LL, a3 - v20);
return a3;
}
return v20;
}
| my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
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 dword ptr [RBP + -0x4c],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0xf
CMP EAX,0x0
JNZ 0x00188b68
MOV EAX,dword ptr [RBP + 0x10]
OR EAX,0xf
MOV dword ptr [RBP + 0x10],EAX
LAB_00188b68:
JMP 0x00188b6a
LAB_00188b6a:
MOV ECX,dword ptr [RBP + -0x4c]
MOV EAX,0x1
SHL EAX,CL
AND EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x5c],EAX
LAB_00188b7a:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x00188bdd
MOV dword ptr [RBP + -0x34],0x0
CMP dword ptr [RBP + -0x4c],0x3
JZ 0x00188bd8
MOV EAX,dword ptr [RBP + -0x4c]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x4c],ECX
CMP EAX,0x0
JNZ 0x00188bbb
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00188bc6
LAB_00188bbb:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
LAB_00188bc6:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x34],0x1
LAB_00188bd8:
JMP 0x00188e37
LAB_00188bdd:
MOVSXD RCX,dword ptr [RBP + -0x4c]
LEA RAX,[0x328390]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x00188c11
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00188b7a
LAB_00188c11:
CMP dword ptr [RBP + -0x34],0x2
JNZ 0x00188d1d
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x70],RAX
LAB_00188c2b:
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x28]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x99],AL
JGE 0x00188c70
MOVSXD RCX,dword ptr [RBP + -0x4c]
LEA RAX,[0x328390]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RCX,qword ptr [RBP + -0x70]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2
SETZ AL
MOV byte ptr [RBP + -0x99],AL
LAB_00188c70:
MOV AL,byte ptr [RBP + -0x99]
TEST AL,0x1
JNZ 0x00188c7c
JMP 0x00188c8a
LAB_00188c7c:
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
MOV qword ptr [RBP + -0x70],RAX
JMP 0x00188c2b
LAB_00188c8a:
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x00188ca9
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x40],RAX
LAB_00188ca9:
CMP dword ptr [RBP + -0x4c],0x2
JG 0x00188cce
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x00188cce
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x40],RAX
LAB_00188cce:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x00188cea
JMP 0x00188b7a
LAB_00188cea:
CMP dword ptr [RBP + -0x4c],0x1
JLE 0x00188cf5
JMP 0x00188e37
LAB_00188cf5:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,0x1
SUB EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00188e37
LAB_00188d1d:
CMP dword ptr [RBP + -0x34],0xff
JNZ 0x00188e2b
MOV dword ptr [RBP + -0x74],0x0
LAB_00188d31:
CMP dword ptr [RBP + -0x74],0x50
JGE 0x00188e29
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x3283b0]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x88],RAX
MOV dword ptr [RBP + -0x8c],0x0
LAB_00188d69:
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x8c]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x00188dd6
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x00188db1
MOV RAX,qword ptr [RBP + -0x88]
MOVSX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVSXD RDX,dword ptr [RBP + -0x8c]
MOVSX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00188db3
LAB_00188db1:
JMP 0x00188dd6
LAB_00188db3:
MOV EAX,dword ptr [RBP + -0x8c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8c],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00188d69
LAB_00188dd6:
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x8c]
CMP byte ptr [RAX + RCX*0x1],0x0
JNZ 0x00188e19
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x3283b0]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x4c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00188e29
LAB_00188e19:
JMP 0x00188e1b
LAB_00188e1b:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
JMP 0x00188d31
LAB_00188e29:
JMP 0x00188e2b
LAB_00188e2b:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_00188e37:
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00188e64
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00188e62
MOV EAX,dword ptr [RBP + -0x34]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x58]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x58],RSI
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00188e62:
JMP 0x00188e64
LAB_00188e64:
JMP 0x00188e66
LAB_00188e66:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x00188b6a
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00188ea9
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x00188ea9
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr [RBP + -0x58]
MOV ESI,0x20
CALL 0x001362e0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
LAB_00188ea9:
MOV RAX,qword ptr [RBP + -0x58]
ADD RSP,0xa0
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
char cVar1;
long lVar2;
byte *pbVar3;
byte bVar4;
bool bVar5;
byte *local_a0;
int local_94;
byte *local_90;
int local_7c;
byte *local_78;
ulong local_60;
int local_54;
byte *local_50;
byte *local_48;
local_54 = 0;
local_60 = 0;
local_50 = param_5;
local_48 = param_5;
if ((param_7 & 0xf) == 0) {
param_7 = param_7 | 0xf;
}
LAB_00188b6a:
bVar4 = (byte)local_54;
do {
while( true ) {
if ((long)param_6 <= (long)local_48 - (long)param_5) {
cVar1 = '\0';
if (local_54 != 3) {
local_a0 = param_5;
if (local_54 == 0) {
local_a0 = local_50;
}
local_48 = local_a0;
cVar1 = '\x01';
local_54 = local_54 + 1;
}
goto LAB_00188e37;
}
cVar1 = (&CZ_SORT_TABLE)[local_54][*local_48];
if (cVar1 != '\0') break;
local_48 = local_48 + 1;
}
if (cVar1 != '\x02') {
if (cVar1 != -1) goto LAB_00188e2b;
local_7c = 0;
goto LAB_00188d31;
}
local_48 = local_48 + 1;
local_78 = local_48;
while( true ) {
bVar5 = false;
if ((long)local_78 - (long)param_5 < (long)param_6) {
bVar5 = (&CZ_SORT_TABLE)[local_54][*local_78] == '\x02';
}
if (!bVar5) break;
local_78 = local_78 + 1;
}
if ((long)param_6 <= (long)local_78 - (long)param_5) {
local_48 = local_78;
}
if ((local_54 < 3) && ((long)local_78 - (long)param_5 < (long)param_6)) {
local_48 = local_78;
}
pbVar3 = local_48;
} while ((long)param_6 <= (long)local_48 - (long)param_5);
if (local_54 < 2) {
local_48 = local_50;
local_50 = pbVar3;
local_54 = 1 - local_54;
}
goto LAB_00188e37;
LAB_00188d31:
if (0x4f < local_7c) goto LAB_00188e2b;
lVar2 = *(long *)(doubles + (long)local_7c * 0x10);
local_94 = 0;
for (local_90 = local_48;
((*(char *)(lVar2 + local_94) != '\0' && ((long)local_90 - (long)param_5 < (long)param_6)) &&
(*local_90 == *(byte *)(lVar2 + local_94))); local_90 = local_90 + 1) {
local_94 = local_94 + 1;
}
if (*(char *)(lVar2 + local_94) == '\0') {
cVar1 = *(char *)(*(long *)(doubles + (long)local_7c * 0x10 + 8) + (long)local_54);
local_48 = local_90 + -1;
goto LAB_00188e2b;
}
local_7c = local_7c + 1;
goto LAB_00188d31;
LAB_00188e2b:
local_48 = local_48 + 1;
LAB_00188e37:
if (((1 << (bVar4 & 0x1f) & param_7) != 0) && (local_60 < param_3)) {
*(char *)(param_2 + local_60) = cVar1;
local_60 = local_60 + 1;
}
if (cVar1 == '\0') {
if (((param_7 & 0x80) != 0) && (local_60 < param_3)) {
memset((void *)(param_2 + local_60),0x20,param_3 - local_60);
local_60 = param_3;
}
return local_60;
}
goto LAB_00188b6a;
}
| |
34,923 | my_uca_copy_page | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_copy_page(MY_CHARSET_LOADER *loader,
const MY_UCA_WEIGHT_LEVEL *src,
MY_UCA_WEIGHT_LEVEL *dst,
size_t page)
{
uint chc, size= 256 * dst->lengths[page] * sizeof(uint16);
if (!(dst->weights[page]= (uint16 *) (loader->once_alloc)(size)))
return TRUE;
DBUG_ASSERT(src->lengths[page] <= dst->lengths[page]);
memset(dst->weights[page], 0, size);
for (chc=0 ; chc < 256; chc++)
{
memcpy(dst->weights[page] + chc * dst->lengths[page],
src->weights[page] + chc * src->lengths[page],
src->lengths[page] * sizeof(uint16));
}
return FALSE;
} | O0 | c | my_uca_copy_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
cltq
shlq %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edi
callq *%rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x9ffb4
movb $0x1, -0x1(%rbp)
jmp 0xa0070
jmp 0x9ffb6
jmp 0x9ffb8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x30(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x362e0
movl $0x0, -0x2c(%rbp)
cmpl $0x100, -0x2c(%rbp) # imm = 0x100
jae 0xa006c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movl %eax, %eax
shlq %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
shlq %rdx
callq 0x360b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9ffdb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_uca_copy_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
cdqe
shl rax, 1
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax+80h]
mov ecx, [rbp+var_30]
mov edi, ecx
call rax
mov rcx, [rbp+var_20]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_28]
mov [rcx+rdx*8], rax
cmp rax, 0
jnz short loc_9FFB4
mov [rbp+var_1], 1
jmp loc_A0070
loc_9FFB4:
jmp short $+2
loc_9FFB6:
jmp short $+2
loc_9FFB8:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_30]
mov edx, eax
xor esi, esi
call _memset
mov [rbp+var_2C], 0
loc_9FFDB:
cmp [rbp+var_2C], 100h
jnb loc_A006C
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_20]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rdi, rax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rsi, [rax+rcx*8]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_18]
mov rcx, [rcx+8]
mov rdx, [rbp+var_28]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
mov eax, eax
shl rax, 1
add rsi, rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
mov edx, eax
shl rdx, 1
call _memcpy
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp loc_9FFDB
loc_A006C:
mov [rbp+var_1], 0
loc_A0070:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_copy_page(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int v6; // [rsp+0h] [rbp-30h]
unsigned int i; // [rsp+4h] [rbp-2Ch]
v6 = *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) << 9;
v4 = (*(long long ( **)(_QWORD))(a1 + 128))(v6);
*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4) = v4;
if ( !v4 )
return 1;
memset(*(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4), 0LL, v6);
for ( i = 0; i < 0x100; ++i )
memcpy(
2LL * *(unsigned __int8 *)(*(_QWORD *)(a3 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a3 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4) * i + *(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * a4),
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a4));
return 0;
}
| my_uca_copy_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
CDQE
SHL RAX,0x1
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x30]
MOV EDI,ECX
CALL RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x0019ffb4
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001a0070
LAB_0019ffb4:
JMP 0x0019ffb6
LAB_0019ffb6:
JMP 0x0019ffb8
LAB_0019ffb8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x30]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001362e0
MOV dword ptr [RBP + -0x2c],0x0
LAB_0019ffdb:
CMP dword ptr [RBP + -0x2c],0x100
JNC 0x001a006c
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
MOV EAX,EAX
SHL RAX,0x1
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV EDX,EAX
SHL RDX,0x1
CALL 0x001360b0
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0019ffdb
LAB_001a006c:
MOV byte ptr [RBP + -0x1],0x0
LAB_001a0070:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_copy_page(long param_1,long param_2,long param_3,long param_4)
{
size_t __n;
long lVar1;
int4 local_34;
int1 local_9;
__n = (long)(int)((uint)*(byte *)(*(long *)(param_3 + 8) + param_4) << 8) << 1;
lVar1 = (**(code **)(param_1 + 0x80))(__n);
*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) = lVar1;
if (lVar1 == 0) {
local_9 = 1;
}
else {
memset(*(void **)(*(long *)(param_3 + 0x10) + param_4 * 8),0,__n);
for (local_34 = 0; local_34 < 0x100; local_34 = local_34 + 1) {
memcpy((void *)(*(long *)(*(long *)(param_3 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_3 + 8) + param_4)) * 2),
(void *)(*(long *)(*(long *)(param_2 + 0x10) + param_4 * 8) +
(ulong)(local_34 * *(byte *)(*(long *)(param_2 + 8) + param_4)) * 2),
(ulong)*(byte *)(*(long *)(param_2 + 8) + param_4) << 1);
}
local_9 = 0;
}
return local_9;
}
| |
34,924 | stbi__hdr_info(stbi__context*, int*, int*, int*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__hdr_test(s) == 0) {
stbi__rewind( s );
return 0;
}
for(;;) {
token = stbi__hdr_gettoken(s,buffer);
if (token[0] == 0) break;
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
}
if (!valid) {
stbi__rewind( s );
return 0;
}
token = stbi__hdr_gettoken(s,buffer);
if (strncmp(token, "-Y ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*y = (int) strtol(token, &token, 10);
while (*token == ' ') ++token;
if (strncmp(token, "+X ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*x = (int) strtol(token, NULL, 10);
*comp = 3;
return 1;
} | O0 | c | stbi__hdr_info(stbi__context*, int*, int*, int*):
subq $0x438, %rsp # imm = 0x438
movq %rdi, 0x428(%rsp)
movq %rsi, 0x420(%rsp)
movq %rdx, 0x418(%rsp)
movq %rcx, 0x410(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x420(%rsp)
jne 0x2d4a5
movq %rsp, %rax
movq %rax, 0x420(%rsp)
cmpq $0x0, 0x418(%rsp)
jne 0x2d4bb
movq %rsp, %rax
movq %rax, 0x418(%rsp)
cmpq $0x0, 0x410(%rsp)
jne 0x2d4d1
movq %rsp, %rax
movq %rax, 0x410(%rsp)
movq 0x428(%rsp), %rdi
callq 0xf080
cmpl $0x0, %eax
jne 0x2d500
movq 0x428(%rsp), %rdi
callq 0x17f10
movl $0x0, 0x434(%rsp)
jmp 0x2d681
jmp 0x2d502
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2d528
jmp 0x2d548
movq 0x8(%rsp), %rdi
leaq 0x15199e(%rip), %rsi # 0x17eed2
callq 0xbaa0
cmpl $0x0, %eax
jne 0x2d546
movl $0x1, 0x4(%rsp)
jmp 0x2d502
cmpl $0x0, 0x4(%rsp)
jne 0x2d56c
movq 0x428(%rsp), %rdi
callq 0x17f10
movl $0x0, 0x434(%rsp)
jmp 0x2d681
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2b2e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x15196d(%rip), %rsi # 0x17eefc
movl $0x3, %edx
callq 0xb310
cmpl $0x0, %eax
je 0x2d5bb
movq 0x428(%rsp), %rdi
callq 0x17f10
movl $0x0, 0x434(%rsp)
jmp 0x2d681
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0xbf18
movl %eax, %ecx
movq 0x418(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2d606
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2d5e9
movq 0x8(%rsp), %rdi
leaq 0x151906(%rip), %rsi # 0x17ef18
movl $0x3, %edx
callq 0xb310
cmpl $0x0, %eax
je 0x2d63b
movq 0x428(%rsp), %rdi
callq 0x17f10
movl $0x0, 0x434(%rsp)
jmp 0x2d681
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xbf18
movl %eax, %ecx
movq 0x420(%rsp), %rax
movl %ecx, (%rax)
movq 0x410(%rsp), %rax
movl $0x3, (%rax)
movl $0x1, 0x434(%rsp)
movl 0x434(%rsp), %eax
addq $0x438, %rsp # imm = 0x438
retq
| _ZL14stbi__hdr_infoP13stbi__contextPiS1_S1_:
sub rsp, 438h
mov [rsp+438h+var_10], rdi
mov [rsp+438h+var_18], rsi
mov [rsp+438h+var_20], rdx
mov [rsp+438h+var_28], rcx
mov [rsp+438h+var_434], 0
cmp [rsp+438h+var_18], 0
jnz short loc_2D4A5
mov rax, rsp
mov [rsp+438h+var_18], rax
loc_2D4A5:
cmp [rsp+438h+var_20], 0
jnz short loc_2D4BB
mov rax, rsp
mov [rsp+438h+var_20], rax
loc_2D4BB:
cmp [rsp+438h+var_28], 0
jnz short loc_2D4D1
mov rax, rsp
mov [rsp+438h+var_28], rax
loc_2D4D1:
mov rdi, [rsp+438h+var_10]
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
cmp eax, 0
jnz short loc_2D500
mov rdi, [rsp+438h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+438h+var_4], 0
jmp loc_2D681
loc_2D500:
jmp short $+2
loc_2D502:
mov rdi, [rsp+438h+var_10]
lea rsi, [rsp+438h+var_428]
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
mov [rsp+438h+var_430], rax
mov rax, [rsp+438h+var_430]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_2D528
jmp short loc_2D548
loc_2D528:
mov rdi, [rsp+438h+var_430]
lea rsi, aFormat32BitRle; "FORMAT=32-bit_rle_rgbe"
call _strcmp
cmp eax, 0
jnz short loc_2D546
mov [rsp+438h+var_434], 1
loc_2D546:
jmp short loc_2D502
loc_2D548:
cmp [rsp+438h+var_434], 0
jnz short loc_2D56C
mov rdi, [rsp+438h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+438h+var_4], 0
jmp loc_2D681
loc_2D56C:
mov rdi, [rsp+438h+var_10]
lea rsi, [rsp+438h+var_428]
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
mov [rsp+438h+var_430], rax
mov rdi, [rsp+438h+var_430]
lea rsi, aY; "-Y "
mov edx, 3
call _strncmp
cmp eax, 0
jz short loc_2D5BB
mov rdi, [rsp+438h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+438h+var_4], 0
jmp loc_2D681
loc_2D5BB:
mov rax, [rsp+438h+var_430]
add rax, 3
mov [rsp+438h+var_430], rax
mov rdi, [rsp+438h+var_430]
lea rsi, [rsp+438h+var_430]
mov edx, 0Ah
call strtol
mov ecx, eax
mov rax, [rsp+438h+var_20]
mov [rax], ecx
loc_2D5E9:
mov rax, [rsp+438h+var_430]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jnz short loc_2D606
mov rax, [rsp+438h+var_430]
add rax, 1
mov [rsp+438h+var_430], rax
jmp short loc_2D5E9
loc_2D606:
mov rdi, [rsp+438h+var_430]
lea rsi, asc_17EF18; "+X "
mov edx, 3
call _strncmp
cmp eax, 0
jz short loc_2D63B
mov rdi, [rsp+438h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+438h+var_4], 0
jmp short loc_2D681
loc_2D63B:
mov rax, [rsp+438h+var_430]
add rax, 3
mov [rsp+438h+var_430], rax
mov rdi, [rsp+438h+var_430]
xor eax, eax
mov esi, eax
mov edx, 0Ah
call strtol
mov ecx, eax
mov rax, [rsp+438h+var_18]
mov [rax], ecx
mov rax, [rsp+438h+var_28]
mov dword ptr [rax], 3
mov [rsp+438h+var_4], 1
loc_2D681:
mov eax, [rsp+438h+var_4]
add rsp, 438h
retn
| long long stbi__hdr_info(_QWORD *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
int v4; // eax
int v5; // eax
_BYTE v7[4]; // [rsp+0h] [rbp-438h] BYREF
int v8; // [rsp+4h] [rbp-434h]
_BYTE *v9; // [rsp+8h] [rbp-430h] BYREF
_BYTE v10[1024]; // [rsp+10h] [rbp-428h] BYREF
_DWORD *v11; // [rsp+410h] [rbp-28h]
_DWORD *v12; // [rsp+418h] [rbp-20h]
_DWORD *v13; // [rsp+420h] [rbp-18h]
_QWORD *v14; // [rsp+428h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v8 = 0;
if ( !a2 )
v13 = v7;
if ( !v12 )
v12 = v7;
if ( !v11 )
v11 = v7;
if ( !(unsigned int)stbi__hdr_test((long long)v14) )
goto LABEL_14;
while ( 1 )
{
v9 = (_BYTE *)stbi__hdr_gettoken((long long)v14, (long long)v10);
if ( !*v9 )
break;
if ( !(unsigned int)strcmp(v9, "FORMAT=32-bit_rle_rgbe") )
v8 = 1;
}
if ( !v8 )
goto LABEL_14;
v9 = (_BYTE *)stbi__hdr_gettoken((long long)v14, (long long)v10);
if ( (unsigned int)strncmp(v9, "-Y ", 3LL) )
goto LABEL_14;
v9 += 3;
v4 = strtol(v9, &v9, 10LL);
*v12 = v4;
while ( *v9 == 32 )
++v9;
if ( !(unsigned int)strncmp(v9, "+X ", 3LL) )
{
v9 += 3;
v5 = strtol(v9, 0LL, 10LL);
*v13 = v5;
*v11 = 3;
return 1;
}
else
{
LABEL_14:
stbi__rewind(v14);
return 0;
}
}
| stbi__hdr_info:
SUB RSP,0x438
MOV qword ptr [RSP + 0x428],RDI
MOV qword ptr [RSP + 0x420],RSI
MOV qword ptr [RSP + 0x418],RDX
MOV qword ptr [RSP + 0x410],RCX
MOV dword ptr [RSP + 0x4],0x0
CMP qword ptr [RSP + 0x420],0x0
JNZ 0x0012d4a5
MOV RAX,RSP
MOV qword ptr [RSP + 0x420],RAX
LAB_0012d4a5:
CMP qword ptr [RSP + 0x418],0x0
JNZ 0x0012d4bb
MOV RAX,RSP
MOV qword ptr [RSP + 0x418],RAX
LAB_0012d4bb:
CMP qword ptr [RSP + 0x410],0x0
JNZ 0x0012d4d1
MOV RAX,RSP
MOV qword ptr [RSP + 0x410],RAX
LAB_0012d4d1:
MOV RDI,qword ptr [RSP + 0x428]
CALL 0x0010f080
CMP EAX,0x0
JNZ 0x0012d500
MOV RDI,qword ptr [RSP + 0x428]
CALL 0x00117f10
MOV dword ptr [RSP + 0x434],0x0
JMP 0x0012d681
LAB_0012d500:
JMP 0x0012d502
LAB_0012d502:
MOV RDI,qword ptr [RSP + 0x428]
LEA RSI,[RSP + 0x10]
CALL 0x0012b2e0
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0012d528
JMP 0x0012d548
LAB_0012d528:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x27eed2]
CALL 0x0010baa0
CMP EAX,0x0
JNZ 0x0012d546
MOV dword ptr [RSP + 0x4],0x1
LAB_0012d546:
JMP 0x0012d502
LAB_0012d548:
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x0012d56c
MOV RDI,qword ptr [RSP + 0x428]
CALL 0x00117f10
MOV dword ptr [RSP + 0x434],0x0
JMP 0x0012d681
LAB_0012d56c:
MOV RDI,qword ptr [RSP + 0x428]
LEA RSI,[RSP + 0x10]
CALL 0x0012b2e0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x27eefc]
MOV EDX,0x3
CALL 0x0010b310
CMP EAX,0x0
JZ 0x0012d5bb
MOV RDI,qword ptr [RSP + 0x428]
CALL 0x00117f10
MOV dword ptr [RSP + 0x434],0x0
JMP 0x0012d681
LAB_0012d5bb:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x8]
MOV EDX,0xa
CALL 0x0010bf18
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x418]
MOV dword ptr [RAX],ECX
LAB_0012d5e9:
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JNZ 0x0012d606
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0012d5e9
LAB_0012d606:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x27ef18]
MOV EDX,0x3
CALL 0x0010b310
CMP EAX,0x0
JZ 0x0012d63b
MOV RDI,qword ptr [RSP + 0x428]
CALL 0x00117f10
MOV dword ptr [RSP + 0x434],0x0
JMP 0x0012d681
LAB_0012d63b:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x3
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x8]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0xa
CALL 0x0010bf18
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x420]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x410]
MOV dword ptr [RAX],0x3
MOV dword ptr [RSP + 0x434],0x1
LAB_0012d681:
MOV EAX,dword ptr [RSP + 0x434]
ADD RSP,0x438
RET
|
/* stbi__hdr_info(stbi__context*, int*, int*, int*) */
int4 stbi__hdr_info(stbi__context *param_1,int *param_2,int *param_3,int *param_4)
{
int iVar1;
long lVar2;
int local_438;
int local_434;
char *local_430;
char local_428 [1024];
int *local_28;
int *local_20;
int *local_18;
stbi__context *local_10;
int4 local_4;
local_434 = 0;
local_18 = param_2;
if (param_2 == (int *)0x0) {
local_18 = &local_438;
}
local_20 = param_3;
if (param_3 == (int *)0x0) {
local_20 = &local_438;
}
local_28 = param_4;
if (param_4 == (int *)0x0) {
local_28 = &local_438;
}
local_10 = param_1;
iVar1 = stbi__hdr_test(param_1);
if (iVar1 == 0) {
stbi__rewind(local_10);
local_4 = 0;
}
else {
while (local_430 = (char *)stbi__hdr_gettoken(local_10,local_428), *local_430 != '\0') {
iVar1 = strcmp(local_430,"FORMAT=32-bit_rle_rgbe");
if (iVar1 == 0) {
local_434 = 1;
}
}
if (local_434 == 0) {
stbi__rewind(local_10);
local_4 = 0;
}
else {
local_430 = (char *)stbi__hdr_gettoken(local_10,local_428);
iVar1 = strncmp(local_430,"-Y ",3);
if (iVar1 == 0) {
local_430 = local_430 + 3;
lVar2 = strtol(local_430,&local_430,10);
*local_20 = (int)lVar2;
for (; *local_430 == ' '; local_430 = local_430 + 1) {
}
iVar1 = strncmp(local_430,"+X ",3);
if (iVar1 == 0) {
local_430 = local_430 + 3;
lVar2 = strtol(local_430,(char **)0x0,10);
*local_18 = (int)lVar2;
*local_28 = 3;
local_4 = 1;
}
else {
stbi__rewind(local_10);
local_4 = 0;
}
}
else {
stbi__rewind(local_10);
local_4 = 0;
}
}
}
return local_4;
}
| |
34,925 | stbi__hdr_info(stbi__context*, int*, int*, int*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__hdr_test(s) == 0) {
stbi__rewind( s );
return 0;
}
for(;;) {
token = stbi__hdr_gettoken(s,buffer);
if (token[0] == 0) break;
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
}
if (!valid) {
stbi__rewind( s );
return 0;
}
token = stbi__hdr_gettoken(s,buffer);
if (strncmp(token, "-Y ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*y = (int) strtol(token, &token, 10);
while (*token == ' ') ++token;
if (strncmp(token, "+X ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*x = (int) strtol(token, NULL, 10);
*comp = 3;
return 1;
} | O1 | c | stbi__hdr_info(stbi__context*, int*, int*, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x1ad6c
testl %eax, %eax
je 0x2e826
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d9c2
cmpb $0x0, (%r13)
je 0x2e822
movq %rbx, 0x8(%rsp)
xorl %ebp, %ebp
movl $0x1, %ebx
leaq 0x10(%rsp), %r13
movdqu 0x17(%rsp), %xmm0
pcmpeqb 0x8c9a7(%rip), %xmm0 # 0xbb0e0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0x8c9a9(%rip), %xmm1 # 0xbb0f0
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
cmovel %ebx, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d9c2
cmpb $0x0, 0x10(%rsp)
jne 0x2e72b
movq %r13, (%rsp)
testl %ebp, %ebp
je 0x2e826
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d9c2
movl $0x592d, %eax # imm = 0x592D
xorl 0x10(%rsp), %eax
movq %r13, (%rsp)
movzbl 0x12(%rsp), %ecx
xorl $0x20, %ecx
orw %ax, %cx
jne 0x2e826
leaq 0x13(%rsp), %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
movl $0xa, %edx
callq 0xa870
testq %r12, %r12
je 0x2e7bc
movl %eax, (%r12)
movq (%rsp), %r12
decq %r12
movq 0x8(%rsp), %rbx
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x2e7c8
movq %r12, (%rsp)
leaq 0x8e3ce(%rip), %rsi # 0xbcbae
movl $0x3, %edx
movq %r12, %rdi
callq 0xa270
testl %eax, %eax
jne 0x2e826
addq $0x3, %r12
movq %r12, (%rsp)
movq %r12, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0xa870
testq %r14, %r14
je 0x2e810
movl %eax, (%r14)
movl $0x1, %eax
testq %rbx, %rbx
je 0x2e83a
movl $0x3, (%rbx)
jmp 0x2e83a
movq %r13, (%rsp)
movdqu 0xd0(%r15), %xmm0
movdqu %xmm0, 0xc0(%r15)
xorl %eax, %eax
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL14stbi__hdr_infoP13stbi__contextPiS1_S1_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
test eax, eax
jz loc_2E826
lea r13, [rsp+448h+var_438]
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
cmp byte ptr [r13+0], 0
jz loc_2E822
mov [rsp+448h+var_440], rbx
xor ebp, ebp
mov ebx, 1
lea r13, [rsp+448h+var_438]
loc_2E72B:
movdqu xmm0, [rsp+448h+var_438+7]
pcmpeqb xmm0, cs:xmmword_BB0E0
movdqa xmm1, [rsp+448h+var_438]
pcmpeqb xmm1, cs:xmmword_BB0F0
pand xmm1, xmm0
pmovmskb eax, xmm1
cmp eax, 0FFFFh
cmovz ebp, ebx
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
cmp byte ptr [rsp+448h+var_438], 0
jnz short loc_2E72B
mov [rsp+448h+var_448], r13
test ebp, ebp
jz loc_2E826
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
mov eax, 592Dh
xor eax, dword ptr [rsp+448h+var_438]
mov [rsp+448h+var_448], r13
movzx ecx, byte ptr [rsp+448h+var_438+2]
xor ecx, 20h
or cx, ax
jnz loc_2E826
lea rdi, [rsp+448h+var_438+3]
mov rsi, rsp
mov [rsi], rdi
mov edx, 0Ah
call _strtol
test r12, r12
jz short loc_2E7BC
mov [r12], eax
loc_2E7BC:
mov r12, [rsp+448h+var_448]
dec r12
mov rbx, [rsp+448h+var_440]
loc_2E7C8:
cmp byte ptr [r12+1], 20h ; ' '
lea r12, [r12+1]
jz short loc_2E7C8
mov [rsp+448h+var_448], r12
lea rsi, asc_BCBAE; "+X "
mov edx, 3
mov rdi, r12
call _strncmp
test eax, eax
jnz short loc_2E826
add r12, 3
mov [rsp+448h+var_448], r12
mov rdi, r12
xor esi, esi
mov edx, 0Ah
call _strtol
test r14, r14
jz short loc_2E810
mov [r14], eax
loc_2E810:
mov eax, 1
test rbx, rbx
jz short loc_2E83A
mov dword ptr [rbx], 3
jmp short loc_2E83A
loc_2E822:
mov [rsp+448h+var_448], r13
loc_2E826:
movdqu xmm0, xmmword ptr [r15+0D0h]
movdqu xmmword ptr [r15+0C0h], xmm0
xor eax, eax
loc_2E83A:
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long stbi__hdr_info(__m128i *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
int v6; // ebp
int v7; // eax
__int8 *v8; // r12
_DWORD *v9; // rbx
int v11; // eax
long long result; // rax
__m128i *v13; // [rsp+0h] [rbp-448h] BYREF
_DWORD *v14; // [rsp+8h] [rbp-440h]
__m128i v15[67]; // [rsp+10h] [rbp-438h] BYREF
if ( !(unsigned int)stbi__hdr_test((long long)a1) )
goto LABEL_19;
stbi__hdr_gettoken((long long)a1, (long long)v15);
if ( !v15[0].m128i_i8[0] )
{
v13 = v15;
LABEL_19:
a1[12] = _mm_loadu_si128(a1 + 13);
return 0LL;
}
v14 = a4;
v6 = 0;
do
{
if ( _mm_movemask_epi8(
_mm_and_si128(
_mm_cmpeq_epi8(_mm_load_si128(v15), (__m128i)xmmword_BB0F0),
_mm_cmpeq_epi8(
_mm_loadu_si128((const __m128i *)((char *)&v15[0].m128i_u32[1] + 3)),
(__m128i)xmmword_BB0E0))) == 0xFFFF )
v6 = 1;
stbi__hdr_gettoken((long long)a1, (long long)v15);
}
while ( v15[0].m128i_i8[0] );
v13 = v15;
if ( !v6 )
goto LABEL_19;
stbi__hdr_gettoken((long long)a1, (long long)v15);
v13 = v15;
if ( v15[0].m128i_i16[0] ^ 0x592D | v15[0].m128i_u8[2] ^ 0x20 )
goto LABEL_19;
v13 = (__m128i *)((char *)v15[0].m128i_i32 + 3);
v7 = strtol((char *)v15[0].m128i_i32 + 3, &v13, 10LL);
if ( a3 )
*a3 = v7;
v8 = &v13[-1].m128i_i8[15];
v9 = v14;
while ( *++v8 == 32 )
;
v13 = (__m128i *)v8;
if ( (unsigned int)strncmp(v8, "+X ", 3LL) )
goto LABEL_19;
v13 = (__m128i *)(v8 + 3);
v11 = strtol(v8 + 3, 0LL, 10LL);
if ( a2 )
*a2 = v11;
result = 1LL;
if ( v9 )
*v9 = 3;
return result;
}
| |||
34,926 | stbi__hdr_info(stbi__context*, int*, int*, int*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__hdr_test(s) == 0) {
stbi__rewind( s );
return 0;
}
for(;;) {
token = stbi__hdr_gettoken(s,buffer);
if (token[0] == 0) break;
if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
}
if (!valid) {
stbi__rewind( s );
return 0;
}
token = stbi__hdr_gettoken(s,buffer);
if (strncmp(token, "-Y ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*y = (int) strtol(token, &token, 10);
while (*token == ' ') ++token;
if (strncmp(token, "+X ", 3)) {
stbi__rewind( s );
return 0;
}
token += 3;
*x = (int) strtol(token, NULL, 10);
*comp = 3;
return 1;
} | O3 | c | stbi__hdr_info(stbi__context*, int*, int*, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x1a809
testl %eax, %eax
je 0x2da69
movq %r14, 0x8(%rsp)
movq %rbx, %r14
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2cc1a
cmpb $0x0, (%r13)
je 0x2da69
xorl %ebp, %ebp
movl $0x1, %ebx
leaq 0x10(%rsp), %r13
movdqu 0x17(%rsp), %xmm0
pcmpeqb 0x8c747(%rip), %xmm0 # 0xba0e0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0x8c749(%rip), %xmm1 # 0xba0f0
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
cmovel %ebx, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq 0x2cc1a
cmpb $0x0, 0x10(%rsp)
jne 0x2d98b
testl %ebp, %ebp
je 0x2da69
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x2cc1a
movl $0x592d, %eax # imm = 0x592D
xorl (%r13), %eax
movzbl 0x2(%r13), %ecx
xorl $0x20, %ecx
orw %ax, %cx
jne 0x2da69
leaq 0x13(%rsp), %rdi
movq %rsp, %rsi
movq %rdi, (%rsi)
movl $0xa, %edx
callq 0xa860
testq %r12, %r12
je 0x2da15
movl %eax, (%r12)
movq (%rsp), %rdi
addq $0x2, %rdi
movzbl -0x2(%rdi), %eax
incq %rdi
cmpl $0x20, %eax
je 0x2da1d
cmpl $0x2b, %eax
jne 0x2da69
cmpb $0x58, -0x2(%rdi)
jne 0x2da69
cmpb $0x20, -0x1(%rdi)
jne 0x2da69
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0xa, %edx
callq 0xa860
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x2da56
movl %eax, (%rcx)
movl $0x1, %eax
testq %r14, %r14
je 0x2da7d
movl $0x3, (%r14)
jmp 0x2da7d
movdqu 0xd0(%r15), %xmm0
movdqu %xmm0, 0xc0(%r15)
xorl %eax, %eax
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL14stbi__hdr_infoP13stbi__contextPiS1_S1_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
test eax, eax
jz loc_2DA69
mov [rsp+448h+var_440], r14
mov r14, rbx
lea r13, [rsp+448h+var_438]
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
cmp byte ptr [r13+0], 0
jz loc_2DA69
xor ebp, ebp
mov ebx, 1
lea r13, [rsp+448h+var_438]
loc_2D98B:
movdqu xmm0, [rsp+448h+var_438+7]
pcmpeqb xmm0, cs:xmmword_BA0E0
movdqa xmm1, [rsp+448h+var_438]
pcmpeqb xmm1, cs:xmmword_BA0F0
pand xmm1, xmm0
pmovmskb eax, xmm1
cmp eax, 0FFFFh
cmovz ebp, ebx
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
cmp byte ptr [rsp+448h+var_438], 0
jnz short loc_2D98B
test ebp, ebp
jz loc_2DA69
lea r13, [rsp+448h+var_438]
mov rdi, r15
mov rsi, r13
call _ZL18stbi__hdr_gettokenP13stbi__contextPc; stbi__hdr_gettoken(stbi__context *,char *)
mov eax, 592Dh
xor eax, [r13+0]
movzx ecx, byte ptr [r13+2]
xor ecx, 20h
or cx, ax
jnz short loc_2DA69
lea rdi, [rsp+448h+var_438+3]
mov rsi, rsp
mov [rsi], rdi
mov edx, 0Ah
call _strtol
test r12, r12
jz short loc_2DA15
mov [r12], eax
loc_2DA15:
mov rdi, [rsp+448h+var_448]
add rdi, 2
loc_2DA1D:
movzx eax, byte ptr [rdi-2]
inc rdi
cmp eax, 20h ; ' '
jz short loc_2DA1D
cmp eax, 2Bh ; '+'
jnz short loc_2DA69
cmp byte ptr [rdi-2], 58h ; 'X'
jnz short loc_2DA69
cmp byte ptr [rdi-1], 20h ; ' '
jnz short loc_2DA69
mov [rsp+448h+var_448], rdi
xor esi, esi
mov edx, 0Ah
call _strtol
mov rcx, [rsp+448h+var_440]
test rcx, rcx
jz short loc_2DA56
mov [rcx], eax
loc_2DA56:
mov eax, 1
test r14, r14
jz short loc_2DA7D
mov dword ptr [r14], 3
jmp short loc_2DA7D
loc_2DA69:
movdqu xmm0, xmmword ptr [r15+0D0h]
movdqu xmmword ptr [r15+0C0h], xmm0
xor eax, eax
loc_2DA7D:
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long stbi__hdr_info(__m128i *a1, _DWORD *a2, _DWORD *a3, _DWORD *a4)
{
int v7; // ebp
int v8; // eax
char *v9; // rdi
int v10; // eax
int v11; // eax
long long result; // rax
__int8 *v13; // [rsp+0h] [rbp-448h] BYREF
_DWORD *v14; // [rsp+8h] [rbp-440h]
__m128i v15[67]; // [rsp+10h] [rbp-438h] BYREF
if ( !(unsigned int)stbi__hdr_test((long long)a1) )
goto LABEL_20;
v14 = a2;
stbi__hdr_gettoken((long long)a1, (long long)v15);
if ( !v15[0].m128i_i8[0] )
goto LABEL_20;
v7 = 0;
do
{
if ( _mm_movemask_epi8(
_mm_and_si128(
_mm_cmpeq_epi8(_mm_load_si128(v15), (__m128i)xmmword_BA0F0),
_mm_cmpeq_epi8(
_mm_loadu_si128((const __m128i *)((char *)&v15[0].m128i_u32[1] + 3)),
(__m128i)xmmword_BA0E0))) == 0xFFFF )
v7 = 1;
stbi__hdr_gettoken((long long)a1, (long long)v15);
}
while ( v15[0].m128i_i8[0] );
if ( !v7 )
goto LABEL_20;
stbi__hdr_gettoken((long long)a1, (long long)v15);
if ( v15[0].m128i_i16[0] ^ 0x592D | v15[0].m128i_u8[2] ^ 0x20 )
goto LABEL_20;
v13 = &v15[0].m128i_i8[3];
v8 = strtol((char *)v15[0].m128i_i32 + 3, &v13, 10LL);
if ( a3 )
*a3 = v8;
v9 = v13 + 2;
do
{
v10 = (unsigned __int8)*(v9 - 2);
++v9;
}
while ( v10 == 32 );
if ( v10 == 43 && *(v9 - 2) == 88 && *(v9 - 1) == 32 )
{
v13 = v9;
v11 = strtol(v9, 0LL, 10LL);
if ( v14 )
*v14 = v11;
result = 1LL;
if ( a4 )
*a4 = 3;
}
else
{
LABEL_20:
a1[12] = _mm_loadu_si128(a1 + 13);
return 0LL;
}
return result;
}
| |||
34,927 | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static float parseNumberOrPercentage(std::string_view input, bool allowPercentage, float defaultValue)
{
float value;
if(!parseNumber(input, value))
return defaultValue;
if(allowPercentage) {
if(skipDelimiter(input, '%'))
value /= 100.f;
value = std::clamp(value, 0.f, 1.f);
}
if(!input.empty())
return defaultValue;
return value;
} | O0 | cpp | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movss %xmm0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x339b0
testb $0x1, %al
jne 0x314ac
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3152e
testb $0x1, -0x19(%rbp)
je 0x3150b
leaq -0x18(%rbp), %rdi
movl $0x25, %esi
callq 0x33420
testb $0x1, %al
jne 0x314c6
jmp 0x314dc
movss -0x24(%rbp), %xmm0
movss 0x5aefd(%rip), %xmm1 # 0x8c3d0
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x5abdc(%rip), %xmm0 # 0x8c0c8
movss %xmm0, -0x2c(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x22880
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x20620
testb $0x1, %al
jne 0x31524
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3152e
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN7lunasvgL23parseNumberOrPercentageESt17basic_string_viewIcSt11char_traitsIcEEbf:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_18], rdi
mov [rbp+var_10], rsi
and al, 1
mov [rbp+var_19], al
movss [rbp+var_20], xmm0
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_24]
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, 1
jnz short loc_314AC
movss xmm0, [rbp+var_20]
movss [rbp+var_4], xmm0
jmp loc_3152E
loc_314AC:
test [rbp+var_19], 1
jz short loc_3150B
lea rdi, [rbp+var_18]
mov esi, 25h ; '%'
call _ZN7lunasvg13skipDelimiterERSt17basic_string_viewIcSt11char_traitsIcEEc; lunasvg::skipDelimiter(std::string_view &,char)
test al, 1
jnz short loc_314C6
jmp short loc_314DC
loc_314C6:
movss xmm0, [rbp+var_24]
movss xmm1, cs:dword_8C3D0
divss xmm0, xmm1
movss [rbp+var_24], xmm0
loc_314DC:
xorps xmm0, xmm0
movss [rbp+var_28], xmm0
movss xmm0, cs:flt_8C0C8
movss [rbp+var_2C], xmm0
lea rdi, [rbp+var_24]
lea rsi, [rbp+var_28]
lea rdx, [rbp+var_2C]
call _ZSt5clampIfERKT_S2_S2_S2_; std::clamp<float>(float const&,float const&,float const&)
movss xmm0, dword ptr [rax]
movss [rbp+var_24], xmm0
loc_3150B:
lea rdi, [rbp+var_18]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5emptyEv; std::string_view::empty(void)
test al, 1
jnz short loc_31524
movss xmm0, [rbp+var_20]
movss [rbp+var_4], xmm0
jmp short loc_3152E
loc_31524:
movss xmm0, [rbp+var_24]
movss [rbp+var_4], xmm0
loc_3152E:
movss xmm0, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| float lunasvg::parseNumberOrPercentage(long long a1, long long a2, char a3, float a4)
{
int v5; // [rsp+4h] [rbp-2Ch] BYREF
int v6; // [rsp+8h] [rbp-28h] BYREF
float v7; // [rsp+Ch] [rbp-24h] BYREF
float v8; // [rsp+10h] [rbp-20h]
char v9; // [rsp+17h] [rbp-19h]
_QWORD v10[2]; // [rsp+18h] [rbp-18h] BYREF
v10[0] = a1;
v10[1] = a2;
v9 = a3 & 1;
v8 = a4;
if ( (lunasvg::parseNumber<float>(v10, &v7) & 1) == 0 )
return v8;
if ( (v9 & 1) != 0 )
{
if ( (lunasvg::skipDelimiter(v10, 37LL) & 1) != 0 )
v7 = v7 / 100.0;
v6 = 0;
v5 = 1065353216;
v7 = *std::clamp<float>(&v7, (float *)&v6, (float *)&v5);
}
if ( std::string_view::empty(v10) )
return v7;
else
return v8;
}
| parseNumberOrPercentage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x10],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOVSS dword ptr [RBP + -0x20],XMM0
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x24]
CALL 0x001339b0
TEST AL,0x1
JNZ 0x001314ac
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x0013152e
LAB_001314ac:
TEST byte ptr [RBP + -0x19],0x1
JZ 0x0013150b
LEA RDI,[RBP + -0x18]
MOV ESI,0x25
CALL 0x00133420
TEST AL,0x1
JNZ 0x001314c6
JMP 0x001314dc
LAB_001314c6:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS XMM1,dword ptr [0x0018c3d0]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_001314dc:
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x28],XMM0
MOVSS XMM0,dword ptr [0x0018c0c8]
MOVSS dword ptr [RBP + -0x2c],XMM0
LEA RDI,[RBP + -0x24]
LEA RSI,[RBP + -0x28]
LEA RDX,[RBP + -0x2c]
CALL 0x00122880
MOVSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_0013150b:
LEA RDI,[RBP + -0x18]
CALL 0x00120620
TEST AL,0x1
JNZ 0x00131524
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x0013152e
LAB_00131524:
MOVSS XMM0,dword ptr [RBP + -0x24]
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_0013152e:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
/* lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char> >, bool,
float) */
float __thiscall
lunasvg::parseNumberOrPercentage(float param_1,lunasvg *this,int8 param_3,byte param_4)
{
bool bVar1;
ulong uVar2;
float *pfVar3;
float local_34;
float local_30;
float local_2c;
float local_28;
byte local_21;
lunasvg *local_20;
int8 local_18;
float local_c;
local_21 = param_4 & 1;
local_28 = param_1;
local_20 = this;
local_18 = param_3;
bVar1 = parseNumber<float>((basic_string_view *)&local_20,&local_2c);
if (bVar1) {
if ((local_21 & 1) != 0) {
uVar2 = skipDelimiter((basic_string_view *)&local_20,'%');
if ((uVar2 & 1) != 0) {
local_2c = local_2c / DAT_0018c3d0;
}
local_30 = 0.0;
local_34 = DAT_0018c0c8;
pfVar3 = std::clamp<float>(&local_2c,&local_30,&local_34);
local_2c = *pfVar3;
}
uVar2 = std::basic_string_view<char,std::char_traits<char>>::empty
((basic_string_view<char,std::char_traits<char>> *)&local_20);
if ((uVar2 & 1) == 0) {
local_c = local_28;
}
else {
local_c = local_2c;
}
}
else {
local_c = local_28;
}
return local_c;
}
| |
34,928 | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static float parseNumberOrPercentage(std::string_view input, bool allowPercentage, float defaultValue)
{
float value;
if(!parseNumber(input, value))
return defaultValue;
if(allowPercentage) {
if(skipDelimiter(input, '%'))
value /= 100.f;
value = std::clamp(value, 0.f, 1.f);
}
if(!input.empty())
return defaultValue;
return value;
} | O1 | cpp | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float):
pushq %rbx
subq $0x20, %rsp
movss %xmm0, 0xc(%rsp)
movl %edx, %ebx
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x172e2
testb %al, %al
je 0x16b4f
testb %bl, %bl
movss 0xc(%rsp), %xmm0
je 0x16b3f
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x16b1c
movq 0x18(%rsp), %rcx
cmpb $0x25, (%rcx)
jne 0x16b1c
incq %rcx
movq %rcx, 0x18(%rsp)
decq %rax
movq %rax, 0x10(%rsp)
movss 0x8(%rsp), %xmm1
divss 0x2ce42(%rip), %xmm1 # 0x43958
movss %xmm1, 0x8(%rsp)
movss 0x8(%rsp), %xmm3
movss 0x2c5ca(%rip), %xmm1 # 0x430f4
minss %xmm3, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm3
andnps %xmm1, %xmm3
movss %xmm3, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x16b55
movss 0x8(%rsp), %xmm0
jmp 0x16b55
movss 0xc(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
| _ZN7lunasvgL23parseNumberOrPercentageESt17basic_string_viewIcSt11char_traitsIcEEbf:
push rbx
sub rsp, 20h
movss [rsp+28h+var_1C], xmm0
mov ebx, edx
lea rax, [rsp+28h+var_18]
mov [rax], rdi
mov [rax+8], rsi
lea rsi, [rsp+28h+var_20]
mov rdi, rax
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz short loc_16B4F
test bl, bl
movss xmm0, [rsp+28h+var_1C]
jz short loc_16B3F
mov rax, [rsp+28h+var_18]
test rax, rax
jz short loc_16B1C
mov rcx, [rsp+28h+var_10]
cmp byte ptr [rcx], 25h ; '%'
jnz short loc_16B1C
inc rcx
mov [rsp+28h+var_10], rcx
dec rax
mov [rsp+28h+var_18], rax
movss xmm1, [rsp+28h+var_20]
divss xmm1, cs:dword_43958
movss [rsp+28h+var_20], xmm1
loc_16B1C:
movss xmm3, [rsp+28h+var_20]
movss xmm1, cs:flt_430F4
minss xmm1, xmm3
xorps xmm2, xmm2
cmpltss xmm3, xmm2
andnps xmm3, xmm1
movss [rsp+28h+var_20], xmm3
loc_16B3F:
cmp [rsp+28h+var_18], 0
jnz short loc_16B55
movss xmm0, [rsp+28h+var_20]
jmp short loc_16B55
loc_16B4F:
movss xmm0, [rsp+28h+var_1C]
loc_16B55:
add rsp, 20h
pop rbx
retn
| float lunasvg::parseNumberOrPercentage(long long a1, _BYTE *a2, char a3, float a4)
{
float result; // xmm0_4
__m128 v6; // xmm1
float v7; // [rsp+8h] [rbp-20h] BYREF
float v8; // [rsp+Ch] [rbp-1Ch]
long long v9; // [rsp+10h] [rbp-18h] BYREF
_BYTE *v10; // [rsp+18h] [rbp-10h]
v8 = a4;
v9 = a1;
v10 = a2;
if ( !(unsigned __int8)lunasvg::parseNumber<float>(&v9, &v7) )
return v8;
result = v8;
if ( a3 )
{
if ( v9 && *v10 == 37 )
{
++v10;
--v9;
v7 = v7 / 100.0;
}
v6 = (__m128)0x3F800000u;
v6.m128_f32[0] = fminf(1.0, v7);
LODWORD(v7) = _mm_andnot_ps(_mm_cmplt_ss((__m128)LODWORD(v7), (__m128)0LL), v6).m128_u32[0];
}
if ( !v9 )
return v7;
return result;
}
| parseNumberOrPercentage:
PUSH RBX
SUB RSP,0x20
MOVSS dword ptr [RSP + 0xc],XMM0
MOV EBX,EDX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX],RDI
MOV qword ptr [RAX + 0x8],RSI
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x001172e2
TEST AL,AL
JZ 0x00116b4f
TEST BL,BL
MOVSS XMM0,dword ptr [RSP + 0xc]
JZ 0x00116b3f
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x00116b1c
MOV RCX,qword ptr [RSP + 0x18]
CMP byte ptr [RCX],0x25
JNZ 0x00116b1c
INC RCX
MOV qword ptr [RSP + 0x18],RCX
DEC RAX
MOV qword ptr [RSP + 0x10],RAX
MOVSS XMM1,dword ptr [RSP + 0x8]
DIVSS XMM1,dword ptr [0x00143958]
MOVSS dword ptr [RSP + 0x8],XMM1
LAB_00116b1c:
MOVSS XMM3,dword ptr [RSP + 0x8]
MOVSS XMM1,dword ptr [0x001430f4]
MINSS XMM1,XMM3
XORPS XMM2,XMM2
CMPLTSS XMM3,XMM2
ANDNPS XMM3,XMM1
MOVSS dword ptr [RSP + 0x8],XMM3
LAB_00116b3f:
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00116b55
MOVSS XMM0,dword ptr [RSP + 0x8]
JMP 0x00116b55
LAB_00116b4f:
MOVSS XMM0,dword ptr [RSP + 0xc]
LAB_00116b55:
ADD RSP,0x20
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char> >, bool,
float) */
float __thiscall
lunasvg::parseNumberOrPercentage(float param_1,lunasvg *this,char *param_3,char param_4)
{
bool bVar1;
float fVar2;
float local_20;
float local_1c;
lunasvg *local_18;
char *local_10;
local_1c = param_1;
local_18 = this;
local_10 = param_3;
bVar1 = parseNumber<float>((basic_string_view *)&local_18,&local_20);
if (bVar1) {
if (param_4 != '\0') {
if ((local_18 != (lunasvg *)0x0) && (*local_10 == '%')) {
local_18 = local_18 + -1;
local_20 = local_20 / _DAT_00143958;
}
fVar2 = DAT_001430f4;
if (local_20 <= DAT_001430f4) {
fVar2 = local_20;
}
local_20 = (float)(~-(uint)(local_20 < 0.0) & (uint)fVar2);
}
if (local_18 == (lunasvg *)0x0) {
local_1c = local_20;
}
}
return local_1c;
}
| |
34,929 | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static float parseNumberOrPercentage(std::string_view input, bool allowPercentage, float defaultValue)
{
float value;
if(!parseNumber(input, value))
return defaultValue;
if(allowPercentage) {
if(skipDelimiter(input, '%'))
value /= 100.f;
value = std::clamp(value, 0.f, 1.f);
}
if(!input.empty())
return defaultValue;
return value;
} | O3 | cpp | lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char>>, bool, float):
pushq %rbx
subq $0x20, %rsp
movss %xmm0, 0xc(%rsp)
movl %edx, %ebx
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x16bbd
testb %al, %al
je 0x1640b
movq 0x10(%rsp), %rax
testb %bl, %bl
je 0x16438
testq %rax, %rax
je 0x16413
movq 0x18(%rsp), %rcx
cmpb $0x25, (%rcx)
movss 0x8(%rsp), %xmm0
jne 0x1641b
decq %rax
divss 0x2d5b7(%rip), %xmm0 # 0x439c0
jmp 0x1641b
movss 0xc(%rsp), %xmm0
jmp 0x16449
movss 0x8(%rsp), %xmm0
xorl %eax, %eax
movss 0x2ccd1(%rip), %xmm1 # 0x430f4
minss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0xc(%rsp), %xmm0
testq %rax, %rax
jne 0x16449
movss 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
| _ZN7lunasvgL23parseNumberOrPercentageESt17basic_string_viewIcSt11char_traitsIcEEbf:
push rbx
sub rsp, 20h
movss [rsp+28h+var_1C], xmm0
mov ebx, edx
lea rax, [rsp+28h+var_18]
mov [rax], rdi
mov [rax+8], rsi
lea rsi, [rsp+28h+var_20]
mov rdi, rax
call _ZN7lunasvg11parseNumberIfEEbRSt17basic_string_viewIcSt11char_traitsIcEERT_; lunasvg::parseNumber<float>(std::string_view &,float &)
test al, al
jz short loc_1640B
mov rax, [rsp+28h+var_18]
test bl, bl
jz short loc_16438
test rax, rax
jz short loc_16413
mov rcx, [rsp+28h+var_10]
cmp byte ptr [rcx], 25h ; '%'
movss xmm0, [rsp+28h+var_20]
jnz short loc_1641B
dec rax
divss xmm0, cs:dword_439C0
jmp short loc_1641B
loc_1640B:
movss xmm0, [rsp+28h+var_1C]
jmp short loc_16449
loc_16413:
movss xmm0, [rsp+28h+var_20]
xor eax, eax
loc_1641B:
movss xmm1, cs:flt_430F4
minss xmm1, xmm0
xorps xmm2, xmm2
cmpltss xmm0, xmm2
andnps xmm0, xmm1
movss [rsp+28h+var_20], xmm0
loc_16438:
movss xmm0, [rsp+28h+var_1C]
test rax, rax
jnz short loc_16449
movss xmm0, [rsp+28h+var_20]
loc_16449:
add rsp, 20h
pop rbx
retn
| float lunasvg::parseNumberOrPercentage(long long a1, _BYTE *a2, char a3, float a4)
{
long long v5; // rax
__m128 v6; // xmm0
float result; // xmm0_4
__m128 v8; // xmm1
float v9; // [rsp+8h] [rbp-20h] BYREF
float v10; // [rsp+Ch] [rbp-1Ch]
long long v11; // [rsp+10h] [rbp-18h] BYREF
_BYTE *v12; // [rsp+18h] [rbp-10h]
v10 = a4;
v11 = a1;
v12 = a2;
if ( !(unsigned __int8)lunasvg::parseNumber<float>(&v11, &v9) )
return v10;
v5 = v11;
if ( a3 )
{
if ( v11 )
{
v6 = (__m128)LODWORD(v9);
if ( *v12 == 37 )
{
v5 = v11 - 1;
v6.m128_f32[0] = v9 / 100.0;
}
}
else
{
v6 = (__m128)LODWORD(v9);
v5 = 0LL;
}
v8 = (__m128)0x3F800000u;
v8.m128_f32[0] = fminf(1.0, v6.m128_f32[0]);
LODWORD(v9) = _mm_andnot_ps(_mm_cmplt_ss(v6, (__m128)0LL), v8).m128_u32[0];
}
result = v10;
if ( !v5 )
return v9;
return result;
}
| parseNumberOrPercentage:
PUSH RBX
SUB RSP,0x20
MOVSS dword ptr [RSP + 0xc],XMM0
MOV EBX,EDX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX],RDI
MOV qword ptr [RAX + 0x8],RSI
LEA RSI,[RSP + 0x8]
MOV RDI,RAX
CALL 0x00116bbd
TEST AL,AL
JZ 0x0011640b
MOV RAX,qword ptr [RSP + 0x10]
TEST BL,BL
JZ 0x00116438
TEST RAX,RAX
JZ 0x00116413
MOV RCX,qword ptr [RSP + 0x18]
CMP byte ptr [RCX],0x25
MOVSS XMM0,dword ptr [RSP + 0x8]
JNZ 0x0011641b
DEC RAX
DIVSS XMM0,dword ptr [0x001439c0]
JMP 0x0011641b
LAB_0011640b:
MOVSS XMM0,dword ptr [RSP + 0xc]
JMP 0x00116449
LAB_00116413:
MOVSS XMM0,dword ptr [RSP + 0x8]
XOR EAX,EAX
LAB_0011641b:
MOVSS XMM1,dword ptr [0x001430f4]
MINSS XMM1,XMM0
XORPS XMM2,XMM2
CMPLTSS XMM0,XMM2
ANDNPS XMM0,XMM1
MOVSS dword ptr [RSP + 0x8],XMM0
LAB_00116438:
MOVSS XMM0,dword ptr [RSP + 0xc]
TEST RAX,RAX
JNZ 0x00116449
MOVSS XMM0,dword ptr [RSP + 0x8]
LAB_00116449:
ADD RSP,0x20
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lunasvg::parseNumberOrPercentage(std::basic_string_view<char, std::char_traits<char> >, bool,
float) */
float __thiscall
lunasvg::parseNumberOrPercentage(float param_1,lunasvg *this,char *param_3,char param_4)
{
bool bVar1;
float fVar2;
float local_20;
float local_1c;
lunasvg *local_18;
char *local_10;
local_1c = param_1;
local_18 = this;
local_10 = param_3;
bVar1 = parseNumber<float>((basic_string_view *)&local_18,&local_20);
if (bVar1) {
if (param_4 != '\0') {
if (local_18 == (lunasvg *)0x0) {
local_18 = (lunasvg *)0x0;
}
else if (*local_10 == '%') {
local_18 = local_18 + -1;
local_20 = local_20 / _DAT_001439c0;
}
fVar2 = DAT_001430f4;
if (local_20 <= DAT_001430f4) {
fVar2 = local_20;
}
local_20 = (float)(~-(uint)(local_20 < 0.0) & (uint)fVar2);
}
if (local_18 == (lunasvg *)0x0) {
local_1c = local_20;
}
}
return local_1c;
}
| |
34,930 | transid_get_packed | eloqsql/storage/maria/ma_key.c | ulonglong transid_get_packed(MARIA_SHARE *share, const uchar *from)
{
ulonglong value;
uint length;
if (from[0] < MARIA_MIN_TRANSID_PACK_OFFSET)
value= (ulonglong) from[0];
else
{
value= 0;
for (length= (uint) (from[0] - MARIA_TRANSID_PACK_OFFSET),
value= (ulonglong) from[1], from+=2;
--length ;
from++)
value= (value << 8) + ((ulonglong) *from);
}
return (value >> 1) + share->state.create_trid;
} | O3 | c | transid_get_packed:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
cmpq $0xf2, %rcx
ja 0x36742
movq %rcx, %rax
jmp 0x3676b
movzbl 0x1(%rsi), %eax
cmpl $0xfa, %ecx
je 0x3676b
addq $-0xfa, %rcx
xorl %edx, %edx
shlq $0x8, %rax
movzbl 0x2(%rsi,%rdx), %r8d
orq %r8, %rax
incq %rdx
cmpl %edx, %ecx
jne 0x36757
shrq %rax
addq 0xe0(%rdi), %rax
popq %rbp
retq
| transid_get_packed:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
cmp rcx, 0F2h
ja short loc_36742
mov rax, rcx
jmp short loc_3676B
loc_36742:
movzx eax, byte ptr [rsi+1]
cmp ecx, 0FAh
jz short loc_3676B
add rcx, 0FFFFFFFFFFFFFF06h
xor edx, edx
loc_36757:
shl rax, 8
movzx r8d, byte ptr [rsi+rdx+2]
or rax, r8
inc rdx
cmp ecx, edx
jnz short loc_36757
loc_3676B:
shr rax, 1
add rax, [rdi+0E0h]
pop rbp
retn
| unsigned long long transid_get_packed(long long a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
unsigned long long v3; // rax
int v4; // ecx
long long v5; // rdx
v2 = *a2;
if ( v2 > 0xF2 )
{
v3 = a2[1];
if ( (_DWORD)v2 != 250 )
{
v4 = v2 - 250;
v5 = 0LL;
do
v3 = a2[v5++ + 2] | (v3 << 8);
while ( v4 != (_DWORD)v5 );
}
}
else
{
v3 = *a2;
}
return *(_QWORD *)(a1 + 224) + (v3 >> 1);
}
| transid_get_packed:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
CMP RCX,0xf2
JA 0x00136742
MOV RAX,RCX
JMP 0x0013676b
LAB_00136742:
MOVZX EAX,byte ptr [RSI + 0x1]
CMP ECX,0xfa
JZ 0x0013676b
ADD RCX,-0xfa
XOR EDX,EDX
LAB_00136757:
SHL RAX,0x8
MOVZX R8D,byte ptr [RSI + RDX*0x1 + 0x2]
OR RAX,R8
INC RDX
CMP ECX,EDX
JNZ 0x00136757
LAB_0013676b:
SHR RAX,0x1
ADD RAX,qword ptr [RDI + 0xe0]
POP RBP
RET
|
long transid_get_packed(long param_1,byte *param_2)
{
byte bVar1;
ulong uVar2;
long lVar3;
bVar1 = *param_2;
uVar2 = (ulong)bVar1;
if ((0xf2 < uVar2) && (uVar2 = (ulong)param_2[1], bVar1 != 0xfa)) {
lVar3 = 0;
do {
uVar2 = uVar2 << 8 | (ulong)param_2[lVar3 + 2];
lVar3 = lVar3 + 1;
} while (bVar1 - 0xfa != (int)lVar3);
}
return (uVar2 >> 1) + *(long *)(param_1 + 0xe0);
}
| |
34,931 | POINTonE2_times_minus_z | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/map_to_g2.c | static void POINTonE2_times_minus_z(POINTonE2 *out, const POINTonE2 *in)
{
POINTonE2_double(out, in); /* 1: 0x2 */
POINTonE2_add_n_dbl(out, in, 2); /* 2..4: 0x3..0xc */
POINTonE2_add_n_dbl(out, in, 3); /* 5..8: 0xd..0x68 */
POINTonE2_add_n_dbl(out, in, 9); /* 9..18: 0x69..0xd200 */
POINTonE2_add_n_dbl(out, in, 32); /* 19..51: ..0xd20100000000 */
POINTonE2_add_n_dbl(out, in, 16); /* 52..68: ..0xd201000000010000 */
} | O2 | c | POINTonE2_times_minus_z:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x548e8
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cbca
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cbca
pushq $0x9
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cbca
pushq $0x20
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5cbca
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5cbca
| POINTonE2_times_minus_z:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call POINTonE2_double
push 2
pop rdx
mov rdi, r14
mov rsi, rbx
call POINTonE2_add_n_dbl
push 3
pop rdx
mov rdi, r14
mov rsi, rbx
call POINTonE2_add_n_dbl
push 9
pop rdx
mov rdi, r14
mov rsi, rbx
call POINTonE2_add_n_dbl
push 20h ; ' '
pop rdx
mov rdi, r14
mov rsi, rbx
call POINTonE2_add_n_dbl
push 10h
pop rdx
mov rdi, r14
mov rsi, rbx
pop rbx
pop r14
pop rbp
jmp $+5
| long long POINTonE2_times_minus_z(long long a1, long long a2)
{
POINTonE2_double(a1, a2);
POINTonE2_add_n_dbl(a1, a2, 2LL);
POINTonE2_add_n_dbl(a1, a2, 3LL);
POINTonE2_add_n_dbl(a1, a2, 9LL);
POINTonE2_add_n_dbl(a1, a2, 32LL);
return POINTonE2_add_n_dbl(a1, a2, 16LL);
}
| POINTonE2_times_minus_z:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001548e8
PUSH 0x2
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0015cbca
PUSH 0x3
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0015cbca
PUSH 0x9
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0015cbca
PUSH 0x20
POP RDX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0015cbca
PUSH 0x10
POP RDX
MOV RDI,R14
MOV RSI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0015cbca
|
void POINTonE2_times_minus_z(int8 param_1,int8 param_2)
{
POINTonE2_double();
POINTonE2_add_n_dbl(param_1,param_2,2);
POINTonE2_add_n_dbl(param_1,param_2,3);
POINTonE2_add_n_dbl(param_1,param_2,9);
POINTonE2_add_n_dbl(param_1,param_2,0x20);
POINTonE2_add_n_dbl(param_1,param_2,0x10);
return;
}
| |
34,932 | lzr_siemens_handle_reponse | xtate/src/probe-modules/lzr-probes/lzr-siemens.c | static unsigned lzr_siemens_handle_reponse(unsigned th_idx, ProbeTarget *target,
const unsigned char *px,
unsigned sizeof_px, OutItem *item) {
if (sizeof_px >= 6 && px[4] + 1 == sizeof_px - 4 && px[5] == 0xd0) {
item->level = OUT_SUCCESS;
safe_strcpy(item->classification, OUT_CLS_SIZE, "siemens");
safe_strcpy(item->reason, OUT_RSN_SIZE, "matched");
return 0;
}
item->level = OUT_FAILURE;
safe_strcpy(item->classification, OUT_CLS_SIZE, "not siemens");
safe_strcpy(item->reason, OUT_RSN_SIZE, "not matched");
return 0;
} | O3 | c | lzr_siemens_handle_reponse:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
cmpl $0x6, %ecx
jb 0x2cd96
movzbl 0x4(%rdx), %eax
addl $-0x5, %ecx
cmpl %eax, %ecx
jne 0x2cd96
cmpb $-0x30, 0x5(%rdx)
jne 0x2cd96
leaq 0x3d3d8(%rip), %r14 # 0x6a160
leaq 0x3c213(%rip), %rdx # 0x68fa2
movl $0x2, %eax
jmp 0x2cda9
leaq 0x3d36d(%rip), %r14 # 0x6a10a
leaq 0x3c1fa(%rip), %rdx # 0x68f9e
movl $0x1, %eax
movl %eax, 0x8(%rbx)
leaq 0x50(%rbx), %rdi
movl $0x1e, %esi
callq 0x51195
addq $0x6e, %rbx
movl $0x1e, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x51195
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| lzr_siemens_handle_reponse:
push r14
push rbx
push rax
mov rbx, r8
cmp ecx, 6
jb short loc_2CD96
movzx eax, byte ptr [rdx+4]
add ecx, 0FFFFFFFBh
cmp ecx, eax
jnz short loc_2CD96
cmp byte ptr [rdx+5], 0D0h
jnz short loc_2CD96
lea r14, aProtocolMatche_0+9; "matched"
lea rdx, aNotSiemens+4; "siemens"
mov eax, 2
jmp short loc_2CDA9
loc_2CD96:
lea r14, aProtocolNotMat+9; "not matched"
lea rdx, aNotSiemens; "not siemens"
mov eax, 1
loc_2CDA9:
mov [rbx+8], eax
lea rdi, [rbx+50h]
mov esi, 1Eh
call safe_strcpy
add rbx, 6Eh ; 'n'
mov esi, 1Eh
mov rdi, rbx
mov rdx, r14
call safe_strcpy
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
| long long lzr_siemens_handle_reponse(long long a1, long long a2, long long a3, unsigned int a4, long long a5)
{
int v6; // eax
if ( a4 >= 6 && a4 - 5 == *(unsigned __int8 *)(a3 + 4) && *(_BYTE *)(a3 + 5) == 0xD0 )
v6 = 2;
else
v6 = 1;
*(_DWORD *)(a5 + 8) = v6;
safe_strcpy(a5 + 80, 30LL);
safe_strcpy(a5 + 110, 30LL);
return 0LL;
}
| lzr_siemens_handle_reponse:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R8
CMP ECX,0x6
JC 0x0012cd96
MOVZX EAX,byte ptr [RDX + 0x4]
ADD ECX,-0x5
CMP ECX,EAX
JNZ 0x0012cd96
CMP byte ptr [RDX + 0x5],0xd0
JNZ 0x0012cd96
LEA R14,[0x16a160]
LEA RDX,[0x168fa2]
MOV EAX,0x2
JMP 0x0012cda9
LAB_0012cd96:
LEA R14,[0x16a10a]
LEA RDX,[0x168f9e]
MOV EAX,0x1
LAB_0012cda9:
MOV dword ptr [RBX + 0x8],EAX
LEA RDI,[RBX + 0x50]
MOV ESI,0x1e
CALL 0x00151195
ADD RBX,0x6e
MOV ESI,0x1e
MOV RDI,RBX
MOV RDX,R14
CALL 0x00151195
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8
lzr_siemens_handle_reponse
(int8 param_1,int8 param_2,long param_3,uint param_4,long param_5)
{
char *pcVar1;
int4 uVar2;
char *pcVar3;
if (((param_4 < 6) || (param_4 - 5 != (uint)*(byte *)(param_3 + 4))) ||
(*(char *)(param_3 + 5) != -0x30)) {
pcVar1 = "protocol not matched";
pcVar3 = "not siemens";
uVar2 = 1;
}
else {
pcVar1 = "protocol matched";
pcVar3 = "siemens";
uVar2 = 2;
}
*(int4 *)(param_5 + 8) = uVar2;
safe_strcpy(param_5 + 0x50,0x1e,pcVar3);
safe_strcpy(param_5 + 0x6e,0x1e,pcVar1 + 9);
return 0;
}
| |
34,933 | EndMode3D | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rcore.c | void EndMode3D(void)
{
rlDrawRenderBatchActive(); // Update and draw internal render batch
rlMatrixMode(RL_PROJECTION); // Switch to projection matrix
rlPopMatrix(); // Restore previous matrix (projection) from matrix stack
rlMatrixMode(RL_MODELVIEW); // Switch back to modelview matrix
rlLoadIdentity(); // Reset current matrix (modelview)
if (rlGetActiveFramebuffer() == 0) rlMultMatrixf(MatrixToFloat(CORE.Window.screenScale)); // Apply screen scaling if required
rlDisableDepthTest(); // Disable DEPTH_TEST for 2D
} | O3 | c | EndMode3D:
pushq %rbx
subq $0x50, %rsp
movq 0xc76a7(%rip), %rdi # 0x13b118
callq 0x611ec
leaq 0xc772b(%rip), %rax # 0x13b1a8
movq %rax, 0xc76dc(%rip) # 0x13b160
movl $0x1701, 0xc76ce(%rip) # imm = 0x1701
callq 0x603d3
leaq 0xc76ce(%rip), %rax # 0x13b168
movq %rax, 0xc76bf(%rip) # 0x13b160
movl $0x1700, 0xc76b1(%rip) # imm = 0x1700
movl $0x3f800000, %eax # imm = 0x3F800000
movl %eax, 0xc76b2(%rip) # 0x13b168
xorps %xmm0, %xmm0
movups %xmm0, 0xc76ac(%rip) # 0x13b16c
movl %eax, 0xc76b6(%rip) # 0x13b17c
movups %xmm0, 0xc76b3(%rip) # 0x13b180
movl %eax, 0xc76bd(%rip) # 0x13b190
movups %xmm0, 0xc76ba(%rip) # 0x13b194
movl %eax, 0xc76c4(%rip) # 0x13b1a4
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movl $0x8ca6, %edi # imm = 0x8CA6
movq %rbx, %rsi
callq *0xc60b7(%rip) # 0x139bb0
cmpl $0x0, (%rbx)
jne 0x73beb
movss 0xc811a(%rip), %xmm0 # 0x13bc24
movss 0xc8116(%rip), %xmm1 # 0x13bc28
movss 0xc8112(%rip), %xmm2 # 0x13bc2c
movss 0xc810e(%rip), %xmm3 # 0x13bc30
movss 0xc810a(%rip), %xmm4 # 0x13bc34
movss 0xc8106(%rip), %xmm5 # 0x13bc38
movss 0xc8102(%rip), %xmm6 # 0x13bc3c
movss 0xc80fe(%rip), %xmm7 # 0x13bc40
movss 0xc80f9(%rip), %xmm8 # 0x13bc44
movss 0xc80f4(%rip), %xmm9 # 0x13bc48
movss 0xc80ef(%rip), %xmm10 # 0x13bc4c
movss 0xc80ea(%rip), %xmm11 # 0x13bc50
movss 0xc80e5(%rip), %xmm12 # 0x13bc54
movss 0xc80e0(%rip), %xmm13 # 0x13bc58
movss 0xc80db(%rip), %xmm14 # 0x13bc5c
movss 0xc80d6(%rip), %xmm15 # 0x13bc60
leaq 0x10(%rsp), %rdi
movss %xmm0, (%rdi)
movss %xmm4, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movss %xmm12, 0xc(%rdi)
movss %xmm1, 0x10(%rdi)
movss %xmm5, 0x14(%rdi)
movss %xmm9, 0x18(%rdi)
movss %xmm13, 0x1c(%rdi)
movss %xmm2, 0x20(%rdi)
movss %xmm6, 0x24(%rdi)
movss %xmm10, 0x28(%rdi)
movss %xmm14, 0x2c(%rdi)
movss %xmm3, 0x30(%rdi)
movss %xmm7, 0x34(%rdi)
movss %xmm11, 0x38(%rdi)
movss %xmm15, 0x3c(%rdi)
callq 0x60adb
movl $0xb71, %edi # imm = 0xB71
callq *0xc5b3a(%rip) # 0x139730
addq $0x50, %rsp
popq %rbx
retq
| EndMode3D:
push rbx
sub rsp, 50h
mov rdi, cs:RLGL
call rlDrawRenderBatch
lea rax, xmmword_13B1A8
mov cs:qword_13B160, rax
mov cs:dword_13B15C, 1701h
call rlPopMatrix
lea rax, xmmword_13B168
mov cs:qword_13B160, rax
mov cs:dword_13B15C, 1700h
mov eax, 3F800000h
mov dword ptr cs:xmmword_13B168, eax
xorps xmm0, xmm0
movups cs:xmmword_13B168+4, xmm0
mov dword ptr cs:xmmword_13B178+4, eax
movups cs:xmmword_13B178+8, xmm0
mov dword ptr cs:xmmword_13B188+8, eax
movups cs:xmmword_13B188+0Ch, xmm0
mov dword ptr cs:xmmword_13B198+0Ch, eax
lea rbx, [rsp+58h+var_4C]
mov dword ptr [rbx], 0
mov edi, 8CA6h
mov rsi, rbx
call cs:glad_glGetIntegerv
cmp dword ptr [rbx], 0
jnz loc_73BEB
movss xmm0, cs:dword_13BC24
movss xmm1, dword ptr cs:xmmword_13BC28
movss xmm2, dword ptr cs:xmmword_13BC28+4
movss xmm3, dword ptr cs:xmmword_13BC28+8
movss xmm4, dword ptr cs:xmmword_13BC28+0Ch
movss xmm5, cs:dword_13BC38
movss xmm6, dword ptr cs:xmmword_13BC3C
movss xmm7, dword ptr cs:xmmword_13BC3C+4
movss xmm8, dword ptr cs:xmmword_13BC3C+8
movss xmm9, dword ptr cs:xmmword_13BC3C+0Ch
movss xmm10, cs:dword_13BC4C
movss xmm11, dword ptr cs:xmmword_13BC50
movss xmm12, dword ptr cs:xmmword_13BC50+4
movss xmm13, dword ptr cs:xmmword_13BC50+8
movss xmm14, dword ptr cs:xmmword_13BC50+0Ch
movss xmm15, cs:dword_13BC60
lea rdi, [rsp+58h+var_48]
movss dword ptr [rdi], xmm0
movss dword ptr [rdi+4], xmm4
movss dword ptr [rdi+8], xmm8
movss dword ptr [rdi+0Ch], xmm12
movss dword ptr [rdi+10h], xmm1
movss dword ptr [rdi+14h], xmm5
movss dword ptr [rdi+18h], xmm9
movss dword ptr [rdi+1Ch], xmm13
movss dword ptr [rdi+20h], xmm2
movss dword ptr [rdi+24h], xmm6
movss dword ptr [rdi+28h], xmm10
movss dword ptr [rdi+2Ch], xmm14
movss dword ptr [rdi+30h], xmm3
movss dword ptr [rdi+34h], xmm7
movss dword ptr [rdi+38h], xmm11
movss dword ptr [rdi+3Ch], xmm15
call rlMultMatrixf
loc_73BEB:
mov edi, 0B71h
call cs:glad_glDisable
add rsp, 50h
pop rbx
retn
| long long EndMode3D(
double a1,
__m128 a2,
__m128 a3,
__m128 a4,
double a5,
double a6,
__m128 a7,
__m128 a8,
long long a9,
long long a10)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
int v15; // [rsp+Ch] [rbp-4Ch] BYREF
__int32 v16[18]; // [rsp+10h] [rbp-48h] BYREF
rlDrawRenderBatch(RLGL[0], a10, a1, a2, a3, a4, a5, a6, a7, a8);
qword_13B160 = (long long)&xmmword_13B1A8;
dword_13B15C = 5889;
rlPopMatrix();
qword_13B160 = (long long)&xmmword_13B168;
dword_13B15C = 5888;
LODWORD(xmmword_13B168) = 1065353216;
*(__int128 *)((char *)&xmmword_13B168 + 4) = 0LL;
DWORD1(xmmword_13B178) = 1065353216;
*(__int128 *)((char *)&xmmword_13B178 + 8) = 0LL;
DWORD2(xmmword_13B188) = 1065353216;
*(__int128 *)((char *)&xmmword_13B188 + 12) = 0LL;
HIDWORD(xmmword_13B198) = 1065353216;
v15 = 0;
glad_glGetIntegerv(36006LL, &v15);
if ( !v15 )
{
v16[0] = dword_13BC24;
v16[1] = HIDWORD(xmmword_13BC28);
v16[2] = DWORD2(xmmword_13BC3C);
v16[3] = DWORD1(xmmword_13BC50);
v16[4] = xmmword_13BC28;
v16[5] = dword_13BC38;
v16[6] = HIDWORD(xmmword_13BC3C);
v16[7] = DWORD2(xmmword_13BC50);
v16[8] = DWORD1(xmmword_13BC28);
v16[9] = xmmword_13BC3C;
v16[10] = dword_13BC4C;
v16[11] = HIDWORD(xmmword_13BC50);
v16[12] = DWORD2(xmmword_13BC28);
v16[13] = DWORD1(xmmword_13BC3C);
v16[14] = xmmword_13BC50;
v16[15] = dword_13BC60;
rlMultMatrixf(
v16,
(long long)&v15,
v10,
v11,
v12,
v13,
COERCE_DOUBLE((unsigned long long)dword_13BC24),
COERCE_DOUBLE((unsigned long long)(unsigned int)xmmword_13BC28),
COERCE_DOUBLE((unsigned long long)DWORD1(xmmword_13BC28)),
COERCE_DOUBLE((unsigned long long)DWORD2(xmmword_13BC28)),
(__m128)HIDWORD(xmmword_13BC28),
(__m128)(unsigned int)dword_13BC38,
(__m128)(unsigned int)xmmword_13BC3C,
(__m128)DWORD1(xmmword_13BC3C));
}
return glad_glDisable(2929LL);
}
| EndMode3D:
PUSH RBX
SUB RSP,0x50
MOV RDI,qword ptr [0x0023b118]
CALL 0x001611ec
LEA RAX,[0x23b1a8]
MOV qword ptr [0x0023b160],RAX
MOV dword ptr [0x0023b15c],0x1701
CALL 0x001603d3
LEA RAX,[0x23b168]
MOV qword ptr [0x0023b160],RAX
MOV dword ptr [0x0023b15c],0x1700
MOV EAX,0x3f800000
MOV dword ptr [0x0023b168],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [0x0023b16c],XMM0
MOV dword ptr [0x0023b17c],EAX
MOVUPS xmmword ptr [0x0023b180],XMM0
MOV dword ptr [0x0023b190],EAX
MOVUPS xmmword ptr [0x0023b194],XMM0
MOV dword ptr [0x0023b1a4],EAX
LEA RBX,[RSP + 0xc]
MOV dword ptr [RBX],0x0
MOV EDI,0x8ca6
MOV RSI,RBX
CALL qword ptr [0x00239bb0]
CMP dword ptr [RBX],0x0
JNZ 0x00173beb
MOVSS XMM0,dword ptr [0x0023bc24]
MOVSS XMM1,dword ptr [0x0023bc28]
MOVSS XMM2,dword ptr [0x0023bc2c]
MOVSS XMM3,dword ptr [0x0023bc30]
MOVSS XMM4,dword ptr [0x0023bc34]
MOVSS XMM5,dword ptr [0x0023bc38]
MOVSS XMM6,dword ptr [0x0023bc3c]
MOVSS XMM7,dword ptr [0x0023bc40]
MOVSS XMM8,dword ptr [0x0023bc44]
MOVSS XMM9,dword ptr [0x0023bc48]
MOVSS XMM10,dword ptr [0x0023bc4c]
MOVSS XMM11,dword ptr [0x0023bc50]
MOVSS XMM12,dword ptr [0x0023bc54]
MOVSS XMM13,dword ptr [0x0023bc58]
MOVSS XMM14,dword ptr [0x0023bc5c]
MOVSS XMM15,dword ptr [0x0023bc60]
LEA RDI,[RSP + 0x10]
MOVSS dword ptr [RDI],XMM0
MOVSS dword ptr [RDI + 0x4],XMM4
MOVSS dword ptr [RDI + 0x8],XMM8
MOVSS dword ptr [RDI + 0xc],XMM12
MOVSS dword ptr [RDI + 0x10],XMM1
MOVSS dword ptr [RDI + 0x14],XMM5
MOVSS dword ptr [RDI + 0x18],XMM9
MOVSS dword ptr [RDI + 0x1c],XMM13
MOVSS dword ptr [RDI + 0x20],XMM2
MOVSS dword ptr [RDI + 0x24],XMM6
MOVSS dword ptr [RDI + 0x28],XMM10
MOVSS dword ptr [RDI + 0x2c],XMM14
MOVSS dword ptr [RDI + 0x30],XMM3
MOVSS dword ptr [RDI + 0x34],XMM7
MOVSS dword ptr [RDI + 0x38],XMM11
MOVSS dword ptr [RDI + 0x3c],XMM15
CALL 0x00160adb
LAB_00173beb:
MOV EDI,0xb71
CALL qword ptr [0x00239730]
ADD RSP,0x50
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void EndMode3D(void)
{
int local_4c;
int4 local_48;
int4 local_44;
int4 local_40;
int4 local_3c;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 local_28;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
rlDrawRenderBatch(RLGL);
DAT_0023b160 = &DAT_0023b1a8;
DAT_0023b15c = 0x1701;
rlPopMatrix();
DAT_0023b160 = &DAT_0023b168;
DAT_0023b15c = 0x1700;
DAT_0023b168 = 0x3f800000;
_DAT_0023b16c = 0;
_DAT_0023b174 = 0;
DAT_0023b17c = 0x3f800000;
_DAT_0023b180 = 0;
_DAT_0023b188 = 0;
DAT_0023b190 = 0x3f800000;
_DAT_0023b194 = 0;
_DAT_0023b19c = 0;
DAT_0023b1a4 = 0x3f800000;
local_4c = 0;
(*glad_glGetIntegerv)(0x8ca6,&local_4c);
if (local_4c == 0) {
local_48 = _DAT_0023bc24;
local_44 = _DAT_0023bc34;
local_40 = _DAT_0023bc44;
local_3c = _DAT_0023bc54;
local_38 = _DAT_0023bc28;
local_34 = _DAT_0023bc38;
local_30 = _DAT_0023bc48;
local_2c = _DAT_0023bc58;
local_28 = _DAT_0023bc2c;
local_24 = _DAT_0023bc3c;
local_20 = _DAT_0023bc4c;
local_1c = _DAT_0023bc5c;
local_18 = _DAT_0023bc30;
local_14 = _DAT_0023bc40;
local_10 = _DAT_0023bc50;
local_c = _DAT_0023bc60;
rlMultMatrixf();
}
(*glad_glDisable)(0xb71);
return;
}
| |
34,934 | ggml_compute_forward_clamp | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_clamp(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_clamp_f32(params, dst);
} break;
case GGML_TYPE_F16:
case GGML_TYPE_BF16:
case GGML_TYPE_Q4_0:
case GGML_TYPE_Q4_1:
case GGML_TYPE_Q5_0:
case GGML_TYPE_Q5_1:
case GGML_TYPE_Q8_0:
case GGML_TYPE_Q8_1:
case GGML_TYPE_Q2_K:
case GGML_TYPE_Q3_K:
case GGML_TYPE_Q4_K:
case GGML_TYPE_Q5_K:
case GGML_TYPE_Q6_K:
case GGML_TYPE_TQ1_0:
case GGML_TYPE_TQ2_0:
case GGML_TYPE_IQ2_XXS:
case GGML_TYPE_IQ2_XS:
case GGML_TYPE_IQ3_XXS:
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ1_M:
case GGML_TYPE_IQ4_NL:
case GGML_TYPE_IQ4_XS:
case GGML_TYPE_IQ3_S:
case GGML_TYPE_IQ2_S:
case GGML_TYPE_Q8_K:
case GGML_TYPE_I8:
case GGML_TYPE_I16:
case GGML_TYPE_I32:
case GGML_TYPE_I64:
case GGML_TYPE_F64:
case GGML_TYPE_COUNT:
{
GGML_ABORT("fatal error");
}
}
} | O0 | c | ggml_compute_forward_clamp:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x16754
jmp 0x16720
movl 0xc(%rsp), %eax
decl %eax
subl $0x3, %eax
jb 0x16765
jmp 0x1672d
movl 0xc(%rsp), %eax
addl $-0x6, %eax
subl $0x19, %eax
jb 0x16765
jmp 0x1673b
movl 0xc(%rsp), %eax
addl $-0x22, %eax
subl $0x2, %eax
jb 0x16765
jmp 0x16749
movl 0xc(%rsp), %eax
subl $0x27, %eax
je 0x16765
jmp 0x1677f
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x34f40
jmp 0x1677f
leaq 0x9b3ee(%rip), %rdi # 0xb1b5a
movl $0x23c8, %esi # imm = 0x23C8
leaq 0x9b54f(%rip), %rdx # 0xb1cc7
movb $0x0, %al
callq 0xd030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_compute_forward_clamp:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_10]
mov rax, [rax+98h]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov eax, [rax]
mov [rsp+28h+var_1C], eax
test eax, eax
jz short loc_16754
jmp short $+2
loc_16720:
mov eax, [rsp+28h+var_1C]
dec eax
sub eax, 3
jb short loc_16765
jmp short $+2
loc_1672D:
mov eax, [rsp+28h+var_1C]
add eax, 0FFFFFFFAh
sub eax, 19h
jb short loc_16765
jmp short $+2
loc_1673B:
mov eax, [rsp+28h+var_1C]
add eax, 0FFFFFFDEh
sub eax, 2
jb short loc_16765
jmp short $+2
loc_16749:
mov eax, [rsp+28h+var_1C]
sub eax, 27h ; '''
jz short loc_16765
jmp short loc_1677F
loc_16754:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call ggml_compute_forward_clamp_f32
jmp short loc_1677F
loc_16765:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 23C8h
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_1677F:
add rsp, 28h
retn
| double ggml_compute_forward_clamp(long long a1, long long a2)
{
double result; // xmm0_8
int v3; // [rsp+Ch] [rbp-1Ch]
v3 = **(_DWORD **)(a2 + 152);
if ( v3 )
{
if ( (unsigned int)(v3 - 1) < 3 || (unsigned int)(v3 - 6) < 0x19 || (unsigned int)(v3 - 34) < 2 || v3 == 39 )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
9160LL,
"fatal error");
}
else
{
ggml_compute_forward_clamp_f32(a1, a2);
}
return result;
}
| ggml_compute_forward_clamp:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0xc],EAX
TEST EAX,EAX
JZ 0x00116754
JMP 0x00116720
LAB_00116720:
MOV EAX,dword ptr [RSP + 0xc]
DEC EAX
SUB EAX,0x3
JC 0x00116765
JMP 0x0011672d
LAB_0011672d:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x6
SUB EAX,0x19
JC 0x00116765
JMP 0x0011673b
LAB_0011673b:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x22
SUB EAX,0x2
JC 0x00116765
JMP 0x00116749
LAB_00116749:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x27
JZ 0x00116765
JMP 0x0011677f
LAB_00116754:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00134f40
JMP 0x0011677f
LAB_00116765:
LEA RDI,[0x1b1b5a]
MOV ESI,0x23c8
LEA RDX,[0x1b1cc7]
MOV AL,0x0
CALL 0x0010d030
LAB_0011677f:
ADD RSP,0x28
RET
|
void ggml_compute_forward_clamp(int8 param_1,long param_2)
{
int iVar1;
iVar1 = **(int **)(param_2 + 0x98);
if (iVar1 == 0) {
ggml_compute_forward_clamp_f32(param_1,param_2);
}
else if ((((iVar1 - 1U < 3) || (iVar1 - 6U < 0x19)) || (iVar1 - 0x22U < 2)) || (iVar1 == 0x27)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x23c8,"fatal error");
}
return;
}
| |
34,935 | stbi__convert_format(unsigned char*, int, int, unsigned int, unsigned int) | llama.cpp/examples/llava/../../common/stb_image.h | static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
unsigned char *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
if (good == NULL) {
STBI_FREE(data);
return stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
unsigned char *src = data + j * x * img_n ;
unsigned char *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
} | O3 | c | stbi__convert_format(unsigned char*, int, int, unsigned int, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl %esi, %edx
jne 0x3def7
movq %r14, %r13
jmp 0x3e2cf
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %ebx
movl %edx, %edi
movl %ecx, %esi
movl %r8d, %edx
xorl %ecx, %ecx
callq 0x3f1ae
testq %rax, %rax
je 0x3e2aa
movq %rax, %r13
movq %rbx, 0x20(%rsp)
testl %ebp, %ebp
jle 0x3e2a0
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rax
leal (%rdx,%rax,8), %eax
cmpl $0x23, %eax
ja 0x3e2e1
movabsq $0xe161a1c00, %rcx # imm = 0xE161A1C00
btq %rax, %rcx
jae 0x3e2e1
leal -0x1(%r15), %ecx
movl %ecx, 0x4(%rsp)
movl %ebp, %ecx
movq %rcx, 0x40(%rsp)
movl %r15d, %esi
movl %r15d, %ecx
imull %edx, %ecx
movl %ecx, 0x14(%rsp)
movl %r15d, %ecx
imull 0x8(%rsp), %ecx
movl %ecx, 0x10(%rsp)
leaq 0x3(%r13), %rcx
movq %rcx, 0x28(%rsp)
leaq 0x2(%r13), %rcx
movq %rcx, 0x18(%rsp)
xorl %r11d, %r11d
addl $-0xa, %eax
xorl %r10d, %r10d
xorl %r8d, %r8d
movq %rax, 0x38(%rsp)
movq %r14, 0x30(%rsp)
movl %r11d, %ebp
addq %r14, %rbp
movl %r8d, %r12d
imull %r15d, %r12d
cmpl $0x18, %eax
ja 0x3e247
movq %r14, %rbx
movq %rax, %r14
movl %r10d, %edx
leaq (%rdx,%r13), %rcx
movq 0x28(%rsp), %rdi
addq %rdx, %rdi
movl %r12d, %r9d
imull 0x8(%rsp), %r9d
addq %rbx, %r9
leaq 0xf9eba(%rip), %rax # 0x137e98
movslq (%rax,%r14,4), %rbx
addq %rax, %rbx
jmpq *%rbx
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movb (%rbp,%rdx), %dil
movb %dil, (%rcx,%rdx,2)
movb $-0x1, 0x1(%rcx,%rdx,2)
incq %rdx
cmpl %edx, %esi
jne 0x3dff4
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movzbl (%rbp,%rdx,4), %edi
movzbl 0x1(%rbp,%rdx,4), %r9d
movzbl 0x2(%rbp,%rdx,4), %ebx
imull $0x4d, %edi, %edi
imull $0x96, %r9d, %r9d
addl %edi, %r9d
leal (%rbx,%rbx,8), %edi
leal (%rdi,%rdi,2), %edi
addl %ebx, %ebx
addl %edi, %ebx
addl %r9d, %ebx
movb %bh, (%rcx,%rdx,2)
movb 0x3(%rbp,%rdx,4), %dil
movb %dil, 0x1(%rcx,%rdx,2)
incq %rdx
cmpl %edx, %esi
jne 0x3e01b
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
addq 0x18(%rsp), %rdx
xorl %ecx, %ecx
movb (%rbp,%rcx,2), %dil
movb %dil, (%rdx)
movb %dil, -0x1(%rdx)
movb %dil, -0x2(%rdx)
incq %rcx
addq $0x3, %rdx
cmpl %ecx, %esi
jne 0x3e070
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %ecx, %ecx
movb (%rbp,%rcx,2), %dl
movb %dl, -0x1(%rdi,%rcx,4)
movb %dl, -0x2(%rdi,%rcx,4)
movb %dl, -0x3(%rdi,%rcx,4)
movb 0x1(%rbp,%rcx,2), %dl
movb %dl, (%rdi,%rcx,4)
incq %rcx
cmpl %ecx, %esi
jne 0x3e09d
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movb (%rbp,%rdx,2), %dil
movb %dil, (%rcx,%rdx)
incq %rdx
cmpl %edx, %esi
jne 0x3e0cd
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %ecx, %ecx
movb (%rbp,%rcx), %dl
movb %dl, -0x1(%rdi,%rcx,4)
movb %dl, -0x2(%rdi,%rcx,4)
movb %dl, -0x3(%rdi,%rcx,4)
movb $-0x1, (%rdi,%rcx,4)
incq %rcx
cmpl %ecx, %esi
jne 0x3e0ef
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
addq 0x18(%rsp), %rdx
xorl %ecx, %ecx
movb (%rbp,%rcx), %dil
movb %dil, (%rdx)
movb %dil, -0x1(%rdx)
movb %dil, -0x2(%rdx)
incq %rcx
addq $0x3, %rdx
cmpl %ecx, %esi
jne 0x3e121
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movzbl (%r9), %edi
movzbl 0x1(%r9), %ebp
movzbl 0x2(%r9), %ebx
imull $0x4d, %edi, %edi
imull $0x96, %ebp, %ebp
addl %edi, %ebp
leal (%rbx,%rbx,8), %edi
leal (%rdi,%rdi,2), %edi
addl %ebx, %ebx
addl %edi, %ebx
addl %ebp, %ebx
movb %bh, (%rcx,%rdx)
incq %rdx
addq $0x3, %r9
cmpl %edx, %esi
jne 0x3e14e
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movzbl (%r9), %edi
movzbl 0x1(%r9), %ebp
movzbl 0x2(%r9), %ebx
imull $0x4d, %edi, %edi
imull $0x96, %ebp, %ebp
addl %edi, %ebp
leal (%rbx,%rbx,8), %edi
leal (%rdi,%rdi,2), %edi
addl %ebx, %ebx
addl %edi, %ebx
addl %ebp, %ebx
movb %bh, (%rcx,%rdx,2)
movb $-0x1, 0x1(%rcx,%rdx,2)
incq %rdx
addq $0x3, %r9
cmpl %edx, %esi
jne 0x3e193
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movzbl (%rbp,%rdx,4), %edi
movzbl 0x1(%rbp,%rdx,4), %r9d
movzbl 0x2(%rbp,%rdx,4), %ebx
imull $0x4d, %edi, %edi
imull $0x96, %r9d, %r9d
addl %edi, %r9d
leal (%rbx,%rbx,8), %edi
leal (%rdi,%rdi,2), %edi
addl %ebx, %ebx
addl %edi, %ebx
addl %r9d, %ebx
movb %bh, (%rcx,%rdx)
incq %rdx
cmpl %edx, %esi
jne 0x3e1dd
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
xorl %edx, %edx
movb (%r9), %dil
movb %dil, (%rcx,%rdx,4)
movb 0x1(%r9), %dil
movb %dil, 0x1(%rcx,%rdx,4)
movb 0x2(%r9), %dil
movb %dil, 0x2(%rcx,%rdx,4)
movb $-0x1, 0x3(%rcx,%rdx,4)
incq %rdx
addq $0x3, %r9
cmpl %edx, %esi
jne 0x3e21c
jmp 0x3e27e
cmpl $0x0, 0x4(%rsp)
js 0x3e27e
imull 0x20(%rsp), %r12d
addq %r13, %r12
xorl %ecx, %ecx
movb (%rbp,%rcx,4), %dl
movb %dl, (%r12)
movb 0x1(%rbp,%rcx,4), %dl
movb %dl, 0x1(%r12)
movb 0x2(%rbp,%rcx,4), %dl
movb %dl, 0x2(%r12)
incq %rcx
addq $0x3, %r12
cmpl %ecx, %esi
jne 0x3e259
incq %r8
addl 0x14(%rsp), %r10d
addl 0x10(%rsp), %r11d
cmpq 0x40(%rsp), %r8
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %r14
jne 0x3dfa0
movq %r14, %rdi
callq 0x23300
jmp 0x3e2cf
movq %r14, %rdi
callq 0x23300
movq %fs:0x0, %rax
leaq 0xfa879(%rip), %rcx # 0x138b3e
movq %rcx, -0x20(%rax)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x23300
movq %r13, %rdi
callq 0x23300
movq %fs:0x0, %rax
leaq 0xfa876(%rip), %rcx # 0x138b7a
jmp 0x3e2c5
| _ZL20stbi__convert_formatPhiijj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdi
mov [rsp+78h+var_70], rsi
cmp edx, esi
jnz short loc_3DEF7
mov r13, r14
jmp loc_3E2CF
loc_3DEF7:
mov ebp, r8d
mov r15d, ecx
mov ebx, edx
mov edi, edx; int
mov esi, ecx; int
mov edx, r8d; int
xor ecx, ecx; int
call _ZL17stbi__malloc_mad3iiii; stbi__malloc_mad3(int,int,int,int)
test rax, rax
jz loc_3E2AA
mov r13, rax
mov [rsp+78h+var_58], rbx
test ebp, ebp
jle loc_3E2A0
mov rdx, [rsp+78h+var_58]
mov rax, [rsp+78h+var_70]
lea eax, [rdx+rax*8]
cmp eax, 23h ; '#'
ja loc_3E2E1
mov rcx, 0E161A1C00h
bt rcx, rax
jnb loc_3E2E1
lea ecx, [r15-1]
mov [rsp+78h+var_74], ecx
mov ecx, ebp
mov [rsp+78h+var_38], rcx
mov esi, r15d
mov ecx, r15d
imul ecx, edx
mov [rsp+78h+var_64], ecx
mov ecx, r15d
imul ecx, dword ptr [rsp+78h+var_70]
mov [rsp+78h+var_68], ecx
lea rcx, [r13+3]
mov [rsp+78h+var_50], rcx
lea rcx, [r13+2]
mov [rsp+78h+var_60], rcx
xor r11d, r11d
add eax, 0FFFFFFF6h
xor r10d, r10d
xor r8d, r8d
mov [rsp+78h+var_40], rax
mov [rsp+78h+var_48], r14
loc_3DFA0:
mov ebp, r11d
add rbp, r14
mov r12d, r8d
imul r12d, r15d
cmp eax, 18h; switch 25 cases
ja def_3DFE5; jumptable 000000000003DFE5 default case, cases 3-6,8,11-14,17,19-22
mov rbx, r14
mov r14, rax
mov edx, r10d
lea rcx, [rdx+r13]
mov rdi, [rsp+78h+var_50]
add rdi, rdx
mov r9d, r12d
imul r9d, dword ptr [rsp+78h+var_70]
add r9, rbx
lea rax, jpt_3DFE5
movsxd rbx, ds:(jpt_3DFE5 - 137E98h)[rax+r14*4]
add rbx, rax
jmp rbx; switch jump
loc_3DFE7:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 0
js loc_3E27E
xor edx, edx
loc_3DFF4:
mov dil, [rbp+rdx+0]
mov [rcx+rdx*2], dil
mov byte ptr [rcx+rdx*2+1], 0FFh
inc rdx
cmp esi, edx
jnz short loc_3DFF4
jmp loc_3E27E
loc_3E00E:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 24
js loc_3E27E
xor edx, edx
loc_3E01B:
movzx edi, byte ptr [rbp+rdx*4+0]
movzx r9d, byte ptr [rbp+rdx*4+1]
movzx ebx, byte ptr [rbp+rdx*4+2]
imul edi, 4Dh ; 'M'
imul r9d, 96h
add r9d, edi
lea edi, [rbx+rbx*8]
lea edi, [rdi+rdi*2]
add ebx, ebx
add ebx, edi
add ebx, r9d
mov [rcx+rdx*2], bh
mov dil, [rbp+rdx*4+3]
mov [rcx+rdx*2+1], dil
inc rdx
cmp esi, edx
jnz short loc_3E01B
jmp loc_3E27E
loc_3E05E:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 9
js loc_3E27E
add rdx, [rsp+78h+var_60]
xor ecx, ecx
loc_3E070:
mov dil, [rbp+rcx*2+0]
mov [rdx], dil
mov [rdx-1], dil
mov [rdx-2], dil
inc rcx
add rdx, 3
cmp esi, ecx
jnz short loc_3E070
jmp loc_3E27E
loc_3E090:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 10
js loc_3E27E
xor ecx, ecx
loc_3E09D:
mov dl, [rbp+rcx*2+0]
mov [rdi+rcx*4-1], dl
mov [rdi+rcx*4-2], dl
mov [rdi+rcx*4-3], dl
mov dl, [rbp+rcx*2+1]
mov [rdi+rcx*4], dl
inc rcx
cmp esi, ecx
jnz short loc_3E09D
jmp loc_3E27E
loc_3E0C0:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 7
js loc_3E27E
xor edx, edx
loc_3E0CD:
mov dil, [rbp+rdx*2+0]
mov [rcx+rdx], dil
inc rdx
cmp esi, edx
jnz short loc_3E0CD
jmp loc_3E27E
loc_3E0E2:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 2
js loc_3E27E
xor ecx, ecx
loc_3E0EF:
mov dl, [rbp+rcx+0]
mov [rdi+rcx*4-1], dl
mov [rdi+rcx*4-2], dl
mov [rdi+rcx*4-3], dl
mov byte ptr [rdi+rcx*4], 0FFh
inc rcx
cmp esi, ecx
jnz short loc_3E0EF
jmp loc_3E27E
loc_3E10F:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 1
js loc_3E27E
add rdx, [rsp+78h+var_60]
xor ecx, ecx
loc_3E121:
mov dil, [rbp+rcx+0]
mov [rdx], dil
mov [rdx-1], dil
mov [rdx-2], dil
inc rcx
add rdx, 3
cmp esi, ecx
jnz short loc_3E121
jmp loc_3E27E
loc_3E141:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 15
js loc_3E27E
xor edx, edx
loc_3E14E:
movzx edi, byte ptr [r9]
movzx ebp, byte ptr [r9+1]
movzx ebx, byte ptr [r9+2]
imul edi, 4Dh ; 'M'
imul ebp, 96h
add ebp, edi
lea edi, [rbx+rbx*8]
lea edi, [rdi+rdi*2]
add ebx, ebx
add ebx, edi
add ebx, ebp
mov [rcx+rdx], bh
inc rdx
add r9, 3
cmp esi, edx
jnz short loc_3E14E
jmp loc_3E27E
loc_3E186:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 16
js loc_3E27E
xor edx, edx
loc_3E193:
movzx edi, byte ptr [r9]
movzx ebp, byte ptr [r9+1]
movzx ebx, byte ptr [r9+2]
imul edi, 4Dh ; 'M'
imul ebp, 96h
add ebp, edi
lea edi, [rbx+rbx*8]
lea edi, [rdi+rdi*2]
add ebx, ebx
add ebx, edi
add ebx, ebp
mov [rcx+rdx*2], bh
mov byte ptr [rcx+rdx*2+1], 0FFh
inc rdx
add r9, 3
cmp esi, edx
jnz short loc_3E193
jmp loc_3E27E
loc_3E1D0:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 23
js loc_3E27E
xor edx, edx
loc_3E1DD:
movzx edi, byte ptr [rbp+rdx*4+0]
movzx r9d, byte ptr [rbp+rdx*4+1]
movzx ebx, byte ptr [rbp+rdx*4+2]
imul edi, 4Dh ; 'M'
imul r9d, 96h
add r9d, edi
lea edi, [rbx+rbx*8]
lea edi, [rdi+rdi*2]
add ebx, ebx
add ebx, edi
add ebx, r9d
mov [rcx+rdx], bh
inc rdx
cmp esi, edx
jnz short loc_3E1DD
jmp short loc_3E27E
loc_3E213:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 case 18
js short loc_3E27E
xor edx, edx
loc_3E21C:
mov dil, [r9]
mov [rcx+rdx*4], dil
mov dil, [r9+1]
mov [rcx+rdx*4+1], dil
mov dil, [r9+2]
mov [rcx+rdx*4+2], dil
mov byte ptr [rcx+rdx*4+3], 0FFh
inc rdx
add r9, 3
cmp esi, edx
jnz short loc_3E21C
jmp short loc_3E27E
def_3DFE5:
cmp [rsp+78h+var_74], 0; jumptable 000000000003DFE5 default case, cases 3-6,8,11-14,17,19-22
js short loc_3E27E
imul r12d, dword ptr [rsp+78h+var_58]
add r12, r13
xor ecx, ecx
loc_3E259:
mov dl, [rbp+rcx*4+0]
mov [r12], dl
mov dl, [rbp+rcx*4+1]
mov [r12+1], dl
mov dl, [rbp+rcx*4+2]
mov [r12+2], dl
inc rcx
add r12, 3
cmp esi, ecx
jnz short loc_3E259
loc_3E27E:
inc r8
add r10d, [rsp+78h+var_64]
add r11d, [rsp+78h+var_68]
cmp r8, [rsp+78h+var_38]
mov rax, [rsp+78h+var_40]
mov r14, [rsp+78h+var_48]
jnz loc_3DFA0
loc_3E2A0:
mov rdi, r14
call _free
jmp short loc_3E2CF
loc_3E2AA:
mov rdi, r14
call _free
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
loc_3E2C5:
mov [rax-20h], rcx
xor r13d, r13d
loc_3E2CF:
mov rax, r13
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3E2E1:
mov rdi, r14
call _free
mov rdi, r13
call _free
mov rax, fs:0
lea rcx, aUnsupported; "unsupported"
jmp short loc_3E2C5
| unsigned __int8 * stbi__convert_format(unsigned __int8 *a1, int a2, int a3, int a4, int a5)
{
unsigned __int8 *v5; // r14
long long v6; // r13
long long v10; // rax
unsigned long long v11; // rax
long long v12; // rcx
int v13; // r11d
int v14; // eax
unsigned int v15; // r10d
long long v16; // r8
unsigned __int8 *v17; // rbp
long long v18; // rcx
long long v19; // rdi
unsigned __int8 *v20; // r9
long long v21; // rdx
long long v22; // rdx
unsigned __int8 *v23; // rdx
long long v24; // rcx
unsigned __int8 v25; // di
long long v26; // rcx
unsigned __int8 v27; // dl
long long v28; // rdx
long long v29; // rcx
unsigned __int8 v30; // dl
unsigned __int8 *v31; // rdx
long long v32; // rcx
unsigned __int8 v33; // di
long long v34; // rdx
long long v35; // rdx
long long v36; // rdx
long long v37; // rdx
_BYTE *v38; // r12
long long v39; // rcx
unsigned long long v40; // rax
const char *v41; // rcx
int v43; // [rsp+4h] [rbp-74h]
long long v44; // [rsp+18h] [rbp-60h]
int v46; // [rsp+38h] [rbp-40h]
long long v47; // [rsp+40h] [rbp-38h]
v5 = a1;
if ( a3 != a2 )
{
v10 = stbi__malloc_mad3(a3, a4, a5, 0);
if ( v10 )
{
v6 = v10;
if ( a5 <= 0 )
{
LABEL_57:
free(v5);
return (unsigned __int8 *)v6;
}
v11 = (unsigned int)(a3 + 8 * a2);
if ( (unsigned int)v11 <= 0x23 )
{
v12 = 0xE161A1C00LL;
if ( _bittest64(&v12, v11) )
{
v43 = a4 - 1;
v47 = (unsigned int)a5;
v44 = v6 + 2;
v13 = 0;
v14 = v11 - 10;
v15 = 0;
v16 = 0LL;
v46 = v14;
do
{
v17 = &v5[v13];
v18 = v15 + v6;
v19 = v15 + v6 + 3;
v20 = &v5[(unsigned int)(a2 * a4 * v16)];
switch ( v14 )
{
case 0:
if ( v43 >= 0 )
{
v21 = 0LL;
do
{
*(_BYTE *)(v18 + 2 * v21) = v17[v21];
*(_BYTE *)(v18 + 2 * v21++ + 1) = -1;
}
while ( a4 != (_DWORD)v21 );
}
break;
case 1:
if ( v43 >= 0 )
{
v31 = (unsigned __int8 *)(v44 + v15);
v32 = 0LL;
do
{
v33 = v17[v32];
*v31 = v33;
*(v31 - 1) = v33;
*(v31 - 2) = v33;
++v32;
v31 += 3;
}
while ( a4 != (_DWORD)v32 );
}
break;
case 2:
if ( v43 >= 0 )
{
v29 = 0LL;
do
{
v30 = v17[v29];
*(_BYTE *)(v19 + 4 * v29 - 1) = v30;
*(_BYTE *)(v19 + 4 * v29 - 2) = v30;
*(_BYTE *)(v15 + v6 + 4 * v29) = v30;
*(_BYTE *)(v19 + 4 * v29++) = -1;
}
while ( a4 != (_DWORD)v29 );
}
break;
case 7:
if ( v43 >= 0 )
{
v28 = 0LL;
do
{
*(_BYTE *)(v18 + v28) = v17[2 * v28];
++v28;
}
while ( a4 != (_DWORD)v28 );
}
break;
case 9:
if ( v43 >= 0 )
{
v23 = (unsigned __int8 *)(v44 + v15);
v24 = 0LL;
do
{
v25 = v17[2 * v24];
*v23 = v25;
*(v23 - 1) = v25;
*(v23 - 2) = v25;
++v24;
v23 += 3;
}
while ( a4 != (_DWORD)v24 );
}
break;
case 10:
if ( v43 >= 0 )
{
v26 = 0LL;
do
{
v27 = v17[2 * v26];
*(_BYTE *)(v19 + 4 * v26 - 1) = v27;
*(_BYTE *)(v19 + 4 * v26 - 2) = v27;
*(_BYTE *)(v15 + v6 + 4 * v26) = v27;
*(_BYTE *)(v19 + 4 * v26) = v17[2 * v26 + 1];
++v26;
}
while ( a4 != (_DWORD)v26 );
}
break;
case 15:
if ( v43 >= 0 )
{
v34 = 0LL;
do
{
*(_BYTE *)(v18 + v34++) = (unsigned __int16)(77 * *v20 + 150 * v20[1] + 29 * v20[2]) >> 8;
v20 += 3;
}
while ( a4 != (_DWORD)v34 );
}
break;
case 16:
if ( v43 >= 0 )
{
v35 = 0LL;
do
{
*(_BYTE *)(v18 + 2 * v35) = (unsigned __int16)(77 * *v20 + 150 * v20[1] + 29 * v20[2]) >> 8;
*(_BYTE *)(v18 + 2 * v35++ + 1) = -1;
v20 += 3;
}
while ( a4 != (_DWORD)v35 );
}
break;
case 18:
if ( v43 >= 0 )
{
v37 = 0LL;
do
{
*(_BYTE *)(v18 + 4 * v37) = *v20;
*(_BYTE *)(v18 + 4 * v37 + 1) = v20[1];
*(_BYTE *)(v18 + 4 * v37 + 2) = v20[2];
*(_BYTE *)(v18 + 4 * v37++ + 3) = -1;
v20 += 3;
}
while ( a4 != (_DWORD)v37 );
}
break;
case 23:
if ( v43 >= 0 )
{
v36 = 0LL;
do
{
*(_BYTE *)(v18 + v36) = (unsigned __int16)(77 * v17[4 * v36]
+ 150 * v17[4 * v36 + 1]
+ 29 * v17[4 * v36 + 2]) >> 8;
++v36;
}
while ( a4 != (_DWORD)v36 );
}
break;
case 24:
if ( v43 >= 0 )
{
v22 = 0LL;
do
{
*(_BYTE *)(v18 + 2 * v22) = (unsigned __int16)(77 * v17[4 * v22]
+ 150 * v17[4 * v22 + 1]
+ 29 * v17[4 * v22 + 2]) >> 8;
*(_BYTE *)(v18 + 2 * v22 + 1) = v17[4 * v22 + 3];
++v22;
}
while ( a4 != (_DWORD)v22 );
}
break;
default:
if ( v43 >= 0 )
{
v38 = (_BYTE *)(v6 + (unsigned int)(a3 * a4 * v16));
v39 = 0LL;
do
{
*v38 = v17[4 * v39];
v38[1] = v17[4 * v39 + 1];
v38[2] = v17[4 * v39++ + 2];
v38 += 3;
}
while ( a4 != (_DWORD)v39 );
}
break;
}
++v16;
v15 += a3 * a4;
v13 += a2 * a4;
v14 = v46;
v5 = a1;
}
while ( v16 != v47 );
goto LABEL_57;
}
}
free(a1);
free(v6);
v40 = __readfsqword(0);
v41 = "unsupported";
}
else
{
free(a1);
v40 = __readfsqword(0);
v41 = "outofmem";
}
*(_QWORD *)(v40 - 32) = v41;
return 0LL;
}
return a1;
}
| stbi__convert_format:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,ESI
JNZ 0x0013def7
MOV R13,R14
JMP 0x0013e2cf
LAB_0013def7:
MOV EBP,R8D
MOV R15D,ECX
MOV EBX,EDX
MOV EDI,EDX
MOV ESI,ECX
MOV EDX,R8D
XOR ECX,ECX
CALL 0x0013f1ae
TEST RAX,RAX
JZ 0x0013e2aa
MOV R13,RAX
MOV qword ptr [RSP + 0x20],RBX
TEST EBP,EBP
JLE 0x0013e2a0
MOV RDX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
LEA EAX,[RDX + RAX*0x8]
CMP EAX,0x23
JA 0x0013e2e1
MOV RCX,0xe161a1c00
BT RCX,RAX
JNC 0x0013e2e1
LEA ECX,[R15 + -0x1]
MOV dword ptr [RSP + 0x4],ECX
MOV ECX,EBP
MOV qword ptr [RSP + 0x40],RCX
MOV ESI,R15D
MOV ECX,R15D
IMUL ECX,EDX
MOV dword ptr [RSP + 0x14],ECX
MOV ECX,R15D
IMUL ECX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x10],ECX
LEA RCX,[R13 + 0x3]
MOV qword ptr [RSP + 0x28],RCX
LEA RCX,[R13 + 0x2]
MOV qword ptr [RSP + 0x18],RCX
XOR R11D,R11D
ADD EAX,-0xa
XOR R10D,R10D
XOR R8D,R8D
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x30],R14
LAB_0013dfa0:
MOV EBP,R11D
ADD RBP,R14
MOV R12D,R8D
IMUL R12D,R15D
CMP EAX,0x18
JA 0x0013e247
MOV RBX,R14
MOV R14,RAX
MOV EDX,R10D
LEA RCX,[RDX + R13*0x1]
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,RDX
MOV R9D,R12D
IMUL R9D,dword ptr [RSP + 0x8]
ADD R9,RBX
LEA RAX,[0x237e98]
MOVSXD RBX,dword ptr [RAX + R14*0x4]
ADD RBX,RAX
switchD:
JMP RBX
caseD_a:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013dff4:
MOV DIL,byte ptr [RBP + RDX*0x1]
MOV byte ptr [RCX + RDX*0x2],DIL
MOV byte ptr [RCX + RDX*0x2 + 0x1],0xff
INC RDX
CMP ESI,EDX
JNZ 0x0013dff4
JMP 0x0013e27e
caseD_22:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e01b:
MOVZX EDI,byte ptr [RBP + RDX*0x4]
MOVZX R9D,byte ptr [RBP + RDX*0x4 + 0x1]
MOVZX EBX,byte ptr [RBP + RDX*0x4 + 0x2]
IMUL EDI,EDI,0x4d
IMUL R9D,R9D,0x96
ADD R9D,EDI
LEA EDI,[RBX + RBX*0x8]
LEA EDI,[RDI + RDI*0x2]
ADD EBX,EBX
ADD EBX,EDI
ADD EBX,R9D
MOV byte ptr [RCX + RDX*0x2],BH
MOV DIL,byte ptr [RBP + RDX*0x4 + 0x3]
MOV byte ptr [RCX + RDX*0x2 + 0x1],DIL
INC RDX
CMP ESI,EDX
JNZ 0x0013e01b
JMP 0x0013e27e
caseD_13:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
ADD RDX,qword ptr [RSP + 0x18]
XOR ECX,ECX
LAB_0013e070:
MOV DIL,byte ptr [RBP + RCX*0x2]
MOV byte ptr [RDX],DIL
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RDX + -0x2],DIL
INC RCX
ADD RDX,0x3
CMP ESI,ECX
JNZ 0x0013e070
JMP 0x0013e27e
caseD_14:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR ECX,ECX
LAB_0013e09d:
MOV DL,byte ptr [RBP + RCX*0x2]
MOV byte ptr [RDI + RCX*0x4 + -0x1],DL
MOV byte ptr [RDI + RCX*0x4 + -0x2],DL
MOV byte ptr [RDI + RCX*0x4 + -0x3],DL
MOV DL,byte ptr [RBP + RCX*0x2 + 0x1]
MOV byte ptr [RDI + RCX*0x4],DL
INC RCX
CMP ESI,ECX
JNZ 0x0013e09d
JMP 0x0013e27e
caseD_11:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e0cd:
MOV DIL,byte ptr [RBP + RDX*0x2]
MOV byte ptr [RCX + RDX*0x1],DIL
INC RDX
CMP ESI,EDX
JNZ 0x0013e0cd
JMP 0x0013e27e
caseD_c:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR ECX,ECX
LAB_0013e0ef:
MOV DL,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RDI + RCX*0x4 + -0x1],DL
MOV byte ptr [RDI + RCX*0x4 + -0x2],DL
MOV byte ptr [RDI + RCX*0x4 + -0x3],DL
MOV byte ptr [RDI + RCX*0x4],0xff
INC RCX
CMP ESI,ECX
JNZ 0x0013e0ef
JMP 0x0013e27e
caseD_b:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
ADD RDX,qword ptr [RSP + 0x18]
XOR ECX,ECX
LAB_0013e121:
MOV DIL,byte ptr [RBP + RCX*0x1]
MOV byte ptr [RDX],DIL
MOV byte ptr [RDX + -0x1],DIL
MOV byte ptr [RDX + -0x2],DIL
INC RCX
ADD RDX,0x3
CMP ESI,ECX
JNZ 0x0013e121
JMP 0x0013e27e
caseD_19:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e14e:
MOVZX EDI,byte ptr [R9]
MOVZX EBP,byte ptr [R9 + 0x1]
MOVZX EBX,byte ptr [R9 + 0x2]
IMUL EDI,EDI,0x4d
IMUL EBP,EBP,0x96
ADD EBP,EDI
LEA EDI,[RBX + RBX*0x8]
LEA EDI,[RDI + RDI*0x2]
ADD EBX,EBX
ADD EBX,EDI
ADD EBX,EBP
MOV byte ptr [RCX + RDX*0x1],BH
INC RDX
ADD R9,0x3
CMP ESI,EDX
JNZ 0x0013e14e
JMP 0x0013e27e
caseD_1a:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e193:
MOVZX EDI,byte ptr [R9]
MOVZX EBP,byte ptr [R9 + 0x1]
MOVZX EBX,byte ptr [R9 + 0x2]
IMUL EDI,EDI,0x4d
IMUL EBP,EBP,0x96
ADD EBP,EDI
LEA EDI,[RBX + RBX*0x8]
LEA EDI,[RDI + RDI*0x2]
ADD EBX,EBX
ADD EBX,EDI
ADD EBX,EBP
MOV byte ptr [RCX + RDX*0x2],BH
MOV byte ptr [RCX + RDX*0x2 + 0x1],0xff
INC RDX
ADD R9,0x3
CMP ESI,EDX
JNZ 0x0013e193
JMP 0x0013e27e
caseD_21:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e1dd:
MOVZX EDI,byte ptr [RBP + RDX*0x4]
MOVZX R9D,byte ptr [RBP + RDX*0x4 + 0x1]
MOVZX EBX,byte ptr [RBP + RDX*0x4 + 0x2]
IMUL EDI,EDI,0x4d
IMUL R9D,R9D,0x96
ADD R9D,EDI
LEA EDI,[RBX + RBX*0x8]
LEA EDI,[RDI + RDI*0x2]
ADD EBX,EBX
ADD EBX,EDI
ADD EBX,R9D
MOV byte ptr [RCX + RDX*0x1],BH
INC RDX
CMP ESI,EDX
JNZ 0x0013e1dd
JMP 0x0013e27e
caseD_1c:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
XOR EDX,EDX
LAB_0013e21c:
MOV DIL,byte ptr [R9]
MOV byte ptr [RCX + RDX*0x4],DIL
MOV DIL,byte ptr [R9 + 0x1]
MOV byte ptr [RCX + RDX*0x4 + 0x1],DIL
MOV DIL,byte ptr [R9 + 0x2]
MOV byte ptr [RCX + RDX*0x4 + 0x2],DIL
MOV byte ptr [RCX + RDX*0x4 + 0x3],0xff
INC RDX
ADD R9,0x3
CMP ESI,EDX
JNZ 0x0013e21c
JMP 0x0013e27e
caseD_d:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e27e
IMUL R12D,dword ptr [RSP + 0x20]
ADD R12,R13
XOR ECX,ECX
LAB_0013e259:
MOV DL,byte ptr [RBP + RCX*0x4]
MOV byte ptr [R12],DL
MOV DL,byte ptr [RBP + RCX*0x4 + 0x1]
MOV byte ptr [R12 + 0x1],DL
MOV DL,byte ptr [RBP + RCX*0x4 + 0x2]
MOV byte ptr [R12 + 0x2],DL
INC RCX
ADD R12,0x3
CMP ESI,ECX
JNZ 0x0013e259
LAB_0013e27e:
INC R8
ADD R10D,dword ptr [RSP + 0x14]
ADD R11D,dword ptr [RSP + 0x10]
CMP R8,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x38]
MOV R14,qword ptr [RSP + 0x30]
JNZ 0x0013dfa0
LAB_0013e2a0:
MOV RDI,R14
CALL 0x00123300
JMP 0x0013e2cf
LAB_0013e2aa:
MOV RDI,R14
CALL 0x00123300
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x238b3e]
LAB_0013e2c5:
MOV qword ptr [RAX + -0x20],RCX
XOR R13D,R13D
LAB_0013e2cf:
MOV RAX,R13
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013e2e1:
MOV RDI,R14
CALL 0x00123300
MOV RDI,R13
CALL 0x00123300
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x238b7a]
JMP 0x0013e2c5
|
/* stbi__convert_format(unsigned char*, int, int, unsigned int, unsigned int) */
uchar * stbi__convert_format(uchar *param_1,int param_2,int param_3,uint param_4,uint param_5)
{
int iVar1;
uchar uVar2;
byte bVar3;
uint uVar4;
uchar *__ptr;
long lVar5;
char *pcVar6;
ulong uVar7;
byte *pbVar8;
ulong uVar9;
ulong uVar10;
int iVar11;
uchar *puVar12;
long *in_FS_OFFSET;
if (param_3 == param_2) {
return param_1;
}
__ptr = (uchar *)stbi__malloc_mad3(param_3,param_4,param_5,0);
if (__ptr == (uchar *)0x0) {
free(param_1);
lVar5 = *in_FS_OFFSET;
pcVar6 = "outofmem";
LAB_0013e2c5:
*(char **)(lVar5 + -0x20) = pcVar6;
__ptr = (uchar *)0x0;
}
else {
if (0 < (int)param_5) {
uVar4 = param_3 + param_2 * 8;
if ((0x23 < uVar4) || ((0xe161a1c00U >> ((ulong)uVar4 & 0x3f) & 1) == 0)) {
free(param_1);
free(__ptr);
lVar5 = *in_FS_OFFSET;
pcVar6 = "unsupported";
goto LAB_0013e2c5;
}
iVar1 = param_4 - 1;
uVar10 = 0;
uVar9 = 0;
uVar7 = 0;
do {
iVar11 = (int)uVar7 * param_4;
if (uVar4 - 10 < 0x19) {
pbVar8 = param_1 + (uint)(iVar11 * param_2);
switch(uVar4) {
case 10:
if (-1 < iVar1) {
lVar5 = 0;
do {
__ptr[lVar5 * 2 + uVar9] = param_1[lVar5 + uVar10];
__ptr[lVar5 * 2 + uVar9 + 1] = 0xff;
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
break;
case 0xb:
if (-1 < iVar1) {
puVar12 = __ptr + uVar9 + 2;
lVar5 = 0;
do {
uVar2 = param_1[lVar5 + uVar10];
*puVar12 = uVar2;
puVar12[-1] = uVar2;
puVar12[-2] = uVar2;
lVar5 = lVar5 + 1;
puVar12 = puVar12 + 3;
} while (param_4 != (uint)lVar5);
}
break;
case 0xc:
if (-1 < iVar1) {
lVar5 = 0;
do {
uVar2 = param_1[lVar5 + uVar10];
__ptr[lVar5 * 4 + uVar9 + 2] = uVar2;
__ptr[lVar5 * 4 + uVar9 + 1] = uVar2;
__ptr[lVar5 * 4 + uVar9] = uVar2;
__ptr[lVar5 * 4 + uVar9 + 3] = 0xff;
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
break;
default:
goto switchD_0013dfe5_caseD_d;
case 0x11:
if (-1 < iVar1) {
lVar5 = 0;
do {
__ptr[lVar5 + uVar9] = param_1[lVar5 * 2 + uVar10];
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
break;
case 0x13:
if (-1 < iVar1) {
puVar12 = __ptr + uVar9 + 2;
lVar5 = 0;
do {
uVar2 = param_1[lVar5 * 2 + uVar10];
*puVar12 = uVar2;
puVar12[-1] = uVar2;
puVar12[-2] = uVar2;
lVar5 = lVar5 + 1;
puVar12 = puVar12 + 3;
} while (param_4 != (uint)lVar5);
}
break;
case 0x14:
if (-1 < iVar1) {
lVar5 = 0;
do {
uVar2 = param_1[lVar5 * 2 + uVar10];
__ptr[lVar5 * 4 + uVar9 + 2] = uVar2;
__ptr[lVar5 * 4 + uVar9 + 1] = uVar2;
__ptr[lVar5 * 4 + uVar9] = uVar2;
__ptr[lVar5 * 4 + uVar9 + 3] = param_1[lVar5 * 2 + uVar10 + 1];
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
break;
case 0x19:
if (-1 < iVar1) {
lVar5 = 0;
do {
bVar3 = pbVar8[2];
__ptr[lVar5 + uVar9] =
(uchar)((uint)bVar3 * 2 + ((uint)bVar3 + (uint)bVar3 * 8) * 3 +
(uint)pbVar8[1] * 0x96 + (uint)*pbVar8 * 0x4d >> 8);
lVar5 = lVar5 + 1;
pbVar8 = pbVar8 + 3;
} while (param_4 != (uint)lVar5);
}
break;
case 0x1a:
if (-1 < iVar1) {
lVar5 = 0;
do {
bVar3 = pbVar8[2];
__ptr[lVar5 * 2 + uVar9] =
(uchar)((uint)bVar3 * 2 + ((uint)bVar3 + (uint)bVar3 * 8) * 3 +
(uint)pbVar8[1] * 0x96 + (uint)*pbVar8 * 0x4d >> 8);
__ptr[lVar5 * 2 + uVar9 + 1] = 0xff;
lVar5 = lVar5 + 1;
pbVar8 = pbVar8 + 3;
} while (param_4 != (uint)lVar5);
}
break;
case 0x1c:
if (-1 < iVar1) {
lVar5 = 0;
do {
__ptr[lVar5 * 4 + uVar9] = *pbVar8;
__ptr[lVar5 * 4 + uVar9 + 1] = pbVar8[1];
__ptr[lVar5 * 4 + uVar9 + 2] = pbVar8[2];
__ptr[lVar5 * 4 + uVar9 + 3] = 0xff;
lVar5 = lVar5 + 1;
pbVar8 = pbVar8 + 3;
} while (param_4 != (uint)lVar5);
}
break;
case 0x21:
if (-1 < iVar1) {
lVar5 = 0;
do {
bVar3 = param_1[lVar5 * 4 + uVar10 + 2];
__ptr[lVar5 + uVar9] =
(uchar)((uint)bVar3 * 2 + ((uint)bVar3 + (uint)bVar3 * 8) * 3 +
(uint)param_1[lVar5 * 4 + uVar10 + 1] * 0x96 +
(uint)param_1[lVar5 * 4 + uVar10] * 0x4d >> 8);
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
break;
case 0x22:
if (-1 < iVar1) {
lVar5 = 0;
do {
bVar3 = param_1[lVar5 * 4 + uVar10 + 2];
__ptr[lVar5 * 2 + uVar9] =
(uchar)((uint)bVar3 * 2 + ((uint)bVar3 + (uint)bVar3 * 8) * 3 +
(uint)param_1[lVar5 * 4 + uVar10 + 1] * 0x96 +
(uint)param_1[lVar5 * 4 + uVar10] * 0x4d >> 8);
__ptr[lVar5 * 2 + uVar9 + 1] = param_1[lVar5 * 4 + uVar10 + 3];
lVar5 = lVar5 + 1;
} while (param_4 != (uint)lVar5);
}
}
}
else {
switchD_0013dfe5_caseD_d:
if (-1 < iVar1) {
puVar12 = __ptr + (uint)(iVar11 * param_3);
lVar5 = 0;
do {
*puVar12 = param_1[lVar5 * 4 + uVar10];
puVar12[1] = param_1[lVar5 * 4 + uVar10 + 1];
puVar12[2] = param_1[lVar5 * 4 + uVar10 + 2];
lVar5 = lVar5 + 1;
puVar12 = puVar12 + 3;
} while (param_4 != (uint)lVar5);
}
}
uVar7 = uVar7 + 1;
uVar9 = (ulong)((int)uVar9 + param_4 * param_3);
uVar10 = (ulong)((int)uVar10 + param_4 * param_2);
} while (uVar7 != param_5);
}
free(param_1);
}
return __ptr;
}
| |
34,936 | my_coll_parser_scan_reset_sequence | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_reset_sequence(MY_COLL_RULE_PARSER *p)
{
my_coll_rule_reset(&p->rule);
/* Scan "[before x]" option, if exists */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_OPTION)
my_coll_parser_scan_reset_before(p);
/* Try logical reset position */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_OPTION)
{
if (!my_coll_parser_scan_logical_position(p, p->rule.base, 1))
return 0;
}
else
{
/* Scan single reset character or expansion */
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION, "Expansion"))
return 0;
}
return 1;
} | O0 | c | my_coll_parser_scan_reset_sequence:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x863e0
movq -0x10(%rbp), %rdi
callq 0x858e0
cmpl $0x7, (%rax)
jne 0x86140
movq -0x10(%rbp), %rdi
callq 0x86410
movq -0x10(%rbp), %rdi
callq 0x858e0
cmpl $0x7, (%rax)
jne 0x86174
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movl $0x1, %edx
callq 0x86580
cmpl $0x0, %eax
jne 0x86172
movl $0x0, -0x4(%rbp)
jmp 0x861a8
jmp 0x861a1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movl $0xa, %edx
leaq 0x2e324(%rip), %rcx # 0xb44b0
callq 0x868a0
cmpl $0x0, %eax
jne 0x8619f
movl $0x0, -0x4(%rbp)
jmp 0x861a8
jmp 0x861a1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_reset_sequence:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call my_coll_rule_reset
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 7
jnz short loc_86140
mov rdi, [rbp+var_10]
call my_coll_parser_scan_reset_before
loc_86140:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 7
jnz short loc_86174
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
mov edx, 1
call my_coll_parser_scan_logical_position
cmp eax, 0
jnz short loc_86172
mov [rbp+var_4], 0
jmp short loc_861A8
loc_86172:
jmp short loc_861A1
loc_86174:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
mov edx, 0Ah
lea rcx, aExpansion; "Expansion"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_8619F
mov [rbp+var_4], 0
jmp short loc_861A8
loc_8619F:
jmp short $+2
loc_861A1:
mov [rbp+var_4], 1
loc_861A8:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| _BOOL8 my_coll_parser_scan_reset_sequence(long long a1)
{
my_coll_rule_reset(a1 + 80);
if ( *(_DWORD *)my_coll_parser_curr(a1) == 7 )
my_coll_parser_scan_reset_before(a1);
if ( *(_DWORD *)my_coll_parser_curr(a1) != 7 )
return (unsigned int)my_coll_parser_scan_character_list(a1, a1 + 80, 10LL, "Expansion") != 0;
return (unsigned int)my_coll_parser_scan_logical_position(a1, a1 + 80, 1LL) != 0;
}
| my_coll_parser_scan_reset_sequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001863e0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001858e0
CMP dword ptr [RAX],0x7
JNZ 0x00186140
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00186410
LAB_00186140:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001858e0
CMP dword ptr [RAX],0x7
JNZ 0x00186174
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
MOV EDX,0x1
CALL 0x00186580
CMP EAX,0x0
JNZ 0x00186172
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001861a8
LAB_00186172:
JMP 0x001861a1
LAB_00186174:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
MOV EDX,0xa
LEA RCX,[0x1b44b0]
CALL 0x001868a0
CMP EAX,0x0
JNZ 0x0018619f
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001861a8
LAB_0018619f:
JMP 0x001861a1
LAB_001861a1:
MOV dword ptr [RBP + -0x4],0x1
LAB_001861a8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 my_coll_parser_scan_reset_sequence(long param_1)
{
int iVar1;
int *piVar2;
my_coll_rule_reset(param_1 + 0x50);
piVar2 = (int *)my_coll_parser_curr(param_1);
if (*piVar2 == 7) {
my_coll_parser_scan_reset_before(param_1);
}
piVar2 = (int *)my_coll_parser_curr(param_1);
if (*piVar2 == 7) {
iVar1 = my_coll_parser_scan_logical_position(param_1,param_1 + 0x50,1);
if (iVar1 == 0) {
return 0;
}
}
else {
iVar1 = my_coll_parser_scan_character_list(param_1,param_1 + 0x50,10,"Expansion");
if (iVar1 == 0) {
return 0;
}
}
return 1;
}
| |
34,937 | JS_GetArrayBuffer | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValue obj)
{
JSArrayBuffer *abuf = js_get_array_buffer(ctx, obj);
if (!abuf)
goto fail;
if (abuf->detached) {
JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
goto fail;
}
*psize = abuf->byte_length;
return abuf->data;
fail:
*psize = 0;
return NULL;
} | O0 | c | JS_GetArrayBuffer:
subq $0x48, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x56df0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x56d8b
jmp 0x56dcc
movq 0x18(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x56dac
movq 0x28(%rsp), %rdi
callq 0x56e80
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
jmp 0x56dcc
movq 0x18(%rsp), %rax
movslq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x56de1
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
| JS_GetArrayBuffer:
sub rsp, 48h
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_10], rcx
mov [rsp+48h+var_20], rdi
mov [rsp+48h+var_28], rsi
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
call js_get_array_buffer
mov [rsp+48h+var_30], rax
cmp [rsp+48h+var_30], 0
jnz short loc_56D8B
jmp short loc_56DCC
loc_56D8B:
mov rax, [rsp+48h+var_30]
cmp byte ptr [rax+8], 0
jz short loc_56DAC
mov rdi, [rsp+48h+var_20]
call JS_ThrowTypeErrorDetachedArrayBuffer
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_38], rdx
jmp short loc_56DCC
loc_56DAC:
mov rax, [rsp+48h+var_30]
movsxd rcx, dword ptr [rax]
mov rax, [rsp+48h+var_28]
mov [rax], rcx
mov rax, [rsp+48h+var_30]
mov rax, [rax+10h]
mov [rsp+48h+var_8], rax
jmp short loc_56DE1
loc_56DCC:
mov rax, [rsp+48h+var_28]
mov qword ptr [rax], 0
mov [rsp+48h+var_8], 0
loc_56DE1:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
| long long JS_GetArrayBuffer(long long a1, _QWORD *a2, long long a3, long long a4)
{
int *array_buffer; // [rsp+18h] [rbp-30h]
array_buffer = (int *)js_get_array_buffer(a1, a3, a4);
if ( !array_buffer )
goto LABEL_5;
if ( *((_BYTE *)array_buffer + 8) )
{
JS_ThrowTypeErrorDetachedArrayBuffer(a1);
LABEL_5:
*a2 = 0LL;
return 0LL;
}
*a2 = *array_buffer;
return *((_QWORD *)array_buffer + 2);
}
| JS_GetArrayBuffer:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x00156df0
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x00156d8b
JMP 0x00156dcc
LAB_00156d8b:
MOV RAX,qword ptr [RSP + 0x18]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x00156dac
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00156e80
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
JMP 0x00156dcc
LAB_00156dac:
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x40],RAX
JMP 0x00156de1
LAB_00156dcc:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],0x0
MOV qword ptr [RSP + 0x40],0x0
LAB_00156de1:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int8 JS_GetArrayBuffer(int8 param_1,long *param_2,int8 param_3,int8 param_4)
{
int *piVar1;
piVar1 = (int *)js_get_array_buffer(param_1,param_3,param_4);
if (piVar1 != (int *)0x0) {
if ((char)piVar1[2] == '\0') {
*param_2 = (long)*piVar1;
return *(int8 *)(piVar1 + 4);
}
JS_ThrowTypeErrorDetachedArrayBuffer(param_1);
}
*param_2 = 0;
return 0;
}
| |
34,938 | JS_GetArrayBuffer | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValue obj)
{
JSArrayBuffer *abuf = js_get_array_buffer(ctx, obj);
if (!abuf)
goto fail;
if (abuf->detached) {
JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
goto fail;
}
*psize = abuf->byte_length;
return abuf->data;
fail:
*psize = 0;
return NULL;
} | O1 | c | JS_GetArrayBuffer:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x383bb
testq %rax, %rax
je 0x3839e
cmpb $0x0, 0x8(%rax)
je 0x383a9
leaq 0x6895d(%rip), %rsi # 0xa0cf1
movq %r14, %rdi
xorl %eax, %eax
callq 0x21953
movq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x383b3
movslq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| JS_GetArrayBuffer:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rsi, rdx
mov rdx, rcx
call js_get_array_buffer
test rax, rax
jz short loc_3839E
cmp byte ptr [rax+8], 0
jz short loc_383A9
lea rsi, aArraybufferIsD; "ArrayBuffer is detached"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_3839E:
mov qword ptr [rbx], 0
xor eax, eax
jmp short loc_383B3
loc_383A9:
movsxd rcx, dword ptr [rax]
mov [rbx], rcx
mov rax, [rax+10h]
loc_383B3:
add rsp, 8
pop rbx
pop r14
retn
| long long JS_GetArrayBuffer(
long long a1,
_QWORD *a2,
long long a3,
long long a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
char v12; // al
int *array_buffer; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
char v21; // [rsp-8h] [rbp-18h]
v21 = v12;
array_buffer = (int *)js_get_array_buffer(a1, a3, a4);
if ( !array_buffer )
goto LABEL_4;
if ( *((_BYTE *)array_buffer + 8) )
{
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached",
v14,
v15,
v16,
v17,
a5,
a6,
a7,
a8,
v18,
v19,
a11,
a12,
v21);
LABEL_4:
*a2 = 0LL;
return 0LL;
}
*a2 = *array_buffer;
return *((_QWORD *)array_buffer + 2);
}
| JS_GetArrayBuffer:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x001383bb
TEST RAX,RAX
JZ 0x0013839e
CMP byte ptr [RAX + 0x8],0x0
JZ 0x001383a9
LEA RSI,[0x1a0cf1]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00121953
LAB_0013839e:
MOV qword ptr [RBX],0x0
XOR EAX,EAX
JMP 0x001383b3
LAB_001383a9:
MOVSXD RCX,dword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [RAX + 0x10]
LAB_001383b3:
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 JS_GetArrayBuffer(int8 param_1,long *param_2,int8 param_3,int8 param_4)
{
int *piVar1;
piVar1 = (int *)js_get_array_buffer(param_1,param_3,param_4);
if (piVar1 != (int *)0x0) {
if ((char)piVar1[2] == '\0') {
*param_2 = (long)*piVar1;
return *(int8 *)(piVar1 + 4);
}
JS_ThrowTypeError(param_1,"ArrayBuffer is detached");
}
*param_2 = 0;
return 0;
}
| |
34,939 | my_strntod_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static double
my_strntod_mb2_or_mb4(CHARSET_INFO *cs,
char *nptr, size_t length,
char **endptr, int *err)
{
char buf[256];
double res;
register char *b= buf;
register const uchar *s= (const uchar*) nptr;
const uchar *end;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
*err= 0;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf) - 1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be part of double */
*b++= (char) wc;
}
*endptr= b;
res= my_strtod(buf, endptr, err);
*endptr= nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
} | O0 | c | my_strntod_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x118(%rbp)
movq %rsi, -0x120(%rbp)
movq %rdx, -0x128(%rbp)
movq %rcx, -0x130(%rbp)
movq %r8, -0x138(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x118(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x168(%rbp)
movq -0x138(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x100, -0x128(%rbp) # imm = 0x100
jb 0x60c45
movq $0xff, -0x128(%rbp)
movq -0x150(%rbp), %rax
addq -0x128(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x168(%rbp), %rax
movq -0x118(%rbp), %rdi
movq -0x150(%rbp), %rdx
movq -0x158(%rbp), %rcx
leaq -0x160(%rbp), %rsi
callq *%rax
movl %eax, -0x16c(%rbp)
cmpl $0x0, %eax
jle 0x60cdf
movl -0x16c(%rbp), %ecx
movq -0x150(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x150(%rbp)
cmpq $0x65, -0x160(%rbp)
ja 0x60cb8
cmpq $0x0, -0x160(%rbp)
jne 0x60cba
jmp 0x60cdf
movq -0x160(%rbp), %rax
movb %al, %cl
movq -0x148(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x148(%rbp)
movb %cl, (%rax)
jmp 0x60c5a
movq -0x148(%rbp), %rcx
movq -0x130(%rbp), %rax
movq %rcx, (%rax)
movq -0x130(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x110(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x771a0
movq -0x180(%rbp), %rdi
movsd %xmm0, -0x140(%rbp)
movq -0x120(%rbp), %rcx
movq -0x118(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, %edx
movq -0x130(%rbp), %rax
movq (%rax), %rsi
subq %rdi, %rsi
imulq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movsd -0x140(%rbp), %xmm0
movsd %xmm0, -0x178(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x60d80
movsd -0x178(%rbp), %xmm0
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
callq 0x24300
nopw %cs:(%rax,%rax)
| my_strntod_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 180h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_118], rdi
mov [rbp+var_120], rsi
mov [rbp+var_128], rdx
mov [rbp+var_130], rcx
mov [rbp+var_138], r8
lea rax, [rbp+var_110]
mov [rbp+var_148], rax
mov rax, [rbp+var_120]
mov [rbp+var_150], rax
mov rax, [rbp+var_118]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_168], rax
mov rax, [rbp+var_138]
mov dword ptr [rax], 0
cmp [rbp+var_128], 100h
jb short loc_60C45
mov [rbp+var_128], 0FFh
loc_60C45:
mov rax, [rbp+var_150]
add rax, [rbp+var_128]
mov [rbp+var_158], rax
loc_60C5A:
mov rax, [rbp+var_168]
mov rdi, [rbp+var_118]
mov rdx, [rbp+var_150]
mov rcx, [rbp+var_158]
lea rsi, [rbp+var_160]
call rax
mov [rbp+var_16C], eax
cmp eax, 0
jle short loc_60CDF
mov ecx, [rbp+var_16C]
mov rax, [rbp+var_150]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_150], rax
cmp [rbp+var_160], 65h ; 'e'
ja short loc_60CB8
cmp [rbp+var_160], 0
jnz short loc_60CBA
loc_60CB8:
jmp short loc_60CDF
loc_60CBA:
mov rax, [rbp+var_160]
mov cl, al
mov rax, [rbp+var_148]
mov rdx, rax
add rdx, 1
mov [rbp+var_148], rdx
mov [rax], cl
jmp loc_60C5A
loc_60CDF:
mov rcx, [rbp+var_148]
mov rax, [rbp+var_130]
mov [rax], rcx
mov rsi, [rbp+var_130]
mov rdx, [rbp+var_138]
lea rdi, [rbp+var_110]
mov [rbp+var_180], rdi
call my_strtod
mov rdi, [rbp+var_180]
movsd [rbp+var_140], xmm0
mov rcx, [rbp+var_120]
mov rax, [rbp+var_118]
mov eax, [rax+98h]
mov edx, eax
mov rax, [rbp+var_130]
mov rsi, [rax]
sub rsi, rdi
imul rdx, rsi
add rcx, rdx
mov [rax], rcx
movsd xmm0, [rbp+var_140]
movsd [rbp+var_178], xmm0
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_60D80
movsd xmm0, [rbp+var_178]
add rsp, 180h
pop rbp
retn
loc_60D80:
call ___stack_chk_fail
| double my_strntod_mb2_or_mb4(long long a1, long long a2, unsigned long long a3, _QWORD *a4, _DWORD *a5)
{
_BYTE *v5; // rax
int v7; // [rsp+14h] [rbp-16Ch]
long long ( *v8)(long long, unsigned long long *, long long, long long); // [rsp+18h] [rbp-168h]
unsigned long long v9; // [rsp+20h] [rbp-160h] BYREF
long long v10; // [rsp+28h] [rbp-158h]
long long v11; // [rsp+30h] [rbp-150h]
_BYTE *v12; // [rsp+38h] [rbp-148h]
double v13; // [rsp+40h] [rbp-140h]
_DWORD *v14; // [rsp+48h] [rbp-138h]
_QWORD *v15; // [rsp+50h] [rbp-130h]
unsigned long long v16; // [rsp+58h] [rbp-128h]
long long v17; // [rsp+60h] [rbp-120h]
long long v18; // [rsp+68h] [rbp-118h]
_BYTE v19[264]; // [rsp+70h] [rbp-110h] BYREF
unsigned long long v20; // [rsp+178h] [rbp-8h]
v20 = __readfsqword(0x28u);
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v12 = v19;
v11 = a2;
v8 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
*a5 = 0;
if ( v16 >= 0x100 )
v16 = 255LL;
v10 = v16 + v11;
while ( 1 )
{
v7 = v8(v18, &v9, v11, v10);
if ( v7 <= 0 )
break;
v11 += v7;
if ( v9 > 0x65 || !v9 )
break;
v5 = v12++;
*v5 = v9;
}
*v15 = v12;
v13 = my_strtod(v19, v15, v14);
*v15 = (*v15 - (_QWORD)v19) * *(unsigned int *)(v18 + 152) + v17;
return v13;
}
| my_strntod_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x118],RDI
MOV qword ptr [RBP + -0x120],RSI
MOV qword ptr [RBP + -0x128],RDX
MOV qword ptr [RBP + -0x130],RCX
MOV qword ptr [RBP + -0x138],R8
LEA RAX,[RBP + -0x110]
MOV qword ptr [RBP + -0x148],RAX
MOV RAX,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0x150],RAX
MOV RAX,qword ptr [RBP + -0x118]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x168],RAX
MOV RAX,qword ptr [RBP + -0x138]
MOV dword ptr [RAX],0x0
CMP qword ptr [RBP + -0x128],0x100
JC 0x00160c45
MOV qword ptr [RBP + -0x128],0xff
LAB_00160c45:
MOV RAX,qword ptr [RBP + -0x150]
ADD RAX,qword ptr [RBP + -0x128]
MOV qword ptr [RBP + -0x158],RAX
LAB_00160c5a:
MOV RAX,qword ptr [RBP + -0x168]
MOV RDI,qword ptr [RBP + -0x118]
MOV RDX,qword ptr [RBP + -0x150]
MOV RCX,qword ptr [RBP + -0x158]
LEA RSI,[RBP + -0x160]
CALL RAX
MOV dword ptr [RBP + -0x16c],EAX
CMP EAX,0x0
JLE 0x00160cdf
MOV ECX,dword ptr [RBP + -0x16c]
MOV RAX,qword ptr [RBP + -0x150]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x150],RAX
CMP qword ptr [RBP + -0x160],0x65
JA 0x00160cb8
CMP qword ptr [RBP + -0x160],0x0
JNZ 0x00160cba
LAB_00160cb8:
JMP 0x00160cdf
LAB_00160cba:
MOV RAX,qword ptr [RBP + -0x160]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x148]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x148],RDX
MOV byte ptr [RAX],CL
JMP 0x00160c5a
LAB_00160cdf:
MOV RCX,qword ptr [RBP + -0x148]
MOV RAX,qword ptr [RBP + -0x130]
MOV qword ptr [RAX],RCX
MOV RSI,qword ptr [RBP + -0x130]
MOV RDX,qword ptr [RBP + -0x138]
LEA RDI,[RBP + -0x110]
MOV qword ptr [RBP + -0x180],RDI
CALL 0x001771a0
MOV RDI,qword ptr [RBP + -0x180]
MOVSD qword ptr [RBP + -0x140],XMM0
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RBP + -0x118]
MOV EAX,dword ptr [RAX + 0x98]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x130]
MOV RSI,qword ptr [RAX]
SUB RSI,RDI
IMUL RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOVSD XMM0,qword ptr [RBP + -0x140]
MOVSD qword ptr [RBP + -0x178],XMM0
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00160d80
MOVSD XMM0,qword ptr [RBP + -0x178]
ADD RSP,0x180
POP RBP
RET
LAB_00160d80:
CALL 0x00124300
|
int8
my_strntod_mb2_or_mb4(long param_1,long param_2,ulong param_3,long *param_4,int4 *param_5)
{
code *pcVar1;
int iVar2;
long in_FS_OFFSET;
ulong local_168;
long local_160;
long local_158;
int1 *local_150;
int8 local_148;
int4 *local_140;
long *local_138;
ulong local_130;
long local_128;
long local_120;
int1 local_118 [264];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_5 = 0;
local_130 = param_3;
if (0xff < param_3) {
local_130 = 0xff;
}
local_160 = param_2 + local_130;
local_158 = param_2;
local_150 = local_118;
local_140 = param_5;
local_138 = param_4;
local_128 = param_2;
local_120 = param_1;
while (((iVar2 = (*pcVar1)(local_120,&local_168,local_158,local_160), 0 < iVar2 &&
(local_158 = local_158 + iVar2, local_168 < 0x66)) && (local_168 != 0))) {
*local_150 = (char)local_168;
local_150 = local_150 + 1;
}
*local_138 = (long)local_150;
local_148 = my_strtod(local_118,local_138,local_140);
*local_138 = local_128 + (ulong)*(uint *)(local_120 + 0x98) * (*local_138 - (long)local_118);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_148;
}
| |
34,940 | close_var_refs | bluesky950520[P]quickjs/quickjs.c | static void close_var_refs(JSRuntime *rt, JSStackFrame *sf)
{
struct list_head *el, *el1;
JSVarRef *var_ref;
int var_idx;
list_for_each_safe(el, el1, &sf->var_ref_list) {
var_ref = list_entry(el, JSVarRef, header.link);
var_idx = var_ref->var_idx;
if (var_ref->is_arg)
var_ref->value = js_dup(sf->arg_buf[var_idx]);
else
var_ref->value = js_dup(sf->var_buf[var_idx]);
var_ref->pvalue = &var_ref->value;
/* the reference is no longer to a local variable */
var_ref->is_detached = TRUE;
add_gc_object(rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
}
} | O1 | c | close_var_refs:
leaq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
cmpq %rax, %rcx
je 0x3b5d0
addq $0x98, %rdi
movq 0x8(%rcx), %rdx
movzwl -0x2(%rcx), %r9d
testb $0x2, -0x3(%rcx)
jne 0x3b57b
movq 0x20(%rsi), %r10
jmp 0x3b57f
movq 0x18(%rsi), %r10
shll $0x4, %r9d
movq (%r10,%r9), %r8
movq 0x8(%r10,%r9), %r9
movq %r8, -0x8(%rsp)
cmpl $-0x9, %r9d
jb 0x3b59f
movq -0x8(%rsp), %r10
incl (%r10)
leaq 0x18(%rcx), %r10
movq %r8, 0x18(%rcx)
movq %r9, 0x20(%rcx)
movq %r10, 0x10(%rcx)
orb $0x1, -0x3(%rcx)
movb $0x3, -0x4(%rcx)
movq (%rdi), %r8
movq %rcx, 0x8(%r8)
movq %r8, (%rcx)
movq %rdi, 0x8(%rcx)
movq %rcx, (%rdi)
movq %rdx, %rcx
cmpq %rax, %rdx
jne 0x3b566
retq
| close_var_refs:
lea rax, [rsi+28h]
mov rcx, [rsi+30h]
cmp rcx, rax
jz short locret_3B5D0
add rdi, 98h
loc_3B566:
mov rdx, [rcx+8]
movzx r9d, word ptr [rcx-2]
test byte ptr [rcx-3], 2
jnz short loc_3B57B
mov r10, [rsi+20h]
jmp short loc_3B57F
loc_3B57B:
mov r10, [rsi+18h]
loc_3B57F:
shl r9d, 4
mov r8, [r10+r9]
mov r9, [r10+r9+8]
mov [rsp+var_8], r8
cmp r9d, 0FFFFFFF7h
jb short loc_3B59F
mov r10, [rsp+var_8]
inc dword ptr [r10]
loc_3B59F:
lea r10, [rcx+18h]
mov [rcx+18h], r8
mov [rcx+20h], r9
mov [rcx+10h], r10
or byte ptr [rcx-3], 1
mov byte ptr [rcx-4], 3
mov r8, [rdi]
mov [r8+8], rcx
mov [rcx], r8
mov [rcx+8], rdi
mov [rdi], rcx
mov rcx, rdx
cmp rdx, rax
jnz short loc_3B566
locret_3B5D0:
retn
| _QWORD * close_var_refs(long long a1, _QWORD *a2)
{
_QWORD *result; // rax
_QWORD *v3; // rcx
long long *v4; // rdi
_QWORD *v5; // rdx
long long v6; // r10
long long v7; // r9
_DWORD *v8; // r8
long long v9; // r9
long long v10; // r8
result = a2 + 5;
v3 = (_QWORD *)a2[6];
if ( v3 != a2 + 5 )
{
v4 = (long long *)(a1 + 152);
do
{
v5 = (_QWORD *)v3[1];
if ( (*((_BYTE *)v3 - 3) & 2) != 0 )
v6 = a2[3];
else
v6 = a2[4];
v7 = 16 * (unsigned int)*((unsigned __int16 *)v3 - 1);
v8 = *(_DWORD **)(v6 + v7);
v9 = *(_QWORD *)(v6 + v7 + 8);
if ( (unsigned int)v9 >= 0xFFFFFFF7 )
++*v8;
v3[3] = v8;
v3[4] = v9;
v3[2] = v3 + 3;
*((_BYTE *)v3 - 3) |= 1u;
*((_BYTE *)v3 - 4) = 3;
v10 = *v4;
*(_QWORD *)(v10 + 8) = v3;
*v3 = v10;
v3[1] = v4;
*v4 = (long long)v3;
v3 = v5;
}
while ( v5 != result );
}
return result;
}
| |||
34,941 | close_var_refs | bluesky950520[P]quickjs/quickjs.c | static void close_var_refs(JSRuntime *rt, JSStackFrame *sf)
{
struct list_head *el, *el1;
JSVarRef *var_ref;
int var_idx;
list_for_each_safe(el, el1, &sf->var_ref_list) {
var_ref = list_entry(el, JSVarRef, header.link);
var_idx = var_ref->var_idx;
if (var_ref->is_arg)
var_ref->value = js_dup(sf->arg_buf[var_idx]);
else
var_ref->value = js_dup(sf->var_buf[var_idx]);
var_ref->pvalue = &var_ref->value;
/* the reference is no longer to a local variable */
var_ref->is_detached = TRUE;
add_gc_object(rt, &var_ref->header, JS_GC_OBJ_TYPE_VAR_REF);
}
} | O2 | c | close_var_refs:
leaq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
addq $0x98, %rdi
cmpq %rax, %rcx
je 0x3435d
movq 0x8(%rcx), %rdx
movzwl -0x2(%rcx), %r9d
testb $0x2, -0x3(%rcx)
jne 0x34315
movq 0x20(%rsi), %r10
shll $0x4, %r9d
movq (%r10,%r9), %r8
movq 0x8(%r10,%r9), %r9
cmpl $-0x9, %r9d
jae 0x3432c
jmp 0x3432f
movq 0x18(%rsi), %r10
shll $0x4, %r9d
movq (%r10,%r9), %r8
movq 0x8(%r10,%r9), %r9
cmpl $-0xa, %r9d
jbe 0x3432f
incl (%r8)
leaq 0x18(%rcx), %r10
movq %r8, 0x18(%rcx)
movq %r9, 0x20(%rcx)
movq %r10, 0x10(%rcx)
orb $0x1, -0x3(%rcx)
movb $0x3, -0x4(%rcx)
movq (%rdi), %r8
movq %rcx, 0x8(%r8)
movq %r8, (%rcx)
movq %rdi, 0x8(%rcx)
movq %rcx, (%rdi)
movq %rdx, %rcx
jmp 0x342e8
retq
| close_var_refs:
lea rax, [rsi+28h]
mov rcx, [rsi+30h]
add rdi, 98h
loc_342E8:
cmp rcx, rax
jz short locret_3435D
mov rdx, [rcx+8]
movzx r9d, word ptr [rcx-2]
test byte ptr [rcx-3], 2
jnz short loc_34315
mov r10, [rsi+20h]
shl r9d, 4
mov r8, [r10+r9]
mov r9, [r10+r9+8]
cmp r9d, 0FFFFFFF7h
jnb short loc_3432C
jmp short loc_3432F
loc_34315:
mov r10, [rsi+18h]
shl r9d, 4
mov r8, [r10+r9]
mov r9, [r10+r9+8]
cmp r9d, 0FFFFFFF6h
jbe short loc_3432F
loc_3432C:
inc dword ptr [r8]
loc_3432F:
lea r10, [rcx+18h]
mov [rcx+18h], r8
mov [rcx+20h], r9
mov [rcx+10h], r10
or byte ptr [rcx-3], 1
mov byte ptr [rcx-4], 3
mov r8, [rdi]
mov [r8+8], rcx
mov [rcx], r8
mov [rcx+8], rdi
mov [rdi], rcx
mov rcx, rdx
jmp short loc_342E8
locret_3435D:
retn
| _QWORD * close_var_refs(long long a1, _QWORD *a2)
{
_QWORD *result; // rax
_QWORD *v3; // rcx
long long *v4; // rdi
_QWORD *v5; // rdx
int v6; // r9d
long long v7; // r10
long long v8; // r9
_DWORD *v9; // r8
long long v10; // r9
long long v11; // r10
long long v12; // r9
long long v13; // r8
result = a2 + 5;
v3 = (_QWORD *)a2[6];
v4 = (long long *)(a1 + 152);
while ( v3 != result )
{
v5 = (_QWORD *)v3[1];
v6 = *((unsigned __int16 *)v3 - 1);
if ( (*((_BYTE *)v3 - 3) & 2) != 0 )
{
v11 = a2[3];
v12 = (unsigned int)(16 * v6);
v9 = *(_DWORD **)(v11 + v12);
v10 = *(_QWORD *)(v11 + v12 + 8);
if ( (unsigned int)v10 <= 0xFFFFFFF6 )
goto LABEL_8;
LABEL_7:
++*v9;
goto LABEL_8;
}
v7 = a2[4];
v8 = (unsigned int)(16 * v6);
v9 = *(_DWORD **)(v7 + v8);
v10 = *(_QWORD *)(v7 + v8 + 8);
if ( (unsigned int)v10 >= 0xFFFFFFF7 )
goto LABEL_7;
LABEL_8:
v3[3] = v9;
v3[4] = v10;
v3[2] = v3 + 3;
*((_BYTE *)v3 - 3) |= 1u;
*((_BYTE *)v3 - 4) = 3;
v13 = *v4;
*(_QWORD *)(v13 + 8) = v3;
*v3 = v13;
v3[1] = v4;
*v4 = (long long)v3;
v3 = v5;
}
return result;
}
| close_var_refs:
LEA RAX,[RSI + 0x28]
MOV RCX,qword ptr [RSI + 0x30]
ADD RDI,0x98
LAB_001342e8:
CMP RCX,RAX
JZ 0x0013435d
MOV RDX,qword ptr [RCX + 0x8]
MOVZX R9D,word ptr [RCX + -0x2]
TEST byte ptr [RCX + -0x3],0x2
JNZ 0x00134315
MOV R10,qword ptr [RSI + 0x20]
SHL R9D,0x4
MOV R8,qword ptr [R10 + R9*0x1]
MOV R9,qword ptr [R10 + R9*0x1 + 0x8]
CMP R9D,-0x9
JNC 0x0013432c
JMP 0x0013432f
LAB_00134315:
MOV R10,qword ptr [RSI + 0x18]
SHL R9D,0x4
MOV R8,qword ptr [R10 + R9*0x1]
MOV R9,qword ptr [R10 + R9*0x1 + 0x8]
CMP R9D,-0xa
JBE 0x0013432f
LAB_0013432c:
INC dword ptr [R8]
LAB_0013432f:
LEA R10,[RCX + 0x18]
MOV qword ptr [RCX + 0x18],R8
MOV qword ptr [RCX + 0x20],R9
MOV qword ptr [RCX + 0x10],R10
OR byte ptr [RCX + -0x3],0x1
MOV byte ptr [RCX + -0x4],0x3
MOV R8,qword ptr [RDI]
MOV qword ptr [R8 + 0x8],RCX
MOV qword ptr [RCX],R8
MOV qword ptr [RCX + 0x8],RDI
MOV qword ptr [RDI],RCX
MOV RCX,RDX
JMP 0x001342e8
LAB_0013435d:
RET
|
void close_var_refs(long param_1,long param_2)
{
long *plVar1;
int *piVar2;
long *plVar3;
long *plVar4;
uint uVar5;
long lVar6;
plVar4 = (long *)(param_1 + 0x98);
plVar3 = *(long **)(param_2 + 0x30);
while (plVar3 != (long *)(param_2 + 0x28)) {
plVar1 = (long *)plVar3[1];
if ((*plVar3 & 0x20000000000) == 0) {
lVar6 = (ulong)*(ushort *)((long)plVar3 + -2) * 0x10;
piVar2 = *(int **)(*(long *)(param_2 + 0x20) + lVar6);
lVar6 = *(long *)(*(long *)(param_2 + 0x20) + 8 + lVar6);
uVar5 = (uint)lVar6;
}
else {
lVar6 = (ulong)*(ushort *)((long)plVar3 + -2) * 0x10;
piVar2 = *(int **)(*(long *)(param_2 + 0x18) + lVar6);
lVar6 = *(long *)(*(long *)(param_2 + 0x18) + 8 + lVar6);
uVar5 = (uint)lVar6;
}
if (0xfffffff6 < uVar5) {
*piVar2 = *piVar2 + 1;
}
plVar3[3] = (long)piVar2;
plVar3[4] = lVar6;
plVar3[2] = (long)(plVar3 + 3);
*(byte *)((long)plVar3 + -3) = *(byte *)((long)plVar3 + -3) | 1;
*(int1 *)((long)plVar3 + -4) = 3;
lVar6 = *plVar4;
*(long **)(lVar6 + 8) = plVar3;
*plVar3 = lVar6;
plVar3[1] = (long)plVar4;
*plVar4 = (long)plVar3;
plVar3 = plVar1;
}
return;
}
| |
34,942 | console_get_line | qoraal-tictactoe/build_O0/_deps/qoraal-src/src/example/console.c | int32_t
console_get_line (char * buffer, uint32_t len)
{
uint32_t i = 0 ;
for (i=0; i<len; i++) {
int c = getc(stdin);
if (_shell_exit) break;
if (c == EOF) {
// If EOF is due to `/dev/null`, prevent infinite loop
os_thread_sleep (1000);
continue;
}
if (c == '\n') break;
buffer[i] = (char)c;
}
return i ;
} | O0 | c | console_get_line:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x26e86
movq 0x251a4(%rip), %rax # 0x4bfe0
movq (%rax), %rdi
callq 0x6580
movl %eax, -0x14(%rbp)
testb $0x1, 0x28cea(%rip) # 0x4fb38
je 0x26e52
jmp 0x26e86
cmpl $-0x1, -0x14(%rbp)
jne 0x26e64
movl $0x3e8, %edi # imm = 0x3E8
callq 0x1c5e0
jmp 0x26e7b
cmpl $0xa, -0x14(%rbp)
jne 0x26e6c
jmp 0x26e86
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26e2d
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| console_get_line:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], 0
mov [rbp+var_10], 0
loc_26E2D:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jnb short loc_26E86
mov rax, cs:stdin_ptr
mov rdi, [rax]
call _getc
mov [rbp+var_14], eax
test cs:_shell_exit, 1
jz short loc_26E52
jmp short loc_26E86
loc_26E52:
cmp [rbp+var_14], 0FFFFFFFFh
jnz short loc_26E64
mov edi, 3E8h
call os_thread_sleep
jmp short loc_26E7B
loc_26E64:
cmp [rbp+var_14], 0Ah
jnz short loc_26E6C
jmp short loc_26E86
loc_26E6C:
mov eax, [rbp+var_14]
mov dl, al
mov rax, [rbp+var_8]
mov ecx, [rbp+var_10]
mov [rax+rcx], dl
loc_26E7B:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_26E2D
loc_26E86:
mov eax, [rbp+var_10]
add rsp, 20h
pop rbp
retn
| long long console_get_line(long long a1, unsigned int a2)
{
int v3; // [rsp+Ch] [rbp-14h]
unsigned int i; // [rsp+10h] [rbp-10h]
for ( i = 0; i < a2; ++i )
{
v3 = getc(stdin);
if ( (shell_exit & 1) != 0 )
break;
if ( v3 == -1 )
{
os_thread_sleep(1000);
}
else
{
if ( v3 == 10 )
return i;
*(_BYTE *)(a1 + i) = v3;
}
}
return i;
}
| console_get_line:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0x10],0x0
LAB_00126e2d:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JNC 0x00126e86
MOV RAX,qword ptr [0x0014bfe0]
MOV RDI,qword ptr [RAX]
CALL 0x00106580
MOV dword ptr [RBP + -0x14],EAX
TEST byte ptr [0x0014fb38],0x1
JZ 0x00126e52
JMP 0x00126e86
LAB_00126e52:
CMP dword ptr [RBP + -0x14],-0x1
JNZ 0x00126e64
MOV EDI,0x3e8
CALL 0x0011c5e0
JMP 0x00126e7b
LAB_00126e64:
CMP dword ptr [RBP + -0x14],0xa
JNZ 0x00126e6c
JMP 0x00126e86
LAB_00126e6c:
MOV EAX,dword ptr [RBP + -0x14]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x10]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00126e7b:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00126e2d
LAB_00126e86:
MOV EAX,dword ptr [RBP + -0x10]
ADD RSP,0x20
POP RBP
RET
|
uint console_get_line(long param_1,uint param_2)
{
int iVar1;
uint local_18;
local_18 = 0;
while ((local_18 < param_2 && (iVar1 = getc(*(FILE **)PTR_stdin_0014bfe0), (_shell_exit & 1) == 0)
)) {
if (iVar1 == -1) {
os_thread_sleep(1000);
}
else {
if (iVar1 == 10) {
return local_18;
}
*(char *)(param_1 + (ulong)local_18) = (char)iVar1;
}
local_18 = local_18 + 1;
}
return local_18;
}
| |
34,943 | 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> minja::Value::get<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/minja.hpp | inline json Value::get<json>() const {
if (is_primitive()) return primitive_;
if (is_null()) return json();
if (array_) {
std::vector<json> res;
for (const auto& item : *array_) {
res.push_back(item.get<json>());
}
return res;
}
if (object_) {
json res = json::object();
for (const auto& [key, value] : *object_) {
if (key.is_string()) {
res[key.get<std::string>()] = value.get<json>();
} else if (key.is_primitive()) {
res[key.dump()] = value.get<json>();
} else {
throw std::runtime_error("Invalid key type for conversion to JSON: " + key.dump());
}
}
if (is_callable()) {
res["__callable__"] = true;
}
return res;
}
throw std::runtime_error("get<json> not defined for this value type: " + dump());
} | 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> minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rdi
callq 0x3cf44
testb %al, %al
je 0x6736d
addq $0x40, %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0x2c946
jmp 0x67531
movq %r14, %rdi
callq 0x3d906
testb %al, %al
je 0x67388
movq %r13, %rdi
xorl %esi, %esi
callq 0x2d21c
jmp 0x67531
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x673f3
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movq (%rax), %r15
movq 0x8(%rax), %rbx
leaq 0x38(%rsp), %r12
cmpq %rbx, %r15
je 0x673d7
movq %r12, %rdi
movq %r15, %rsi
callq 0x67336
movq %r14, %rdi
movq %r12, %rsi
callq 0x3df72
movq %r12, %rdi
callq 0x2c78c
addq $0x50, %r15
jmp 0x673ae
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x67d3c
leaq 0x10(%rsp), %rdi
callq 0x3de74
jmp 0x67531
cmpq $0x0, 0x20(%r14)
je 0x675a9
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x67d74
movq 0x20(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x78(%rsp), %rbp
leaq 0xa8(%rsp), %r13
leaq 0x88(%rsp), %r12
cmpq 0x30(%rsp), %r15
je 0x674ec
leaq 0x10(%r15), %rsi
movzbl (%r15), %eax
testl %eax, %eax
je 0x67499
cmpl $0x4, %eax
je 0x67499
cmpl $0x3, %eax
jne 0x6748f
leaq 0x68(%rsp), %rdi
callq 0x67336
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e6c6
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x62eae
movq %r12, %rbx
movq %rax, %rdi
leaq 0x68(%rsp), %r12
movq %r12, %rsi
callq 0x2c748
movq %rbx, %rdi
jmp 0x674d6
addb $-0x5, %al
cmpb $0x3, %al
ja 0x67546
movq %rbp, %rdi
callq 0x67336
movq %r13, %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2d946
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x62eae
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2c748
movq %r13, %rdi
movq %rbp, %r12
callq 0x20d88
movq %r12, %rdi
callq 0x2c78c
addq $0x60, %r15
jmp 0x6742c
cmpq $0x0, 0x30(%r14)
movq 0x8(%rsp), %r13
je 0x67531
leaq 0x10(%rsp), %rsi
movb $0x1, (%rsi)
leaq 0x58(%rsp), %rdi
callq 0x67d88
leaq 0x2b1aa(%rip), %rsi # 0x926bb
movq %r13, %rdi
callq 0x5f1be
leaq 0x58(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x2c748
movq %r14, %rdi
callq 0x2c78c
movq %r13, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r12
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2d946
leaq 0x2b120(%rip), %rsi # 0x92691
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x28a89
movb $0x1, %bl
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x20aa0
xorl %ebx, %ebx
movq 0x69a50(%rip), %rsi # 0xd0fe8
movq 0x699c1(%rip), %rdx # 0xd0f60
movq %r12, %rdi
callq 0x20b30
jmp 0x67604
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3cf54
leaq 0x2b0fb(%rip), %rsi # 0x926c8
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x28a89
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x699f3(%rip), %rsi # 0xd0fe8
movq 0x69964(%rip), %rdx # 0xd0f60
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d88
jmp 0x67619
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x20d88
testb %bpl, %bpl
jne 0x67630
jmp 0x676e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x20510
jmp 0x676e2
movq %rax, %r14
leaq 0x58(%rsp), %rdi
jmp 0x676b0
jmp 0x676c6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d88
jmp 0x6765d
movq %rax, %r14
movb $0x1, %bl
leaq 0x38(%rsp), %rdi
callq 0x20d88
testb %bl, %bl
jne 0x67670
jmp 0x676ba
movq %rax, %r14
movq %r12, %rdi
callq 0x20510
jmp 0x676ba
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x20d88
jmp 0x6768f
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x676b0
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x20d88
jmp 0x676ab
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x2c78c
jmp 0x676ba
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2c78c
jmp 0x676e2
movq %rax, %r14
jmp 0x676d8
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x2c78c
leaq 0x10(%rsp), %rdi
callq 0x3de74
movq %r14, %rdi
callq 0x20b90
| _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r14, rsi
mov r13, rdi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_6736D
add r14, 40h ; '@'
mov rdi, r13
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp loc_67531
loc_6736D:
mov rdi, r14; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_67388
mov rdi, r13
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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(decltype(nullptr))
jmp loc_67531
loc_67388:
mov rax, [r14+10h]
test rax, rax
jz short loc_673F3
xorps xmm0, xmm0
lea r14, [rsp+0F8h+var_E8]
and qword ptr [r14+10h], 0
movaps xmmword ptr [r14], xmm0
mov r15, [rax]
mov rbx, [rax+8]
lea r12, [rsp+0F8h+var_C0]
loc_673AE:
cmp r15, rbx
jz short loc_673D7
mov rdi, r12
mov rsi, r15
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r12
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()
add r15, 50h ; 'P'
jmp short loc_673AE
loc_673D7:
lea rsi, [rsp+0F8h+var_E8]
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rsp+0F8h+var_E8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
jmp loc_67531
loc_673F3:
cmp qword ptr [r14+20h], 0
jz loc_675A9
mov [rsp+0F8h+var_F0], r13
mov rdi, r13
xor esi, esi
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6objectESt16initializer_listINS0_6detail8json_refISD_EEE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::object(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov rax, [r14+20h]
mov r15, [rax]
mov rax, [rax+8]
mov [rsp+0F8h+var_C8], rax
lea rbp, [rsp+0F8h+var_80]
lea r13, [rsp+0F8h+var_50]
loc_6742C:
lea r12, [rsp+0F8h+var_70]
cmp r15, [rsp+0F8h+var_C8]
jz loc_674EC
lea rsi, [r15+10h]
movzx eax, byte ptr [r15]
test eax, eax
jz short loc_67499
cmp eax, 4
jz short loc_67499
cmp eax, 3
jnz short loc_6748F
lea rdi, [rsp+0F8h+var_90]
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, r12
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rdi, [rsp+0F8h+var_F0]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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)
mov rbx, r12
mov rdi, rax
lea r12, [rsp+0F8h+var_90]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
jmp short loc_674D6
loc_6748F:
add al, 0FBh
cmp al, 3
ja loc_67546
loc_67499:
mov rdi, rbp
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, r13
mov rsi, r15
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, [rsp+0F8h+var_F0]
mov rsi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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)
mov rdi, rax
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r13; void *
mov r12, rbp
loc_674D6:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12
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()
add r15, 60h ; '`'
jmp loc_6742C
loc_674EC:
cmp qword ptr [r14+30h], 0
mov r13, [rsp+0F8h+var_F0]
jz short loc_67531
lea rsi, [rsp+0F8h+var_E8]
mov byte ptr [rsi], 1
lea rdi, [rsp+0F8h+var_A0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
lea rsi, aCallable; "__callable__"
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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[]<char const>(char const *)
lea r14, [rsp+0F8h+var_A0]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
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_67531:
mov rax, r13
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_67546:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r12, rax
lea rdi, [rsp+0F8h+var_C0]
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
mov rsi, r15
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
lea rsi, aInvalidKeyType; "Invalid key type for conversion to JSON"...
lea rdi, [rsp+0F8h+var_E8]
lea rdx, [rsp+0F8h+var_C0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bl, 1
lea rsi, [rsp+0F8h+var_E8]
mov rdi, r12
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebx, ebx
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r12; void *
call ___cxa_throw
jmp short loc_67604
loc_675A9:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0F8h+var_C0]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetJsonNotDefi; "get<json> not defined for this value ty"...
lea rdi, [rsp+0F8h+var_E8]
lea rdx, [rsp+0F8h+var_C0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+0F8h+var_E8]
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:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_67604:
mov r14, rax
lea rdi, [rsp+0F8h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_67619
mov r14, rax
mov bpl, 1
loc_67619:
lea rdi, [rsp+0F8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_67630
jmp loc_676E2
mov r14, rax
loc_67630:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp loc_676E2
mov r14, rax
lea rdi, [rsp+0F8h+var_A0]
jmp short loc_676B0
jmp short loc_676C6
mov r14, rax
lea rdi, [rsp+0F8h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6765D
mov r14, rax
mov bl, 1
loc_6765D:
lea rdi, [rsp+0F8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bl, bl
jnz short loc_67670
jmp short loc_676BA
mov r14, rax
loc_67670:
mov rdi, r12; void *
call ___cxa_free_exception
jmp short loc_676BA
mov r14, rax
lea rdi, [rsp+0F8h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6768F
mov r14, rax
loc_6768F:
lea rdi, [rsp+0F8h+var_90]
jmp short loc_676B0
mov r14, rax
lea rdi, [rsp+0F8h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_676AB
mov r14, rax
loc_676AB:
lea rdi, [rsp+0F8h+var_80]
loc_676B0:
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_676BA
mov r14, rax
loc_676BA:
mov rdi, [rsp+0F8h+var_F0]
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_676E2
loc_676C6:
mov r14, rax
jmp short loc_676D8
mov r14, rax
lea rdi, [rsp+0F8h+var_C0]
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_676D8:
lea rdi, [rsp+0F8h+var_E8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_676E2:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1,
minja::Value *a2)
{
long long *v4; // rax
long long v5; // r15
long long v6; // rbx
long long v7; // rax
_BYTE *v8; // r15
_BYTE *v9; // rsi
int v10; // eax
char *v11; // rax
char *v12; // r12
_QWORD *v13; // rdi
char *v14; // rax
char *v15; // rax
void *v17; // r12
void *exception; // rbx
__int128 v20; // [rsp+10h] [rbp-E8h] BYREF
long long v21; // [rsp+20h] [rbp-D8h]
_BYTE *v22; // [rsp+30h] [rbp-C8h]
_BYTE v23[32]; // [rsp+38h] [rbp-C0h] BYREF
char v24[16]; // [rsp+58h] [rbp-A0h] BYREF
char v25[16]; // [rsp+68h] [rbp-90h] BYREF
char v26[16]; // [rsp+78h] [rbp-80h] BYREF
_QWORD v27[4]; // [rsp+88h] [rbp-70h] BYREF
_QWORD v28[10]; // [rsp+A8h] [rbp-50h] BYREF
if ( minja::Value::is_primitive(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>::basic_json(
a1,
(long long)a2 + 64);
return a1;
}
if ( minja::Value::is_null(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>::basic_json(a1);
return a1;
}
v4 = (long long *)*((_QWORD *)a2 + 2);
if ( v4 )
{
v21 = 0LL;
v20 = 0LL;
v5 = *v4;
v6 = v4[1];
while ( v5 != v6 )
{
minja::Value::get<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>>(
v23,
v5);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v20,
(long long)v23);
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)v23);
v5 += 80LL;
}
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_(
a1,
&v20);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v20);
return a1;
}
if ( !*((_QWORD *)a2 + 4) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v23, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v20, (long long)"get<json> not defined for this value type: ", (long long)v23);
std::runtime_error::runtime_error(exception, &v20);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
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>::object(
a1,
0LL,
0LL);
v7 = *((_QWORD *)a2 + 4);
v8 = *(_BYTE **)v7;
v22 = *(_BYTE **)(v7 + 8);
while ( v8 != v22 )
{
v9 = v8 + 16;
v10 = (unsigned __int8)*v8;
if ( *v8 && v10 != 4 )
{
if ( v10 == 3 )
{
minja::Value::get<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>>(
v25,
v9);
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
(long long)v27,
(long long)v8);
v11 = (char *)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,
v27);
v12 = v25;
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=(
v11,
v25);
v13 = v27;
goto LABEL_19;
}
if ( (unsigned __int8)(v10 - 5) > 3u )
{
v17 = __cxa_allocate_exception(0x10uLL);
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>::dump(
(long long)v23,
(long long)v8,
-1,
32,
0,
0);
std::operator+<char>((long long)&v20, (long long)"Invalid key type for conversion to JSON: ", (long long)v23);
std::runtime_error::runtime_error(v17, &v20);
__cxa_throw(
v17,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
minja::Value::get<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>>(
v26,
v9);
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>::dump(
(long long)v28,
(long long)v8,
-1,
32,
0,
0);
v14 = (char *)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,
v28);
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=(
v14,
v26);
v13 = v28;
v12 = v26;
LABEL_19:
std::string::~string(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v12);
v8 += 96;
}
if ( *((_QWORD *)a2 + 6) )
{
LOBYTE(v20) = 1;
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(
v24,
&v20);
v15 = (char *)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>(
a1,
(long long)"__callable__");
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=(
v15,
v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v24);
}
return a1;
}
| get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R14,RSI
MOV R13,RDI
MOV RDI,RSI
CALL 0x0013cf44
TEST AL,AL
JZ 0x0016736d
ADD R14,0x40
MOV RDI,R13
MOV RSI,R14
CALL 0x0012c946
JMP 0x00167531
LAB_0016736d:
MOV RDI,R14
CALL 0x0013d906
TEST AL,AL
JZ 0x00167388
MOV RDI,R13
XOR ESI,ESI
CALL 0x0012d21c
JMP 0x00167531
LAB_00167388:
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
JZ 0x001673f3
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
AND qword ptr [R14 + 0x10],0x0
MOVAPS xmmword ptr [R14],XMM0
MOV R15,qword ptr [RAX]
MOV RBX,qword ptr [RAX + 0x8]
LEA R12,[RSP + 0x38]
LAB_001673ae:
CMP R15,RBX
JZ 0x001673d7
LAB_001673b3:
MOV RDI,R12
MOV RSI,R15
CALL 0x00167336
LAB_001673be:
MOV RDI,R14
MOV RSI,R12
CALL 0x0013df72
MOV RDI,R12
CALL 0x0012c78c
ADD R15,0x50
JMP 0x001673ae
LAB_001673d7:
LEA RSI,[RSP + 0x10]
MOV RDI,R13
CALL 0x00167d3c
LAB_001673e4:
LEA RDI,[RSP + 0x10]
CALL 0x0013de74
JMP 0x00167531
LAB_001673f3:
CMP qword ptr [R14 + 0x20],0x0
JZ 0x001675a9
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00167d74
MOV RAX,qword ptr [R14 + 0x20]
MOV R15,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RAX
LEA RBP,[RSP + 0x78]
LEA R13,[RSP + 0xa8]
LAB_0016742c:
LEA R12,[RSP + 0x88]
CMP R15,qword ptr [RSP + 0x30]
JZ 0x001674ec
LEA RSI,[R15 + 0x10]
MOVZX EAX,byte ptr [R15]
TEST EAX,EAX
JZ 0x00167499
CMP EAX,0x4
JZ 0x00167499
CMP EAX,0x3
JNZ 0x0016748f
LAB_00167455:
LEA RDI,[RSP + 0x68]
CALL 0x00167336
LAB_0016745f:
MOV RDI,R12
MOV RSI,R15
CALL 0x0013e6c6
LAB_0016746a:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x00162eae
MOV RBX,R12
MOV RDI,RAX
LEA R12,[RSP + 0x68]
MOV RSI,R12
CALL 0x0012c748
MOV RDI,RBX
JMP 0x001674d6
LAB_0016748f:
ADD AL,0xfb
CMP AL,0x3
JA 0x00167546
LAB_00167499:
MOV RDI,RBP
CALL 0x00167336
LAB_001674a1:
MOV RDI,R13
MOV RSI,R15
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0012d946
LAB_001674b8:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R13
CALL 0x00162eae
MOV RDI,RAX
MOV RSI,RBP
CALL 0x0012c748
MOV RDI,R13
MOV R12,RBP
LAB_001674d6:
CALL 0x00120d88
MOV RDI,R12
CALL 0x0012c78c
ADD R15,0x60
JMP 0x0016742c
LAB_001674ec:
CMP qword ptr [R14 + 0x30],0x0
MOV R13,qword ptr [RSP + 0x8]
JZ 0x00167531
LEA RSI,[RSP + 0x10]
MOV byte ptr [RSI],0x1
LEA RDI,[RSP + 0x58]
CALL 0x00167d88
LAB_0016750a:
LEA RSI,[0x1926bb]
MOV RDI,R13
CALL 0x0015f1be
LAB_00167519:
LEA R14,[RSP + 0x58]
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012c748
MOV RDI,R14
CALL 0x0012c78c
LAB_00167531:
MOV RAX,R13
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00167546:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R12,RAX
LAB_00167551:
LEA RDI,[RSP + 0x38]
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
MOV RSI,R15
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0012d946
LAB_0016756a:
LEA RSI,[0x192691]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x38]
CALL 0x00128a89
MOV BL,0x1
LAB_00167582:
LEA RSI,[RSP + 0x10]
MOV RDI,R12
CALL 0x00120aa0
XOR EBX,EBX
MOV RSI,qword ptr [0x001d0fe8]
MOV RDX,qword ptr [0x001d0f60]
MOV RDI,R12
CALL 0x00120b30
LAB_001675a9:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV RBX,RAX
LAB_001675b4:
LEA RDI,[RSP + 0x38]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0013cf54
LAB_001675c6:
LEA RSI,[0x1926c8]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x38]
CALL 0x00128a89
MOV BPL,0x1
LAB_001675df:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001d0fe8]
MOV RDX,qword ptr [0x001d0f60]
MOV RDI,RBX
CALL 0x00120b30
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* minja::Value::
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(void)
{
long *plVar1;
long lVar2;
char cVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar4;
runtime_error *prVar5;
Value *in_RSI;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*in_RDI;
string *this;
long lVar6;
char *pcVar7;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
char *local_c8;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_c0 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_a0 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_90 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_80 [16];
string local_70 [32];
string local_50 [32];
cVar3 = is_primitive(in_RSI);
if (cVar3 == '\0') {
cVar3 = is_null(in_RSI);
if (cVar3 == '\0') {
plVar1 = *(long **)(in_RSI + 0x10);
if (plVar1 == (long *)0x0) {
if (*(long *)(in_RSI + 0x20) == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001675b4 to 001675c5 has its CatchHandler @ 0016762d */
dump_abi_cxx11_((int)local_c0,SUB81(in_RSI,0));
/* try { // try from 001675c6 to 001675db has its CatchHandler @ 00167613 */
std::operator+((char *)&local_e8,(string *)"get<json> not defined for this value type: ");
/* try { // try from 001675df to 00167603 has its CatchHandler @ 00167604 */
std::runtime_error::runtime_error(prVar5,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001d0fe8,PTR__runtime_error_001d0f60);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::object();
local_c8 = (char *)(*(int8 **)(in_RSI + 0x20))[1];
for (pcVar7 = (char *)**(int8 **)(in_RSI + 0x20); pcVar7 != local_c8;
pcVar7 = pcVar7 + 0x60) {
cVar3 = *pcVar7;
if ((cVar3 == '\0') || (cVar3 == '\x04')) {
LAB_00167499:
/* try { // try from 00167499 to 001674a0 has its CatchHandler @ 001676b7 */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 001674a1 to 001674b7 has its CatchHandler @ 001676a8 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_50,pcVar7,0xffffffffffffffff,0x20,0,0);
/* try { // try from 001674b8 to 001674c4 has its CatchHandler @ 00167696 */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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[](in_RDI,local_50);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar4,local_80);
this = local_50;
pbVar4 = local_80;
}
else {
if (cVar3 != '\x03') {
if (3 < (byte)(cVar3 - 5U)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10,pcVar7 + 0x10);
/* try { // try from 00167551 to 00167569 has its CatchHandler @ 0016766d */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_c0,pcVar7,0xffffffffffffffff,0x20,0,0);
/* try { // try from 0016756a to 0016757f has its CatchHandler @ 00167658 */
std::operator+((char *)&local_e8,
(string *)"Invalid key type for conversion to JSON: ");
/* try { // try from 00167582 to 001675a6 has its CatchHandler @ 00167649 */
std::runtime_error::runtime_error(prVar5,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001d0fe8,PTR__runtime_error_001d0f60);
}
goto LAB_00167499;
}
/* try { // try from 00167455 to 0016745e has its CatchHandler @ 001676b7 */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 0016745f to 00167469 has its CatchHandler @ 0016768c */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(local_70,pcVar7);
/* try { // try from 0016746a to 00167476 has its CatchHandler @ 0016767a */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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[](in_RDI,local_70);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(pbVar4,local_90);
this = local_70;
pbVar4 = local_90;
}
std::__cxx11::string::~string(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(pbVar4);
}
if (*(long *)(in_RSI + 0x30) != 0) {
local_e8 = CONCAT71(local_e8._1_7_,1);
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_a0);
/* try { // try from 0016750a to 00167518 has its CatchHandler @ 0016763d */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>(in_RDI,"__callable__");
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar4,local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_a0);
}
}
else {
local_d8 = 0;
local_e8 = 0;
uStack_e0 = 0;
lVar2 = plVar1[1];
for (lVar6 = *plVar1; lVar6 != lVar2; lVar6 = lVar6 + 0x50) {
/* try { // try from 001673b3 to 001673bd has its CatchHandler @ 001676c6 */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 001673be to 001673c8 has its CatchHandler @ 001676cb */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_e8,local_c0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_c0);
}
/* try { // try from 001673d7 to 001673e3 has its CatchHandler @ 00167647 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
();
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_e8);
}
}
else {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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((_func_decltype_nullptr *)in_RDI);
}
}
else {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(in_RDI,in_RSI + 0x40);
}
return in_RDI;
}
| |
34,944 | Proc_purge_account::operator()(PFS_account*) | eloqsql/storage/perfschema/pfs_account.cc | virtual void operator()(PFS_account *pfs)
{
PFS_user *user= sanitize_user(pfs->m_user);
PFS_host *host= sanitize_host(pfs->m_host);
pfs->aggregate(true, user, host);
if (pfs->get_refcount() == 0)
purge_account(m_thread, pfs);
} | O3 | cpp | Proc_purge_account::operator()(PFS_account*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa90(%rsi), %rdi
callq 0x3ad51
movq %rax, %r15
movq 0xa98(%rbx), %rdi
callq 0x443bf
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3eeb2
movl 0xaa8(%rbx), %eax
testl %eax, %eax
je 0x3fa77
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f5fc
nop
| _ZN18Proc_purge_accountclEP11PFS_account:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, [rsi+0A90h]; PFS_user *
call _Z13sanitize_userP8PFS_user; sanitize_user(PFS_user *)
mov r15, rax
mov rdi, [rbx+0A98h]; PFS_host *
call _Z13sanitize_hostP8PFS_host; sanitize_host(PFS_host *)
mov rdi, rbx; this
mov esi, 1; bool
mov rdx, r15; PFS_user *
mov rcx, rax; PFS_host *
call _ZN11PFS_account9aggregateEbP8PFS_userP8PFS_host; PFS_account::aggregate(bool,PFS_user *,PFS_host *)
mov eax, [rbx+0AA8h]
test eax, eax
jz short loc_3FA77
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3FA77:
mov rdi, [r14+8]; PFS_thread *
mov rsi, rbx; PFS_account *
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _Z13purge_accountP10PFS_threadP11PFS_account; purge_account(PFS_thread *,PFS_account *)
| void Proc_purge_account::operator()(long long a1, long long a2)
{
PFS_user *v2; // r15
PFS_host *v3; // rax
v2 = sanitize_user(*(PFS_user **)(a2 + 2704));
v3 = (PFS_host *)sanitize_host(*(PFS_host **)(a2 + 2712));
PFS_account::aggregate((PFS_account *)a2, 1, v2, v3);
if ( !*(_DWORD *)(a2 + 2728) )
purge_account(*(PFS_thread **)(a1 + 8), (PFS_account *)a2);
}
| operator():
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RSI + 0xa90]
CALL 0x0013ad51
MOV R15,RAX
MOV RDI,qword ptr [RBX + 0xa98]
CALL 0x001443bf
MOV RDI,RBX
MOV ESI,0x1
MOV RDX,R15
MOV RCX,RAX
CALL 0x0013eeb2
MOV EAX,dword ptr [RBX + 0xaa8]
TEST EAX,EAX
JZ 0x0013fa77
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013fa77:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0013f5fc
|
/* Proc_purge_account::TEMPNAMEPLACEHOLDERVALUE(PFS_account*) */
void __thiscall Proc_purge_account::operator()(Proc_purge_account *this,PFS_account *param_1)
{
PFS_user *pPVar1;
PFS_host *pPVar2;
pPVar1 = (PFS_user *)sanitize_user(*(PFS_user **)(param_1 + 0xa90));
pPVar2 = (PFS_host *)sanitize_host(*(PFS_host **)(param_1 + 0xa98));
PFS_account::aggregate(param_1,true,pPVar1,pPVar2);
if (*(int *)(param_1 + 0xaa8) != 0) {
return;
}
purge_account(*(PFS_thread **)(this + 8),param_1);
return;
}
| |
34,945 | transid_get_packed | eloqsql/storage/maria/ma_key.c | ulonglong transid_get_packed(MARIA_SHARE *share, const uchar *from)
{
ulonglong value;
uint length;
if (from[0] < MARIA_MIN_TRANSID_PACK_OFFSET)
value= (ulonglong) from[0];
else
{
value= 0;
for (length= (uint) (from[0] - MARIA_TRANSID_PACK_OFFSET),
value= (ulonglong) from[1], from+=2;
--length ;
from++)
value= (value << 8) + ((ulonglong) *from);
}
return (value >> 1) + share->state.create_trid;
} | O0 | c | transid_get_packed:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xf3, %eax
jge 0x33b17
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0x33b7a
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
subl $0xf9, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x33b78
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x33b46
jmp 0x33b7a
movq -0x18(%rbp), %rax
shrq %rax
movq -0x8(%rbp), %rcx
addq 0xe0(%rcx), %rax
popq %rbp
retq
nop
| transid_get_packed:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 0F3h
jge short loc_33B17
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
jmp short loc_33B7A
loc_33B17:
mov [rbp+var_18], 0
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
sub eax, 0F9h
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
loc_33B46:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
cmp eax, 0
jz short loc_33B78
mov rax, [rbp+var_18]
shl rax, 8
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_33B46
loc_33B78:
jmp short $+2
loc_33B7A:
mov rax, [rbp+var_18]
shr rax, 1
mov rcx, [rbp+var_8]
add rax, [rcx+0E0h]
pop rbp
retn
| unsigned long long transid_get_packed(long long a1, unsigned __int8 *a2)
{
int v3; // [rsp+0h] [rbp-1Ch]
unsigned long long v4; // [rsp+4h] [rbp-18h]
unsigned __int8 *i; // [rsp+Ch] [rbp-10h]
if ( *a2 >= 0xF3u )
{
v3 = *a2 - 249;
v4 = a2[1];
for ( i = a2 + 2; --v3; ++i )
v4 = *i + (v4 << 8);
}
else
{
v4 = *a2;
}
return *(_QWORD *)(a1 + 224) + (v4 >> 1);
}
| transid_get_packed:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xf3
JGE 0x00133b17
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00133b7a
LAB_00133b17:
MOV qword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
SUB EAX,0xf9
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
LAB_00133b46:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JZ 0x00133b78
MOV RAX,qword ptr [RBP + -0x18]
SHL RAX,0x8
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00133b46
LAB_00133b78:
JMP 0x00133b7a
LAB_00133b7a:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x1
MOV RCX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RCX + 0xe0]
POP RBP
RET
|
long transid_get_packed(long param_1,byte *param_2)
{
int local_24;
ulong local_20;
byte *local_18;
if (*param_2 < 0xf3) {
local_20 = (ulong)*param_2;
}
else {
local_24 = *param_2 - 0xf9;
local_20 = (ulong)param_2[1];
local_18 = param_2 + 2;
while (local_24 = local_24 + -1, local_24 != 0) {
local_20 = local_20 * 0x100 + (ulong)*local_18;
local_18 = local_18 + 1;
}
}
return (local_20 >> 1) + *(long *)(param_1 + 0xe0);
}
| |
34,946 | dequantize_row_q6_K | monkey531[P]llama/ggml/src/ggml-quants.c | void dequantize_row_q6_K(const block_q6_K * restrict x, float * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const uint8_t * restrict ql = x[i].ql;
const uint8_t * restrict qh = x[i].qh;
const int8_t * restrict sc = x[i].scales;
for (int n = 0; n < QK_K; n += 128) {
for (int l = 0; l < 32; ++l) {
int is = l/16;
const int8_t q1 = (int8_t)((ql[l + 0] & 0xF) | (((qh[l] >> 0) & 3) << 4)) - 32;
const int8_t q2 = (int8_t)((ql[l + 32] & 0xF) | (((qh[l] >> 2) & 3) << 4)) - 32;
const int8_t q3 = (int8_t)((ql[l + 0] >> 4) | (((qh[l] >> 4) & 3) << 4)) - 32;
const int8_t q4 = (int8_t)((ql[l + 32] >> 4) | (((qh[l] >> 6) & 3) << 4)) - 32;
y[l + 0] = d * sc[is + 0] * q1;
y[l + 32] = d * sc[is + 2] * q2;
y[l + 64] = d * sc[is + 4] * q3;
y[l + 96] = d * sc[is + 6] * q4;
}
y += 128;
ql += 64;
qh += 32;
sc += 8;
}
}
} | O3 | c | dequantize_row_q6_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xff(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
movq %rax, -0x8(%rsp)
cmpq $0x100, %rdx # imm = 0x100
jl 0x307b3
sarq $0x8, -0x8(%rsp)
xorl %ecx, %ecx
imulq $0xd2, %rcx, %rdx
leaq (%rdi,%rdx), %r8
leaq (%rdi,%rdx), %r9
addq $0x80, %r9
movzwl 0x50(%r9), %r10d
movq 0x3994e(%rip), %rax # 0x69fa8
movss (%rax,%r10,4), %xmm0
leaq (%rdi,%rdx), %r10
addq $0xc0, %r10
movb $0x1, %r11b
xorl %ebx, %ebx
movl %ebx, %r14d
shrl $0x4, %r14d
movb (%r8,%rbx), %r13b
movb 0x20(%r8,%rbx), %dl
movl %r13d, %ebp
andb $0xf, %bpl
movb (%r9,%rbx), %r15b
movl %r15d, %r12d
shlb $0x4, %r12b
andb $0x30, %r12b
orb %bpl, %r12b
addb $-0x20, %r12b
movl %edx, %ebp
andb $0xf, %bpl
movsbl (%r10,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
leal (,%r15,4), %eax
andb $0x30, %al
orb %bpl, %al
addb $-0x20, %al
shrb $0x4, %r13b
movl %r15d, %ebp
andb $0x30, %bpl
orb %r13b, %bpl
addb $-0x20, %bpl
shrb $0x4, %dl
shrb $0x2, %r15b
andb $0x30, %r15b
movsbl %r12b, %r12d
xorps %xmm2, %xmm2
cvtsi2ss %r12d, %xmm2
orb %dl, %r15b
mulss %xmm0, %xmm1
mulss %xmm1, %xmm2
movss %xmm2, (%rsi,%rbx,4)
movsbl 0x2(%r10,%r14), %edx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
movsbl %al, %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
addb $-0x20, %r15b
mulss %xmm0, %xmm1
mulss %xmm1, %xmm2
movss %xmm2, 0x80(%rsi,%rbx,4)
movsbl 0x4(%r10,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movsbl %bpl, %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm0, %xmm1
mulss %xmm1, %xmm2
movss %xmm2, 0x100(%rsi,%rbx,4)
movsbl 0x6(%r10,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movsbl %r15b, %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, 0x180(%rsi,%rbx,4)
incq %rbx
cmpq $0x20, %rbx
jne 0x30670
addq $0x200, %rsi # imm = 0x200
addq $0x40, %r8
addq $0x20, %r9
addq $0x8, %r10
testb $0x1, %r11b
movl $0x0, %r11d
jne 0x3066e
incq %rcx
cmpq -0x8(%rsp), %rcx
jne 0x30638
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| dequantize_row_q6_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
lea rax, [rdx+0FFh]
test rdx, rdx
cmovns rax, rdx
mov [rsp+30h+var_38], rax
cmp rdx, 100h
jl loc_307B3
sar [rsp+30h+var_38], 8
xor ecx, ecx
loc_30638:
imul rdx, rcx, 0D2h
lea r8, [rdi+rdx]
lea r9, [rdi+rdx]
add r9, 80h
movzx r10d, word ptr [r9+50h]
mov rax, cs:ggml_table_f32_f16_ptr
movss xmm0, dword ptr [rax+r10*4]
lea r10, [rdi+rdx]
add r10, 0C0h
mov r11b, 1
loc_3066E:
xor ebx, ebx
loc_30670:
mov r14d, ebx
shr r14d, 4
mov r13b, [r8+rbx]
mov dl, [r8+rbx+20h]
mov ebp, r13d
and bpl, 0Fh
mov r15b, [r9+rbx]
mov r12d, r15d
shl r12b, 4
and r12b, 30h
or r12b, bpl
add r12b, 0E0h
mov ebp, edx
and bpl, 0Fh
movsx eax, byte ptr [r10+r14]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
lea eax, ds:0[r15*4]
and al, 30h
or al, bpl
add al, 0E0h
shr r13b, 4
mov ebp, r15d
and bpl, 30h
or bpl, r13b
add bpl, 0E0h
shr dl, 4
shr r15b, 2
and r15b, 30h
movsx r12d, r12b
xorps xmm2, xmm2
cvtsi2ss xmm2, r12d
or r15b, dl
mulss xmm1, xmm0
mulss xmm2, xmm1
movss dword ptr [rsi+rbx*4], xmm2
movsx edx, byte ptr [r10+r14+2]
xorps xmm1, xmm1
cvtsi2ss xmm1, edx
movsx eax, al
xorps xmm2, xmm2
cvtsi2ss xmm2, eax
add r15b, 0E0h
mulss xmm1, xmm0
mulss xmm2, xmm1
movss dword ptr [rsi+rbx*4+80h], xmm2
movsx eax, byte ptr [r10+r14+4]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
movsx eax, bpl
xorps xmm2, xmm2
cvtsi2ss xmm2, eax
mulss xmm1, xmm0
mulss xmm2, xmm1
movss dword ptr [rsi+rbx*4+100h], xmm2
movsx eax, byte ptr [r10+r14+6]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movsx eax, r15b
xorps xmm2, xmm2
cvtsi2ss xmm2, eax
mulss xmm2, xmm1
movss dword ptr [rsi+rbx*4+180h], xmm2
inc rbx
cmp rbx, 20h ; ' '
jnz loc_30670
add rsi, 200h
add r8, 40h ; '@'
add r9, 20h ; ' '
add r10, 8
test r11b, 1
mov r11d, 0
jnz loc_3066E
inc rcx
cmp rcx, [rsp+30h+var_38]
jnz loc_30638
loc_307B3:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long dequantize_row_q6_K(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rcx
long long v5; // r8
long long v6; // r9
float v7; // xmm0_4
long long v8; // r10
char v9; // r11
long long i; // rbx
long long v11; // r14
unsigned __int8 v12; // r15
char v13; // al
char v14; // bp
char v15; // r15
bool v16; // zf
long long v17; // [rsp+0h] [rbp-38h]
result = a3 + 255;
if ( a3 >= 0 )
result = a3;
if ( a3 >= 256 )
{
v17 = result >> 8;
v4 = 0LL;
do
{
v5 = a1 + 210 * v4;
v6 = v5 + 128;
v7 = ggml_table_f32_f16[*(unsigned __int16 *)(v5 + 208)];
v8 = v5 + 192;
v9 = 1;
do
{
for ( i = 0LL; i != 32; ++i )
{
v11 = (unsigned int)i >> 4;
v12 = *(_BYTE *)(v6 + i);
v13 = (*(_BYTE *)(v5 + i + 32) & 0xF | (4 * v12) & 0x30) - 32;
v14 = ((*(_BYTE *)(v5 + i) >> 4) | v12 & 0x30) - 32;
v15 = (*(_BYTE *)(v5 + i + 32) >> 4) | (v12 >> 2) & 0x30;
*(float *)(a2 + 4 * i) = (float)(char)((*(_BYTE *)(v5 + i) & 0xF | (16 * *(_BYTE *)(v6 + i)) & 0x30) - 32)
* (float)((float)*(char *)(v8 + v11) * v7);
*(float *)(a2 + 4 * i + 128) = (float)v13 * (float)((float)*(char *)(v8 + v11 + 2) * v7);
*(float *)(a2 + 4 * i + 256) = (float)v14 * (float)((float)*(char *)(v8 + v11 + 4) * v7);
result = (unsigned int)(char)(v15 - 32);
*(float *)(a2 + 4 * i + 384) = (float)(int)result * (float)((float)*(char *)(v8 + v11 + 6) * v7);
}
a2 += 512LL;
v5 += 64LL;
v6 += 32LL;
v8 += 8LL;
v16 = (v9 & 1) == 0;
v9 = 0;
}
while ( !v16 );
++v4;
}
while ( v4 != v17 );
}
return result;
}
| dequantize_row_q6_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
LEA RAX,[RDX + 0xff]
TEST RDX,RDX
CMOVNS RAX,RDX
MOV qword ptr [RSP + -0x8],RAX
CMP RDX,0x100
JL 0x001307b3
SAR qword ptr [RSP + -0x8],0x8
XOR ECX,ECX
LAB_00130638:
IMUL RDX,RCX,0xd2
LEA R8,[RDI + RDX*0x1]
LEA R9,[RDI + RDX*0x1]
ADD R9,0x80
MOVZX R10D,word ptr [R9 + 0x50]
MOV RAX,qword ptr [0x00169fa8]
MOVSS XMM0,dword ptr [RAX + R10*0x4]
LEA R10,[RDI + RDX*0x1]
ADD R10,0xc0
MOV R11B,0x1
LAB_0013066e:
XOR EBX,EBX
LAB_00130670:
MOV R14D,EBX
SHR R14D,0x4
MOV R13B,byte ptr [R8 + RBX*0x1]
MOV DL,byte ptr [R8 + RBX*0x1 + 0x20]
MOV EBP,R13D
AND BPL,0xf
MOV R15B,byte ptr [R9 + RBX*0x1]
MOV R12D,R15D
SHL R12B,0x4
AND R12B,0x30
OR R12B,BPL
ADD R12B,0xe0
MOV EBP,EDX
AND BPL,0xf
MOVSX EAX,byte ptr [R10 + R14*0x1]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
LEA EAX,[R15*0x4]
AND AL,0x30
OR AL,BPL
ADD AL,0xe0
SHR R13B,0x4
MOV EBP,R15D
AND BPL,0x30
OR BPL,R13B
ADD BPL,0xe0
SHR DL,0x4
SHR R15B,0x2
AND R15B,0x30
MOVSX R12D,R12B
XORPS XMM2,XMM2
CVTSI2SS XMM2,R12D
OR R15B,DL
MULSS XMM1,XMM0
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RBX*0x4],XMM2
MOVSX EDX,byte ptr [R10 + R14*0x1 + 0x2]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EDX
MOVSX EAX,AL
XORPS XMM2,XMM2
CVTSI2SS XMM2,EAX
ADD R15B,0xe0
MULSS XMM1,XMM0
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RBX*0x4 + 0x80],XMM2
MOVSX EAX,byte ptr [R10 + R14*0x1 + 0x4]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MOVSX EAX,BPL
XORPS XMM2,XMM2
CVTSI2SS XMM2,EAX
MULSS XMM1,XMM0
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RBX*0x4 + 0x100],XMM2
MOVSX EAX,byte ptr [R10 + R14*0x1 + 0x6]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSX EAX,R15B
XORPS XMM2,XMM2
CVTSI2SS XMM2,EAX
MULSS XMM2,XMM1
MOVSS dword ptr [RSI + RBX*0x4 + 0x180],XMM2
INC RBX
CMP RBX,0x20
JNZ 0x00130670
ADD RSI,0x200
ADD R8,0x40
ADD R9,0x20
ADD R10,0x8
TEST R11B,0x1
MOV R11D,0x0
JNZ 0x0013066e
INC RCX
CMP RCX,qword ptr [RSP + -0x8]
JNZ 0x00130638
LAB_001307b3:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void dequantize_row_q6_K(long param_1,long param_2,long param_3)
{
float fVar1;
byte bVar2;
byte bVar3;
byte bVar4;
bool bVar5;
long lVar6;
long lVar7;
long lVar8;
ulong uVar9;
long lVar10;
long lVar11;
bool bVar12;
ulong uVar13;
lVar6 = param_3 + 0xff;
if (-1 < param_3) {
lVar6 = param_3;
}
if (0xff < param_3) {
lVar7 = 0;
do {
lVar8 = lVar7 * 0xd2;
lVar10 = param_1 + lVar8;
lVar11 = param_1 + lVar8 + 0x80;
fVar1 = *(float *)(PTR_ggml_table_f32_f16_00169fa8 +
(ulong)*(ushort *)(param_1 + lVar8 + 0xd0) * 4);
lVar8 = param_1 + lVar8 + 0xc0;
bVar5 = true;
do {
bVar12 = bVar5;
uVar9 = 0;
do {
uVar13 = uVar9 >> 4 & 0xfffffff;
bVar2 = *(byte *)(lVar10 + uVar9);
bVar3 = *(byte *)(lVar10 + 0x20 + uVar9);
bVar4 = *(byte *)(lVar11 + uVar9);
*(float *)(param_2 + uVar9 * 4) =
(float)(int)(char)(((bVar4 & 3) << 4 | bVar2 & 0xf) - 0x20) *
(float)(int)*(char *)(lVar8 + uVar13) * fVar1;
*(float *)(param_2 + 0x80 + uVar9 * 4) =
(float)(int)(char)((bVar4 * '\x04' & 0x30 | bVar3 & 0xf) - 0x20) *
(float)(int)*(char *)(lVar8 + 2 + uVar13) * fVar1;
*(float *)(param_2 + 0x100 + uVar9 * 4) =
(float)(int)(char)((bVar4 & 0x30 | bVar2 >> 4) - 0x20) *
(float)(int)*(char *)(lVar8 + 4 + uVar13) * fVar1;
*(float *)(param_2 + 0x180 + uVar9 * 4) =
(float)(int)(char)((bVar4 >> 2 & 0x30 | bVar3 >> 4) - 0x20) *
(float)(int)*(char *)(lVar8 + 6 + uVar13) * fVar1;
uVar9 = uVar9 + 1;
} while (uVar9 != 0x20);
param_2 = param_2 + 0x200;
lVar10 = lVar10 + 0x40;
lVar11 = lVar11 + 0x20;
lVar8 = lVar8 + 8;
bVar5 = false;
} while (bVar12);
lVar7 = lVar7 + 1;
} while (lVar7 != lVar6 >> 8);
}
return;
}
| |
34,947 | ftxui::(anonymous namespace)::compose(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>)::$_0::~$_0() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/util.cpp | Decorator compose(Decorator a, Decorator b) {
return [a = std::move(a), b = std::move(b)](Element element) {
return b(a(std::move(element)));
};
} | O3 | cpp | ftxui::(anonymous namespace)::compose(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>)::$_0::~$_0():
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x25ddd
leaq 0x20(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x25df3
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
popq %rbx
retq
jmp 0x25df7
movq %rax, %rdi
callq 0x1049a
nop
| _ZZN5ftxui12_GLOBAL__N_17composeESt8functionIFSt10shared_ptrINS_4NodeEES4_EES6_EN3$_0D2Ev:
push rbx
mov rbx, rdi
mov rax, [rdi+30h]
test rax, rax
jz short loc_25DDD
lea rdi, [rbx+20h]
mov rsi, rdi
mov edx, 3
call rax
loc_25DDD:
mov rax, [rbx+10h]
test rax, rax
jz short loc_25DF3
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_25DF3:
pop rbx
retn
jmp short $+2
loc_25DF7:
mov rdi, rax
call __clang_call_terminate
| long long ( * ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::~$_0(
long long a1))(long long, long long, long long)
{
void ( *v1)(long long, long long, long long); // rax
long long ( *result)(long long, long long, long long); // rax
v1 = *(void ( **)(long long, long long, long long))(a1 + 48);
if ( v1 )
v1(a1 + 32, a1 + 32, 3LL);
result = *(long long ( **)(long long, long long, long long))(a1 + 16);
if ( result )
return (long long ( *)(long long, long long, long long))result(a1, a1, 3LL);
return result;
}
| ~$_0:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x00125ddd
LEA RDI,[RBX + 0x20]
LAB_00125dd3:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00125ddd:
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x00125df3
LAB_00125de6:
MOV RDI,RBX
MOV RSI,RBX
MOV EDX,0x3
CALL RAX
LAB_00125df3:
POP RBX
RET
|
/* ~$_0() */
void __thiscall
ftxui::(anonymous_namespace)::
compose(std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>)
::$_0::~__0(__0 *this)
{
if (*(code **)(this + 0x30) != (code *)0x0) {
/* try { // try from 00125dd3 to 00125ddc has its CatchHandler @ 00125df7 */
(**(code **)(this + 0x30))(this + 0x20,this + 0x20,3);
}
if (*(code **)(this + 0x10) != (code *)0x0) {
/* try { // try from 00125de6 to 00125df2 has its CatchHandler @ 00125df5 */
(**(code **)(this + 0x10))(this,this,3);
}
return;
}
| |
34,948 | ma_store_length | eloqsql/storage/maria/ma_blockrec.c | uchar *ma_store_length(uchar *to, ulong nr)
{
if (nr < 251)
{
*to=(uchar) nr;
return to+1;
}
if (nr < 65536)
{
if (nr <= 255)
{
to[0]= (uchar) 251;
to[1]= (uchar) nr;
return to+2;
}
to[0]= (uchar) 252;
int2store(to+1, nr);
return to+3;
}
if (nr < 16777216)
{
*to++= (uchar) 253;
int3store(to, nr);
return to+3;
}
*to++= (uchar) 254;
int4store(to, nr);
return to+4;
} | O0 | c | ma_store_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0xfb, -0x18(%rbp)
jae 0x59d33
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x59e27
cmpq $0x10000, -0x18(%rbp) # imm = 0x10000
jae 0x59d9e
cmpq $0xff, -0x18(%rbp)
ja 0x59d6c
movq -0x10(%rbp), %rax
movb $-0x5, (%rax)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x59e27
movq -0x10(%rbp), %rax
movb $-0x4, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x59e27
cmpq $0x1000000, -0x18(%rbp) # imm = 0x1000000
jae 0x59df5
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x3, (%rax)
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x8(%rbp)
jmp 0x59e27
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $-0x2, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| ma_store_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0FBh
jnb short loc_59D33
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_8], rax
jmp loc_59E27
loc_59D33:
cmp [rbp+var_18], 10000h
jnb short loc_59D9E
cmp [rbp+var_18], 0FFh
ja short loc_59D6C
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FBh
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_8], rax
jmp loc_59E27
loc_59D6C:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FCh
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov cx, ax
mov rax, [rbp+var_20]
mov [rax], cx
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_8], rax
jmp loc_59E27
loc_59D9E:
cmp [rbp+var_18], 1000000h
jnb short loc_59DF5
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0FDh
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_18]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_10]
add rax, 3
mov [rbp+var_8], rax
jmp short loc_59E27
loc_59DF5:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0FEh
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax], ecx
mov rax, [rbp+var_10]
add rax, 4
mov [rbp+var_8], rax
loc_59E27:
mov rax, [rbp+var_8]
pop rbp
retn
| long long ma_store_length(long long a1, unsigned long long a2)
{
if ( a2 >= 0xFB )
{
if ( a2 >= 0x10000 )
{
if ( a2 >= 0x1000000 )
{
*(_BYTE *)a1 = -2;
*(_DWORD *)(a1 + 1) = a2;
return a1 + 5;
}
else
{
*(_BYTE *)a1 = -3;
*(_WORD *)(a1 + 1) = a2;
*(_BYTE *)(a1 + 3) = BYTE2(a2);
return a1 + 4;
}
}
else if ( a2 > 0xFF )
{
*(_BYTE *)a1 = -4;
*(_WORD *)(a1 + 1) = a2;
return a1 + 3;
}
else
{
*(_BYTE *)a1 = -5;
*(_BYTE *)(a1 + 1) = a2;
return a1 + 2;
}
}
else
{
*(_BYTE *)a1 = a2;
return a1 + 1;
}
}
| ma_store_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0xfb
JNC 0x00159d33
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00159e27
LAB_00159d33:
CMP qword ptr [RBP + -0x18],0x10000
JNC 0x00159d9e
CMP qword ptr [RBP + -0x18],0xff
JA 0x00159d6c
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xfb
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00159e27
LAB_00159d6c:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xfc
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00159e27
LAB_00159d9e:
CMP qword ptr [RBP + -0x18],0x1000000
JNC 0x00159df5
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0xfd
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00159e27
LAB_00159df5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0xfe
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
MOV qword ptr [RBP + -0x8],RAX
LAB_00159e27:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
int1 * ma_store_length(int1 *param_1,ulong param_2)
{
int1 uVar1;
int1 *local_10;
uVar1 = (int1)param_2;
if (param_2 < 0xfb) {
*param_1 = uVar1;
local_10 = param_1 + 1;
}
else if (param_2 < 0x10000) {
if (param_2 < 0x100) {
*param_1 = 0xfb;
param_1[1] = uVar1;
local_10 = param_1 + 2;
}
else {
*param_1 = 0xfc;
*(short *)(param_1 + 1) = (short)param_2;
local_10 = param_1 + 3;
}
}
else if (param_2 < 0x1000000) {
*param_1 = 0xfd;
param_1[1] = uVar1;
param_1[2] = (char)(param_2 >> 8);
param_1[3] = (char)(param_2 >> 0x10);
local_10 = param_1 + 4;
}
else {
*param_1 = 0xfe;
*(int *)(param_1 + 1) = (int)param_2;
local_10 = param_1 + 5;
}
return local_10;
}
| |
34,949 | my_strnncoll_binary | eloqsql/strings/ctype-bin.c | static int my_strnncoll_binary(CHARSET_INFO * cs __attribute__((unused)),
const uchar *s, size_t slen,
const uchar *t, size_t tlen,
my_bool t_is_prefix)
{
size_t len=MY_MIN(slen,tlen);
int cmp= memcmp(s,t,len);
return cmp ? cmp : (int)((t_is_prefix ? len : slen) - tlen);
} | O0 | c | my_strnncoll_binary:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x95726
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x9572e
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x38b10
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x95758
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x9577e
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x9576b
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x95773
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
subq -0x28(%rbp), %rax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_strnncoll_binary:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, r9b
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_29], al
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
jnb short loc_95726
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
jmp short loc_9572E
loc_95726:
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
loc_9572E:
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_38]
call _memcmp
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jz short loc_95758
mov eax, [rbp+var_3C]
mov [rbp+var_4C], eax
jmp short loc_9577E
loc_95758:
movsx eax, [rbp+var_29]
cmp eax, 0
jz short loc_9576B
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
jmp short loc_95773
loc_9576B:
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
loc_95773:
mov rax, [rbp+var_58]
sub rax, [rbp+var_28]
mov [rbp+var_4C], eax
loc_9577E:
mov eax, [rbp+var_4C]
add rsp, 60h
pop rbp
retn
| long long my_strnncoll_binary(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
int v7; // [rsp+8h] [rbp-58h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned int v10; // [rsp+24h] [rbp-3Ch]
int v12; // [rsp+38h] [rbp-28h]
int v13; // [rsp+48h] [rbp-18h]
v13 = a3;
v12 = a5;
if ( a3 >= a5 )
v9 = a5;
else
v9 = a3;
v10 = memcmp(a2, a4, v9);
if ( v10 )
{
return v10;
}
else
{
if ( a6 )
v7 = v9;
else
v7 = v13;
return (unsigned int)(v7 - v12);
}
}
| my_strnncoll_binary:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,R9B
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 byte ptr [RBP + -0x29],AL
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x00195726
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0019572e
LAB_00195726:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
LAB_0019572e:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00138b10
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00195758
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0019577e
LAB_00195758:
MOVSX EAX,byte ptr [RBP + -0x29]
CMP EAX,0x0
JZ 0x0019576b
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00195773
LAB_0019576b:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
LAB_00195773:
MOV RAX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4c],EAX
LAB_0019577e:
MOV EAX,dword ptr [RBP + -0x4c]
ADD RSP,0x60
POP RBP
RET
|
int my_strnncoll_binary(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
ulong local_60;
int local_54;
size_t local_50;
local_50 = param_5;
if (param_3 < param_5) {
local_50 = param_3;
}
local_54 = memcmp(param_2,param_4,local_50);
if (local_54 == 0) {
local_60 = param_3;
if (param_6 != '\0') {
local_60 = local_50;
}
local_54 = (int)local_60 - (int)param_5;
}
return local_54;
}
| |
34,950 | 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_codepoint() | llama.cpp/common/json.hpp | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get_codepoint():
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x8497c
leaq 0x14(%rdi), %rsi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x21ab8
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x93b85(%rip), %rdi # 0x118508
leaq 0x93bb9(%rip), %rdx # 0x118543
leaq 0x94897(%rip), %rcx # 0x119228
movl $0x1d79, %esi # imm = 0x1D79
xorl %eax, %eax
callq 0x20e00
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
push rbx
sub rsp, 10h
cmp dword ptr [rdi+14h], 75h ; 'u'
jnz short loc_8497C
lea rsi, [rdi+14h]
lea rbx, [rsp+18h+var_C]
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv_cold_1; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(void) [clone]
mov eax, [rbx]
add rsp, 10h
pop rbx
retn
loc_8497C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov esi, 1D79h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(
__m128i *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
unsigned int v14[3]; // [rsp+Ch] [rbp-Ch] BYREF
if ( a1[1].m128i_i32[1] == 117 )
{
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(
a1,
&a1[1].m128i_u32[1],
v14);
return v14[0];
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
return nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::next_byte_in_range(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7545LL,
v10,
v11,
v12,
v13,
a7,
a8,
a9);
}
}
| get_codepoint:
PUSH RBX
SUB RSP,0x10
CMP dword ptr [RDI + 0x14],0x75
JNZ 0x0018497c
LEA RSI,[RDI + 0x14]
LEA RBX,[RSP + 0xc]
MOV RDX,RBX
CALL 0x00121ab8
MOV EAX,dword ptr [RBX]
ADD RSP,0x10
POP RBX
RET
LAB_0018497c:
LEA RDI,[0x218508]
LEA RDX,[0x218543]
LEA RCX,[0x219228]
MOV ESI,0x1d79
XOR EAX,EAX
CALL 0x00120e00
|
/* 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 > > >::get_codepoint() */
int4 __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>>>
::get_codepoint(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)
{
int4 local_c;
if (*(int *)(this + 0x14) == 0x75) {
get_codepoint();
return local_c;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1d79,
"GGML_ASSERT(%s) failed","current == \'u\'");
}
| |
34,951 | my_dirend | eloqsql/mysys/my_lib.c | void my_dirend(MY_DIR *dir)
{
MY_DIR_HANDLE *dirh= (MY_DIR_HANDLE*) dir;
DBUG_ENTER("my_dirend");
if (dirh)
{
delete_dynamic(&dirh->array);
free_root(&dirh->root, MYF(0));
my_free(dirh);
}
DBUG_VOID_RETURN;
} | O3 | c | my_dirend:
testq %rdi, %rdi
je 0xa5df8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x94b7c
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0xa09d7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa6612
retq
| my_dirend:
test rdi, rdi
jz short locret_A5DF8
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 10h
call delete_dynamic
lea rdi, [rbx+38h]
xor esi, esi
call free_root
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_free
locret_A5DF8:
retn
| long long my_dirend(long long a1)
{
long long result; // rax
if ( a1 )
{
delete_dynamic((long long *)(a1 + 16));
free_root((_QWORD *)(a1 + 56), 0);
return my_free(a1);
}
return result;
}
| my_dirend:
TEST RDI,RDI
JZ 0x001a5df8
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x10
CALL 0x00194b7c
LEA RDI,[RBX + 0x38]
XOR ESI,ESI
CALL 0x001a09d7
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001a6612
LAB_001a5df8:
RET
|
void my_dirend(long param_1)
{
if (param_1 != 0) {
delete_dynamic(param_1 + 0x10);
free_root(param_1 + 0x38,0);
my_free(param_1);
return;
}
return;
}
| |
34,952 | rlSetBlendMode | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlSetBlendMode(int mode)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified))
{
rlDrawRenderBatch(RLGL.currentBatch);
switch (mode)
{
case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break;
case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_CUSTOM:
{
// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation);
} break;
case RL_BLEND_CUSTOM_SEPARATE:
{
// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate()
glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha);
glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha);
} break;
default: break;
}
RLGL.State.currentBlendMode = mode;
RLGL.State.glCustomBlendModeModified = false;
}
#endif
} | O0 | c | rlSetBlendMode:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x167a6b(%rip), %eax # 0x21ac2c
cmpl -0x4(%rbp), %eax
jne 0xb31e3
cmpl $0x6, -0x4(%rbp)
je 0xb31d6
cmpl $0x7, -0x4(%rbp)
jne 0xb3338
testb $0x1, 0x167a77(%rip) # 0x21ac54
je 0xb3338
movq 0x166fee(%rip), %rdi # 0x21a1d8
callq 0xb0c00
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x7, %rax
ja 0xb3326
movq -0x10(%rbp), %rax
leaq 0x100185(%rip), %rcx # 0x1b3390
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x302, %edi # imm = 0x302
movl $0x303, %esi # imm = 0x303
callq *0x1651bc(%rip) # 0x2183e0
movl $0x8006, %edi # imm = 0x8006
callq *0x165181(%rip) # 0x2183b0
jmp 0xb3328
movl $0x302, %edi # imm = 0x302
movl $0x1, %esi
callq *0x16519c(%rip) # 0x2183e0
movl $0x8006, %edi # imm = 0x8006
callq *0x165161(%rip) # 0x2183b0
jmp 0xb3328
movl $0x306, %edi # imm = 0x306
movl $0x303, %esi # imm = 0x303
callq *0x16517c(%rip) # 0x2183e0
movl $0x8006, %edi # imm = 0x8006
callq *0x165141(%rip) # 0x2183b0
jmp 0xb3328
movl $0x1, %esi
movl %esi, %edi
callq *0x16515f(%rip) # 0x2183e0
movl $0x8006, %edi # imm = 0x8006
callq *0x165124(%rip) # 0x2183b0
jmp 0xb3328
movl $0x1, %esi
movl %esi, %edi
callq *0x165142(%rip) # 0x2183e0
movl $0x800a, %edi # imm = 0x800A
callq *0x165107(%rip) # 0x2183b0
jmp 0xb3328
movl $0x1, %edi
movl $0x303, %esi # imm = 0x303
callq *0x165125(%rip) # 0x2183e0
movl $0x8006, %edi # imm = 0x8006
callq *0x1650ea(%rip) # 0x2183b0
jmp 0xb3328
movq 0x165111(%rip), %rax # 0x2183e0
movl 0x16795b(%rip), %edi # 0x21ac30
movl 0x167959(%rip), %esi # 0x21ac34
callq *%rax
movq 0x1650cc(%rip), %rax # 0x2183b0
movl 0x16794e(%rip), %edi # 0x21ac38
callq *%rax
jmp 0xb3328
movq 0x1650f3(%rip), %rax # 0x2183e8
movl 0x167941(%rip), %edi # 0x21ac3c
movl 0x16793f(%rip), %esi # 0x21ac40
movl 0x16793d(%rip), %edx # 0x21ac44
movl 0x16793b(%rip), %ecx # 0x21ac48
callq *%rax
movq 0x1650a2(%rip), %rax # 0x2183b8
movl 0x167930(%rip), %edi # 0x21ac4c
movl 0x16792e(%rip), %esi # 0x21ac50
callq *%rax
jmp 0xb3328
jmp 0xb3328
movl -0x4(%rbp), %eax
movl %eax, 0x1678fb(%rip) # 0x21ac2c
movb $0x0, 0x16791c(%rip) # 0x21ac54
addq $0x10, %rsp
popq %rbp
retq
nop
| rlSetBlendMode:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov eax, cs:dword_21AC2C
cmp eax, [rbp+var_4]
jnz short loc_B31E3
cmp [rbp+var_4], 6
jz short loc_B31D6
cmp [rbp+var_4], 7
jnz loc_B3338
loc_B31D6:
test cs:byte_21AC54, 1
jz loc_B3338
loc_B31E3:
mov rdi, cs:RLGL
call rlDrawRenderBatch
mov eax, [rbp+var_4]
mov [rbp+var_10], rax
sub rax, 7; switch 8 cases
ja def_B3212; jumptable 00000000000B3212 default case
mov rax, [rbp+var_10]
lea rcx, jpt_B3212
movsxd rax, ds:(jpt_B3212 - 1B3390h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B3214:
mov edi, 302h; jumptable 00000000000B3212 case 0
mov esi, 303h
call cs:glad_glBlendFunc
mov edi, 8006h
call cs:glad_glBlendEquation
jmp loc_B3328
loc_B3234:
mov edi, 302h; jumptable 00000000000B3212 case 1
mov esi, 1
call cs:glad_glBlendFunc
mov edi, 8006h
call cs:glad_glBlendEquation
jmp loc_B3328
loc_B3254:
mov edi, 306h; jumptable 00000000000B3212 case 2
mov esi, 303h
call cs:glad_glBlendFunc
mov edi, 8006h
call cs:glad_glBlendEquation
jmp loc_B3328
loc_B3274:
mov esi, 1; jumptable 00000000000B3212 case 3
mov edi, esi
call cs:glad_glBlendFunc
mov edi, 8006h
call cs:glad_glBlendEquation
jmp loc_B3328
loc_B3291:
mov esi, 1; jumptable 00000000000B3212 case 4
mov edi, esi
call cs:glad_glBlendFunc
mov edi, 800Ah
call cs:glad_glBlendEquation
jmp short loc_B3328
loc_B32AB:
mov edi, 1; jumptable 00000000000B3212 case 5
mov esi, 303h
call cs:glad_glBlendFunc
mov edi, 8006h
call cs:glad_glBlendEquation
jmp short loc_B3328
loc_B32C8:
mov rax, cs:glad_glBlendFunc; jumptable 00000000000B3212 case 6
mov edi, cs:dword_21AC30
mov esi, cs:dword_21AC34
call rax ; glad_glBlendFunc
mov rax, cs:glad_glBlendEquation
mov edi, cs:dword_21AC38
call rax ; glad_glBlendEquation
jmp short loc_B3328
loc_B32EE:
mov rax, cs:glad_glBlendFuncSeparate; jumptable 00000000000B3212 case 7
mov edi, cs:dword_21AC3C
mov esi, cs:dword_21AC40
mov edx, cs:dword_21AC44
mov ecx, cs:dword_21AC48
call rax ; glad_glBlendFuncSeparate
mov rax, cs:glad_glBlendEquationSeparate
mov edi, cs:dword_21AC4C
mov esi, cs:dword_21AC50
call rax ; glad_glBlendEquationSeparate
jmp short loc_B3328
def_B3212:
jmp short $+2; jumptable 00000000000B3212 default case
loc_B3328:
mov eax, [rbp+var_4]
mov cs:dword_21AC2C, eax
mov cs:byte_21AC54, 0
loc_B3338:
add rsp, 10h
pop rbp
retn
| long long rlSetBlendMode(
unsigned int a1,
double a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
double a9)
{
long long result; // rax
result = (unsigned int)dword_21AC2C;
if ( dword_21AC2C != a1 || (a1 == 6 || a1 == 7) && (byte_21AC54 & 1) != 0 )
{
rlDrawRenderBatch(RLGL[0], a2, a3, a4, a5, a6, a7, a8, a9);
switch ( a1 )
{
case 0u:
glad_glBlendFunc(770LL, 771LL);
glad_glBlendEquation(32774LL);
break;
case 1u:
glad_glBlendFunc(770LL, 1LL);
glad_glBlendEquation(32774LL);
break;
case 2u:
glad_glBlendFunc(774LL, 771LL);
glad_glBlendEquation(32774LL);
break;
case 3u:
glad_glBlendFunc(1LL, 1LL);
glad_glBlendEquation(32774LL);
break;
case 4u:
glad_glBlendFunc(1LL, 1LL);
glad_glBlendEquation(32778LL);
break;
case 5u:
glad_glBlendFunc(1LL, 771LL);
glad_glBlendEquation(32774LL);
break;
case 6u:
glad_glBlendFunc((unsigned int)dword_21AC30, (unsigned int)dword_21AC34);
glad_glBlendEquation((unsigned int)dword_21AC38);
break;
case 7u:
glad_glBlendFuncSeparate(
(unsigned int)dword_21AC3C,
(unsigned int)dword_21AC40,
(unsigned int)dword_21AC44,
(unsigned int)dword_21AC48);
glad_glBlendEquationSeparate((unsigned int)dword_21AC4C, (unsigned int)dword_21AC50);
break;
default:
break;
}
result = a1;
dword_21AC2C = a1;
byte_21AC54 = 0;
}
return result;
}
| rlSetBlendMode:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [0x0031ac2c]
CMP EAX,dword ptr [RBP + -0x4]
JNZ 0x001b31e3
CMP dword ptr [RBP + -0x4],0x6
JZ 0x001b31d6
CMP dword ptr [RBP + -0x4],0x7
JNZ 0x001b3338
LAB_001b31d6:
TEST byte ptr [0x0031ac54],0x1
JZ 0x001b3338
LAB_001b31e3:
MOV RDI,qword ptr [0x0031a1d8]
CALL 0x001b0c00
MOV EAX,dword ptr [RBP + -0x4]
MOV qword ptr [RBP + -0x10],RAX
SUB RAX,0x7
JA 0x001b3326
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2b3390]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV EDI,0x302
MOV ESI,0x303
CALL qword ptr [0x003183e0]
MOV EDI,0x8006
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_1:
MOV EDI,0x302
MOV ESI,0x1
CALL qword ptr [0x003183e0]
MOV EDI,0x8006
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_2:
MOV EDI,0x306
MOV ESI,0x303
CALL qword ptr [0x003183e0]
MOV EDI,0x8006
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_3:
MOV ESI,0x1
MOV EDI,ESI
CALL qword ptr [0x003183e0]
MOV EDI,0x8006
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_4:
MOV ESI,0x1
MOV EDI,ESI
CALL qword ptr [0x003183e0]
MOV EDI,0x800a
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_5:
MOV EDI,0x1
MOV ESI,0x303
CALL qword ptr [0x003183e0]
MOV EDI,0x8006
CALL qword ptr [0x003183b0]
JMP 0x001b3328
caseD_6:
MOV RAX,qword ptr [0x003183e0]
MOV EDI,dword ptr [0x0031ac30]
MOV ESI,dword ptr [0x0031ac34]
CALL RAX
MOV RAX,qword ptr [0x003183b0]
MOV EDI,dword ptr [0x0031ac38]
CALL RAX
JMP 0x001b3328
caseD_7:
MOV RAX,qword ptr [0x003183e8]
MOV EDI,dword ptr [0x0031ac3c]
MOV ESI,dword ptr [0x0031ac40]
MOV EDX,dword ptr [0x0031ac44]
MOV ECX,dword ptr [0x0031ac48]
CALL RAX
MOV RAX,qword ptr [0x003183b8]
MOV EDI,dword ptr [0x0031ac4c]
MOV ESI,dword ptr [0x0031ac50]
CALL RAX
JMP 0x001b3328
LAB_001b3326:
JMP 0x001b3328
default:
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [0x0031ac2c],EAX
MOV byte ptr [0x0031ac54],0x0
LAB_001b3338:
ADD RSP,0x10
POP RBP
RET
|
void rlSetBlendMode(int param_1)
{
if ((DAT_0031ac2c != param_1) || (((param_1 == 6 || (param_1 == 7)) && ((DAT_0031ac54 & 1) != 0)))
) {
rlDrawRenderBatch(RLGL);
switch(param_1) {
case 0:
(*glad_glBlendFunc)(0x302,0x303);
(*glad_glBlendEquation)(0x8006);
break;
case 1:
(*glad_glBlendFunc)(0x302,1);
(*glad_glBlendEquation)(0x8006);
break;
case 2:
(*glad_glBlendFunc)(0x306,0x303);
(*glad_glBlendEquation)(0x8006);
break;
case 3:
(*glad_glBlendFunc)(1);
(*glad_glBlendEquation)(0x8006);
break;
case 4:
(*glad_glBlendFunc)(1);
(*glad_glBlendEquation)(0x800a);
break;
case 5:
(*glad_glBlendFunc)(1,0x303);
(*glad_glBlendEquation)(0x8006);
break;
case 6:
(*glad_glBlendFunc)(DAT_0031ac30,DAT_0031ac34);
(*glad_glBlendEquation)(DAT_0031ac38);
break;
case 7:
(*glad_glBlendFuncSeparate)(DAT_0031ac3c,DAT_0031ac40,DAT_0031ac44,DAT_0031ac48);
(*glad_glBlendEquationSeparate)(DAT_0031ac4c,DAT_0031ac50);
}
DAT_0031ac54 = 0;
DAT_0031ac2c = param_1;
}
return;
}
| |
34,953 | rlSetBlendMode | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | void rlSetBlendMode(int mode)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified))
{
rlDrawRenderBatch(RLGL.currentBatch);
switch (mode)
{
case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break;
case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
case RL_BLEND_CUSTOM:
{
// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation);
} break;
case RL_BLEND_CUSTOM_SEPARATE:
{
// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate()
glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha);
glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha);
} break;
default: break;
}
RLGL.State.currentBlendMode = mode;
RLGL.State.glCustomBlendModeModified = false;
}
#endif
} | O2 | c | rlSetBlendMode:
pushq %rbx
movl %edi, %ebx
cmpl %edi, 0xd48e7(%rip) # 0x127b8c
jne 0x532c2
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x6, %eax
jne 0x53372
cmpb $0x1, 0xd48f8(%rip) # 0x127bb4
jne 0x53372
movq 0xd3e6f(%rip), %rdi # 0x127138
callq 0x51407
cmpl $0x7, %ebx
ja 0x53365
movl %ebx, %eax
leaq 0x7040c(%rip), %rcx # 0xc36ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x302, %edi # imm = 0x302
jmp 0x5334f
pushq $0x1
popq %rdi
movl %edi, %esi
callq *0xd2045(%rip) # 0x125340
movl $0x800a, %edi # imm = 0x800A
jmp 0x5335f
movl $0x306, %edi # imm = 0x306
jmp 0x5334f
pushq $0x1
popq %rdi
movl %edi, %esi
jmp 0x53354
movl 0xd4886(%rip), %edi # 0x127b9c
movl 0xd4884(%rip), %esi # 0x127ba0
movl 0xd4882(%rip), %edx # 0x127ba4
movl 0xd4880(%rip), %ecx # 0x127ba8
callq *0xd201a(%rip) # 0x125348
movl 0xd4878(%rip), %edi # 0x127bac
movl 0xd4876(%rip), %esi # 0x127bb0
callq *0xd1fd8(%rip) # 0x125318
jmp 0x53365
pushq $0x1
popq %rsi
movl $0x302, %edi # imm = 0x302
jmp 0x53354
pushq $0x1
popq %rdi
movl $0x303, %esi # imm = 0x303
callq *0xd1fe6(%rip) # 0x125340
movl $0x8006, %edi # imm = 0x8006
callq *0xd1fab(%rip) # 0x125310
movl %ebx, 0xd4821(%rip) # 0x127b8c
movb $0x0, 0xd4842(%rip) # 0x127bb4
popq %rbx
retq
movl 0xd4816(%rip), %edi # 0x127b90
movl 0xd4814(%rip), %esi # 0x127b94
callq *0xd1fba(%rip) # 0x125340
movl 0xd480c(%rip), %edi # 0x127b98
jmp 0x5335f
| rlSetBlendMode:
push rbx
mov ebx, edi
cmp cs:dword_127B8C, edi
jnz short loc_532C2
mov eax, ebx
and eax, 0FFFFFFFEh
cmp eax, 6
jnz loc_53372
cmp cs:byte_127BB4, 1
jnz loc_53372
loc_532C2:
mov rdi, cs:RLGL
call rlDrawRenderBatch
cmp ebx, 7; switch 8 cases
ja def_532E7; jumptable 00000000000532E7 default case
mov eax, ebx
lea rcx, jpt_532E7
movsxd rax, ds:(jpt_532E7 - 0C36ECh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_532E9:
mov edi, 302h; jumptable 00000000000532E7 case 0
jmp short loc_5334F
loc_532F0:
push 1; jumptable 00000000000532E7 case 4
pop rdi
mov esi, edi
call cs:glad_glBlendFunc
mov edi, 800Ah
jmp short loc_5335F
loc_53302:
mov edi, 306h; jumptable 00000000000532E7 case 2
jmp short loc_5334F
loc_53309:
push 1; jumptable 00000000000532E7 case 3
pop rdi
mov esi, edi
jmp short loc_53354
loc_53310:
mov edi, cs:dword_127B9C; jumptable 00000000000532E7 case 7
mov esi, cs:dword_127BA0
mov edx, cs:dword_127BA4
mov ecx, cs:dword_127BA8
call cs:glad_glBlendFuncSeparate
mov edi, cs:dword_127BAC
mov esi, cs:dword_127BB0
call cs:glad_glBlendEquationSeparate
jmp short def_532E7; jumptable 00000000000532E7 default case
loc_53342:
push 1; jumptable 00000000000532E7 case 1
pop rsi
mov edi, 302h
jmp short loc_53354
loc_5334C:
push 1; jumptable 00000000000532E7 case 5
pop rdi
loc_5334F:
mov esi, 303h
loc_53354:
call cs:glad_glBlendFunc
mov edi, 8006h
loc_5335F:
call cs:glad_glBlendEquation
def_532E7:
mov cs:dword_127B8C, ebx; jumptable 00000000000532E7 default case
mov cs:byte_127BB4, 0
loc_53372:
pop rbx
retn
loc_53374:
mov edi, cs:dword_127B90; jumptable 00000000000532E7 case 6
mov esi, cs:dword_127B94
call cs:glad_glBlendFunc
mov edi, cs:dword_127B98
jmp short loc_5335F
| long long rlSetBlendMode(
unsigned int a1,
long long a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long result; // rax
long long v12; // rdi
long long v13; // rdi
long long v14; // rsi
if ( dword_127B8C != a1 || (result = a1 & 0xFFFFFFFE, (_DWORD)result == 6) && byte_127BB4 == 1 )
{
rlDrawRenderBatch(RLGL[0], a2, a3, a4, a5, a6, a7, a8, a9, a10);
result = a1;
switch ( a1 )
{
case 0u:
v12 = 770LL;
goto LABEL_12;
case 1u:
v14 = 1LL;
v12 = 770LL;
goto LABEL_13;
case 2u:
v12 = 774LL;
goto LABEL_12;
case 3u:
v12 = 1LL;
v14 = 1LL;
goto LABEL_13;
case 4u:
glad_glBlendFunc(1LL, 1LL);
v13 = 32778LL;
goto LABEL_14;
case 5u:
v12 = 1LL;
LABEL_12:
v14 = 771LL;
LABEL_13:
glad_glBlendFunc(v12, v14);
v13 = 32774LL;
goto LABEL_14;
case 6u:
glad_glBlendFunc((unsigned int)dword_127B90, (unsigned int)dword_127B94);
v13 = (unsigned int)dword_127B98;
LABEL_14:
result = glad_glBlendEquation(v13);
break;
case 7u:
glad_glBlendFuncSeparate(
(unsigned int)dword_127B9C,
(unsigned int)dword_127BA0,
(unsigned int)dword_127BA4,
(unsigned int)dword_127BA8);
result = glad_glBlendEquationSeparate((unsigned int)dword_127BAC, (unsigned int)dword_127BB0);
break;
default:
break;
}
dword_127B8C = a1;
byte_127BB4 = 0;
}
return result;
}
| rlSetBlendMode:
PUSH RBX
MOV EBX,EDI
CMP dword ptr [0x00227b8c],EDI
JNZ 0x001532c2
MOV EAX,EBX
AND EAX,0xfffffffe
CMP EAX,0x6
JNZ 0x00153372
CMP byte ptr [0x00227bb4],0x1
JNZ 0x00153372
LAB_001532c2:
MOV RDI,qword ptr [0x00227138]
CALL 0x00151407
CMP EBX,0x7
JA 0x00153365
MOV EAX,EBX
LEA RCX,[0x1c36ec]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV EDI,0x302
JMP 0x0015334f
caseD_4:
PUSH 0x1
POP RDI
MOV ESI,EDI
CALL qword ptr [0x00225340]
MOV EDI,0x800a
JMP 0x0015335f
caseD_2:
MOV EDI,0x306
JMP 0x0015334f
caseD_3:
PUSH 0x1
POP RDI
MOV ESI,EDI
JMP 0x00153354
caseD_7:
MOV EDI,dword ptr [0x00227b9c]
MOV ESI,dword ptr [0x00227ba0]
MOV EDX,dword ptr [0x00227ba4]
MOV ECX,dword ptr [0x00227ba8]
CALL qword ptr [0x00225348]
MOV EDI,dword ptr [0x00227bac]
MOV ESI,dword ptr [0x00227bb0]
CALL qword ptr [0x00225318]
JMP 0x00153365
caseD_1:
PUSH 0x1
POP RSI
MOV EDI,0x302
JMP 0x00153354
caseD_5:
PUSH 0x1
POP RDI
LAB_0015334f:
MOV ESI,0x303
LAB_00153354:
CALL qword ptr [0x00225340]
MOV EDI,0x8006
LAB_0015335f:
CALL qword ptr [0x00225310]
default:
MOV dword ptr [0x00227b8c],EBX
MOV byte ptr [0x00227bb4],0x0
LAB_00153372:
POP RBX
RET
caseD_6:
MOV EDI,dword ptr [0x00227b90]
MOV ESI,dword ptr [0x00227b94]
CALL qword ptr [0x00225340]
MOV EDI,dword ptr [0x00227b98]
JMP 0x0015335f
|
void rlSetBlendMode(uint param_1)
{
int8 uVar1;
int4 uVar2;
int8 uVar3;
if (DAT_00227b8c == param_1) {
if ((param_1 & 0xfffffffe) != 6) {
return;
}
if (DAT_00227bb4 != '\x01') {
return;
}
}
rlDrawRenderBatch(RLGL);
switch(param_1) {
case 0:
uVar3 = 0x302;
break;
case 1:
uVar1 = 1;
uVar3 = 0x302;
goto LAB_00153354;
case 2:
uVar3 = 0x306;
break;
case 3:
uVar3 = 1;
uVar1 = 1;
goto LAB_00153354;
case 4:
(*glad_glBlendFunc)(1,1);
uVar2 = 0x800a;
goto LAB_0015335f;
case 5:
uVar3 = 1;
break;
case 6:
(*glad_glBlendFunc)(DAT_00227b90,DAT_00227b94);
uVar2 = DAT_00227b98;
goto LAB_0015335f;
case 7:
(*glad_glBlendFuncSeparate)(DAT_00227b9c,DAT_00227ba0,DAT_00227ba4,DAT_00227ba8);
(*glad_glBlendEquationSeparate)(DAT_00227bac,DAT_00227bb0);
default:
goto switchD_001532e7_default;
}
uVar1 = 0x303;
LAB_00153354:
(*glad_glBlendFunc)(uVar3,uVar1);
uVar2 = 0x8006;
LAB_0015335f:
(*glad_glBlendEquation)(uVar2);
switchD_001532e7_default:
DAT_00227bb4 = 0;
DAT_00227b8c = param_1;
return;
}
| |
34,954 | testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->MakeNewHolder();
ThreadLocalValueHolderBase* const holder_base = new_holder;
GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
return new_holder->pointer();
} | O0 | c | testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl (%rax), %edi
callq 0xb810
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x5a7a3
movq 0x50(%rsp), %rdi
callq 0x5a8a0
movq %rax, %rdi
callq 0x5a990
movq %rax, 0x60(%rsp)
jmp 0x5a889
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x5a9a0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movl (%rax), %edi
movq 0x40(%rsp), %rsi
callq 0xb0d0
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x5a87a
leaq 0x1b71e(%rip), %rdx # 0x75f11
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x73b, %ecx # imm = 0x73B
callq 0x1b8d0
movq 0x10(%rsp), %rdi
callq 0x107d0
movq %rax, %rdi
leaq 0x1b9f2(%rip), %rsi # 0x76212
callq 0xb460
movq %rax, 0x18(%rsp)
jmp 0x5a82c
movq 0x18(%rsp), %rdi
leaq 0x1b76d(%rip), %rsi # 0x75fa5
callq 0xb460
movq %rax, 0x8(%rsp)
jmp 0x5a844
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0xb8f0
jmp 0x5a854
leaq 0x38(%rsp), %rdi
callq 0x1ba40
jmp 0x5a87a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1ba40
jmp 0x5a893
movq 0x48(%rsp), %rdi
callq 0x5a990
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xb910
nopl (%rax)
| _ZNK7testing8internal11ThreadLocalISt6vectorINS0_9TraceInfoESaIS3_EEE16GetOrCreateValueEv:
sub rsp, 68h
mov qword ptr [rsp+68h+var_10], rdi
mov rax, qword ptr [rsp+68h+var_10]
mov qword ptr [rsp+68h+var_48], rax; int
mov edi, [rax]
call _pthread_getspecific
mov qword ptr [rsp+68h+var_18], rax
cmp qword ptr [rsp+68h+var_18], 0
jz short loc_5A7A3
mov rdi, qword ptr [rsp+68h+var_18]; int
call _ZN7testing8internal27CheckedDowncastToActualTypeINS0_11ThreadLocalISt6vectorINS0_9TraceInfoESaIS4_EEE11ValueHolderENS0_26ThreadLocalValueHolderBaseEEEPT_PT0_; testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder,testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase *)
mov rdi, rax
call _ZN7testing8internal11ThreadLocalISt6vectorINS0_9TraceInfoESaIS3_EEE11ValueHolder7pointerEv; testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder::pointer(void)
mov [rsp+68h+var_8], rax
jmp loc_5A889
loc_5A7A3:
mov rdi, qword ptr [rsp+68h+var_48]
add rdi, 8
call _ZNKSt10unique_ptrIN7testing8internal11ThreadLocalISt6vectorINS1_9TraceInfoESaIS4_EEE18ValueHolderFactoryESt14default_deleteIS8_EEptEv; std::unique_ptr<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolderFactory,std::default_delete<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolderFactory>>::operator->(void)
mov rdi, rax
mov rax, [rdi]
call qword ptr [rax+10h]
mov rcx, rax
mov rax, qword ptr [rsp+68h+var_48]
mov qword ptr [rsp+68h+var_20], rcx; char
mov rcx, qword ptr [rsp+68h+var_20]
mov [rsp+68h+var_28], rcx; __int64
mov edi, [rax]
mov rsi, [rsp+68h+var_28]
call _pthread_setspecific
mov [rsp+68h+var_2C], eax
cmp [rsp+68h+var_2C], 0
jz loc_5A87A
lea rdx, aWorkspaceLlm4b_6; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+68h+var_30]; int
mov [rsp+68h+var_58], rdi; int
mov esi, 3
mov ecx, 73Bh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, [rsp+68h+var_58]; this
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov rdi, rax
lea rsi, aPthreadSetspec_0; "pthread_setspecific(key_, holder_base)"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_50], rax
jmp short $+2
loc_5A82C:
mov rdi, [rsp+68h+var_50]
lea rsi, aFailedWithErro; "failed with error "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+68h+var_60], rax
jmp short $+2
loc_5A844:
mov rdi, [rsp+68h+var_60]
mov esi, [rsp+68h+var_2C]
call __ZNSolsEi; std::ostream::operator<<(int)
jmp short $+2
loc_5A854:
lea rdi, [rsp+68h+var_30]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_5A87A
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_30]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_5A893
loc_5A87A:
mov rdi, qword ptr [rsp+68h+var_20]
call _ZN7testing8internal11ThreadLocalISt6vectorINS0_9TraceInfoESaIS3_EEE11ValueHolder7pointerEv; testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder::pointer(void)
mov [rsp+68h+var_8], rax
loc_5A889:
mov rax, [rsp+68h+var_8]
add rsp, 68h
retn
loc_5A893:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::GetOrCreateValue(
unsigned int *a1)
{
long long v1; // rax
long long v2; // rax
void *Stream; // rax
int v5; // [rsp+0h] [rbp-68h]
int v6; // [rsp+8h] [rbp-60h]
long long v7; // [rsp+8h] [rbp-60h]
int v8; // [rsp+10h] [rbp-58h]
long long v9; // [rsp+18h] [rbp-50h]
long long v10; // [rsp+18h] [rbp-50h]
int v11; // [rsp+38h] [rbp-30h] BYREF
unsigned int v12; // [rsp+3Ch] [rbp-2Ch]
long long v13; // [rsp+40h] [rbp-28h]
char v14[8]; // [rsp+48h] [rbp-20h]
int v15[2]; // [rsp+50h] [rbp-18h]
int v16[2]; // [rsp+58h] [rbp-10h]
*(_QWORD *)v16 = a1;
*(_QWORD *)v15 = pthread_getspecific(*a1);
if ( *(_QWORD *)v15 )
{
v1 = testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder,testing::internal::ThreadLocalValueHolderBase>(
v15[0],
v5,
v6,
v8,
v9,
(int)a1);
return testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder::pointer(v1);
}
else
{
v2 = std::unique_ptr<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolderFactory,std::default_delete<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolderFactory>>::operator->(a1 + 2);
*(_QWORD *)v14 = (*(long long ( **)(long long))(*(_QWORD *)v2 + 16LL))(v2);
v13 = *(_QWORD *)v14;
v12 = pthread_setspecific(*a1, *(_QWORD *)v14);
if ( v12 )
{
testing::internal::GTestLog::GTestLog(
(testing::internal::GTestLog *)&v11,
3,
(long long)"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/inter"
"nal/gtest-port.h",
1851);
Stream = testing::internal::GTestLog::GetStream((testing::internal::GTestLog *)&v11);
v10 = std::operator<<<std::char_traits<char>>(Stream, "pthread_setspecific(key_, holder_base)");
v7 = std::operator<<<std::char_traits<char>>(v10, "failed with error ");
std::ostream::operator<<(v7, v12);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)&v11);
}
return testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo>>::ValueHolder::pointer(*(_QWORD *)v14);
}
}
| GetOrCreateValue:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x20],RAX
MOV EDI,dword ptr [RAX]
CALL 0x0010b810
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [RSP + 0x50],0x0
JZ 0x0015a7a3
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0015a8a0
MOV RDI,RAX
CALL 0x0015a990
MOV qword ptr [RSP + 0x60],RAX
JMP 0x0015a889
LAB_0015a7a3:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x8
CALL 0x0015a9a0
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x40],RCX
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x40]
CALL 0x0010b0d0
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x0015a87a
LEA RDX,[0x175f11]
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x10],RDI
MOV ESI,0x3
MOV ECX,0x73b
CALL 0x0011b8d0
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001107d0
MOV RDI,RAX
LAB_0015a819:
LEA RSI,[0x176212]
CALL 0x0010b460
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0015a82c
LAB_0015a82c:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x175fa5]
CALL 0x0010b460
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0015a844
LAB_0015a844:
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x0010b8f0
LAB_0015a852:
JMP 0x0015a854
LAB_0015a854:
LEA RDI,[RSP + 0x38]
CALL 0x0011ba40
JMP 0x0015a87a
LAB_0015a87a:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0015a990
MOV qword ptr [RSP + 0x60],RAX
LAB_0015a889:
MOV RAX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
/* testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,
std::allocator<testing::internal::TraceInfo> > >::GetOrCreateValue() const */
int8 __thiscall
testing::internal::
ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>
::GetOrCreateValue(ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>
*this)
{
ValueHolder *this_00;
long *plVar1;
ostream *poVar2;
GTestLog local_30 [4];
int local_2c;
ValueHolder *local_28;
ValueHolder *local_20;
ThreadLocalValueHolderBase *local_18;
ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>
*local_10;
int8 local_8;
local_10 = this;
local_18 = (ThreadLocalValueHolderBase *)pthread_getspecific(*(pthread_key_t *)this);
if (local_18 == (ThreadLocalValueHolderBase *)0x0) {
plVar1 = (long *)std::
unique_ptr<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>::ValueHolderFactory,std::default_delete<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>::ValueHolderFactory>>
::operator->((unique_ptr<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>::ValueHolderFactory,std::default_delete<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>::ValueHolderFactory>>
*)(this + 8));
local_28 = (ValueHolder *)(**(code **)(*plVar1 + 0x10))();
local_20 = local_28;
local_2c = pthread_setspecific(*(pthread_key_t *)this,local_28);
if (local_2c != 0) {
GTestLog::GTestLog(local_30,3,
"/workspace/llm4binary/github2025/AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h"
,0x73b);
poVar2 = (ostream *)GTestLog::GetStream();
/* try { // try from 0015a819 to 0015a851 has its CatchHandler @ 0015a860 */
poVar2 = std::operator<<(poVar2,"pthread_setspecific(key_, holder_base)");
poVar2 = std::operator<<(poVar2,"failed with error ");
std::ostream::operator<<(poVar2,local_2c);
GTestLog::~GTestLog(local_30);
}
local_8 = ValueHolder::pointer(local_20);
}
else {
this_00 = CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo,std::allocator<testing::internal::TraceInfo>>>::ValueHolder,testing::internal::ThreadLocalValueHolderBase>
(local_18);
local_8 = ValueHolder::pointer(this_00);
}
return local_8;
}
| |
34,955 | ma_bitmap_delete_all | eloqsql/storage/maria/ma_bitmap.c | void _ma_bitmap_delete_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
DBUG_ENTER("_ma_bitmap_delete_all");
if (bitmap->map) /* Not in create */
{
bzero(bitmap->map, bitmap->block_size);
bitmap->changed= 1;
bitmap->page= 0;
bitmap->used_size= bitmap->full_tail_size= bitmap->full_head_size= 0;
bitmap->total_size= bitmap->max_total_size;
}
DBUG_VOID_RETURN;
} | O3 | c | ma_bitmap_delete_all:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa18(%rdi), %rdi
testq %rdi, %rdi
je 0x3c325
movl 0xb44(%rbx), %edx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x292b0
movb $0x1, 0xa30(%rbx)
movq %r14, 0xa20(%rbx)
movl $0x0, 0xa3c(%rbx)
movq %r14, 0xa34(%rbx)
movl 0xb3c(%rbx), %eax
movl %eax, 0xb38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| _ma_bitmap_delete_all:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rdi, [rdi+0A18h]
test rdi, rdi
jz short loc_3C325
mov edx, [rbx+0B44h]
xor r14d, r14d
xor esi, esi
call _memset
mov byte ptr [rbx+0A30h], 1
mov [rbx+0A20h], r14
mov dword ptr [rbx+0A3Ch], 0
mov [rbx+0A34h], r14
mov eax, [rbx+0B3Ch]
mov [rbx+0B38h], eax
loc_3C325:
pop rbx
pop r14
pop rbp
retn
| long long ma_bitmap_delete_all(long long a1)
{
long long v2; // rdi
long long result; // rax
v2 = *(_QWORD *)(a1 + 2584);
if ( v2 )
{
memset(v2, 0LL, *(unsigned int *)(a1 + 2884));
*(_BYTE *)(a1 + 2608) = 1;
*(_QWORD *)(a1 + 2592) = 0LL;
*(_DWORD *)(a1 + 2620) = 0;
*(_QWORD *)(a1 + 2612) = 0LL;
result = *(unsigned int *)(a1 + 2876);
*(_DWORD *)(a1 + 2872) = result;
}
return result;
}
| _ma_bitmap_delete_all:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xa18]
TEST RDI,RDI
JZ 0x0013c325
MOV EDX,dword ptr [RBX + 0xb44]
XOR R14D,R14D
XOR ESI,ESI
CALL 0x001292b0
MOV byte ptr [RBX + 0xa30],0x1
MOV qword ptr [RBX + 0xa20],R14
MOV dword ptr [RBX + 0xa3c],0x0
MOV qword ptr [RBX + 0xa34],R14
MOV EAX,dword ptr [RBX + 0xb3c]
MOV dword ptr [RBX + 0xb38],EAX
LAB_0013c325:
POP RBX
POP R14
POP RBP
RET
|
void _ma_bitmap_delete_all(long param_1)
{
if (*(void **)(param_1 + 0xa18) != (void *)0x0) {
memset(*(void **)(param_1 + 0xa18),0,(ulong)*(uint *)(param_1 + 0xb44));
*(int1 *)(param_1 + 0xa30) = 1;
*(int8 *)(param_1 + 0xa20) = 0;
*(int4 *)(param_1 + 0xa3c) = 0;
*(int8 *)(param_1 + 0xa34) = 0;
*(int4 *)(param_1 + 0xb38) = *(int4 *)(param_1 + 0xb3c);
}
return;
}
| |
34,956 | 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};
} | O3 | 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 0x7ab9e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7abba
movq %rdi, %rbx
movabsq $0x10000000000000, %r14 # imm = 0x10000000000000
leaq -0x1(%r14), %rdx
andq %rax, %rdx
movq %rax, %rcx
shrq $0x34, %rcx
jne 0x7aaf5
leaq 0x1(,%rax,2), %rdi
addq %rax, %rax
movl $0xfffffbce, 0x4(%rsp) # imm = 0xFFFFFBCE
movl $0xfffffbcd, %esi # imm = 0xFFFFFBCD
jmp 0x7ab3d
movq %rdx, %r8
orq %r14, %r8
leal -0x433(%rcx), %esi
movl %esi, 0x4(%rsp)
testq %rdx, %rdx
setne %dl
shrq $0x35, %rax
sete %al
leaq 0x1(,%r8,2), %rdi
leal -0x434(%rcx), %esi
orb %dl, %al
jne 0x7ab36
addl $0xfffffbcb, %ecx # imm = 0xFFFFFBCB
movabsq $0x3fffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFF
jmp 0x7ab45
leaq (%r8,%r8), %rax
movq %r8, %rdx
decq %rax
movl %esi, %ecx
movq %rdx, %r14
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl %ecx, 0x8(%r15)
callq 0x7ad0a
movq %rax, %r12
movl %edx, %r13d
movq %r15, %rdi
movl %edx, %esi
callq 0x7ad4c
movq %rax, %r15
movl %edx, %ebp
movq %r14, %rdi
movl 0x4(%rsp), %esi
callq 0x7ad0a
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movl %r13d, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eaa2(%rip), %rdi # 0xa9647
leaq 0x2d255(%rip), %rdx # 0xa7e01
leaq 0x315d6(%rip), %rcx # 0xac189
movl $0x42cb, %esi # imm = 0x42CB
jmp 0x7abd4
leaq 0x2ea86(%rip), %rdi # 0xa9647
leaq 0x2d239(%rip), %rdx # 0xa7e01
leaq 0x316d3(%rip), %rcx # 0xac2a2
movl $0x42cc, %esi # imm = 0x42CC
xorl %eax, %eax
callq 0x18ad0
| _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_7AB9E
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe loc_7ABBA
mov rbx, rdi
mov r14, 10000000000000h
lea rdx, [r14-1]
and rdx, rax
mov rcx, rax
shr rcx, 34h
jnz short loc_7AAF5
lea rdi, ds:1[rax*2]
add rax, rax
mov [rsp+48h+var_44], 0FFFFFBCEh
mov esi, 0FFFFFBCDh
jmp short loc_7AB3D
loc_7AAF5:
mov r8, rdx
or r8, r14
lea esi, [rcx-433h]
mov [rsp+48h+var_44], esi
test rdx, rdx
setnz dl
shr rax, 35h
setz al
lea rdi, ds:1[r8*2]
lea esi, [rcx-434h]
or al, dl
jnz short loc_7AB36
add ecx, 0FFFFFBCBh
mov rax, 3FFFFFFFFFFFFFh
jmp short loc_7AB45
loc_7AB36:
lea rax, [r8+r8]
mov rdx, r8
loc_7AB3D:
dec rax
mov ecx, esi
mov r14, rdx
loc_7AB45:
lea r15, [rsp+48h+var_40]
mov [r15], rax
mov [r15+8], ecx
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 r12, rax
mov r13d, edx
mov rdi, r15
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 r15, rax
mov ebp, edx
mov rdi, r14
mov esi, [rsp+48h+var_44]
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], r15
mov [rbx+18h], ebp
mov [rbx+20h], r12
mov [rbx+28h], r13d
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7AB9E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 42CBh
jmp short loc_7ABD4
loc_7ABBA:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 42CCh
loc_7ABD4:
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 v12; // r14
long long v13; // rdx
long long v14; // rcx
long long v15; // rdi
long long v16; // rax
long long v17; // rsi
int v18; // ecx
long long v19; // rax
long long v20; // r12
unsigned int v21; // edx
unsigned int v22; // r13d
long long v23; // r15
int v24; // edx
int v25; // ebp
int v26; // edx
long long v28; // rsi
long long v29; // rdx
long long v30; // rcx
long long v31; // r8
long long v32; // r9
unsigned int v33; // [rsp+4h] [rbp-44h]
long long v34; // [rsp+8h] [rbp-40h] BYREF
int v35; // [rsp+10h] [rbp-38h]
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v28 = 17099LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17099LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
}
else
{
if ( a2 > 0.0 )
{
v12 = 0x10000000000000LL;
v13 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL;
v14 = *(_QWORD *)&a2 >> 52;
if ( *(_QWORD *)&a2 >> 52 )
{
v33 = v14 - 1075;
v15 = 2 * (v13 | 0x10000000000000LL) + 1;
v17 = (unsigned int)(v14 - 1076);
if ( v13 == 0 && *(_QWORD *)&a2 >> 53 != 0LL )
{
v18 = v14 - 1077;
v19 = 0x3FFFFFFFFFFFFFLL;
LABEL_9:
v34 = v19;
v35 = v18;
v20 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v15, v17);
v22 = v21;
v23 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(&v34, v21);
v25 = v24;
*(_QWORD *)a1 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v12, v33);
*(_DWORD *)(a1 + 8) = v26;
*(_QWORD *)(a1 + 16) = v23;
*(_DWORD *)(a1 + 24) = v25;
*(_QWORD *)(a1 + 32) = v20;
*(_DWORD *)(a1 + 40) = v22;
return a1;
}
v16 = 2 * (v13 | 0x10000000000000LL);
v13 |= 0x10000000000000uLL;
}
else
{
v15 = 2LL * *(_QWORD *)&a2 + 1;
v16 = 2LL * *(_QWORD *)&a2;
v33 = -1074;
v17 = 4294966221LL;
}
v19 = v16 - 1;
v18 = v17;
v12 = v13;
goto LABEL_9;
}
v28 = 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",
v28,
v29,
v30,
v31,
v32,
a8,
a9,
a10,
a11);
}
| 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 0x0017ab9e
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x0017abba
MOV RBX,RDI
MOV R14,0x10000000000000
LEA RDX,[R14 + -0x1]
AND RDX,RAX
MOV RCX,RAX
SHR RCX,0x34
JNZ 0x0017aaf5
LEA RDI,[0x1 + RAX*0x2]
ADD RAX,RAX
MOV dword ptr [RSP + 0x4],0xfffffbce
MOV ESI,0xfffffbcd
JMP 0x0017ab3d
LAB_0017aaf5:
MOV R8,RDX
OR R8,R14
LEA ESI,[RCX + -0x433]
MOV dword ptr [RSP + 0x4],ESI
TEST RDX,RDX
SETNZ DL
SHR RAX,0x35
SETZ AL
LEA RDI,[0x1 + R8*0x2]
LEA ESI,[RCX + -0x434]
OR AL,DL
JNZ 0x0017ab36
ADD ECX,0xfffffbcb
MOV RAX,0x3fffffffffffff
JMP 0x0017ab45
LAB_0017ab36:
LEA RAX,[R8 + R8*0x1]
MOV RDX,R8
LAB_0017ab3d:
DEC RAX
MOV ECX,ESI
MOV R14,RDX
LAB_0017ab45:
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RAX
MOV dword ptr [R15 + 0x8],ECX
CALL 0x0017ad0a
MOV R12,RAX
MOV R13D,EDX
MOV RDI,R15
MOV ESI,EDX
CALL 0x0017ad4c
MOV R15,RAX
MOV EBP,EDX
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0x4]
CALL 0x0017ad0a
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],EDX
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x18],EBP
MOV qword ptr [RBX + 0x20],R12
MOV dword ptr [RBX + 0x28],R13D
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017ab9e:
LEA RDI,[0x1a9647]
LEA RDX,[0x1a7e01]
LEA RCX,[0x1ac189]
MOV ESI,0x42cb
JMP 0x0017abd4
LAB_0017abba:
LEA RDI,[0x1a9647]
LEA RDX,[0x1a7e01]
LEA RCX,[0x1ac2a2]
MOV ESI,0x42cc
LAB_0017abd4:
XOR EAX,EAX
CALL 0x00118ad0
|
/* 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;
char *pcVar2;
diyfp *pdVar3;
int8 uVar4;
diyfp *pdVar5;
diyfp *pdVar6;
diyfp *pdVar7;
int1 auVar8 [12];
int1 auVar9 [12];
int1 auVar10 [12];
int local_44;
long local_40;
int local_38;
if (0x7fefffffffffffff < (ulong)ABS(param_1)) {
pcVar2 = "std::isfinite(value)";
uVar4 = 0x42cb;
LAB_0017abd4:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar2);
}
if (param_1 <= 0.0) {
pcVar2 = "value > 0";
uVar4 = 0x42cc;
goto LAB_0017abd4;
}
pdVar7 = (diyfp *)0x10000000000000;
pdVar3 = (diyfp *)((ulong)param_1 & 0xfffffffffffff);
if ((ulong)param_1 >> 0x34 == 0) {
pdVar5 = (diyfp *)((long)param_1 * 2 + 1);
local_40 = (long)param_1 * 2;
local_44 = -0x432;
local_38 = -0x433;
pdVar6 = pdVar3;
}
else {
pdVar6 = (diyfp *)((ulong)pdVar3 | 0x10000000000000);
uVar1 = (uint)((ulong)param_1 >> 0x20);
local_44 = (uVar1 >> 0x14) - 0x433;
pdVar5 = (diyfp *)((long)pdVar6 * 2 + 1);
local_38 = (uVar1 >> 0x14) - 0x434;
if ((ulong)param_1 >> 0x35 != 0 && pdVar3 == (diyfp *)0x0) {
local_38 = (uVar1 >> 0x14) - 0x435;
local_40 = 0x3fffffffffffff;
goto LAB_0017ab45;
}
local_40 = (long)pdVar6 * 2;
}
local_40 = local_40 + -1;
pdVar7 = pdVar6;
LAB_0017ab45:
auVar8 = diyfp::normalize(pdVar5);
auVar9 = diyfp::normalize_to((diyfp *)&local_40,auVar8._8_4_);
auVar10 = diyfp::normalize(pdVar7,local_44);
*(int1 (*) [12])this = auVar10;
*(int1 (*) [12])(this + 0x10) = auVar9;
*(int1 (*) [12])(this + 0x20) = auVar8;
return this;
}
| |
34,957 | stbi_load_from_file | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
}
return result;
} | O0 | c | stbi_load_from_file:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x66100
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x110(%rbp), %rdi
callq 0x66130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x660e8
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rsi
movl $0x1, %edx
callq 0xb420
movq -0x30(%rbp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
| stbi_load_from_file:
push rbp
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov rsi, [rbp+var_8]
lea rdi, [rbp+var_110]
call stbi__start_file
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8d, [rbp+var_24]
lea rdi, [rbp+var_110]
call stbi__load_and_postprocess_8bit
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_660E8
mov rdi, [rbp+var_8]
mov rax, [rbp+var_48]
mov rcx, [rbp+var_50]
sub rax, rcx
mov ecx, eax
xor eax, eax
sub eax, ecx
movsxd rsi, eax
mov edx, 1
call _fseek
loc_660E8:
mov rax, [rbp+var_30]
add rsp, 110h
pop rbp
retn
| long long stbi_load_from_file(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
_BYTE v6[192]; // [rsp+0h] [rbp-110h] BYREF
long long v7; // [rsp+C0h] [rbp-50h]
long long v8; // [rsp+C8h] [rbp-48h]
long long v9; // [rsp+E0h] [rbp-30h]
unsigned int v10; // [rsp+ECh] [rbp-24h]
long long v11; // [rsp+F0h] [rbp-20h]
long long v12; // [rsp+F8h] [rbp-18h]
long long v13; // [rsp+100h] [rbp-10h]
long long v14; // [rsp+108h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v10 = a5;
stbi__start_file(v6, a1);
v9 = stbi__load_and_postprocess_8bit(v6, v13, v12, v11, v10);
if ( v9 )
fseek(v14, (int)v7 - (int)v8, 1LL);
return v9;
}
| stbi_load_from_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
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 dword ptr [RBP + -0x24],R8D
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x110]
CALL 0x00166100
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RBP + -0x24]
LEA RDI,[RBP + -0x110]
CALL 0x00166130
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001660e8
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOVSXD RSI,EAX
MOV EDX,0x1
CALL 0x0010b420
LAB_001660e8:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x110
POP RBP
RET
|
long stbi_load_from_file(FILE *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5)
{
int1 local_118 [192];
int local_58;
int local_50;
long local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
FILE *local_10;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
stbi__start_file(local_118,param_1);
local_38 = stbi__load_and_postprocess_8bit(local_118,local_18,local_20,local_28,local_2c);
if (local_38 != 0) {
fseek(local_10,(long)-(local_50 - local_58),1);
}
return local_38;
}
| |
34,958 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) | monkey531[P]llama/common/json.hpp | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// fill up array with null values if given idx is outside range
if (idx >= m_data.m_value.array->size())
{
#if JSON_DIAGNOSTICS
// remember array size & capacity before resizing
const auto old_size = m_data.m_value.array->size();
const auto old_capacity = m_data.m_value.array->capacity();
#endif
m_data.m_value.array->resize(idx + 1);
#if JSON_DIAGNOSTICS
if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
{
// capacity has changed: update all parents
set_parents();
}
else
{
// set parent for values added above
set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
}
#endif
assert_invariant();
}
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | 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>::operator[](unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
jne 0x7e1f9
movb $0x2, (%rbx)
callq 0x3e4fe
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3e3c4
movb (%rbx), %al
cmpb $0x2, %al
jne 0x7e242
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r14, %rcx
ja 0x7e22f
leaq 0x1(%r14), %rsi
callq 0x7e46c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3e3c4
movq 0x8(%rbx), %rax
movq (%rax), %rax
shlq $0x4, %r14
addq %rax, %r14
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %r14
movq %rbx, %rdi
callq 0x43ea6
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38a4c(%rip), %rsi # 0xb6cb0
leaq 0x10(%rsp), %rdi
callq 0x78f46
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl $0x131, %esi # imm = 0x131
movq %rbx, %rcx
callq 0x43d5a
xorl %ebp, %ebp
leaq 0x80ca9(%rip), %rsi # 0xfef38
leaq -0x3d860(%rip), %rdx # 0x40a36
movq %r14, %rdi
callq 0x24ef0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x251d8
testb %bpl, %bpl
jne 0x7e2b5
jmp 0x7e2bd
movq %rax, %rbx
movq %r14, %rdi
callq 0x24680
movq %rbx, %rdi
callq 0x24f80
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov al, [rdi]
test al, al
jnz short loc_7E1F9
mov byte ptr [rbx], 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJEEEPT_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>>>()
mov [rbx+8], rax
push 1
pop rsi
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [rbx]
loc_7E1F9:
cmp al, 2
jnz short loc_7E242
mov rdi, [rbx+8]
mov rax, [rdi]
mov rcx, [rdi+8]
sub rcx, rax
sar rcx, 4
cmp rcx, r14
ja short loc_7E22F
lea rsi, [r14+1]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE6resizeEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::resize(ulong)
push 1
pop rsi
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [rbx+8]
mov rax, [rax]
loc_7E22F:
shl r14, 4
add r14, rax
mov rax, r14
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_7E242:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, r14; this
mov esi, 131h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7E2B5
jmp short loc_7E2BD
mov rbx, rax
loc_7E2B5:
mov rdi, r14; void *
call ___cxa_free_exception
loc_7E2BD:
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[](
long long a1,
unsigned long long a2)
{
char v3; // al
long long *v4; // rdi
long long v5; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // r14
const char *v8; // [rsp+8h] [rbp-40h] BYREF
_BYTE v9[56]; // [rsp+10h] [rbp-38h] BYREF
v3 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 2;
*(_QWORD *)(a1 + 8) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::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>>>();
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);
v3 = *(_BYTE *)a1;
}
if ( v3 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v8 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
(long long)v9,
(long long)"cannot use operator[] with a numeric argument with ",
&v8);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
(long long)v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v4 = *(long long **)(a1 + 8);
v5 = *v4;
if ( (v4[1] - *v4) >> 4 <= a2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::resize(
v4,
a2 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v5 = **(_QWORD **)(a1 + 8);
}
return v5 + 16 * a2;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x0017e1f9
MOV byte ptr [RBX],0x2
CALL 0x0013e4fe
MOV qword ptr [RBX + 0x8],RAX
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x0013e3c4
MOV AL,byte ptr [RBX]
LAB_0017e1f9:
CMP AL,0x2
JNZ 0x0017e242
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
SUB RCX,RAX
SAR RCX,0x4
CMP RCX,R14
JA 0x0017e22f
LEA RSI,[R14 + 0x1]
CALL 0x0017e46c
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x0013e3c4
MOV RAX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RAX]
LAB_0017e22f:
SHL R14,0x4
ADD R14,RAX
MOV RAX,R14
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0017e242:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV R14,RAX
MOV RDI,RBX
CALL 0x00143ea6
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017e25d:
LEA RSI,[0x1b6cb0]
LEA RDI,[RSP + 0x10]
CALL 0x00178f46
MOV BPL,0x1
LAB_0017e271:
LEA RDX,[RSP + 0x10]
MOV RDI,R14
MOV ESI,0x131
MOV RCX,RBX
CALL 0x00143d5a
XOR EBP,EBP
LEA RSI,[0x1fef38]
LEA RDX,[0x140a36]
MOV RDI,R14
CALL 0x00124ef0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](unsigned long) */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
vector *pvVar2;
long lVar3;
int8 uVar4;
char *local_40;
detail local_38 [32];
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
pvVar2 = 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>>>>
();
*(vector **)(this + 8) = pvVar2;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
lVar3 = *(long *)this_00;
if ((ulong)(*(long *)(this_00 + 8) - lVar3 >> 4) <= param_1) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::resize(this_00,param_1 + 1);
assert_invariant(SUB81(this,0));
lVar3 = **(long **)(this + 8);
}
return param_1 * 0x10 + lVar3;
}
uVar4 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017e25d to 0017e26d has its CatchHandler @ 0017e2b2 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 0017e271 to 0017e29d has its CatchHandler @ 0017e29e */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
34,959 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) | monkey531[P]llama/common/json.hpp | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// fill up array with null values if given idx is outside range
if (idx >= m_data.m_value.array->size())
{
#if JSON_DIAGNOSTICS
// remember array size & capacity before resizing
const auto old_size = m_data.m_value.array->size();
const auto old_capacity = m_data.m_value.array->capacity();
#endif
m_data.m_value.array->resize(idx + 1);
#if JSON_DIAGNOSTICS
if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
{
// capacity has changed: update all parents
set_parents();
}
else
{
// set parent for values added above
set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
}
#endif
assert_invariant();
}
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0xaafa2
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1b8a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x590b4
movb (%r14), %al
cmpb $0x2, %al
jne 0xaafed
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
ja 0xaafda
leaq 0x1(%rbx), %rsi
callq 0xab260
movq %r14, %rdi
movl $0x1, %esi
callq 0x590b4
movq 0x8(%r14), %rax
movq (%rax), %rax
shlq $0x4, %rbx
addq %rax, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f5fc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x47caf(%rip), %rsi # 0xf2cc0
leaq 0x10(%rsp), %rdi
callq 0xa1d13
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x5f3a4
xorl %ebp, %ebp
leaq 0x80efc(%rip), %rsi # 0x12bf38
leaq -0x4f811(%rip), %rdx # 0x5b832
movq %rbx, %rdi
callq 0x1bf00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xab069
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8c0
testb %bpl, %bpl
jne 0xab073
jmp 0xab07b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b660
movq %r14, %rdi
callq 0x1bf90
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
mov al, [rdi]
test al, al
jnz short loc_AAFA2
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [r14]
loc_AAFA2:
cmp al, 2
jnz short loc_AAFED
mov rdi, [r14+8]
mov rax, [rdi]
mov rcx, [rdi+8]
sub rcx, rax
sar rcx, 4
cmp rcx, rbx
ja short loc_AAFDA
lea rsi, [rbx+1]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE6resizeEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::resize(ulong)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [r14+8]
mov rax, [rax]
loc_AAFDA:
shl rbx, 4
add rbx, rax
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_AAFED:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AB069
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AB069:
test bpl, bpl
jnz short loc_AB073
jmp short loc_AB07B
mov r14, rax
loc_AB073:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AB07B:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
unsigned long long a2)
{
char v3; // al
long long v4; // rax
long long *v5; // rdi
long long v6; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v9; // [rsp+8h] [rbp-40h] BYREF
_QWORD v10[2]; // [rsp+10h] [rbp-38h] BYREF
v3 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 2;
v4 = operator new(0x18uLL);
*(_OWORD *)v4 = 0LL;
*(_QWORD *)(v4 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v4;
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);
v3 = *(_BYTE *)a1;
}
if ( v3 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
(long long)v10,
(long long)"cannot use operator[] with a numeric argument with ",
&v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v5 = *(long long **)(a1 + 8);
v6 = *v5;
if ( (v5[1] - *v5) >> 4 <= a2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::resize(
v5,
a2 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v6 = **(_QWORD **)(a1 + 8);
}
return v6 + 16 * a2;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x001aafa2
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011b8a0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x001590b4
MOV AL,byte ptr [R14]
LAB_001aafa2:
CMP AL,0x2
JNZ 0x001aafed
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
SUB RCX,RAX
SAR RCX,0x4
CMP RCX,RBX
JA 0x001aafda
LEA RSI,[RBX + 0x1]
CALL 0x001ab260
MOV RDI,R14
MOV ESI,0x1
CALL 0x001590b4
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX]
LAB_001aafda:
SHL RBX,0x4
ADD RBX,RAX
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001aafed:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f5fc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001ab00a:
LEA RSI,[0x1f2cc0]
LEA RDI,[RSP + 0x10]
CALL 0x001a1d13
MOV BPL,0x1
LAB_001ab01e:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x0015f3a4
XOR EBP,EBP
LEA RSI,[0x22bf38]
LEA RDX,[0x15b832]
MOV RDI,RBX
CALL 0x0011bf00
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](unsigned long) */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 *puVar2;
long lVar3;
int8 uVar4;
char *local_40;
detail local_38 [32];
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar2 = (int8 *)operator_new(0x18);
*puVar2 = 0;
puVar2[1] = 0;
puVar2[2] = 0;
*(int8 **)(this + 8) = puVar2;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
lVar3 = *(long *)this_00;
if ((ulong)(*(long *)(this_00 + 8) - lVar3 >> 4) <= param_1) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::resize(this_00,param_1 + 1);
assert_invariant(SUB81(this,0));
lVar3 = **(long **)(this + 8);
}
return param_1 * 0x10 + lVar3;
}
uVar4 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001ab00a to 001ab01a has its CatchHandler @ 001ab070 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 001ab01e to 001ab04a has its CatchHandler @ 001ab04b */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
34,960 | 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>::empty() const | monkey531[P]llama/common/json.hpp | bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
return m_data.m_value.array->empty();
}
case value_t::object:
{
// delegate call to object_t::empty()
return m_data.m_value.object->empty();
}
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
// all other types are nonempty
return false;
}
}
} | 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>::empty() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0xa0222
cmpl $0x1, %eax
je 0xa0213
cmpl $0x2, %eax
jne 0xa0225
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_A0222
cmp eax, 1
jz short loc_A0213
cmp eax, 2
jnz short loc_A0225
loc_A0213:
mov rax, [rdi+8]
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
retn
loc_A0222:
mov al, 1
retn
loc_A0225:
xor eax, eax
retn
| bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::empty(
unsigned __int8 *a1)
{
int v1; // eax
v1 = *a1;
if ( !*a1 )
return 1;
if ( v1 == 1 || v1 == 2 )
return **((_QWORD **)a1 + 1) == *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
return 0;
}
| empty:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001a0222
CMP EAX,0x1
JZ 0x001a0213
CMP EAX,0x2
JNZ 0x001a0225
LAB_001a0213:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
RET
LAB_001a0222:
MOV AL,0x1
RET
LAB_001a0225:
XOR EAX,EAX
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>::empty() const */
int8 __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>
::empty(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
long *plVar2;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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) {
return 1;
}
if ((bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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) &&
(bVar1 != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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)) {
return 0;
}
plVar2 = *(long **)(this + 8);
return CONCAT71((int7)((ulong)plVar2 >> 8),*plVar2 == plVar2[1]);
}
| |
34,961 | my_like_range_czech | eloqsql/strings/ctype-czech.c | static my_bool my_like_range_czech(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr,size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length, char *min_str,
char *max_str,
size_t *min_length,size_t *max_length)
{
#ifdef EXAMPLE
uchar value;
const char *end=ptr+ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == w_one) /* '_' in SQL */
{ break; }
if (*ptr == w_many) /* '%' in SQL */
{ break; }
if (*ptr == escape && ptr+1 != end)
{ ptr++; } /* Skip escape */
value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
if (value == 0) /* Ignore in the first pass */
{ continue; }
if (value <= 2) /* End of pass or end of string */
{ break; }
if (value == 255) /* Double char too compicated */
{ break; }
*min_str++= *max_str++ = *ptr;
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char; /* Because of key compression */
*max_str++ = max_sort_char;
}
return 0;
#else
return 1;
#endif
} | O0 | c | my_like_range_czech:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x50(%rbp)
movl %ecx, %eax
movl -0x50(%rbp), %ecx
movl %eax, -0x4c(%rbp)
movq %rdx, %rax
movl -0x4c(%rbp), %edx
movq %rax, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rdi, %r8
movq -0x40(%rbp), %rdi
movb %r9b, %al
movq 0x30(%rbp), %r9
movq 0x28(%rbp), %r9
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x51(%rbp)
je 0x391a5
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x391b1
jmp 0x39275
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x391c5
jmp 0x39275
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x391d9
jmp 0x39275
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x39202
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
je 0x39202
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq 0x18c4d7(%rip), %rax # 0x1c56e0
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1c(%rbp)
movzbl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x39224
jmp 0x39264
movzbl -0x1c(%rbp), %eax
cmpl $0x2, %eax
jg 0x3922f
jmp 0x39275
movzbl -0x1c(%rbp), %eax
cmpl $0xff, %eax
jne 0x3923c
jmp 0x39275
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x39188
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x39298
movq 0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x392a3
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x392de
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x20, (%rax)
movq 0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rbp)
movb $0x39, (%rax)
jmp 0x392ae
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_like_range_czech:
push rbp
mov rbp, rsp
mov [rbp+var_50], r8d
mov eax, ecx
mov ecx, [rbp+var_50]
mov [rbp+var_4C], eax
mov rax, rdx
mov edx, [rbp+var_4C]
mov [rbp+var_48], rax
mov rax, rsi
mov rsi, [rbp+var_48]
mov [rbp+var_40], rax
mov r8, rdi
mov rdi, [rbp+var_40]
mov al, r9b
mov r9, [rbp+arg_20]
mov r9, [rbp+arg_18]
mov r9, [rbp+arg_10]
mov r9, [rbp+arg_8]
mov r9, [rbp+arg_0]
mov [rbp+var_8], r8
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_19], dl
mov [rbp+var_1A], cl
mov [rbp+var_1B], al
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+arg_8]
mov [rbp+var_30], rax
mov rax, [rbp+arg_8]
add rax, [rbp+arg_0]
mov [rbp+var_38], rax
loc_39188:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_51], al
jz short loc_391A5
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
setnz al
mov [rbp+var_51], al
loc_391A5:
mov al, [rbp+var_51]
test al, 1
jnz short loc_391B1
jmp loc_39275
loc_391B1:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1A]
cmp eax, ecx
jnz short loc_391C5
jmp loc_39275
loc_391C5:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1B]
cmp eax, ecx
jnz short loc_391D9
jmp loc_39275
loc_391D9:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_19]
cmp eax, ecx
jnz short loc_39202
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_28]
jz short loc_39202
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_39202:
mov rax, cs:CZ_SORT_TABLE
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movsxd rcx, ecx
mov al, [rax+rcx]
mov [rbp+var_1C], al
movzx eax, [rbp+var_1C]
cmp eax, 0
jnz short loc_39224
jmp short loc_39264
loc_39224:
movzx eax, [rbp+var_1C]
cmp eax, 2
jg short loc_3922F
jmp short loc_39275
loc_3922F:
movzx eax, [rbp+var_1C]
cmp eax, 0FFh
jnz short loc_3923C
jmp short loc_39275
loc_3923C:
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
mov rdx, rax
add rdx, 1
mov [rbp+arg_8], rdx
mov [rax], cl
loc_39264:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_39188
loc_39275:
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
and eax, 10h
cmp eax, 0
jz short loc_39298
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_30]
sub rcx, rax
mov rax, [rbp+arg_18]
mov [rax], rcx
jmp short loc_392A3
loc_39298:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_18]
mov [rax], rcx
loc_392A3:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_20]
mov [rax], rcx
loc_392AE:
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
jz short loc_392DE
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 20h ; ' '
mov rax, [rbp+arg_10]
mov rcx, rax
add rcx, 1
mov [rbp+arg_10], rcx
mov byte ptr [rax], 39h ; '9'
jmp short loc_392AE
loc_392DE:
xor eax, eax
pop rbp
retn
| long long my_like_range_czech(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
unsigned __int8 *a8,
unsigned __int8 *a9,
_QWORD *a10,
_QWORD *a11)
{
unsigned __int8 v11; // cl
unsigned __int8 *v12; // rax
unsigned __int8 *v13; // rax
unsigned __int8 *v14; // rax
unsigned __int8 *v15; // rax
bool v17; // [rsp+1h] [rbp-51h]
unsigned __int8 *v18; // [rsp+1Ah] [rbp-38h]
long long v19; // [rsp+22h] [rbp-30h]
char *v20; // [rsp+2Ah] [rbp-28h]
unsigned __int8 v21; // [rsp+36h] [rbp-1Ch]
unsigned __int8 *v23; // [rsp+42h] [rbp-10h]
v23 = a2;
v20 = (char *)&a2[a3];
v19 = (long long)a8;
v18 = &a8[a7];
while ( 1 )
{
v17 = 0;
if ( v23 != (unsigned __int8 *)v20 )
v17 = a8 != v18;
if ( !v17 || (char)*v23 == a5 || (char)*v23 == a6 )
break;
if ( (char)*v23 == a4 && v23 + 1 != (unsigned __int8 *)v20 )
++v23;
v21 = byte_D5177[*v23];
if ( v21 )
{
if ( v21 <= 2u || v21 == 255 )
break;
v11 = *v23;
v12 = a9++;
*v12 = *v23;
v13 = a8++;
*v13 = v11;
}
++v23;
}
if ( (*(_DWORD *)(a1 + 12) & 0x10) != 0 )
*a10 = &a8[-v19];
else
*a10 = a7;
*a11 = a7;
while ( a8 != v18 )
{
v14 = a8++;
*v14 = 32;
v15 = a9++;
*v15 = 57;
}
return 0LL;
}
| my_like_range_czech:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x50],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x4c]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x40]
MOV AL,R9B
MOV R9,qword ptr [RBP + 0x30]
MOV R9,qword ptr [RBP + 0x28]
MOV R9,qword ptr [RBP + 0x20]
MOV R9,qword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],R8
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x19],DL
MOV byte ptr [RBP + -0x1a],CL
MOV byte ptr [RBP + -0x1b],AL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_00139188:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x51],AL
JZ 0x001391a5
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_001391a5:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001391b1
JMP 0x00139275
LAB_001391b1:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1a]
CMP EAX,ECX
JNZ 0x001391c5
JMP 0x00139275
LAB_001391c5:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1b]
CMP EAX,ECX
JNZ 0x001391d9
JMP 0x00139275
LAB_001391d9:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x19]
CMP EAX,ECX
JNZ 0x00139202
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x00139202
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_00139202:
MOV RAX,qword ptr [0x002c56e0]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x1c],AL
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x0
JNZ 0x00139224
JMP 0x00139264
LAB_00139224:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x2
JG 0x0013922f
JMP 0x00139275
LAB_0013922f:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0xff
JNZ 0x0013923c
JMP 0x00139275
LAB_0013923c:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x18],RDX
MOV byte ptr [RAX],CL
LAB_00139264:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00139188
LAB_00139275:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00139298
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
JMP 0x001392a3
LAB_00139298:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
LAB_001392a3:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
LAB_001392ae:
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x001392de
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x20
MOV RAX,qword ptr [RBP + 0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x20],RCX
MOV byte ptr [RAX],0x39
JMP 0x001392ae
LAB_001392de:
XOR EAX,EAX
POP RBP
RET
|
int8
my_like_range_czech(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,byte *param_8,byte *param_9,long *param_10,long *param_11)
{
byte bVar1;
byte *pbVar2;
byte *pbVar3;
byte *local_18;
pbVar2 = param_8;
pbVar3 = param_8 + param_7;
for (local_18 = param_2;
((local_18 != param_2 + param_3 && param_8 != pbVar3 && (*local_18 != param_5)) &&
(*local_18 != param_6)); local_18 = local_18 + 1) {
if ((*local_18 == param_4) && (local_18 + 1 != param_2 + param_3)) {
local_18 = local_18 + 1;
}
bVar1 = CZ_SORT_TABLE[(int)(uint)*local_18];
if (bVar1 != 0) {
if ((bVar1 < 3) || (bVar1 == 0xff)) break;
bVar1 = *local_18;
*param_9 = bVar1;
*param_8 = bVar1;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
}
if ((*(uint *)(param_1 + 0xc) & 0x10) == 0) {
*param_10 = param_7;
}
else {
*param_10 = (long)param_8 - (long)pbVar2;
}
*param_11 = param_7;
while (param_8 != pbVar3) {
*param_8 = 0x20;
*param_9 = 0x39;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
return 0;
}
| |
34,962 | my_scan_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_scan_utf32(CHARSET_INFO *cs,
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for ( ; str < end; )
{
my_wc_t wc;
int res= my_utf32_uni(cs, &wc, (uchar*) str, (uchar*) end);
if (res < 0 || wc != ' ')
break;
str+= res;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
} | O0 | c | my_scan_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0x6dd36
jmp 0x6dd2c
movl -0x40(%rbp), %eax
subl $0x3, %eax
je 0x6dd8d
jmp 0x6dd93
jmp 0x6dd38
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6dd7c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq 0x6d1a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x6dd67
cmpq $0x20, -0x38(%rbp)
je 0x6dd69
jmp 0x6dd7c
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6dd38
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6dd9b
jmp 0x6dd8f
jmp 0x6dd91
jmp 0x6dd93
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_scan_utf32:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov eax, [rbp+var_24]
mov [rbp+var_40], eax
sub eax, 2
jz short loc_6DD36
jmp short $+2
loc_6DD2C:
mov eax, [rbp+var_40]
sub eax, 3
jz short loc_6DD8D
jmp short loc_6DD93
loc_6DD36:
jmp short $+2
loc_6DD38:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_6DD7C
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call my_utf32_uni
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jl short loc_6DD67
cmp [rbp+var_38], 20h ; ' '
jz short loc_6DD69
loc_6DD67:
jmp short loc_6DD7C
loc_6DD69:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_6DD38
loc_6DD7C:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_6DD9B
loc_6DD8D:
jmp short $+2
loc_6DD8F:
jmp short $+2
loc_6DD91:
jmp short $+2
loc_6DD93:
mov [rbp+var_8], 0
loc_6DD9B:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| unsigned long long my_scan_utf32(
long long a1,
unsigned long long a2,
unsigned long long a3,
int a4,
long long a5,
long long a6)
{
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h] BYREF
unsigned long long v9; // [rsp+10h] [rbp-30h]
int v10; // [rsp+1Ch] [rbp-24h]
unsigned long long v11; // [rsp+20h] [rbp-20h]
unsigned long long v12; // [rsp+28h] [rbp-18h]
long long v13; // [rsp+30h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a2;
if ( a4 != 2 )
return 0LL;
while ( v12 < v11 )
{
v7 = my_utf32_uni(v13, (long long)&v8, v12, v11, a5, a6);
if ( v7 < 0 || v8 != 32 )
break;
v12 += v7;
}
return v12 - v9;
}
| my_scan_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
SUB EAX,0x2
JZ 0x0016dd36
JMP 0x0016dd2c
LAB_0016dd2c:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3
JZ 0x0016dd8d
JMP 0x0016dd93
LAB_0016dd36:
JMP 0x0016dd38
LAB_0016dd38:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0016dd7c
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL 0x0016d1a0
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JL 0x0016dd67
CMP qword ptr [RBP + -0x38],0x20
JZ 0x0016dd69
LAB_0016dd67:
JMP 0x0016dd7c
LAB_0016dd69:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016dd38
LAB_0016dd7c:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016dd9b
LAB_0016dd8d:
JMP 0x0016dd8f
LAB_0016dd8f:
JMP 0x0016dd91
LAB_0016dd91:
JMP 0x0016dd93
LAB_0016dd93:
MOV qword ptr [RBP + -0x8],0x0
LAB_0016dd9b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long my_scan_utf32(int8 param_1,ulong param_2,ulong param_3,int param_4)
{
int iVar1;
long local_40;
ulong local_38;
int4 local_2c;
ulong local_28;
ulong local_20;
int8 local_18;
long local_10;
if (param_4 == 2) {
local_2c = 2;
local_38 = param_2;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
while (((local_20 < local_28 &&
(iVar1 = my_utf32_uni(local_18,&local_40,local_20,local_28), -1 < iVar1)) &&
(local_40 == 0x20))) {
local_20 = local_20 + (long)iVar1;
}
local_10 = local_20 - local_38;
}
else {
local_10 = 0;
}
return local_10;
}
| |
34,963 | exchange_int128s | bluesky950520[P]quickjs/cutils.c | static void exchange_int128s(void *a, void *b, size_t size) {
uint64_t *ap = (uint64_t *)a;
uint64_t *bp = (uint64_t *)b;
for (size /= sizeof(uint64_t) * 2; size-- != 0; ap += 2, bp += 2) {
uint64_t t = ap[0];
uint64_t u = ap[1];
ap[0] = bp[0];
ap[1] = bp[1];
bp[0] = t;
bp[1] = u;
}
} | O2 | c | exchange_int128s:
shrq $0x4, %rdx
xorl %eax, %eax
subq $0x1, %rdx
jb 0x1aa98
movq (%rsi,%rax), %rcx
movups (%rdi,%rax), %xmm0
movq %rcx, (%rdi,%rax)
movq 0x8(%rsi,%rax), %rcx
movq %rcx, 0x8(%rdi,%rax)
movups %xmm0, (%rsi,%rax)
addq $0x10, %rax
jmp 0x1aa72
retq
| exchange_int128s:
shr rdx, 4
xor eax, eax
loc_1AA72:
sub rdx, 1
jb short locret_1AA98
mov rcx, [rsi+rax]
movups xmm0, xmmword ptr [rdi+rax]
mov [rdi+rax], rcx
mov rcx, [rsi+rax+8]
mov [rdi+rax+8], rcx
movups xmmword ptr [rsi+rax], xmm0
add rax, 10h
jmp short loc_1AA72
locret_1AA98:
retn
| long long exchange_int128s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long result; // rax
__int128 v6; // xmm0
v3 = a3 >> 4;
for ( result = 0LL; v3-- != 0; result += 16LL )
{
v6 = *(_OWORD *)(a1 + result);
*(_QWORD *)(a1 + result) = *(_QWORD *)(a2 + result);
*(_QWORD *)(a1 + result + 8) = *(_QWORD *)(a2 + result + 8);
*(_OWORD *)(a2 + result) = v6;
}
return result;
}
| exchange_int128s:
SHR RDX,0x4
XOR EAX,EAX
LAB_0011aa72:
SUB RDX,0x1
JC 0x0011aa98
MOV RCX,qword ptr [RSI + RAX*0x1]
MOVUPS XMM0,xmmword ptr [RDI + RAX*0x1]
MOV qword ptr [RDI + RAX*0x1],RCX
MOV RCX,qword ptr [RSI + RAX*0x1 + 0x8]
MOV qword ptr [RDI + RAX*0x1 + 0x8],RCX
MOVUPS xmmword ptr [RSI + RAX*0x1],XMM0
ADD RAX,0x10
JMP 0x0011aa72
LAB_0011aa98:
RET
|
void exchange_int128s(long param_1,long param_2,ulong param_3)
{
int8 uVar1;
int8 uVar2;
long lVar3;
bool bVar4;
param_3 = param_3 >> 4;
lVar3 = 0;
while (bVar4 = param_3 != 0, param_3 = param_3 - 1, bVar4) {
uVar1 = *(int8 *)(param_1 + lVar3);
uVar2 = ((int8 *)(param_1 + lVar3))[1];
*(int8 *)(param_1 + lVar3) = *(int8 *)(param_2 + lVar3);
*(int8 *)(param_1 + 8 + lVar3) = *(int8 *)(param_2 + 8 + lVar3);
*(int8 *)(param_2 + lVar3) = uVar1;
((int8 *)(param_2 + lVar3))[1] = uVar2;
lVar3 = lVar3 + 0x10;
}
return;
}
| |
34,964 | my_like_range_czech | eloqsql/strings/ctype-czech.c | static my_bool my_like_range_czech(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr,size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length, char *min_str,
char *max_str,
size_t *min_length,size_t *max_length)
{
#ifdef EXAMPLE
uchar value;
const char *end=ptr+ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == w_one) /* '_' in SQL */
{ break; }
if (*ptr == w_many) /* '%' in SQL */
{ break; }
if (*ptr == escape && ptr+1 != end)
{ ptr++; } /* Skip escape */
value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
if (value == 0) /* Ignore in the first pass */
{ continue; }
if (value <= 2) /* End of pass or end of string */
{ break; }
if (value == 255) /* Double char too compicated */
{ break; }
*min_str++= *max_str++ = *ptr;
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char; /* Because of key compression */
*max_str++ = max_sort_char;
}
return 0;
#else
return 1;
#endif
} | O0 | c | my_like_range_czech:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x50(%rbp)
movl %ecx, %eax
movl -0x50(%rbp), %ecx
movl %eax, -0x4c(%rbp)
movq %rdx, %rax
movl -0x4c(%rbp), %edx
movq %rax, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rdi, %r8
movq -0x40(%rbp), %rdi
movb %r9b, %al
movq 0x30(%rbp), %r9
movq 0x28(%rbp), %r9
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x51(%rbp)
je 0x88f65
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x88f71
jmp 0x89035
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x88f85
jmp 0x89035
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x88f99
jmp 0x89035
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x88fc2
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
je 0x88fc2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq 0x19e3c7(%rip), %rax # 0x227390
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1c(%rbp)
movzbl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jne 0x88fe4
jmp 0x89024
movzbl -0x1c(%rbp), %eax
cmpl $0x2, %eax
jg 0x88fef
jmp 0x89035
movzbl -0x1c(%rbp), %eax
cmpl $0xff, %eax
jne 0x88ffc
jmp 0x89035
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x88f48
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x89058
movq 0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x89063
movq 0x10(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x8909e
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x20, (%rax)
movq 0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rbp)
movb $0x39, (%rax)
jmp 0x8906e
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_like_range_czech:
push rbp
mov rbp, rsp
mov [rbp+var_50], r8d
mov eax, ecx
mov ecx, [rbp+var_50]
mov [rbp+var_4C], eax
mov rax, rdx
mov edx, [rbp+var_4C]
mov [rbp+var_48], rax
mov rax, rsi
mov rsi, [rbp+var_48]
mov [rbp+var_40], rax
mov r8, rdi
mov rdi, [rbp+var_40]
mov al, r9b
mov r9, [rbp+arg_20]
mov r9, [rbp+arg_18]
mov r9, [rbp+arg_10]
mov r9, [rbp+arg_8]
mov r9, [rbp+arg_0]
mov [rbp+var_8], r8
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_19], dl
mov [rbp+var_1A], cl
mov [rbp+var_1B], al
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+arg_8]
mov [rbp+var_30], rax
mov rax, [rbp+arg_8]
add rax, [rbp+arg_0]
mov [rbp+var_38], rax
loc_88F48:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_51], al
jz short loc_88F65
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
setnz al
mov [rbp+var_51], al
loc_88F65:
mov al, [rbp+var_51]
test al, 1
jnz short loc_88F71
jmp loc_89035
loc_88F71:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1A]
cmp eax, ecx
jnz short loc_88F85
jmp loc_89035
loc_88F85:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_1B]
cmp eax, ecx
jnz short loc_88F99
jmp loc_89035
loc_88F99:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_19]
cmp eax, ecx
jnz short loc_88FC2
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_28]
jz short loc_88FC2
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_88FC2:
mov rax, cs:CZ_SORT_TABLE
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movsxd rcx, ecx
mov al, [rax+rcx]
mov [rbp+var_1C], al
movzx eax, [rbp+var_1C]
cmp eax, 0
jnz short loc_88FE4
jmp short loc_89024
loc_88FE4:
movzx eax, [rbp+var_1C]
cmp eax, 2
jg short loc_88FEF
jmp short loc_89035
loc_88FEF:
movzx eax, [rbp+var_1C]
cmp eax, 0FFh
jnz short loc_88FFC
jmp short loc_89035
loc_88FFC:
mov rax, [rbp+var_10]
mov cl, [rax]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
mov rdx, rax
add rdx, 1
mov [rbp+arg_8], rdx
mov [rax], cl
loc_89024:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_88F48
loc_89035:
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
and eax, 10h
cmp eax, 0
jz short loc_89058
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_30]
sub rcx, rax
mov rax, [rbp+arg_18]
mov [rax], rcx
jmp short loc_89063
loc_89058:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_18]
mov [rax], rcx
loc_89063:
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_20]
mov [rax], rcx
loc_8906E:
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_38]
jz short loc_8909E
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 20h ; ' '
mov rax, [rbp+arg_10]
mov rcx, rax
add rcx, 1
mov [rbp+arg_10], rcx
mov byte ptr [rax], 39h ; '9'
jmp short loc_8906E
loc_8909E:
xor eax, eax
pop rbp
retn
| long long my_like_range_czech(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
unsigned __int8 *a8,
unsigned __int8 *a9,
_QWORD *a10,
_QWORD *a11)
{
unsigned __int8 v11; // cl
unsigned __int8 *v12; // rax
unsigned __int8 *v13; // rax
unsigned __int8 *v14; // rax
unsigned __int8 *v15; // rax
bool v17; // [rsp+1h] [rbp-51h]
unsigned __int8 *v18; // [rsp+1Ah] [rbp-38h]
long long v19; // [rsp+22h] [rbp-30h]
char *v20; // [rsp+2Ah] [rbp-28h]
unsigned __int8 v21; // [rsp+36h] [rbp-1Ch]
unsigned __int8 *v23; // [rsp+42h] [rbp-10h]
v23 = a2;
v20 = (char *)&a2[a3];
v19 = (long long)a8;
v18 = &a8[a7];
while ( 1 )
{
v17 = 0;
if ( v23 != (unsigned __int8 *)v20 )
v17 = a8 != v18;
if ( !v17 || (char)*v23 == a5 || (char)*v23 == a6 )
break;
if ( (char)*v23 == a4 && v23 + 1 != (unsigned __int8 *)v20 )
++v23;
v21 = byte_128A67[*v23];
if ( v21 )
{
if ( v21 <= 2u || v21 == 255 )
break;
v11 = *v23;
v12 = a9++;
*v12 = *v23;
v13 = a8++;
*v13 = v11;
}
++v23;
}
if ( (*(_DWORD *)(a1 + 12) & 0x10) != 0 )
*a10 = &a8[-v19];
else
*a10 = a7;
*a11 = a7;
while ( a8 != v18 )
{
v14 = a8++;
*v14 = 32;
v15 = a9++;
*v15 = 57;
}
return 0LL;
}
| my_like_range_czech:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x50],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x4c]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x40]
MOV AL,R9B
MOV R9,qword ptr [RBP + 0x30]
MOV R9,qword ptr [RBP + 0x28]
MOV R9,qword ptr [RBP + 0x20]
MOV R9,qword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],R8
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x19],DL
MOV byte ptr [RBP + -0x1a],CL
MOV byte ptr [RBP + -0x1b],AL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_00188f48:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x51],AL
JZ 0x00188f65
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_00188f65:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x00188f71
JMP 0x00189035
LAB_00188f71:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1a]
CMP EAX,ECX
JNZ 0x00188f85
JMP 0x00189035
LAB_00188f85:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x1b]
CMP EAX,ECX
JNZ 0x00188f99
JMP 0x00189035
LAB_00188f99:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x19]
CMP EAX,ECX
JNZ 0x00188fc2
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x00188fc2
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_00188fc2:
MOV RAX,qword ptr [0x00327390]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x1c],AL
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x0
JNZ 0x00188fe4
JMP 0x00189024
LAB_00188fe4:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0x2
JG 0x00188fef
JMP 0x00189035
LAB_00188fef:
MOVZX EAX,byte ptr [RBP + -0x1c]
CMP EAX,0xff
JNZ 0x00188ffc
JMP 0x00189035
LAB_00188ffc:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x18],RDX
MOV byte ptr [RAX],CL
LAB_00189024:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00188f48
LAB_00189035:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00189058
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
JMP 0x00189063
LAB_00189058:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
LAB_00189063:
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
LAB_0018906e:
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x0018909e
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x20
MOV RAX,qword ptr [RBP + 0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x20],RCX
MOV byte ptr [RAX],0x39
JMP 0x0018906e
LAB_0018909e:
XOR EAX,EAX
POP RBP
RET
|
int8
my_like_range_czech(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,byte *param_8,byte *param_9,long *param_10,long *param_11)
{
byte bVar1;
byte *pbVar2;
byte *pbVar3;
byte *local_18;
pbVar2 = param_8;
pbVar3 = param_8 + param_7;
for (local_18 = param_2;
((local_18 != param_2 + param_3 && param_8 != pbVar3 && (*local_18 != param_5)) &&
(*local_18 != param_6)); local_18 = local_18 + 1) {
if ((*local_18 == param_4) && (local_18 + 1 != param_2 + param_3)) {
local_18 = local_18 + 1;
}
bVar1 = CZ_SORT_TABLE[(int)(uint)*local_18];
if (bVar1 != 0) {
if ((bVar1 < 3) || (bVar1 == 0xff)) break;
bVar1 = *local_18;
*param_9 = bVar1;
*param_8 = bVar1;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
}
if ((*(uint *)(param_1 + 0xc) & 0x10) == 0) {
*param_10 = param_7;
}
else {
*param_10 = (long)param_8 - (long)pbVar2;
}
*param_11 = param_7;
while (param_8 != pbVar3) {
*param_8 = 0x20;
*param_9 = 0x39;
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
return 0;
}
| |
34,965 | ma_write_blob_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_write_blob_record(MARIA_HA *info, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
my_bool buff_alloced;
extra= (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+
MARIA_DYN_DELETE_BLOCK_HEADER+1);
reclength= (info->s->base.pack_reclength +
_ma_calc_total_blob_length(info,record)+ extra);
alloc_on_stack(*info->stack_end_ptr, rec_buff, buff_alloced, reclength);
if (!rec_buff)
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(1);
}
reclength2= _ma_rec_pack(info,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
record);
if (!reclength2)
{
error= 1;
goto err;
}
DBUG_PRINT("info",("reclength: %lu reclength2: %lu",
reclength, reclength2));
DBUG_ASSERT(reclength2 <= reclength);
error= write_dynamic_record(info,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
reclength2);
err:
stack_alloc_free(rec_buff, buff_alloced);
return(error != 0);
} | O0 | c | ma_write_blob_record:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x5d, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x3a0(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c510
movq %rax, %rcx
movq -0x68(%rbp), %rax
addq %rcx, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x3c44c
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x3c42d
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x3c44c
movl $0x1000, %eax # imm = 0x1000
cmpq -0x58(%rbp), %rax
ja 0x3c44c
movb $0x0, -0x49(%rbp)
movq -0x38(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
jmp 0x3c464
movb $0x1, -0x49(%rbp)
movq -0x38(%rbp), %rsi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf3210
movq %rax, -0x28(%rbp)
jmp 0x3c466
cmpq $0x0, -0x28(%rbp)
jne 0x3c47e
callq 0xf5a70
movl $0x80, (%rax)
movb $0x1, -0x9(%rbp)
jmp 0x3c4e8
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x3b450
movl %eax, %eax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3c4a9
movl $0x1, -0x2c(%rbp)
jmp 0x3c4cc
jmp 0x3c4ab
jmp 0x3c4ad
jmp 0x3c4af
jmp 0x3c4b1
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
movq -0x40(%rbp), %rdx
callq 0x3ba40
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movsbl -0x49(%rbp), %esi
callq 0x3c5b0
cmpl $0x0, -0x2c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x69(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3c508
movb -0x69(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
| _ma_write_blob_record:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_48], 5Dh ; ']'
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+3A0h]
mov [rbp+var_68], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _ma_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_68]
add rax, rcx
add rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_58]
sub rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
cmp rax, [rbp+var_58]
jbe short loc_3C44C
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 10000h
cmp rax, rcx
jb short loc_3C42D
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 8000h
cmp rax, rcx
jnb short loc_3C44C
mov eax, 1000h
cmp rax, [rbp+var_58]
ja short loc_3C44C
loc_3C42D:
mov [rbp+var_49], 0
mov rcx, [rbp+var_38]
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_28], rax
jmp short loc_3C464
loc_3C44C:
mov [rbp+var_49], 1
mov rsi, [rbp+var_38]
xor edi, edi
mov edx, offset stru_10010
call my_malloc
mov [rbp+var_28], rax
loc_3C464:
jmp short $+2
loc_3C466:
cmp [rbp+var_28], 0
jnz short loc_3C47E
call _my_thread_var
mov dword ptr [rax], 80h
mov [rbp+var_9], 1
jmp short loc_3C4E8
loc_3C47E:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 18h
mov rdx, [rbp+var_20]
call _ma_rec_pack
mov eax, eax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
jnz short loc_3C4A9
mov [rbp+var_2C], 1
jmp short loc_3C4CC
loc_3C4A9:
jmp short $+2
loc_3C4AB:
jmp short $+2
loc_3C4AD:
jmp short $+2
loc_3C4AF:
jmp short $+2
loc_3C4B1:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 18h
mov rdx, [rbp+var_40]
call write_dynamic_record
movsx eax, al
mov [rbp+var_2C], eax
loc_3C4CC:
mov rdi, [rbp+var_28]
movsx esi, [rbp+var_49]
call stack_alloc_free
cmp [rbp+var_2C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9], al
loc_3C4E8:
mov al, [rbp+var_9]
mov [rbp+var_69], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3C508
mov al, [rbp+var_69]
mov rsp, rbp
pop rbp
retn
loc_3C508:
call ___stack_chk_fail
| bool ma_write_blob_record(long long a1, _BYTE *a2)
{
unsigned int v2; // eax
long long v4; // [rsp+0h] [rbp-70h] BYREF
long long v5; // [rsp+8h] [rbp-68h]
unsigned long long v6; // [rsp+10h] [rbp-60h]
unsigned long long v7; // [rsp+18h] [rbp-58h] BYREF
char v8; // [rsp+27h] [rbp-49h]
long long v9; // [rsp+28h] [rbp-48h]
long long v10; // [rsp+30h] [rbp-40h]
unsigned long long v11; // [rsp+38h] [rbp-38h]
int v12; // [rsp+44h] [rbp-2Ch]
char *v13; // [rsp+48h] [rbp-28h]
_BYTE *v14; // [rsp+50h] [rbp-20h]
_QWORD *v15; // [rsp+58h] [rbp-18h]
unsigned long long v17; // [rsp+68h] [rbp-8h]
v17 = __readfsqword(0x28u);
v15 = (_QWORD *)a1;
v14 = a2;
v9 = 93LL;
v5 = *(_QWORD *)(*(_QWORD *)a1 + 928LL);
v11 = ma_calc_total_blob_length(a1, a2) + v5 + 93;
v7 = v11;
v6 = **(_QWORD **)(a1 + 120) - (_QWORD)&v7;
if ( v6 <= v11 || v6 - v7 <= 0x10000 && (v6 - v7 <= 0x8000 || v7 < 0x1000) )
{
v8 = 1;
v13 = (char *)my_malloc(0LL, v11, &stru_10010);
}
else
{
v8 = 0;
v13 = (char *)&v4 - ((v11 + 15) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v13 )
{
v2 = ma_rec_pack(v15, v13 + 24, v14);
v10 = v2;
if ( v2 )
v12 = write_dynamic_record(v15, (long long)(v13 + 24), v10);
else
v12 = 1;
stack_alloc_free(v13, (unsigned int)v8);
return v12 != 0;
}
else
{
*(_DWORD *)my_thread_var() = 128;
return 1;
}
}
| _ma_write_blob_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x48],0x5d
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013c510
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0x58]
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x0013c44c
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x0013c42d
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x0013c44c
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0x58]
JA 0x0013c44c
LAB_0013c42d:
MOV byte ptr [RBP + -0x49],0x0
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0013c464
LAB_0013c44c:
MOV byte ptr [RBP + -0x49],0x1
MOV RSI,qword ptr [RBP + -0x38]
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f3210
MOV qword ptr [RBP + -0x28],RAX
LAB_0013c464:
JMP 0x0013c466
LAB_0013c466:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0013c47e
CALL 0x001f5a70
MOV dword ptr [RAX],0x80
MOV byte ptr [RBP + -0x9],0x1
JMP 0x0013c4e8
LAB_0013c47e:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0013b450
MOV EAX,EAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x0013c4a9
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x0013c4cc
LAB_0013c4a9:
JMP 0x0013c4ab
LAB_0013c4ab:
JMP 0x0013c4ad
LAB_0013c4ad:
JMP 0x0013c4af
LAB_0013c4af:
JMP 0x0013c4b1
LAB_0013c4b1:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x18
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0013ba40
MOVSX EAX,AL
MOV dword ptr [RBP + -0x2c],EAX
LAB_0013c4cc:
MOV RDI,qword ptr [RBP + -0x28]
MOVSX ESI,byte ptr [RBP + -0x49]
CALL 0x0013c5b0
CMP dword ptr [RBP + -0x2c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9],AL
LAB_0013c4e8:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x69],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013c508
MOV AL,byte ptr [RBP + -0x69]
MOV RSP,RBP
POP RBP
RET
LAB_0013c508:
CALL 0x0012a270
|
int8 _ma_write_blob_record(long *param_1,int8 param_2)
{
int8 uVar1;
long *plVar2;
char cVar3;
uint uVar4;
long lVar5;
int4 *puVar6;
ulong uVar7;
int1 *puVar8;
int iVar9;
int1 *puVar10;
long in_FS_OFFSET;
int1 auStack_78 [7];
bool local_71;
long local_70;
ulong local_68;
ulong local_60;
char local_51;
long local_50;
ulong local_48;
ulong local_40;
int local_34;
int1 *local_30;
int8 local_28;
long *local_20;
bool local_11;
long local_10;
puVar8 = auStack_78;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = 0x5d;
local_70 = *(long *)(*param_1 + 0x3a0);
local_28 = param_2;
local_20 = param_1;
lVar5 = _ma_calc_total_blob_length(param_1,param_2);
local_60 = local_70 + lVar5 + local_50;
local_68 = *(long *)local_20[0xf] - (long)&local_60;
local_40 = local_60;
if ((local_60 < local_68) &&
((0x10000 < local_68 - local_60 || ((0x8000 < local_68 - local_60 && (0xfff < local_60)))))) {
local_51 = '\0';
puVar8 = auStack_78 + -(local_60 + 0xf & 0xfffffffffffffff0);
local_30 = puVar8;
}
else {
local_51 = '\x01';
local_30 = (int1 *)my_malloc(0,local_60,0x10010);
}
plVar2 = local_20;
uVar1 = local_28;
if (local_30 == (int1 *)0x0) {
*(int8 *)(puVar8 + -8) = 0x13c472;
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x80;
local_11 = true;
}
else {
puVar10 = local_30 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13c493;
uVar4 = _ma_rec_pack(plVar2,puVar10,uVar1);
plVar2 = local_20;
uVar7 = (ulong)uVar4;
local_48 = uVar7;
if (uVar7 == 0) {
local_34 = 1;
}
else {
puVar10 = local_30 + 0x18;
*(int8 *)(puVar8 + -8) = 0x13c4c6;
cVar3 = write_dynamic_record(plVar2,puVar10,uVar7);
local_34 = (int)cVar3;
}
puVar10 = local_30;
iVar9 = (int)local_51;
*(int8 *)(puVar8 + -8) = 0x13c4d9;
stack_alloc_free(puVar10,iVar9);
local_11 = local_34 != 0;
}
local_71 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar8 + -8) = 0x13c50d;
__stack_chk_fail();
}
| |
34,966 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x26340
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x59761
callq 0x26050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x5a270
movq %rax, %rcx
movl -0x24(%rbp), %eax
movl %eax, (%rcx)
cmpl $0x16, %eax
jne 0x59727
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26330
jmp 0x5975f
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x59758
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x26050
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x64750
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x5976d
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5976f
jmp 0x59771
jmp 0x59773
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_readlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
mov edx, 1FFh
call _readlink
mov [rbp+var_20], eax
cmp eax, 0
jge short loc_59761
call ___errno_location
mov eax, [rax]
mov [rbp+var_24], eax
call _my_thread_var
mov rcx, rax
mov eax, [rbp+var_24]
mov [rcx], eax
cmp eax, 16h
jnz short loc_59727
mov [rbp+var_1C], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _stpcpy
jmp short loc_5975F
loc_59727:
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_59758
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 18h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_59758:
mov [rbp+var_1C], 0FFFFFFFFh
loc_5975F:
jmp short loc_5976D
loc_59761:
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov byte ptr [rax+rcx], 0
loc_5976D:
jmp short $+2
loc_5976F:
jmp short $+2
loc_59771:
jmp short $+2
loc_59773:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
_DWORD *v3; // rax
int v4; // r8d
int v5; // r9d
int v7; // [rsp+1Ch] [rbp-24h]
int v8; // [rsp+20h] [rbp-20h]
unsigned int v9; // [rsp+24h] [rbp-1Ch]
v9 = 0;
v8 = readlink(a2, a1, 511LL);
if ( v8 >= 0 )
{
*(_BYTE *)(a1 + v8) = 0;
}
else
{
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v7;
if ( v7 == 22 )
{
v9 = 1;
stpcpy(a1, a2);
}
else
{
if ( (a3 & 0x10) != 0 )
{
v3 = (_DWORD *)__errno_location();
my_error(24, 0, a2, *v3, v4, v5);
}
return (unsigned int)-1;
}
}
return v9;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x1ff
CALL 0x00126340
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JGE 0x00159761
CALL 0x00126050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
CALL 0x0015a270
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RCX],EAX
CMP EAX,0x16
JNZ 0x00159727
MOV dword ptr [RBP + -0x1c],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00126330
JMP 0x0015975f
LAB_00159727:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x00159758
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00126050
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0x18
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x00164750
LAB_00159758:
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_0015975f:
JMP 0x0015976d
LAB_00159761:
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0015976d:
JMP 0x0015976f
LAB_0015976f:
JMP 0x00159771
LAB_00159771:
JMP 0x00159773
LAB_00159773:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int4 local_24;
local_24 = 0;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if (iVar1 == 0x16) {
local_24 = 1;
stpcpy(param_1,param_2);
}
else {
if ((param_3 & 0x10) != 0) {
piVar3 = __errno_location();
my_error(0x18,0,param_2,*piVar3);
}
local_24 = 0xffffffff;
}
}
else {
param_1[(int)sVar2] = '\0';
}
return local_24;
}
| |
34,967 | ma_tls_read_async | eloqsql/libmariadb/libmariadb/secure/openssl.c | ssize_t ma_tls_read_async(MARIADB_PVIO *pvio,
const unsigned char *buffer,
size_t length)
{
int res;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
MARIADB_TLS *ctls= pvio->ctls;
for (;;)
{
res= SSL_read((SSL *)ctls->ssl, (void *)buffer, (int)length);
if (ma_tls_async_check_result(res, b, (SSL *)ctls->ssl))
return res;
}
} | O3 | c | ma_tls_read_async:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x38(%rdi), %r13
movq 0x40(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
movq 0x10(%r13), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x13070
movl %eax, %r12d
movq 0x10(%r13), %rdx
movl %eax, %edi
movq %r15, %rsi
callq 0x29f76
testb %al, %al
je 0x29f41
movslq %r12d, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_read_async:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r13, [rdi+38h]
mov rax, [rdi+40h]
mov rax, [rax+480h]
mov r15, [rax+28h]
loc_29F41:
mov rdi, [r13+10h]
mov rsi, r14
mov edx, ebx
call _SSL_read
mov r12d, eax
mov rdx, [r13+10h]
mov edi, eax
mov rsi, r15
call ma_tls_async_check_result
test al, al
jz short loc_29F41
movsxd rax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_tls_read_async(long long a1, long long a2, unsigned int a3)
{
long long v4; // r13
long long v5; // r15
long long v6; // r12
v4 = *(_QWORD *)(a1 + 56);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
do
v6 = (unsigned int)SSL_read(*(_QWORD *)(v4 + 16), a2, a3);
while ( !(unsigned __int8)ma_tls_async_check_result(v6, v5, *(_QWORD *)(v4 + 16)) );
return (int)v6;
}
| ma_tls_read_async:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R13,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RDI + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LAB_00129f41:
MOV RDI,qword ptr [R13 + 0x10]
MOV RSI,R14
MOV EDX,EBX
CALL 0x00113070
MOV R12D,EAX
MOV RDX,qword ptr [R13 + 0x10]
MOV EDI,EAX
MOV RSI,R15
CALL 0x00129f76
TEST AL,AL
JZ 0x00129f41
MOVSXD RAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_tls_read_async(long param_1,void *param_2,int param_3)
{
long lVar1;
int8 uVar2;
char cVar3;
int iVar4;
lVar1 = *(long *)(param_1 + 0x38);
uVar2 = *(int8 *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
do {
iVar4 = SSL_read(*(SSL **)(lVar1 + 0x10),param_2,param_3);
cVar3 = ma_tls_async_check_result(iVar4,uVar2,*(int8 *)(lVar1 + 0x10));
} while (cVar3 == '\0');
return (long)iVar4;
}
| |
34,968 | js_os_rename | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_rename(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *oldpath, *newpath;
int ret;
oldpath = JS_ToCString(ctx, argv[0]);
if (!oldpath)
return JS_EXCEPTION;
newpath = JS_ToCString(ctx, argv[1]);
if (!newpath) {
JS_FreeCString(ctx, oldpath);
return JS_EXCEPTION;
}
ret = js_get_errno(rename(oldpath, newpath));
JS_FreeCString(ctx, oldpath);
JS_FreeCString(ctx, newpath);
return JS_NewInt32(ctx, ret);
} | O0 | c | js_os_rename:
subq $0x78, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x13520
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x174b5
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x1756b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x13520
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x174fb
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x28b90
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x1756b
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe7e0
movslq %eax, %rdi
callq 0x12790
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x28b90
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x28b90
movq 0x30(%rsp), %rcx
movl 0xc(%rsp), %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x68(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x78, %rsp
retq
nopw (%rax,%rax)
| js_os_rename:
sub rsp, 78h
mov [rsp+78h+var_40], rsi
mov [rsp+78h+var_38], rdx
mov [rsp+78h+var_48], rdi
mov [rsp+78h+var_4C], ecx
mov [rsp+78h+var_58], r8
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_58]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToCString
mov [rsp+78h+var_60], rax
cmp [rsp+78h+var_60], 0
jnz short loc_174B5
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp loc_1756B
loc_174B5:
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_58]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_ToCString
mov [rsp+78h+var_68], rax
cmp [rsp+78h+var_68], 0
jnz short loc_174FB
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_60]
call JS_FreeCString
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp short loc_1756B
loc_174FB:
mov rdi, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_68]
call _rename
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_6C], eax
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_60]
call JS_FreeCString
mov rdi, [rsp+78h+var_48]
mov rsi, [rsp+78h+var_68]
call JS_FreeCString
mov rcx, [rsp+78h+var_48]
mov eax, [rsp+78h+var_6C]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_1C], eax
mov eax, [rsp+78h+var_1C]
mov dword ptr [rsp+78h+var_10], eax
mov [rsp+78h+var_8], 0
mov rcx, [rsp+78h+var_10]
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_28], rax
loc_1756B:
mov rax, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
add rsp, 78h
retn
| long long js_os_rename(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
int v5; // eax
int errno; // [rsp+Ch] [rbp-6Ch]
long long v8; // [rsp+10h] [rbp-68h]
long long v9; // [rsp+18h] [rbp-60h]
long long v11; // [rsp+48h] [rbp-30h]
long long v12; // [rsp+68h] [rbp-10h]
v9 = JS_ToCString(a1, *a5, a5[1]);
if ( v9 )
{
v8 = JS_ToCString(a1, a5[2], a5[3]);
if ( v8 )
{
v5 = rename(v9, v8);
errno = js_get_errno(v5);
JS_FreeCString(a1, v9);
JS_FreeCString(a1, v8);
LODWORD(v12) = errno;
return v12;
}
else
{
JS_FreeCString(a1, v9);
LODWORD(v11) = 0;
}
}
else
{
LODWORD(v11) = 0;
}
return v11;
}
| js_os_rename:
SUB RSP,0x78
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ECX
MOV qword ptr [RSP + 0x20],R8
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00113520
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x001174b5
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x0011756b
LAB_001174b5:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00113520
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001174fb
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00128b90
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x0011756b
LAB_001174fb:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0010e7e0
MOVSXD RDI,EAX
CALL 0x00112790
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00128b90
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00128b90
MOV RCX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RSP + 0xc]
MOV qword ptr [RSP + 0x60],RCX
MOV dword ptr [RSP + 0x5c],EAX
MOV EAX,dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x68],EAX
MOV qword ptr [RSP + 0x70],0x0
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],RAX
LAB_0011756b:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RSP,0x78
RET
|
int1 [16] js_os_rename(int8 param_1)
{
int1 auVar1 [16];
int iVar2;
char *__old;
char *__new;
int8 *in_R8;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
__old = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__old == (char *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
__new = (char *)JS_ToCString(param_1,in_R8[2],in_R8[3]);
if (__new == (char *)0x0) {
JS_FreeCString(param_1,__old);
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = rename(__old,__new);
local_30 = js_get_errno((long)iVar2);
JS_FreeCString(param_1,__old);
JS_FreeCString(param_1,__new);
uStack_2c = uStack_c;
local_28 = 0;
}
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
34,969 | js_os_rename | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_rename(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *oldpath, *newpath;
int ret;
oldpath = JS_ToCString(ctx, argv[0]);
if (!oldpath)
return JS_EXCEPTION;
newpath = JS_ToCString(ctx, argv[1]);
if (!newpath) {
JS_FreeCString(ctx, oldpath);
return JS_EXCEPTION;
}
ret = js_get_errno(rename(oldpath, newpath));
JS_FreeCString(ctx, oldpath);
JS_FreeCString(ctx, newpath);
return JS_NewInt32(ctx, ret);
} | O1 | c | js_os_rename:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
xorl %r12d, %r12d
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1ffe3
movl $0x6, %r15d
testq %rax, %rax
je 0x1818a
movq %rax, %r14
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1ffe3
testq %rax, %rax
je 0x1817c
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xe7f0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x1815e
callq 0xe0b0
xorl %ebp, %ebp
subl (%rax), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x202c9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x202c9
movl %ebp, %r12d
xorl %r15d, %r15d
jmp 0x1818a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x202c9
xorl %r12d, %r12d
movq %r12, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_os_rename:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
xor r12d, r12d
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
mov r15d, 6
test rax, rax
jz short loc_1818A
mov r14, rax
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov rdi, rbx
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_1817C
mov r12, rax
mov rdi, r14
mov rsi, rax
call _rename
mov ebp, eax
cmp eax, 0FFFFFFFFh
jnz short loc_1815E
call ___errno_location
xor ebp, ebp
sub ebp, [rax]
loc_1815E:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
mov rdi, rbx
mov rsi, r12
call JS_FreeCString
mov r12d, ebp
xor r15d, r15d
jmp short loc_1818A
loc_1817C:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
xor r12d, r12d
loc_1818A:
mov rax, r12
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_os_rename(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v6; // r12
long long v7; // rax
long long v8; // r14
long long v9; // rax
long long v10; // r12
unsigned int v11; // ebp
v6 = 0LL;
v7 = JS_ToCStringLen2(a1, 0LL, *a5, a5[1], 0LL);
if ( v7 )
{
v8 = v7;
v9 = JS_ToCStringLen2(a1, 0LL, a5[2], a5[3], 0LL);
if ( v9 )
{
v10 = v9;
v11 = rename(v8, v9);
if ( v11 == -1 )
v11 = -*(_DWORD *)__errno_location(v8);
JS_FreeCString(a1, v8);
JS_FreeCString(a1, v10);
return v11;
}
else
{
JS_FreeCString(a1, v8);
return 0LL;
}
}
return v6;
}
| js_os_rename:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
XOR R12D,R12D
XOR ESI,ESI
XOR R8D,R8D
CALL 0x0011ffe3
MOV R15D,0x6
TEST RAX,RAX
JZ 0x0011818a
MOV R14,RAX
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV RDI,RBX
XOR ESI,ESI
XOR R8D,R8D
CALL 0x0011ffe3
TEST RAX,RAX
JZ 0x0011817c
MOV R12,RAX
MOV RDI,R14
MOV RSI,RAX
CALL 0x0010e7f0
MOV EBP,EAX
CMP EAX,-0x1
JNZ 0x0011815e
CALL 0x0010e0b0
XOR EBP,EBP
SUB EBP,dword ptr [RAX]
LAB_0011815e:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001202c9
MOV RDI,RBX
MOV RSI,R12
CALL 0x001202c9
MOV R12D,EBP
XOR R15D,R15D
JMP 0x0011818a
LAB_0011817c:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001202c9
XOR R12D,R12D
LAB_0011818a:
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int js_os_rename(int8 param_1)
{
int iVar1;
char *__old;
char *__new;
int *piVar2;
int8 *in_R8;
iVar1 = 0;
__old = (char *)JS_ToCStringLen2(param_1,0,*in_R8,in_R8[1],0);
if (__old != (char *)0x0) {
__new = (char *)JS_ToCStringLen2(param_1,0,in_R8[2],in_R8[3],0);
if (__new == (char *)0x0) {
JS_FreeCString(param_1,__old);
iVar1 = 0;
}
else {
iVar1 = rename(__old,__new);
if (iVar1 == -1) {
piVar2 = __errno_location();
iVar1 = -*piVar2;
}
JS_FreeCString(param_1,__old);
JS_FreeCString(param_1,__new);
}
}
return iVar1;
}
| |
34,970 | google::protobuf::UninterpretedOption::Clear() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | void UninterpretedOption::Clear() {
// @@protoc_insertion_point(message_clear_start:google.protobuf.UninterpretedOption)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
_impl_.name_.Clear();
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
_impl_.identifier_value_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
_impl_.string_value_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000004u) {
_impl_.aggregate_value_.ClearNonDefaultToEmpty();
}
}
if (cached_has_bits & 0x00000038u) {
::memset(&_impl_.positive_int_value_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&_impl_.double_value_) -
reinterpret_cast<char*>(&_impl_.positive_int_value_)) + sizeof(_impl_.double_value_));
}
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
} | O0 | cpp | google::protobuf::UninterpretedOption::Clear():
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0xdbd80
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0xc9ab7
movl 0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc9a79
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x20, %rdi
callq 0xd4de0
movl 0x1c(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc9a97
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x28, %rdi
callq 0xd4de0
movl 0x1c(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc9ab5
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
addq $0x30, %rdi
callq 0xd4de0
jmp 0xc9ab7
movl 0x1c(%rsp), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0xc9af4
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x10, %rdi
addq $0x38, %rdi
movq %rax, %rdx
addq $0x10, %rdx
addq $0x48, %rdx
addq $0x10, %rax
addq $0x38, %rax
subq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x13200
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x13200
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc9b56
movq 0x8(%rsp), %rdi
callq 0xe0a90
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| _ZN6google8protobuf19UninterpretedOption5ClearEv:
sub rsp, 58h
mov [rsp+58h+var_38], rdi
mov rdi, [rsp+58h+var_38]
mov [rsp+58h+var_48], rdi
mov [rsp+58h+var_3C], 0
add rdi, 10h
add rdi, 8
call _ZN6google8protobuf16RepeatedPtrFieldINS0_28UninterpretedOption_NamePartEE5ClearEv; google::protobuf::RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::Clear(void)
mov rax, [rsp+58h+var_48]
add rax, 10h
mov [rsp+58h+var_18], rax
mov [rsp+58h+var_1C], 0
mov rax, [rsp+58h+var_18]
movsxd rcx, [rsp+58h+var_1C]
mov eax, [rax+rcx*4]
mov [rsp+58h+var_3C], eax
mov eax, [rsp+58h+var_3C]
and eax, 7
cmp eax, 0
jz short loc_C9AB7
mov eax, [rsp+58h+var_3C]
and eax, 1
cmp eax, 0
jz short loc_C9A79
mov rdi, [rsp+58h+var_48]
add rdi, 10h
add rdi, 20h ; ' '; this
call _ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv; google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty(void)
loc_C9A79:
mov eax, [rsp+58h+var_3C]
and eax, 2
cmp eax, 0
jz short loc_C9A97
mov rdi, [rsp+58h+var_48]
add rdi, 10h
add rdi, 28h ; '('; this
call _ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv; google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty(void)
loc_C9A97:
mov eax, [rsp+58h+var_3C]
and eax, 4
cmp eax, 0
jz short loc_C9AB5
mov rdi, [rsp+58h+var_48]
add rdi, 10h
add rdi, 30h ; '0'; this
call _ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv; google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty(void)
loc_C9AB5:
jmp short $+2
loc_C9AB7:
mov eax, [rsp+58h+var_3C]
and eax, 38h
cmp eax, 0
jz short loc_C9AF4
mov rax, [rsp+58h+var_48]
mov rdi, rax
add rdi, 10h
add rdi, 38h ; '8'
mov rdx, rax
add rdx, 10h
add rdx, 48h ; 'H'
add rax, 10h
add rax, 38h ; '8'
sub rdx, rax
add rdx, 8
xor esi, esi
call _memset
loc_C9AF4:
mov rax, [rsp+58h+var_48]
add rax, 10h
mov [rsp+58h+var_10], rax
mov rdi, [rsp+58h+var_10]
xor esi, esi
mov edx, 4
call _memset
mov rax, [rsp+58h+var_48]
add rax, 8
mov [rsp+58h+var_30], rax
mov rax, [rsp+58h+var_30]
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_28], rax
mov rax, [rsp+58h+var_28]
mov [rsp+58h+var_8], rax
mov rax, [rsp+58h+var_8]
mov rax, [rax]
and rax, 1
cmp rax, 0
jz short loc_C9B56
mov rdi, [rsp+58h+var_50]; void *
call _ZN6google8protobuf8internal16InternalMetadata7DoClearINS0_15UnknownFieldSetEEEvv; google::protobuf::internal::InternalMetadata::DoClear<google::protobuf::UnknownFieldSet>(void)
loc_C9B56:
add rsp, 58h
retn
| long long google::protobuf::UninterpretedOption::Clear(google::protobuf::UninterpretedOption *this)
{
long long result; // rax
int v2; // [rsp+1Ch] [rbp-3Ch]
google::protobuf::RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::Clear((char *)this + 24);
v2 = *((_DWORD *)this + 4);
if ( (v2 & 7) != 0 )
{
if ( (v2 & 1) != 0 )
google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty((google::protobuf::UninterpretedOption *)((char *)this + 48));
if ( (v2 & 2) != 0 )
google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty((google::protobuf::UninterpretedOption *)((char *)this + 56));
if ( (v2 & 4) != 0 )
google::protobuf::internal::ArenaStringPtr::ClearNonDefaultToEmpty((google::protobuf::UninterpretedOption *)((char *)this + 64));
}
if ( (v2 & 0x38) != 0 )
memset((char *)this + 72, 0LL, 24LL);
memset((char *)this + 16, 0LL, 4LL);
result = *((_QWORD *)this + 1) & 1LL;
if ( result )
return google::protobuf::internal::InternalMetadata::DoClear<google::protobuf::UnknownFieldSet>((char *)this + 8);
return result;
}
| Clear:
SUB RSP,0x58
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0x1c],0x0
ADD RDI,0x10
ADD RDI,0x8
CALL 0x001dbd80
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x10
MOV qword ptr [RSP + 0x40],RAX
MOV dword ptr [RSP + 0x3c],0x0
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x3c]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x1c]
AND EAX,0x7
CMP EAX,0x0
JZ 0x001c9ab7
MOV EAX,dword ptr [RSP + 0x1c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001c9a79
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
ADD RDI,0x20
CALL 0x001d4de0
LAB_001c9a79:
MOV EAX,dword ptr [RSP + 0x1c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001c9a97
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
ADD RDI,0x28
CALL 0x001d4de0
LAB_001c9a97:
MOV EAX,dword ptr [RSP + 0x1c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001c9ab5
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x10
ADD RDI,0x30
CALL 0x001d4de0
LAB_001c9ab5:
JMP 0x001c9ab7
LAB_001c9ab7:
MOV EAX,dword ptr [RSP + 0x1c]
AND EAX,0x38
CMP EAX,0x0
JZ 0x001c9af4
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,RAX
ADD RDI,0x10
ADD RDI,0x38
MOV RDX,RAX
ADD RDX,0x10
ADD RDX,0x48
ADD RAX,0x10
ADD RAX,0x38
SUB RDX,RAX
ADD RDX,0x8
XOR ESI,ESI
CALL 0x00113200
LAB_001c9af4:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x10
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x48]
XOR ESI,ESI
MOV EDX,0x4
CALL 0x00113200
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x8
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001c9b56
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001e0a90
LAB_001c9b56:
ADD RSP,0x58
RET
|
/* google::protobuf::UninterpretedOption::Clear() */
void __thiscall google::protobuf::UninterpretedOption::Clear(UninterpretedOption *this)
{
uint uVar1;
RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart>::Clear
((RepeatedPtrField<google::protobuf::UninterpretedOption_NamePart> *)(this + 0x18));
uVar1 = *(uint *)(this + 0x10);
if ((uVar1 & 7) != 0) {
if ((uVar1 & 1) != 0) {
internal::ArenaStringPtr::ClearNonDefaultToEmpty((ArenaStringPtr *)(this + 0x30));
}
if ((uVar1 & 2) != 0) {
internal::ArenaStringPtr::ClearNonDefaultToEmpty((ArenaStringPtr *)(this + 0x38));
}
if ((uVar1 & 4) != 0) {
internal::ArenaStringPtr::ClearNonDefaultToEmpty((ArenaStringPtr *)(this + 0x40));
}
}
if ((uVar1 & 0x38) != 0) {
memset(this + 0x48,0,0x18);
}
memset(this + 0x10,0,4);
if ((*(ulong *)(this + 8) & 1) != 0) {
internal::InternalMetadata::DoClear<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8));
}
return;
}
| |
34,971 | postprocess_cpu_params(cpu_params&, cpu_params const*) | monkey531[P]llama/common/common.cpp | void postprocess_cpu_params(cpu_params& cpuparams, const cpu_params* role_model) {
int32_t n_set = 0;
if (cpuparams.n_threads < 0) {
// Assuming everything about cpuparams is invalid
if (role_model != nullptr) {
cpuparams = *role_model;
} else {
cpuparams.n_threads = cpu_get_num_math();
}
}
for (int32_t i = 0; i < GGML_MAX_N_THREADS; i++) {
if (cpuparams.cpumask[i]) {
n_set++;
}
}
if (n_set && n_set < cpuparams.n_threads) {
// Not enough set bits, may experience performance issues.
LOG_WRN("Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n", n_set, cpuparams.n_threads);
}
} | O3 | cpp | postprocess_cpu_params(cpu_params&, cpu_params const*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jns 0x71f9e
testq %rsi, %rsi
je 0x71f97
movl $0x214, %edx # imm = 0x214
movq %rbx, %rdi
callq 0x1a730
jmp 0x71f9e
callq 0x71d8a
movl %eax, (%rbx)
pxor %xmm1, %xmm1
movl $0x4, %eax
pxor %xmm0, %xmm0
movd (%rbx,%rax), %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm2, %xmm0
addq $0x4, %rax
cmpq $0x204, %rax # imm = 0x204
jne 0x71fab
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0x72018
cmpl (%rbx), %ebp
jge 0x72018
leaq 0xbb43b(%rip), %rax # 0x12d428
cmpl $0x0, (%rax)
js 0x72018
callq 0xcc467
movl (%rbx), %r8d
leaq 0x7c9b2(%rip), %rdx # 0xee9b3
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xcc504
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _Z22postprocess_cpu_paramsR10cpu_paramsPKS_:
push rbp
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 0
jns short loc_71F9E
test rsi, rsi
jz short loc_71F97
mov edx, 214h
mov rdi, rbx
call _memcpy
jmp short loc_71F9E
loc_71F97:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov [rbx], eax
loc_71F9E:
pxor xmm1, xmm1
mov eax, 4
pxor xmm0, xmm0
loc_71FAB:
movd xmm2, dword ptr [rbx+rax]
punpcklbw xmm2, xmm1
punpcklwd xmm2, xmm1
paddd xmm0, xmm2
add rax, 4
cmp rax, 204h
jnz short loc_71FAB
pshufd xmm1, xmm0, 0EEh
paddd xmm1, xmm0
pshufd xmm0, xmm1, 55h ; 'U'
paddd xmm0, xmm1
movd ebp, xmm0
test ebp, ebp
jz short loc_72018
cmp ebp, [rbx]
jge short loc_72018
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_72018
call _Z15common_log_mainv; common_log_main(void)
mov r8d, [rbx]
lea rdx, aNotEnoughSetBi; "Not enough set bits in CPU mask (%d) to"...
mov rdi, rax
mov esi, 3
mov ecx, ebp
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_72018:
add rsp, 8
pop rbx
pop rbp
retn
| int * postprocess_cpu_params(int *a1, long long a2)
{
int *result; // rax
__m128i v3; // xmm0
__m128i v4; // xmm1
int v5; // ebp
int v6; // eax
int v7; // r9d
if ( *a1 < 0 )
{
if ( a2 )
memcpy(a1, a2, 532LL);
else
*a1 = cpu_get_num_math();
}
result = (_DWORD *)&byte_4;
v3 = 0LL;
do
v3 = _mm_add_epi32(
v3,
_mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(int *)((char *)result++ + (_QWORD)a1)), (__m128i)0LL),
(__m128i)0LL));
while ( result != &dword_204 );
v4 = _mm_add_epi32(_mm_shuffle_epi32(v3, 238), v3);
v5 = _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v4, 85), v4));
if ( v5 && v5 < *a1 )
{
result = (int *)&common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
return (int *)common_log_add(
v6,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v5,
*a1,
v7);
}
}
return result;
}
| postprocess_cpu_params:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x0
JNS 0x00171f9e
TEST RSI,RSI
JZ 0x00171f97
MOV EDX,0x214
MOV RDI,RBX
CALL 0x0011a730
JMP 0x00171f9e
LAB_00171f97:
CALL 0x00171d8a
MOV dword ptr [RBX],EAX
LAB_00171f9e:
PXOR XMM1,XMM1
MOV EAX,0x4
PXOR XMM0,XMM0
LAB_00171fab:
MOVD XMM2,dword ptr [RBX + RAX*0x1]
PUNPCKLBW XMM2,XMM1
PUNPCKLWD XMM2,XMM1
PADDD XMM0,XMM2
ADD RAX,0x4
CMP RAX,0x204
JNZ 0x00171fab
PSHUFD XMM1,XMM0,0xee
PADDD XMM1,XMM0
PSHUFD XMM0,XMM1,0x55
PADDD XMM0,XMM1
MOVD EBP,XMM0
TEST EBP,EBP
JZ 0x00172018
CMP EBP,dword ptr [RBX]
JGE 0x00172018
LEA RAX,[0x22d428]
CMP dword ptr [RAX],0x0
JS 0x00172018
CALL 0x001cc467
MOV R8D,dword ptr [RBX]
LEA RDX,[0x1ee9b3]
MOV RDI,RAX
MOV ESI,0x3
MOV ECX,EBP
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001cc504
LAB_00172018:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* postprocess_cpu_params(cpu_params&, cpu_params const*) */
void postprocess_cpu_params(cpu_params *param_1,cpu_params *param_2)
{
int1 auVar1 [13];
int1 auVar2 [13];
int1 auVar3 [13];
ulong uVar4;
int1 auVar5 [13];
int4 uVar6;
long lVar7;
int8 uVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (*(int *)param_1 < 0) {
if (param_2 == (cpu_params *)0x0) {
uVar6 = cpu_get_num_math();
*(int4 *)param_1 = uVar6;
}
else {
memcpy(param_1,param_2,0x214);
}
}
lVar7 = 4;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
do {
uVar6 = *(int4 *)(param_1 + lVar7);
uVar4 = (ulong)(ushort)uVar6 & 0xffffffffffff00ff;
auVar1._8_4_ = 0;
auVar1._0_8_ = uVar4;
auVar1[0xc] = (char)((uint)uVar6 >> 0x18);
auVar2[8] = (char)((uint)uVar6 >> 0x10);
auVar2._0_8_ = uVar4;
auVar2[9] = 0;
auVar2._10_3_ = auVar1._10_3_;
auVar5._5_8_ = 0;
auVar5._0_5_ = auVar2._8_5_;
auVar3[4] = (char)((uint)uVar6 >> 8);
auVar3._0_4_ = (int)uVar4;
auVar3[5] = 0;
auVar3._6_7_ = SUB137(auVar5 << 0x40,6);
iVar9 = iVar9 + (int)uVar4;
iVar10 = iVar10 + auVar3._4_4_;
iVar11 = iVar11 + auVar2._8_4_;
iVar12 = iVar12 + (uint)(uint3)(auVar1._10_3_ >> 0x10);
lVar7 = lVar7 + 4;
} while (lVar7 != 0x204);
iVar9 = iVar12 + iVar10 + iVar11 + iVar9;
if (((iVar9 != 0) && (iVar9 < *(int *)param_1)) && (-1 < common_log_verbosity_thold)) {
uVar8 = common_log_main();
common_log_add(uVar8,3,
"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
iVar9,*(int4 *)param_1);
return;
}
return;
}
| |
34,972 | httplib::ClientImpl::create_client_socket(httplib::Error&) const | nickolajgrishuk[P]metricz-cpp/build_O0/_deps/httplib-src/httplib.h | inline socket_t ClientImpl::create_client_socket(Error &error) const {
if (!proxy_host_.empty() && proxy_port_ != -1) {
return detail::create_client_socket(
proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_,
socket_options_, connection_timeout_sec_, connection_timeout_usec_,
read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
write_timeout_usec_, interface_, error);
}
// Check is custom IP specified for host_
std::string ip;
auto it = addr_map_.find(host_);
if (it != addr_map_.end()) ip = it->second;
return detail::create_client_socket(
host_, ip, port_, address_family_, tcp_nodelay_, socket_options_,
connection_timeout_sec_, connection_timeout_usec_, read_timeout_sec_,
read_timeout_usec_, write_timeout_sec_, write_timeout_usec_, interface_,
error);
} | O0 | c | httplib::ClientImpl::create_client_socket(httplib::Error&) const:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
addq $0x290, %rdi # imm = 0x290
callq 0xa380
testb $0x1, %al
jne 0x684c9
movq -0xe0(%rbp), %rax
cmpl $-0x1, 0x2b0(%rax)
je 0x684c9
movq -0xe0(%rbp), %rax
addq $0x290, %rax # imm = 0x290
movq %rax, -0xf8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa450
movq -0xe0(%rbp), %rsi
movl 0x2b0(%rsi), %eax
movl %eax, -0xec(%rbp)
movl 0x23c(%rsi), %eax
movl %eax, -0xe8(%rbp)
movb 0x240(%rsi), %al
movb %al, -0xe1(%rbp)
addq $0x248, %rsi # imm = 0x248
leaq -0x78(%rbp), %rdi
callq 0x35cb0
jmp 0x683d7
movl -0xe8(%rbp), %ecx
movl -0xec(%rbp), %edx
movq -0xf8(%rbp), %rdi
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %r15
movq 0x168(%r15), %r8
movq 0x170(%r15), %r9
movq 0x178(%r15), %r10
movq 0x180(%r15), %r11
movq 0x188(%r15), %rbx
movq 0x190(%r15), %r14
addq $0x270, %r15 # imm = 0x270
movq -0x38(%rbp), %r12
movq %rsp, %rsi
movq %rsi, -0x108(%rbp)
movq %r12, 0x38(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x28(%rsi)
movq %rbx, 0x20(%rsi)
movq %r11, 0x18(%rsi)
movq %r10, 0x10(%rsi)
movq %r9, 0x8(%rsi)
movq %r8, (%rsi)
movzbl %al, %r8d
andl $0x1, %r8d
leaq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %r9
callq 0x686d0
movl %eax, -0xfc(%rbp)
jmp 0x68472
movl -0xfc(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xba30
leaq -0x58(%rbp), %rdi
callq 0xaec8
jmp 0x686a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x684bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xba30
leaq -0x58(%rbp), %rdi
callq 0xaec8
jmp 0x686bb
leaq -0xa8(%rbp), %rdi
callq 0xa450
movq -0xe0(%rbp), %rsi
movq %rsi, %rdi
addq $0xc8, %rdi
addq $0x8, %rsi
callq 0x5f8f0
movq %rax, -0x110(%rbp)
jmp 0x684f8
movq -0xe0(%rbp), %rdi
movq -0x110(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0xc8, %rdi
callq 0x5f920
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x34b20
testb $0x1, %al
jne 0x68539
jmp 0x68570
leaq -0xb0(%rbp), %rdi
callq 0x43d30
movq %rax, %rsi
addq $0x20, %rsi
leaq -0xa8(%rbp), %rdi
callq 0xae20
jmp 0x6855a
jmp 0x68570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x6869a
movq -0xe0(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0x128(%rbp)
movl 0x28(%rsi), %eax
movl %eax, -0x11c(%rbp)
movl 0x23c(%rsi), %eax
movl %eax, -0x118(%rbp)
movb 0x240(%rsi), %al
movb %al, -0x111(%rbp)
addq $0x248, %rsi # imm = 0x248
leaq -0xd8(%rbp), %rdi
callq 0x35cb0
jmp 0x685bb
movl -0x118(%rbp), %ecx
movl -0x11c(%rbp), %edx
movq -0x128(%rbp), %rdi
movb -0x111(%rbp), %al
movq -0xe0(%rbp), %r15
movq 0x168(%r15), %r8
movq 0x170(%r15), %r9
movq 0x178(%r15), %r10
movq 0x180(%r15), %r11
movq 0x188(%r15), %rbx
movq 0x190(%r15), %r14
addq $0x270, %r15 # imm = 0x270
movq -0x38(%rbp), %r12
movq %rsp, %rsi
movq %rsi, -0x138(%rbp)
movq %r12, 0x38(%rsi)
movq %r15, 0x30(%rsi)
movq %r14, 0x28(%rsi)
movq %rbx, 0x20(%rsi)
movq %r11, 0x18(%rsi)
movq %r10, 0x10(%rsi)
movq %r9, 0x8(%rsi)
movq %r8, (%rsi)
movzbl %al, %r8d
andl $0x1, %r8d
leaq -0xa8(%rbp), %rsi
leaq -0xd8(%rbp), %r9
callq 0x686d0
movl %eax, -0x12c(%rbp)
jmp 0x6865c
movl -0x12c(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xba30
leaq -0xa8(%rbp), %rdi
callq 0xaec8
jmp 0x686a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xba30
leaq -0xa8(%rbp), %rdi
callq 0xaec8
jmp 0x686bb
movl -0x24(%rbp), %eax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xa850
nopw %cs:(%rax,%rax)
nop
| _ZNK7httplib10ClientImpl20create_client_socketERNS_5ErrorE:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 160h
mov [rbp+var_30], rdi
mov [rbp+var_38], rsi
mov rdi, [rbp+var_30]
mov [rbp+var_E0], rdi
add rdi, 290h
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz loc_684C9
mov rax, [rbp+var_E0]
cmp dword ptr [rax+2B0h], 0FFFFFFFFh
jz loc_684C9
mov rax, [rbp+var_E0]
add rax, 290h
mov [rbp+var_F8], rax
lea rdi, [rbp+var_58]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rsi, [rbp+var_E0]
mov eax, [rsi+2B0h]
mov [rbp+var_EC], eax
mov eax, [rsi+23Ch]
mov [rbp+var_E8], eax
mov al, [rsi+240h]
mov [rbp+var_E1], al
add rsi, 248h
lea rdi, [rbp+var_78]
call _ZNSt8functionIFviEEC2ERKS1_; std::function<void ()(int)>::function(std::function<void ()(int)> const&)
jmp short $+2
loc_683D7:
mov ecx, [rbp+var_E8]
mov edx, [rbp+var_EC]
mov rdi, [rbp+var_F8]
mov al, [rbp+var_E1]
mov r15, [rbp+var_E0]
mov r8, [r15+168h]
mov r9, [r15+170h]
mov r10, [r15+178h]
mov r11, [r15+180h]
mov rbx, [r15+188h]
mov r14, [r15+190h]
add r15, 270h
mov r12, [rbp+var_38]
mov rsi, rsp
mov [rbp+var_108], rsi
mov [rsi+38h], r12
mov [rsi+30h], r15
mov [rsi+28h], r14
mov [rsi+20h], rbx
mov [rsi+18h], r11
mov [rsi+10h], r10
mov [rsi+8], r9
mov [rsi], r8
movzx r8d, al
and r8d, 1
lea rsi, [rbp+var_58]
lea r9, [rbp+var_78]
call _ZN7httplib6detail20create_client_socketERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_iibSt8functionIFviEEllllllS8_RNS_5ErrorE; httplib::detail::create_client_socket(std::string const&,std::string const&,int,int,bool,std::function<void ()(int)>,long,long,long,long,long,long,std::string const&,httplib::Error &)
mov [rbp+var_FC], eax
jmp short $+2
loc_68472:
mov eax, [rbp+var_FC]
mov [rbp+var_24], eax
lea rdi, [rbp+var_78]
call _ZNSt8functionIFviEED2Ev; std::function<void ()(int)>::~function()
lea rdi, [rbp+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_686A8
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
jmp short loc_684BB
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
lea rdi, [rbp+var_78]
call _ZNSt8functionIFviEED2Ev; std::function<void ()(int)>::~function()
loc_684BB:
lea rdi, [rbp+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_686BB
loc_684C9:
lea rdi, [rbp+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rsi, [rbp+var_E0]
mov rdi, rsi
add rdi, 0C8h
add rsi, 8
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE4findERS9_; std::map<std::string,std::string>::find(std::string const&)
mov [rbp+var_110], rax
jmp short $+2
loc_684F8:
mov rdi, [rbp+var_E0]
mov rax, [rbp+var_110]
mov [rbp+var_B0], rax
add rdi, 0C8h
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_St4lessIS5_ESaISt4pairIKS5_S5_EEE3endEv; std::map<std::string,std::string>::end(void)
mov [rbp+var_B8], rax
lea rdi, [rbp+var_B0]
lea rsi, [rbp+var_B8]
call _ZStneRKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EESB_; std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>> const&,std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>> const&)
test al, 1
jnz short loc_68539
jmp short loc_68570
loc_68539:
lea rdi, [rbp+var_B0]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_EEptEv; std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>::operator->(void)
mov rsi, rax
add rsi, 20h ; ' '
lea rdi, [rbp+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_6855A:
jmp short loc_68570
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
jmp loc_6869A
loc_68570:
mov rsi, [rbp+var_E0]
mov rax, rsi
add rax, 8
mov [rbp+var_128], rax
mov eax, [rsi+28h]
mov [rbp+var_11C], eax
mov eax, [rsi+23Ch]
mov [rbp+var_118], eax
mov al, [rsi+240h]
mov [rbp+var_111], al
add rsi, 248h
lea rdi, [rbp+var_D8]
call _ZNSt8functionIFviEEC2ERKS1_; std::function<void ()(int)>::function(std::function<void ()(int)> const&)
jmp short $+2
loc_685BB:
mov ecx, [rbp+var_118]
mov edx, [rbp+var_11C]
mov rdi, [rbp+var_128]
mov al, [rbp+var_111]
mov r15, [rbp+var_E0]
mov r8, [r15+168h]
mov r9, [r15+170h]
mov r10, [r15+178h]
mov r11, [r15+180h]
mov rbx, [r15+188h]
mov r14, [r15+190h]
add r15, 270h
mov r12, [rbp+var_38]
mov rsi, rsp
mov [rbp+var_138], rsi
mov [rsi+38h], r12
mov [rsi+30h], r15
mov [rsi+28h], r14
mov [rsi+20h], rbx
mov [rsi+18h], r11
mov [rsi+10h], r10
mov [rsi+8], r9
mov [rsi], r8
movzx r8d, al
and r8d, 1
lea rsi, [rbp+var_A8]
lea r9, [rbp+var_D8]
call _ZN7httplib6detail20create_client_socketERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_iibSt8functionIFviEEllllllS8_RNS_5ErrorE; httplib::detail::create_client_socket(std::string const&,std::string const&,int,int,bool,std::function<void ()(int)>,long,long,long,long,long,long,std::string const&,httplib::Error &)
mov [rbp+var_12C], eax
jmp short $+2
loc_6865C:
mov eax, [rbp+var_12C]
mov [rbp+var_24], eax
lea rdi, [rbp+var_D8]
call _ZNSt8functionIFviEED2Ev; std::function<void ()(int)>::~function()
lea rdi, [rbp+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_686A8
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
lea rdi, [rbp+var_D8]
call _ZNSt8functionIFviEED2Ev; std::function<void ()(int)>::~function()
loc_6869A:
lea rdi, [rbp+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_686BB
loc_686A8:
mov eax, [rbp+var_24]
add rsp, 160h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_686BB:
mov rdi, [rbp+var_80]
call __Unwind_Resume
| long long httplib::ClientImpl::create_client_socket(long long a1, long long a2)
{
long long v2; // r8
long long v3; // r9
long long v4; // r10
long long v5; // r11
long long v6; // rbx
long long v7; // r14
long long v8; // rax
long long v9; // r8
long long v10; // r9
long long v11; // r10
long long v12; // r11
long long v13; // rbx
long long v14; // r14
_QWORD v16[10]; // [rsp+0h] [rbp-180h] BYREF
unsigned int client_socket; // [rsp+54h] [rbp-12Ch]
long long v18; // [rsp+58h] [rbp-128h]
int v19; // [rsp+64h] [rbp-11Ch]
int v20; // [rsp+68h] [rbp-118h]
char v21; // [rsp+6Fh] [rbp-111h]
long long v22; // [rsp+70h] [rbp-110h]
_QWORD *v23; // [rsp+78h] [rbp-108h]
unsigned int v24; // [rsp+84h] [rbp-FCh]
long long v25; // [rsp+88h] [rbp-F8h]
int v26; // [rsp+94h] [rbp-ECh]
int v27; // [rsp+98h] [rbp-E8h]
char v28; // [rsp+9Fh] [rbp-E1h]
long long v29; // [rsp+A0h] [rbp-E0h]
_BYTE v30[32]; // [rsp+A8h] [rbp-D8h] BYREF
long long v31; // [rsp+C8h] [rbp-B8h] BYREF
long long v32; // [rsp+D0h] [rbp-B0h] BYREF
_BYTE v33[36]; // [rsp+D8h] [rbp-A8h] BYREF
_BYTE v34[32]; // [rsp+108h] [rbp-78h] BYREF
_BYTE v35[32]; // [rsp+128h] [rbp-58h] BYREF
long long v36; // [rsp+148h] [rbp-38h]
long long v37; // [rsp+150h] [rbp-30h]
unsigned int v38; // [rsp+15Ch] [rbp-24h]
v37 = a1;
v36 = a2;
v29 = a1;
if ( (std::string::empty(a1 + 656) & 1) != 0 || *(_DWORD *)(v29 + 688) == -1 )
{
std::string::basic_string(v33);
v22 = std::map<std::string,std::string>::find(v29 + 200, v29 + 8);
v32 = v22;
v31 = std::map<std::string,std::string>::end(v29 + 200);
if ( std::operator!=(&v32, &v31) )
{
v8 = std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>::operator->(&v32);
std::string::operator=(v33, v8 + 32);
}
v18 = v29 + 8;
v19 = *(_DWORD *)(v29 + 40);
v20 = *(_DWORD *)(v29 + 572);
v21 = *(_BYTE *)(v29 + 576);
std::function<void ()(int)>::function((std::_Function_base *)v30, v29 + 584);
v9 = *(_QWORD *)(v29 + 360);
v10 = *(_QWORD *)(v29 + 368);
v11 = *(_QWORD *)(v29 + 376);
v12 = *(_QWORD *)(v29 + 384);
v13 = *(_QWORD *)(v29 + 392);
v14 = *(_QWORD *)(v29 + 400);
v16[9] = v16;
client_socket = httplib::detail::create_client_socket(
(int)v29 + 8,
(unsigned int)v33,
v19,
v20,
v21 & 1,
(unsigned int)v30,
v9,
v10,
v11,
v12,
v13,
v14,
v29 + 624,
v36);
v38 = client_socket;
std::function<void ()(int)>::~function((std::_Function_base *)v30);
std::string::~string(v33);
}
else
{
v25 = v29 + 656;
std::string::basic_string(v35);
v26 = *(_DWORD *)(v29 + 688);
v27 = *(_DWORD *)(v29 + 572);
v28 = *(_BYTE *)(v29 + 576);
std::function<void ()(int)>::function((std::_Function_base *)v34, v29 + 584);
v2 = *(_QWORD *)(v29 + 360);
v3 = *(_QWORD *)(v29 + 368);
v4 = *(_QWORD *)(v29 + 376);
v5 = *(_QWORD *)(v29 + 384);
v6 = *(_QWORD *)(v29 + 392);
v7 = *(_QWORD *)(v29 + 400);
v23 = v16;
v24 = httplib::detail::create_client_socket(
(int)v29 + 656,
(unsigned int)v35,
v26,
v27,
v28 & 1,
(unsigned int)v34,
v2,
v3,
v4,
v5,
v6,
v7,
v29 + 624,
v36);
v38 = v24;
std::function<void ()(int)>::~function((std::_Function_base *)v34);
std::string::~string(v35);
}
return v38;
}
| create_client_socket:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x160
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RSI
MOV RDI,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0xe0],RDI
ADD RDI,0x290
CALL 0x0010a380
TEST AL,0x1
JNZ 0x001684c9
MOV RAX,qword ptr [RBP + -0xe0]
CMP dword ptr [RAX + 0x2b0],-0x1
JZ 0x001684c9
MOV RAX,qword ptr [RBP + -0xe0]
ADD RAX,0x290
MOV qword ptr [RBP + -0xf8],RAX
LEA RDI,[RBP + -0x58]
CALL 0x0010a450
MOV RSI,qword ptr [RBP + -0xe0]
MOV EAX,dword ptr [RSI + 0x2b0]
MOV dword ptr [RBP + -0xec],EAX
MOV EAX,dword ptr [RSI + 0x23c]
MOV dword ptr [RBP + -0xe8],EAX
MOV AL,byte ptr [RSI + 0x240]
MOV byte ptr [RBP + -0xe1],AL
ADD RSI,0x248
LAB_001683cc:
LEA RDI,[RBP + -0x78]
CALL 0x00135cb0
JMP 0x001683d7
LAB_001683d7:
MOV ECX,dword ptr [RBP + -0xe8]
MOV EDX,dword ptr [RBP + -0xec]
MOV RDI,qword ptr [RBP + -0xf8]
MOV AL,byte ptr [RBP + -0xe1]
MOV R15,qword ptr [RBP + -0xe0]
MOV R8,qword ptr [R15 + 0x168]
MOV R9,qword ptr [R15 + 0x170]
MOV R10,qword ptr [R15 + 0x178]
MOV R11,qword ptr [R15 + 0x180]
MOV RBX,qword ptr [R15 + 0x188]
MOV R14,qword ptr [R15 + 0x190]
ADD R15,0x270
MOV R12,qword ptr [RBP + -0x38]
LAB_0016842c:
MOV RSI,RSP
MOV qword ptr [RBP + -0x108],RSI
MOV qword ptr [RSI + 0x38],R12
MOV qword ptr [RSI + 0x30],R15
MOV qword ptr [RSI + 0x28],R14
MOV qword ptr [RSI + 0x20],RBX
MOV qword ptr [RSI + 0x18],R11
MOV qword ptr [RSI + 0x10],R10
MOV qword ptr [RSI + 0x8],R9
MOV qword ptr [RSI],R8
MOVZX R8D,AL
AND R8D,0x1
LEA RSI,[RBP + -0x58]
LEA R9,[RBP + -0x78]
CALL 0x001686d0
MOV dword ptr [RBP + -0xfc],EAX
JMP 0x00168472
LAB_00168472:
MOV EAX,dword ptr [RBP + -0xfc]
MOV dword ptr [RBP + -0x24],EAX
LEA RDI,[RBP + -0x78]
CALL 0x0010ba30
LEA RDI,[RBP + -0x58]
CALL 0x0010aec8
JMP 0x001686a8
LAB_001684c9:
LEA RDI,[RBP + -0xa8]
CALL 0x0010a450
MOV RSI,qword ptr [RBP + -0xe0]
MOV RDI,RSI
ADD RDI,0xc8
ADD RSI,0x8
LAB_001684ea:
CALL 0x0015f8f0
MOV qword ptr [RBP + -0x110],RAX
JMP 0x001684f8
LAB_001684f8:
MOV RDI,qword ptr [RBP + -0xe0]
MOV RAX,qword ptr [RBP + -0x110]
MOV qword ptr [RBP + -0xb0],RAX
ADD RDI,0xc8
CALL 0x0015f920
MOV qword ptr [RBP + -0xb8],RAX
LEA RDI,[RBP + -0xb0]
LEA RSI,[RBP + -0xb8]
CALL 0x00134b20
TEST AL,0x1
JNZ 0x00168539
JMP 0x00168570
LAB_00168539:
LEA RDI,[RBP + -0xb0]
CALL 0x00143d30
MOV RSI,RAX
ADD RSI,0x20
LEA RDI,[RBP + -0xa8]
CALL 0x0010ae20
JMP 0x0016855a
LAB_0016855a:
JMP 0x00168570
LAB_00168570:
MOV RSI,qword ptr [RBP + -0xe0]
MOV RAX,RSI
ADD RAX,0x8
MOV qword ptr [RBP + -0x128],RAX
MOV EAX,dword ptr [RSI + 0x28]
MOV dword ptr [RBP + -0x11c],EAX
MOV EAX,dword ptr [RSI + 0x23c]
MOV dword ptr [RBP + -0x118],EAX
MOV AL,byte ptr [RSI + 0x240]
MOV byte ptr [RBP + -0x111],AL
ADD RSI,0x248
LEA RDI,[RBP + -0xd8]
CALL 0x00135cb0
JMP 0x001685bb
LAB_001685bb:
MOV ECX,dword ptr [RBP + -0x118]
MOV EDX,dword ptr [RBP + -0x11c]
MOV RDI,qword ptr [RBP + -0x128]
MOV AL,byte ptr [RBP + -0x111]
MOV R15,qword ptr [RBP + -0xe0]
MOV R8,qword ptr [R15 + 0x168]
MOV R9,qword ptr [R15 + 0x170]
MOV R10,qword ptr [R15 + 0x178]
MOV R11,qword ptr [R15 + 0x180]
MOV RBX,qword ptr [R15 + 0x188]
MOV R14,qword ptr [R15 + 0x190]
ADD R15,0x270
MOV R12,qword ptr [RBP + -0x38]
LAB_00168610:
MOV RSI,RSP
MOV qword ptr [RBP + -0x138],RSI
MOV qword ptr [RSI + 0x38],R12
MOV qword ptr [RSI + 0x30],R15
MOV qword ptr [RSI + 0x28],R14
MOV qword ptr [RSI + 0x20],RBX
MOV qword ptr [RSI + 0x18],R11
MOV qword ptr [RSI + 0x10],R10
MOV qword ptr [RSI + 0x8],R9
MOV qword ptr [RSI],R8
MOVZX R8D,AL
AND R8D,0x1
LEA RSI,[RBP + -0xa8]
LEA R9,[RBP + -0xd8]
CALL 0x001686d0
LAB_00168654:
MOV dword ptr [RBP + -0x12c],EAX
JMP 0x0016865c
LAB_0016865c:
MOV EAX,dword ptr [RBP + -0x12c]
MOV dword ptr [RBP + -0x24],EAX
LEA RDI,[RBP + -0xd8]
CALL 0x0010ba30
LEA RDI,[RBP + -0xa8]
CALL 0x0010aec8
JMP 0x001686a8
LAB_001686a8:
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x160
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* httplib::ClientImpl::create_client_socket(httplib::Error&) const */
int4 __thiscall httplib::ClientImpl::create_client_socket(ClientImpl *this,Error *param_1)
{
ulong uVar1;
long lVar2;
int8 local_188;
int8 local_180;
int8 local_178;
int8 local_170;
int8 local_168;
int8 local_160;
ClientImpl *local_158;
Error *local_150;
int1 *local_140;
int4 local_134;
ClientImpl *local_130;
int4 local_124;
int4 local_120;
ClientImpl local_119;
int8 local_118;
int1 *local_110;
int4 local_104;
ClientImpl *local_100;
int4 local_f4;
int4 local_f0;
ClientImpl local_e9;
ClientImpl *local_e8;
function<void(int)> local_e0 [32];
int8 local_c0;
int8 local_b8;
string local_b0 [48];
function<void(int)> local_80 [32];
string local_60 [32];
Error *local_40;
ClientImpl *local_38;
int4 local_2c;
local_e8 = this;
local_40 = param_1;
local_38 = this;
uVar1 = std::__cxx11::string::empty();
if (((uVar1 & 1) == 0) && (*(int *)(local_e8 + 0x2b0) != -1)) {
local_100 = local_e8 + 0x290;
std::__cxx11::string::string(local_60);
local_f4 = *(int4 *)(local_e8 + 0x2b0);
local_f0 = *(int4 *)(local_e8 + 0x23c);
local_e9 = local_e8[0x240];
/* try { // try from 001683cc to 001683d4 has its CatchHandler @ 00168492 */
std::function<void(int)>::function(local_80,(function *)(local_e8 + 0x248));
local_188 = *(int8 *)(local_e8 + 0x168);
local_180 = *(int8 *)(local_e8 + 0x170);
local_178 = *(int8 *)(local_e8 + 0x178);
local_170 = *(int8 *)(local_e8 + 0x180);
local_168 = *(int8 *)(local_e8 + 0x188);
local_160 = *(int8 *)(local_e8 + 400);
local_158 = local_e8 + 0x270;
/* try { // try from 0016842c to 00168469 has its CatchHandler @ 001684a3 */
local_150 = local_40;
local_110 = (int1 *)&local_188;
local_104 = detail::create_client_socket
(local_100,local_60,local_f4,local_f0,(byte)local_e9 & 1,local_80);
local_2c = local_104;
std::function<void(int)>::~function(local_80);
std::__cxx11::string::~string(local_60);
}
else {
std::__cxx11::string::string(local_b0);
/* try { // try from 001684ea to 001685b8 has its CatchHandler @ 0016855c */
local_118 = std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(local_e8 + 200),(string *)(local_e8 + 8));
local_b8 = local_118;
local_c0 = std::
map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::end((map<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(local_e8 + 200));
uVar1 = std::operator!=((_Rb_tree_const_iterator *)&local_b8,
(_Rb_tree_const_iterator *)&local_c0);
if ((uVar1 & 1) != 0) {
lVar2 = std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>::
operator->((_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>
*)&local_b8);
std::__cxx11::string::operator=(local_b0,(string *)(lVar2 + 0x20));
}
local_130 = local_e8 + 8;
local_124 = *(int4 *)(local_e8 + 0x28);
local_120 = *(int4 *)(local_e8 + 0x23c);
local_119 = local_e8[0x240];
std::function<void(int)>::function(local_e0,(function *)(local_e8 + 0x248));
local_188 = *(int8 *)(local_e8 + 0x168);
local_180 = *(int8 *)(local_e8 + 0x170);
local_178 = *(int8 *)(local_e8 + 0x178);
local_170 = *(int8 *)(local_e8 + 0x180);
local_168 = *(int8 *)(local_e8 + 0x188);
local_160 = *(int8 *)(local_e8 + 400);
local_158 = local_e8 + 0x270;
/* try { // try from 00168610 to 00168653 has its CatchHandler @ 0016867f */
local_150 = local_40;
local_140 = (int1 *)&local_188;
local_134 = detail::create_client_socket
(local_130,local_b0,local_124,local_120,(byte)local_119 & 1,local_e0);
local_2c = local_134;
std::function<void(int)>::~function(local_e0);
std::__cxx11::string::~string(local_b0);
}
return local_2c;
}
| |
34,973 | my_numchars_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_numchars_utf16(CHARSET_INFO *cs,
const char *b, const char *e)
{
size_t nchars= 0;
for ( ; ; nchars++)
{
size_t charlen= my_ismbchar(cs, b, e);
if (!charlen)
break;
b+= charlen;
}
return nchars;
} | O0 | c | my_numchars_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6b520
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x67dec
jmp 0x67e06
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x67dcc
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| my_numchars_utf16:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], 0
loc_67DCC:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_1
mov eax, eax
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_67DEC
jmp short loc_67E06
loc_67DEC:
mov rax, [rbp+var_28]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_67DCC
loc_67E06:
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long my_numchars_utf16(long long a1, long long a2, long long a3)
{
unsigned int v3; // eax
long long i; // [rsp+10h] [rbp-20h]
for ( i = 0LL; ; ++i )
{
v3 = my_ismbchar_1(a1, a2, a3);
if ( !v3 )
break;
a2 += v3;
}
return i;
}
| my_numchars_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],0x0
LAB_00167dcc:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0016b520
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00167dec
JMP 0x00167e06
LAB_00167dec:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00167dcc
LAB_00167e06:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
long my_numchars_utf16(int8 param_1,long param_2,int8 param_3)
{
uint uVar1;
int8 local_28;
int8 local_18;
local_28 = 0;
local_18 = param_2;
while( true ) {
uVar1 = my_ismbchar(param_1,local_18,param_3);
if ((ulong)uVar1 == 0) break;
local_18 = (ulong)uVar1 + local_18;
local_28 = local_28 + 1;
}
return local_28;
}
| |
34,974 | my_hash_sort_utf8mb4 | eloqsql/strings/ctype-utf8.c | static void
my_hash_sort_utf8mb4(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb4_nopad(cs, s, e - s, nr1, nr2);
} | O3 | c | my_hash_sort_utf8mb4:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0xcf4e3
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0xcf4e3
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0xcf508
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0xcf4cb
jmp 0xcf4e6
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0xcf502
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0xcf4ec
popq %rbp
jmp 0xcf78c
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0xcf4e6
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0xcf4e6
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0xcf51f
jmp 0xcf4e6
| my_hash_sort_utf8mb4:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_CF4E3
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_CF4E3
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_CF4CB:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_CF508
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_CF4CB
jmp short loc_CF4E6
loc_CF4E3:
mov rax, r10
loc_CF4E6:
mov r9, rax
sub r9, rsi
loc_CF4EC:
mov rdx, r9
cmp rax, rsi
jbe short loc_CF502
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_CF4EC
loc_CF502:
pop rbp
jmp my_hash_sort_utf8mb4_nopad
loc_CF508:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_CF4E6
mov r9, rax
loc_CF51F:
mov rax, r9
cmp r9, rdx
jbe short loc_CF4E6
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_CF51F
jmp short loc_CF4E6
| long long my_hash_sort_utf8mb4(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb4_nopad(a1, a2, v11, a4, a5, v10);
}
| my_hash_sort_utf8mb4:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001cf4e3
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x001cf4e3
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001cf4cb:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x001cf508
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x001cf4cb
JMP 0x001cf4e6
LAB_001cf4e3:
MOV RAX,R10
LAB_001cf4e6:
MOV R9,RAX
SUB R9,RSI
LAB_001cf4ec:
MOV RDX,R9
CMP RAX,RSI
JBE 0x001cf502
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x001cf4ec
LAB_001cf502:
POP RBP
JMP 0x001cf78c
LAB_001cf508:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x001cf4e6
MOV R9,RAX
LAB_001cf51f:
MOV RAX,R9
CMP R9,RDX
JBE 0x001cf4e6
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x001cf51f
JMP 0x001cf4e6
|
void my_hash_sort_utf8mb4(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_001cf51f;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_001cf4ec;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_001cf51f:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_001cf4ec:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb4_nopad();
return;
}
| |
34,975 | minja::Parser::Parser(std::shared_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, minja::Options const&) | monkey531[P]llama/common/minja.hpp | Parser(const std::shared_ptr<std::string>& template_str, const Options & options) : template_str(template_str), options(options) {
if (!template_str) throw std::runtime_error("Template string is null");
start = it = this->template_str->begin();
end = this->template_str->end();
} | O3 | cpp | minja::Parser::Parser(std::shared_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, minja::Options const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x836c0
movq 0xac8c6(%rip), %rcx # 0x12ff78
cmpb $0x0, (%rcx)
je 0x836bc
incl 0x8(%rax)
jmp 0x836c0
lock
incl 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movb 0x2(%rdx), %al
movb %al, 0x2a(%rbx)
movzwl (%rdx), %eax
movw %ax, 0x28(%rbx)
cmpq $0x0, (%rsi)
je 0x83701
movq (%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rbx)
movq %rcx, 0x10(%rbx)
movq (%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1b4d0
movq %rax, %r15
leaq 0x6f4d3(%rip), %rsi # 0xf2be8
movq %rax, %rdi
callq 0x1b370
movq 0xac8c4(%rip), %rsi # 0x12ffe8
movq 0xac825(%rip), %rdx # 0x12ff50
movq %r15, %rdi
callq 0x1c1c0
movq %rax, %r14
jmp 0x83743
movq %rax, %r14
movq %r15, %rdi
callq 0x1b760
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x83751
callq 0x7140a
movq %r14, %rdi
callq 0x1c250
nop
| _ZN5minja6ParserC2ERKSt10shared_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERKNS_7OptionsE:
push r15
push r14
push rbx
mov rbx, rdi
mov rax, [rsi]
mov [rdi], rax
mov rax, [rsi+8]
mov [rdi+8], rax
test rax, rax
jz short loc_836C0
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_836BC
inc dword ptr [rax+8]
jmp short loc_836C0
loc_836BC:
lock inc dword ptr [rax+8]
loc_836C0:
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
mov qword ptr [rbx+20h], 0
mov al, [rdx+2]
mov [rbx+2Ah], al
movzx eax, word ptr [rdx]
mov [rbx+28h], ax
cmp qword ptr [rsi], 0
jz short loc_83701
mov rax, [rbx]
mov rcx, [rax]
mov [rbx+20h], rcx
mov [rbx+10h], rcx
mov rcx, [rax]
add rcx, [rax+8]
mov [rbx+18h], rcx
pop rbx
pop r14
pop r15
retn
loc_83701:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aTemplateString; "Template string is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r14, rax
jmp short loc_83743
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
loc_83743:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_83751
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_83751:
mov rdi, r14
call __Unwind_Resume
| long long * minja::Parser::Parser(long long **a1, long long **a2, long long a3)
{
long long *v3; // rax
long long *result; // rax
long long *v5; // rcx
std::runtime_error *exception; // r15
*a1 = *a2;
v3 = a2[1];
a1[1] = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v3 + 2);
else
_InterlockedIncrement((volatile signed __int32 *)v3 + 2);
}
*((_OWORD *)a1 + 1) = 0LL;
a1[4] = 0LL;
*((_BYTE *)a1 + 42) = *(_BYTE *)(a3 + 2);
*((_WORD *)a1 + 20) = *(_WORD *)a3;
if ( !*a2 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Template string is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
result = *a1;
v5 = (long long *)**a1;
a1[4] = v5;
a1[2] = v5;
a1[3] = (long long *)(result[1] + *result);
return result;
}
| Parser:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x8],RAX
TEST RAX,RAX
JZ 0x001836c0
MOV RCX,qword ptr [0x0022ff78]
CMP byte ptr [RCX],0x0
JZ 0x001836bc
INC dword ptr [RAX + 0x8]
JMP 0x001836c0
LAB_001836bc:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001836c0:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV qword ptr [RBX + 0x20],0x0
MOV AL,byte ptr [RDX + 0x2]
MOV byte ptr [RBX + 0x2a],AL
MOVZX EAX,word ptr [RDX]
MOV word ptr [RBX + 0x28],AX
CMP qword ptr [RSI],0x0
JZ 0x00183701
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX + 0x20],RCX
MOV qword ptr [RBX + 0x10],RCX
MOV RCX,qword ptr [RAX]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x18],RCX
POP RBX
POP R14
POP R15
RET
LAB_00183701:
MOV EDI,0x10
CALL 0x0011b4d0
MOV R15,RAX
LAB_0018370e:
LEA RSI,[0x1f2be8]
MOV RDI,RAX
CALL 0x0011b370
LAB_0018371d:
MOV RSI,qword ptr [0x0022ffe8]
MOV RDX,qword ptr [0x0022ff50]
MOV RDI,R15
CALL 0x0011c1c0
|
/* minja::Parser::Parser(std::shared_ptr<std::__cxx11::string > const&, minja::Options const&) */
void __thiscall minja::Parser::Parser(Parser *this,shared_ptr *param_1,Options *param_2)
{
long lVar1;
long *plVar2;
runtime_error *this_00;
*(int8 *)this = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 8) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022ff78 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(Options *)(this + 0x2a) = param_2[2];
*(int2 *)(this + 0x28) = *(int2 *)param_2;
if (*(long *)param_1 != 0) {
plVar2 = *(long **)this;
lVar1 = *plVar2;
*(long *)(this + 0x20) = lVar1;
*(long *)(this + 0x10) = lVar1;
*(long *)(this + 0x18) = *plVar2 + plVar2[1];
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018370e to 0018371c has its CatchHandler @ 00183738 */
std::runtime_error::runtime_error(this_00,"Template string is null");
/* try { // try from 0018371d to 00183732 has its CatchHandler @ 00183733 */
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022ffe8,PTR__runtime_error_0022ff50);
}
| |
34,976 | get_charset_number_internal | eloqsql/mysys/charset.c | static uint
get_charset_number_internal(const char *charset_name, uint cs_flags)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if ( cs[0] && cs[0]->cs_name.str && (cs[0]->state & cs_flags) &&
!my_strcasecmp(&my_charset_latin1, cs[0]->cs_name.str, charset_name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_charset_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x35c71a(%rip), %rax # 0x386670
movq %rax, -0x20(%rbp)
leaq 0x35c70f(%rip), %rax # 0x386670
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x20(%rbp)
jae 0x29fe7
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29fd4
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x29fd4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0x29fd4
leaq 0x24a8a2(%rip), %rax # 0x274840
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x24a881(%rip), %rdi # 0x274840
callq *%rax
cmpl $0x0, %eax
jne 0x29fd4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x29fee
jmp 0x29fd6
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x29f5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_charset_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
lea rax, all_charsets
mov [rbp+var_20], rax
loc_29F5A:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_20], rax
jnb short loc_29FE7
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_29FD4
mov rax, [rbp+var_20]
mov rax, [rax]
cmp qword ptr [rax+10h], 0
jz short loc_29FD4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+0Ch]
and eax, [rbp+var_14]
cmp eax, 0
jz short loc_29FD4
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
mov rcx, [rcx]
mov rsi, [rcx+10h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_29FD4
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_29FEE
loc_29FD4:
jmp short $+2
loc_29FD6:
mov rax, [rbp+var_20]
add rax, 8
mov [rbp+var_20], rax
jmp loc_29F5A
loc_29FE7:
mov [rbp+var_4], 0
loc_29FEE:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_charset_number_internal(long long a1, int a2)
{
unsigned int **i; // [rsp+0h] [rbp-20h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 2)
&& (a2 & (*i)[3]) != 0
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 2),
a1) )
{
return **i;
}
}
return 0;
}
| get_charset_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
LEA RAX,[0x486670]
MOV qword ptr [RBP + -0x20],RAX
LAB_00129f5a:
LEA RAX,[0x486670]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x20],RAX
JNC 0x00129fe7
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x00129fd4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00129fd4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,dword ptr [RBP + -0x14]
CMP EAX,0x0
JZ 0x00129fd4
LEA RAX,[0x374840]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x374840]
CALL RAX
CMP EAX,0x0
JNZ 0x00129fd4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00129fee
LAB_00129fd4:
JMP 0x00129fd6
LAB_00129fd6:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00129f5a
LAB_00129fe7:
MOV dword ptr [RBP + -0x4],0x0
LAB_00129fee:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_charset_number_internal(int8 param_1,uint param_2)
{
int iVar1;
long *local_28;
local_28 = &all_charsets;
while( true ) {
if ((long *)0x48a66f < local_28) {
return 0;
}
if ((((*local_28 != 0) && (*(long *)(*local_28 + 0x10) != 0)) &&
((*(uint *)(*local_28 + 0xc) & param_2) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00374900 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_28 + 0x10),param_1), iVar1 == 0
)) break;
local_28 = local_28 + 1;
}
return *(int4 *)*local_28;
}
| |
34,977 | my_read_charset_file | eloqsql/mysys/charset.c | static my_bool
my_read_charset_file(MY_CHARSET_LOADER *loader,
const char *filename,
myf myflags)
{
uchar *buf;
int fd;
size_t len, tmp_len;
MY_STAT stat_info;
if (!my_stat(filename, &stat_info, MYF(myflags)) ||
((len= (uint)stat_info.st_size) > MY_MAX_ALLOWED_BUF) ||
!(buf= (uchar*) my_malloc(key_memory_charset_loader,len,myflags)))
return TRUE;
if ((fd= mysql_file_open(key_file_charset, filename, O_RDONLY, myflags)) < 0)
goto error;
tmp_len= mysql_file_read(fd, buf, len, myflags);
mysql_file_close(fd, myflags);
if (tmp_len != len)
goto error;
if (my_parse_charset_xml(loader, (char *) buf, len))
{
my_printf_error(EE_UNKNOWN_CHARSET, "Error while parsing '%s': %s\n",
MYF(0), filename, loader->error);
goto error;
}
my_free(buf);
return FALSE;
error:
my_free(buf);
return TRUE;
} | O3 | c | my_read_charset_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x120(%rbp), %rsi
movq %r14, %rdi
callq 0x9f5e3
testq %rax, %rax
je 0x9356c
movl -0xf0(%rbp), %r13d
cmpq $0x100000, %r13 # imm = 0x100000
ja 0x9356c
leaq 0xb75290(%rip), %rax # 0xc086e4
movl (%rax), %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0x9f901
testq %rax, %rax
je 0x9356c
movq %rax, %r15
movq %rbx, -0x38(%rbp)
leaq 0xb74908(%rip), %rax # 0xc07d80
movl (%rax), %esi
leaq 0x2f2b8f(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rbx
movl $0x2, %edx
movq %r14, %rcx
movq %rbx, %r8
callq *0x148(%rax)
movq %rax, (%rbx)
testq %rax, %rax
jne 0x9357e
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x9ff30
movl %eax, %ebx
testl %ebx, %ebx
js 0x93564
leaq 0x2f2b46(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x935c7
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xa04f0
movq %rax, -0x30(%rbp)
leaq 0x2f2b0b(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x9363b
movl %ebx, %edi
movq %r12, %rsi
callq 0xa00d5
cmpq %r13, -0x30(%rbp)
jne 0x93564
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xd0728
testb %al, %al
je 0x93564
leaq 0x48860(%rip), %rsi # 0xdbdaf
movl $0x16, %edi
xorl %edx, %edx
movq %r14, %rcx
movq -0x38(%rbp), %r8
xorl %eax, %eax
callq 0x9de41
movq %r15, %rdi
callq 0x9fb2e
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f2a8b(%rip), %rcx # 0x386010
movq (%rcx), %rcx
leaq 0x487e7(%rip), %rsi # 0xdbd76
movq %rax, %rdi
movl $0x223, %edx # imm = 0x223
callq *0x1f0(%rcx)
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x9ff30
movl %eax, %ebx
leaq 0x2f2a5d(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movl %ebx, %esi
callq *0x200(%rax)
jmp 0x934bb
movq %rax, %rcx
leaq 0x2f2a3f(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x4879b(%rip), %rdx # 0xdbd76
movq %rcx, -0x40(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
movl $0x225, %ecx # imm = 0x225
callq *0x210(%rax)
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xa04f0
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %ecx
cmoveq %r13, %rcx
cmpq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmovneq %rax, %rsi
testb $0x6, %r12b
cmovneq %rcx, %rsi
leaq 0x2f29e7(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x40(%rbp), %rdi
callq *0x218(%rax)
jmp 0x934fe
movq %rax, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x2e8c4
jmp 0x9352f
| my_read_charset_file:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r12, rdx
mov r14, rsi
mov rbx, rdi
lea rsi, [rbp+var_120]
mov rdi, r14
call my_stat
test rax, rax
jz loc_9356C
mov r13d, [rbp+var_F0]
cmp r13, offset xmmword_100000
ja loc_9356C
lea rax, key_memory_charset_loader
mov edi, [rax]
mov rsi, r13
mov rdx, r12
call my_malloc
test rax, rax
jz loc_9356C
mov r15, rax
mov [rbp+var_38], rbx
lea rax, key_file_charset
mov esi, [rax]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
lea rbx, [rbp+var_48]
mov edx, 2
mov rcx, r14
mov r8, rbx
call qword ptr [rax+148h]
mov [rbx], rax
test rax, rax
jnz loc_9357E
mov rdi, r14
xor esi, esi
mov rdx, r12
call my_open
mov ebx, eax
loc_934BB:
test ebx, ebx
js loc_93564
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_935C7
mov edi, ebx
mov rsi, r15
mov rdx, r13
mov rcx, r12
call my_read
mov [rbp+var_30], rax
loc_934FE:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz loc_9363B
mov edi, ebx
mov rsi, r12
call my_close
loc_9352F:
cmp [rbp+var_30], r13
jnz short loc_93564
mov rdi, [rbp+var_38]
mov rsi, r15
mov rdx, r13
call my_parse_charset_xml
test al, al
jz short loc_93564
lea rsi, aErrorWhilePars; "Error while parsing '%s': %s\n"
mov edi, 16h
xor edx, edx
mov rcx, r14
mov r8, [rbp+var_38]
xor eax, eax
call my_printf_error
loc_93564:
mov rdi, r15
call my_free
loc_9356C:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9357E:
lea rcx, PSI_server
mov rcx, [rcx]
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 223h
call qword ptr [rcx+1F0h]
mov rdi, r14
xor esi, esi
mov rdx, r12
call my_open
mov ebx, eax
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_48]
mov esi, ebx
call qword ptr [rax+200h]
jmp loc_934BB
loc_935C7:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_20; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_40], rcx
mov rdi, rcx
mov rsi, r13
mov ecx, 225h
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, r15
mov rdx, r13
mov rcx, r12
call my_read
xor esi, esi
test rax, rax
mov ecx, 0
cmovz rcx, r13
cmp rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
cmovnz rsi, rax
test r12b, 6
cmovnz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_40]
call qword ptr [rax+218h]
jmp loc_934FE
loc_9363B:
mov rdi, rax
mov esi, ebx
mov rdx, r12
call my_read_charset_file_cold_1
jmp loc_9352F
| long long my_read_charset_file(long long a1, long long a2, long long a3)
{
int v4; // r14d
long long result; // rax
long long v6; // r13
long long v7; // r15
long long v8; // rax
long long v9; // rbx
long long v10; // rax
long long v11; // rax
int v12; // r9d
long long v13; // rax
long long v14; // rdx
long long v15; // rsi
long long v16; // rcx
char v17[48]; // [rsp+0h] [rbp-120h] BYREF
unsigned int v18; // [rsp+30h] [rbp-F0h]
_BYTE v19[72]; // [rsp+90h] [rbp-90h] BYREF
long long v20; // [rsp+D8h] [rbp-48h] BYREF
long long v21; // [rsp+E0h] [rbp-40h]
long long v22; // [rsp+E8h] [rbp-38h]
long long v23; // [rsp+F0h] [rbp-30h]
v4 = a2;
result = my_stat(a2, v17, a3);
if ( result )
{
v6 = v18;
if ( v18 <= (unsigned long long)&xmmword_100000 )
{
result = my_malloc(key_memory_charset_loader, v18, a3);
if ( result )
{
v7 = result;
v22 = a1;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(
v19,
key_file_charset,
2LL,
a2,
&v20);
v20 = v8;
if ( v8 )
{
((void ( *)(long long, const char *, long long))PSI_server[62])(
v8,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
547LL);
v9 = (unsigned int)my_open(a2, 0LL, a3);
((void ( *)(long long, long long))PSI_server[64])(v20, v9);
}
else
{
LODWORD(v9) = my_open(a2, 0LL, a3);
}
if ( (int)v9 >= 0 )
{
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, (unsigned int)v9, 6LL);
if ( v10 )
{
v21 = v10;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v10,
v6,
"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",
549LL);
v13 = my_read((unsigned int)v9, v7, v6, a3);
v15 = 0LL;
v16 = 0LL;
if ( !v13 )
v16 = v6;
v23 = v13;
if ( v13 != -1 )
v15 = v13;
if ( (a3 & 6) != 0 )
v15 = v16;
((void ( *)(long long, long long, long long, long long))PSI_server[67])(v21, v15, v14, v16);
}
else
{
v23 = my_read((unsigned int)v9, v7, v6, a3);
}
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v19, (unsigned int)v9, 4LL);
if ( v11 )
my_read_charset_file_cold_1(v11, v9, a3);
else
my_close((unsigned int)v9, a3);
if ( v23 == v6 )
{
if ( (unsigned __int8)my_parse_charset_xml(v22, v7, v6) )
my_printf_error(22, (unsigned int)"Error while parsing '%s': %s\n", 0, v4, v22, v12);
}
}
return my_free(v7);
}
}
}
return result;
}
| my_read_charset_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RBP + -0x120]
MOV RDI,R14
CALL 0x0019f5e3
TEST RAX,RAX
JZ 0x0019356c
MOV R13D,dword ptr [RBP + -0xf0]
CMP R13,0x100000
JA 0x0019356c
LEA RAX,[0xd086e4]
MOV EDI,dword ptr [RAX]
MOV RSI,R13
MOV RDX,R12
CALL 0x0019f901
TEST RAX,RAX
JZ 0x0019356c
MOV R15,RAX
MOV qword ptr [RBP + -0x38],RBX
LEA RAX,[0xd07d80]
MOV ESI,dword ptr [RAX]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
LEA RBX,[RBP + -0x48]
MOV EDX,0x2
MOV RCX,R14
MOV R8,RBX
CALL qword ptr [RAX + 0x148]
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x0019357e
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R12
CALL 0x0019ff30
MOV EBX,EAX
LAB_001934bb:
TEST EBX,EBX
JS 0x00193564
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001935c7
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x001a04f0
MOV qword ptr [RBP + -0x30],RAX
LAB_001934fe:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0019363b
MOV EDI,EBX
MOV RSI,R12
CALL 0x001a00d5
LAB_0019352f:
CMP qword ptr [RBP + -0x30],R13
JNZ 0x00193564
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R15
MOV RDX,R13
CALL 0x001d0728
TEST AL,AL
JZ 0x00193564
LEA RSI,[0x1dbdaf]
MOV EDI,0x16
XOR EDX,EDX
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x38]
XOR EAX,EAX
CALL 0x0019de41
LAB_00193564:
MOV RDI,R15
CALL 0x0019fb2e
LAB_0019356c:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019357e:
LEA RCX,[0x486010]
MOV RCX,qword ptr [RCX]
LEA RSI,[0x1dbd76]
MOV RDI,RAX
MOV EDX,0x223
CALL qword ptr [RCX + 0x1f0]
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R12
CALL 0x0019ff30
MOV EBX,EAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,EBX
CALL qword ptr [RAX + 0x200]
JMP 0x001934bb
LAB_001935c7:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dbd76]
MOV qword ptr [RBP + -0x40],RCX
MOV RDI,RCX
MOV RSI,R13
MOV ECX,0x225
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R13
MOV RCX,R12
CALL 0x001a04f0
XOR ESI,ESI
TEST RAX,RAX
MOV ECX,0x0
CMOVZ RCX,R13
CMP RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
CMOVNZ RSI,RAX
TEST R12B,0x6
CMOVNZ RSI,RCX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x218]
JMP 0x001934fe
LAB_0019363b:
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R12
CALL 0x0012e8c4
JMP 0x0019352f
|
void my_read_charset_file(int8 param_1,int8 param_2,ulong param_3)
{
char cVar1;
int iVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
int1 local_128 [48];
uint local_f8;
int1 local_98 [72];
long local_50;
long local_48;
int8 local_40;
ulong local_38;
lVar3 = my_stat(param_2,local_128);
if ((lVar3 != 0) && (uVar7 = (ulong)local_f8, uVar7 < 0x100001)) {
lVar3 = my_malloc(key_memory_charset_loader,uVar7,param_3);
if (lVar3 != 0) {
local_40 = param_1;
local_50 = (**(code **)(PSI_server + 0x148))(local_98,key_file_charset,2,param_2,&local_50);
if (local_50 == 0) {
iVar2 = my_open(param_2,0,param_3);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_50,"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x223);
iVar2 = my_open(param_2,0,param_3);
(**(code **)(PSI_server + 0x200))(local_50,iVar2);
}
if (-1 < iVar2) {
lVar4 = (**(code **)(PSI_server + 0x158))(local_98,iVar2,6);
if (lVar4 == 0) {
local_38 = my_read(iVar2,lVar3,uVar7,param_3);
}
else {
local_48 = lVar4;
(**(code **)(PSI_server + 0x210))
(lVar4,uVar7,"/workspace/llm4binary/github2025/eloqsql/mysys/charset.c",0x225);
local_38 = my_read(iVar2,lVar3,uVar7,param_3);
uVar5 = 0;
if (local_38 == 0) {
uVar5 = uVar7;
}
uVar6 = 0;
if (local_38 != 0xffffffffffffffff) {
uVar6 = local_38;
}
if ((param_3 & 6) != 0) {
uVar6 = uVar5;
}
(**(code **)(PSI_server + 0x218))(local_48,uVar6);
}
lVar4 = (**(code **)(PSI_server + 0x158))(local_98,iVar2,4);
if (lVar4 == 0) {
my_close(iVar2,param_3);
}
else {
my_read_charset_file_cold_1(lVar4,iVar2,param_3);
}
if (local_38 == uVar7) {
cVar1 = my_parse_charset_xml(local_40,lVar3,uVar7);
if (cVar1 != '\0') {
my_printf_error(0x16,"Error while parsing \'%s\': %s\n",0,param_2,local_40);
}
}
}
my_free(lVar3);
}
}
return;
}
| |
34,978 | my_uni_ucs2 | eloqsql/strings/ctype-ucs2.c | static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
my_wc_t wc, uchar *r, uchar *e)
{
if ( r+2 > e )
return MY_CS_TOOSMALL2;
if (wc > 0xFFFF) /* UCS2 does not support characters outside BMP */
return MY_CS_ILUNI;
r[0]= (uchar) (wc >> 8);
r[1]= (uchar) (wc & 0xFF);
return 2;
} | O3 | c | my_uni_ucs2:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x51258
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x51258
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
popq %rbp
retq
| my_uni_ucs2:
push rbp
mov rbp, rsp
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_51258
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_51258
rol si, 8
mov [rdx], si
mov eax, 2
loc_51258:
pop rbp
retn
| long long my_uni_ucs2(long long a1, unsigned long long a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
*a3 = __ROL2__(a2, 8);
return 2LL;
}
}
return result;
}
| my_uni_ucs2:
PUSH RBP
MOV RBP,RSP
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00151258
XOR EAX,EAX
CMP RSI,0xffff
JA 0x00151258
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
LAB_00151258:
POP RBP
RET
|
int8 my_uni_ucs2(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9a;
if ((param_3 + 1 <= param_4) && (uVar1 = 0, param_2 < 0x10000)) {
*param_3 = (ushort)param_2 << 8 | (ushort)param_2 >> 8;
uVar1 = 2;
}
return uVar1;
}
| |
34,979 | my_mb_wc_utf8mb3_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb3_quick(my_wc_t * pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s+2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s+3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_mb_wc_utf8mb3_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0xa69c6
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xa6b43
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0xa69f3
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa6b43
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0xa6a0a
movl $0x0, -0x4(%rbp)
jmp 0xa6b43
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0xa6a80
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0xa6a2f
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0xa6b43
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0xa6a4d
movl $0x0, -0x4(%rbp)
jmp 0xa6b43
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0xa6b43
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0xa6b36
movq -0x18(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jbe 0xa6aa9
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0xa6b43
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0xa6ae7
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0xa6ae7
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0xa6af0
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0xa6af0
movl $0x0, -0x4(%rbp)
jmp 0xa6b43
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0xa6b43
jmp 0xa6b38
jmp 0xa6b3a
jmp 0xa6b3c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_mb_wc_utf8mb3_quick:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_A69C6
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_A6B43
loc_A69C6:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_A69F3
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_A6B43
loc_A69F3:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_A6A0A
mov [rbp+var_4], 0
jmp loc_A6B43
loc_A6A0A:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_A6A80
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_A6A2F
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_A6B43
loc_A6A2F:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_A6A4D
mov [rbp+var_4], 0
jmp loc_A6B43
loc_A6A4D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_A6B43
loc_A6A80:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_A6B36
mov rax, [rbp+var_18]
add rax, 3
cmp rax, [rbp+var_20]
jbe short loc_A6AA9
mov [rbp+var_4], 0FFFFFF99h
jmp loc_A6B43
loc_A6AA9:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_A6AE7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_A6AE7
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_A6AF0
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_A6AF0
loc_A6AE7:
mov [rbp+var_4], 0
jmp short loc_A6B43
loc_A6AF0:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_A6B43
loc_A6B36:
jmp short $+2
loc_A6B38:
jmp short $+2
loc_A6B3A:
jmp short $+2
loc_A6B3C:
mov [rbp+var_4], 0
loc_A6B43:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_utf8mb3_quick(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 3) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 && (a2[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a2[1] >= 0xA0u) )
{
*a1 = a2[2] ^ 0x80u | ((long long)(a2[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 )
{
*a1 = a2[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a1 = v4;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_utf8mb3_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001a69c6
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001a6b43
LAB_001a69c6:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x001a69f3
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a6b43
LAB_001a69f3:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x001a6a0a
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a6b43
LAB_001a6a0a:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x001a6a80
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001a6a2f
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001a6b43
LAB_001a6a2f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x001a6a4d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a6b43
LAB_001a6a4d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001a6b43
LAB_001a6a80:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x001a6b36
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001a6aa9
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x001a6b43
LAB_001a6aa9:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001a6ae7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001a6ae7
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x001a6af0
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x001a6af0
LAB_001a6ae7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a6b43
LAB_001a6af0:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001a6b43
LAB_001a6b36:
JMP 0x001a6b38
LAB_001a6b38:
JMP 0x001a6b3a
LAB_001a6b3a:
JMP 0x001a6b3c
LAB_001a6b3c:
MOV dword ptr [RBP + -0x4],0x0
LAB_001a6b43:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb3_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
if (param_2 < param_3) {
bVar1 = *param_2;
if (bVar1 < 0x80) {
*param_1 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2[1] ^ 0x80) < 0x40) {
*param_1 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_2[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
local_c = 0xffffff99;
}
else if ((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_2[1])))) {
*param_1 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_2[1] ^ 0x80) << 6 |
(long)(int)(param_2[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
34,980 | ma_crypt_post_write_hook | eloqsql/storage/maria/ma_crypt.c | static void ma_crypt_post_write_hook(int res,
PAGECACHE_IO_HOOK_ARGS *args)
{
if (args->crypt_buf != NULL)
{
uchar *tmp= args->page;
args->page= args->crypt_buf;
args->crypt_buf= NULL;
my_free(tmp);
}
maria_page_write_failure(res, args);
} | O0 | c | ma_crypt_post_write_hook:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5e809
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0xf3590
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5d320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ma_crypt_post_write_hook:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz short loc_5E809
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov rdi, [rbp+var_18]
call my_free
loc_5E809:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call maria_page_write_failure
add rsp, 20h
pop rbp
retn
| long long ma_crypt_post_write_hook(int a1, long long *a2)
{
long long v3; // [rsp+8h] [rbp-18h]
if ( a2[3] )
{
v3 = *a2;
*a2 = a2[3];
a2[3] = 0LL;
my_free(v3);
}
return maria_page_write_failure(a1, (long long)a2);
}
| ma_crypt_post_write_hook:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0015e809
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001f3590
LAB_0015e809:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0015d320
ADD RSP,0x20
POP RBP
RET
|
void ma_crypt_post_write_hook(int4 param_1,int8 *param_2)
{
int8 uVar1;
if (param_2[3] != 0) {
uVar1 = *param_2;
*param_2 = param_2[3];
param_2[3] = 0;
my_free(uVar1);
}
maria_page_write_failure(param_1,param_2);
return;
}
| |
34,981 | resize_key_cache | eloqsql/mysys/mf_keycache.c | int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit, uint age_threshold,
uint changed_blocks_hash_size)
{
int blocks= -1;
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
if ((uint) keycache->param_partitions != keycache->partitions && use_mem)
blocks= repartition_key_cache_internal(keycache,
key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size,
(uint) keycache->param_partitions,
0);
else
{
blocks= keycache->interface_funcs->resize(keycache->keycache_cb,
key_cache_block_size,
use_mem, division_limit,
age_threshold,
changed_blocks_hash_size);
if (keycache->partitions)
keycache->partitions=
((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->partitions;
}
keycache->key_cache_mem_size=
keycache->partitions ?
((PARTITIONED_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size :
((SIMPLE_KEY_CACHE_CB *)(keycache->keycache_cb))->key_cache_mem_size;
keycache->can_be_used= (blocks >= 0);
pthread_mutex_unlock(&keycache->op_lock);
}
return blocks;
} | O3 | c | resize_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0x48(%rdi)
je 0x9fb85
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl %r9d, -0x2c(%rbp)
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2a200
testq %r14, %r14
je 0x9fb8d
movl 0x38(%rbx), %eax
cmpl %eax, 0x4c(%rbx)
je 0x9fb8d
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r13d, %ecx
movl %r12d, %r8d
movl -0x2c(%rbp), %r9d
pushq $0x0
pushq %rax
callq 0x9fbff
addq $0x10, %rsp
movl %eax, %r15d
movl 0x4c(%rbx), %eax
jmp 0x9fbbb
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jmp 0x9fbe6
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
movl %r15d, %esi
movq %r14, %rdx
movl %r13d, %ecx
movl %r12d, %r8d
movl -0x2c(%rbp), %r9d
callq *0x8(%rax)
movl %eax, %r15d
cmpl $0x0, 0x4c(%rbx)
je 0x9fbf8
movq 0x8(%rbx), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x4c(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq 0x8(,%rcx,8), %rax
movq 0x8(%rbx), %rcx
movq (%rcx,%rax), %rax
movq %rax, 0x50(%rbx)
testl %r15d, %r15d
setns 0x49(%rbx)
movq -0x38(%rbp), %rdi
callq 0x2a1d0
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %eax
jmp 0x9fbca
| resize_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
cmp byte ptr [rdi+48h], 0
jz short loc_9FB85
mov r12d, r8d
mov r13d, ecx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
mov [rbp+var_2C], r9d
add rdi, 58h ; 'X'
mov [rbp+var_38], rdi
call _pthread_mutex_lock
test r14, r14
jz short loc_9FB8D
mov eax, [rbx+38h]
cmp [rbx+4Ch], eax
jz short loc_9FB8D
mov rdi, rbx
mov esi, r15d
mov rdx, r14
mov ecx, r13d
mov r8d, r12d
mov r9d, [rbp+var_2C]
push 0
push rax
call repartition_key_cache_internal
add rsp, 10h
mov r15d, eax
mov eax, [rbx+4Ch]
jmp short loc_9FBBB
loc_9FB85:
mov r15d, 0FFFFFFFFh
jmp short loc_9FBE6
loc_9FB8D:
mov rdi, [rbx+8]
mov rax, [rbx+10h]
mov esi, r15d
mov rdx, r14
mov ecx, r13d
mov r8d, r12d
mov r9d, [rbp+var_2C]
call qword ptr [rax+8]
mov r15d, eax
cmp dword ptr [rbx+4Ch], 0
jz short loc_9FBF8
mov rax, [rbx+8]
mov eax, [rax+1Ch]
mov [rbx+4Ch], eax
loc_9FBBB:
xor ecx, ecx
test eax, eax
setnz cl
lea rax, ds:8[rcx*8]
loc_9FBCA:
mov rcx, [rbx+8]
mov rax, [rcx+rax]
mov [rbx+50h], rax
test r15d, r15d
setns byte ptr [rbx+49h]
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
loc_9FBE6:
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9FBF8:
mov eax, 8
jmp short loc_9FBCA
| long long resize_key_cache(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
int v9; // eax
unsigned int v10; // r15d
int v11; // eax
long long v12; // rax
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
if ( !a3 || (v9 = *(_DWORD *)(a1 + 56), *(_DWORD *)(a1 + 76) == v9) )
{
v10 = (*(long long ( **)(_QWORD, _QWORD, long long, _QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 8LL))(
*(_QWORD *)(a1 + 8),
a2,
a3,
a4,
a5,
a6);
if ( !*(_DWORD *)(a1 + 76) )
{
v12 = 8LL;
goto LABEL_9;
}
v11 = *(_DWORD *)(*(_QWORD *)(a1 + 8) + 28LL);
*(_DWORD *)(a1 + 76) = v11;
}
else
{
v10 = repartition_key_cache_internal(a1, a2, a3, a4, a5, a6, v9, 0);
v11 = *(_DWORD *)(a1 + 76);
}
v12 = 8LL * (v11 != 0) + 8;
LABEL_9:
*(_QWORD *)(a1 + 80) = *(_QWORD *)(*(_QWORD *)(a1 + 8) + v12);
*(_BYTE *)(a1 + 73) = (v10 & 0x80000000) == 0;
pthread_mutex_unlock(a1 + 88);
return v10;
}
return (unsigned int)-1;
}
| resize_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0019fb85
MOV R12D,R8D
MOV R13D,ECX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
MOV dword ptr [RBP + -0x2c],R9D
ADD RDI,0x58
MOV qword ptr [RBP + -0x38],RDI
CALL 0x0012a200
TEST R14,R14
JZ 0x0019fb8d
MOV EAX,dword ptr [RBX + 0x38]
CMP dword ptr [RBX + 0x4c],EAX
JZ 0x0019fb8d
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R13D
MOV R8D,R12D
MOV R9D,dword ptr [RBP + -0x2c]
PUSH 0x0
PUSH RAX
CALL 0x0019fbff
ADD RSP,0x10
MOV R15D,EAX
MOV EAX,dword ptr [RBX + 0x4c]
JMP 0x0019fbbb
LAB_0019fb85:
MOV R15D,0xffffffff
JMP 0x0019fbe6
LAB_0019fb8d:
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RBX + 0x10]
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R13D
MOV R8D,R12D
MOV R9D,dword ptr [RBP + -0x2c]
CALL qword ptr [RAX + 0x8]
MOV R15D,EAX
CMP dword ptr [RBX + 0x4c],0x0
JZ 0x0019fbf8
MOV RAX,qword ptr [RBX + 0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBX + 0x4c],EAX
LAB_0019fbbb:
XOR ECX,ECX
TEST EAX,EAX
SETNZ CL
LEA RAX,[0x8 + RCX*0x8]
LAB_0019fbca:
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + RAX*0x1]
MOV qword ptr [RBX + 0x50],RAX
TEST R15D,R15D
SETNS byte ptr [RBX + 0x49]
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0012a1d0
LAB_0019fbe6:
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019fbf8:
MOV EAX,0x8
JMP 0x0019fbca
|
int resize_key_cache(long param_1,int4 param_2,long param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int iVar2;
long lVar3;
if (*(char *)(param_1 + 0x48) == '\0') {
return -1;
}
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
if ((param_3 == 0) || (*(int *)(param_1 + 0x4c) == *(int *)(param_1 + 0x38))) {
iVar1 = (**(code **)(*(long *)(param_1 + 0x10) + 8))
(*(int8 *)(param_1 + 8),param_2,param_3,param_4,param_5,param_6);
if (*(int *)(param_1 + 0x4c) == 0) {
lVar3 = 8;
goto LAB_0019fbca;
}
iVar2 = *(int *)(*(long *)(param_1 + 8) + 0x1c);
*(int *)(param_1 + 0x4c) = iVar2;
}
else {
iVar1 = repartition_key_cache_internal
(param_1,param_2,param_3,param_4,param_5,param_6,*(int *)(param_1 + 0x38),0);
iVar2 = *(int *)(param_1 + 0x4c);
}
lVar3 = (ulong)(iVar2 != 0) * 8 + 8;
LAB_0019fbca:
*(int8 *)(param_1 + 0x50) = *(int8 *)(*(long *)(param_1 + 8) + lVar3);
*(bool *)(param_1 + 0x49) = -1 < iVar1;
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
return iVar1;
}
| |
34,982 | ma_keyseg_write | eloqsql/storage/maria/ma_open.c | my_bool _ma_keyseg_write(File file, const HA_KEYSEG *keyseg)
{
uchar buff[HA_KEYSEG_SIZE];
uchar *ptr=buff;
ulong pos;
*ptr++= keyseg->type;
*ptr++= keyseg->language & 0xFF; /* Collation ID, low byte */
*ptr++= keyseg->null_bit;
*ptr++= keyseg->bit_start;
*ptr++= keyseg->language >> 8; /* Collation ID, high byte */
*ptr++= keyseg->bit_length;
mi_int2store(ptr,keyseg->flag); ptr+= 2;
mi_int2store(ptr,keyseg->length); ptr+= 2;
mi_int4store(ptr,keyseg->start); ptr+= 4;
pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
mi_int4store(ptr, pos);
ptr+=4;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O3 | c | ma_keyseg_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movb 0x18(%rsi), %al
movb %al, -0x30(%rbp)
movzwl 0x16(%rsi), %eax
movb %al, -0x2f(%rbp)
movb 0x19(%rsi), %cl
movb %cl, -0x2e(%rbp)
movb 0x1a(%rsi), %dl
movb %dl, -0x2d(%rbp)
movb %ah, -0x2c(%rbp)
movb 0x1b(%rsi), %al
movb %al, -0x2b(%rbp)
movzwl 0x12(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl 0x14(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x28(%rbp)
movl 0x8(%rsi), %eax
bswapl %eax
movl %eax, -0x26(%rbp)
testb %cl, %cl
je 0x55740
movl 0xc(%rsi), %eax
jmp 0x55744
movzwl 0x10(%rsi), %eax
bswapl %eax
movl %eax, -0x22(%rbp)
leaq 0x3308c0(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x5579c
leaq -0x30(%rbp), %rsi
movl $0x12, %edx
movl $0x4, %ecx
movl %ebx, %edi
callq 0x2f004
testq %rax, %rax
setne %al
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x557b6
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rcx
callq 0x2d266
movq (%r14), %rax
jmp 0x5577e
callq 0x29270
| _ma_keyseg_write:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 70h
mov ebx, edi
mov rax, fs:28h
mov [rbp+var_18], rax
mov al, [rsi+18h]
mov [rbp+var_30], al
movzx eax, word ptr [rsi+16h]
mov [rbp+var_2F], al
mov cl, [rsi+19h]
mov [rbp+var_2E], cl
mov dl, [rsi+1Ah]
mov [rbp+var_2D], dl
mov [rbp+var_2C], ah
mov al, [rsi+1Bh]
mov [rbp+var_2B], al
movzx eax, word ptr [rsi+12h]
rol ax, 8
mov [rbp+var_2A], ax
movzx eax, word ptr [rsi+14h]
rol ax, 8
mov [rbp+var_28], ax
mov eax, [rsi+8]
bswap eax
mov [rbp+var_26], eax
test cl, cl
jz short loc_55740
mov eax, [rsi+0Ch]
jmp short loc_55744
loc_55740:
movzx eax, word ptr [rsi+10h]
loc_55744:
bswap eax
mov [rbp+var_22], eax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_5579C
lea rsi, [rbp+var_30]
mov edx, 12h
mov ecx, 4
mov edi, ebx
call my_write
loc_5577E:
test rax, rax
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_557B6
add rsp, 70h
pop rbx
pop r14
pop rbp
retn
loc_5579C:
lea rdx, [rbp+var_30]
lea r14, [rbp+var_38]
mov rdi, rax
mov esi, ebx
mov rcx, r14
call _ma_keyseg_write_cold_1
mov rax, [r14]
jmp short loc_5577E
loc_557B6:
call ___stack_chk_fail
| bool ma_keyseg_write(unsigned int a1, long long a2)
{
__int16 v2; // ax
unsigned int v3; // eax
long long v4; // rax
long long v5; // rax
_BYTE v7[72]; // [rsp+0h] [rbp-80h] BYREF
long long v8; // [rsp+48h] [rbp-38h] BYREF
_BYTE v9[2]; // [rsp+50h] [rbp-30h] BYREF
char v10; // [rsp+52h] [rbp-2Eh]
char v11; // [rsp+53h] [rbp-2Dh]
char v12; // [rsp+54h] [rbp-2Ch]
char v13; // [rsp+55h] [rbp-2Bh]
__int16 v14; // [rsp+56h] [rbp-2Ah]
__int16 v15; // [rsp+58h] [rbp-28h]
unsigned __int32 v16; // [rsp+5Ah] [rbp-26h]
unsigned __int32 v17; // [rsp+5Eh] [rbp-22h]
unsigned long long v18; // [rsp+68h] [rbp-18h]
v18 = __readfsqword(0x28u);
v9[0] = *(_BYTE *)(a2 + 24);
v2 = *(_WORD *)(a2 + 22);
v9[1] = v2;
v10 = *(_BYTE *)(a2 + 25);
v11 = *(_BYTE *)(a2 + 26);
v12 = HIBYTE(v2);
v13 = *(_BYTE *)(a2 + 27);
v14 = __ROL2__(*(_WORD *)(a2 + 18), 8);
v15 = __ROL2__(*(_WORD *)(a2 + 20), 8);
v16 = _byteswap_ulong(*(_DWORD *)(a2 + 8));
if ( v10 )
v3 = *(_DWORD *)(a2 + 12);
else
v3 = *(unsigned __int16 *)(a2 + 16);
v17 = _byteswap_ulong(v3);
v4 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a1, 7LL);
if ( v4 )
{
ma_keyseg_write_cold_1(v4, a1, (long long)v9, &v8);
v5 = v8;
}
else
{
v5 = my_write(a1, (long long)v9, 18LL, 4LL);
}
return v5 != 0;
}
| _ma_keyseg_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV EBX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV AL,byte ptr [RSI + 0x18]
MOV byte ptr [RBP + -0x30],AL
MOVZX EAX,word ptr [RSI + 0x16]
MOV byte ptr [RBP + -0x2f],AL
MOV CL,byte ptr [RSI + 0x19]
MOV byte ptr [RBP + -0x2e],CL
MOV DL,byte ptr [RSI + 0x1a]
MOV byte ptr [RBP + -0x2d],DL
MOV byte ptr [RBP + -0x2c],AH
MOV AL,byte ptr [RSI + 0x1b]
MOV byte ptr [RBP + -0x2b],AL
MOVZX EAX,word ptr [RSI + 0x12]
ROL AX,0x8
MOV word ptr [RBP + -0x2a],AX
MOVZX EAX,word ptr [RSI + 0x14]
ROL AX,0x8
MOV word ptr [RBP + -0x28],AX
MOV EAX,dword ptr [RSI + 0x8]
BSWAP EAX
MOV dword ptr [RBP + -0x26],EAX
TEST CL,CL
JZ 0x00155740
MOV EAX,dword ptr [RSI + 0xc]
JMP 0x00155744
LAB_00155740:
MOVZX EAX,word ptr [RSI + 0x10]
LAB_00155744:
BSWAP EAX
MOV dword ptr [RBP + -0x22],EAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0015579c
LEA RSI,[RBP + -0x30]
MOV EDX,0x12
MOV ECX,0x4
MOV EDI,EBX
CALL 0x0012f004
LAB_0015577e:
TEST RAX,RAX
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x001557b6
ADD RSP,0x70
POP RBX
POP R14
POP RBP
RET
LAB_0015579c:
LEA RDX,[RBP + -0x30]
LEA R14,[RBP + -0x38]
MOV RDI,RAX
MOV ESI,EBX
MOV RCX,R14
CALL 0x0012d266
MOV RAX,qword ptr [R14]
JMP 0x0015577e
LAB_001557b6:
CALL 0x00129270
|
bool _ma_keyseg_write(int4 param_1,long param_2)
{
uint uVar1;
long lVar2;
long in_FS_OFFSET;
int1 local_88 [72];
long local_40;
int1 local_38;
int1 local_37;
char local_36;
int1 local_35;
int1 local_34;
int1 local_33;
ushort local_32;
ushort local_30;
uint local_2e;
uint local_2a;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = *(int1 *)(param_2 + 0x18);
local_37 = (int1)*(int2 *)(param_2 + 0x16);
local_36 = *(char *)(param_2 + 0x19);
local_35 = *(int1 *)(param_2 + 0x1a);
local_34 = (int1)((ushort)*(int2 *)(param_2 + 0x16) >> 8);
local_33 = *(int1 *)(param_2 + 0x1b);
local_32 = *(ushort *)(param_2 + 0x12) << 8 | *(ushort *)(param_2 + 0x12) >> 8;
local_30 = *(ushort *)(param_2 + 0x14) << 8 | *(ushort *)(param_2 + 0x14) >> 8;
uVar1 = *(uint *)(param_2 + 8);
local_2e = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
if (local_36 == '\0') {
uVar1 = (uint)*(ushort *)(param_2 + 0x10);
}
else {
uVar1 = *(uint *)(param_2 + 0xc);
}
local_2a = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
lVar2 = (**(code **)(PSI_server + 0x158))(local_88,param_1,7);
if (lVar2 == 0) {
local_40 = my_write(param_1,&local_38,0x12,4);
}
else {
_ma_keyseg_write_cold_1(lVar2,param_1,&local_38,&local_40);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return local_40 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,983 | 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 0x6064c
movb $0x0, 0x60(%rbx)
cmpl $0x0, 0x5c(%rbx)
je 0x60659
leaq 0x28(%rbx), %rdi
callq 0x28040
jmp 0x60659
movq %rbx, %rdi
callq 0x285c0
decl 0x58(%rbx)
je 0x6063b
movq %rbx, %rdi
callq 0x28290
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_6064C
mov byte ptr [rbx+60h], 0
loc_6063B:
cmp dword ptr [rbx+5Ch], 0
jz short loc_60659
lea rdi, [rbx+28h]
call _pthread_cond_signal
jmp short loc_60659
loc_6064C:
mov rdi, rbx
call _pthread_mutex_lock
dec dword ptr [rbx+58h]
jz short loc_6063B
loc_60659:
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 0x0016064c
MOV byte ptr [RBX + 0x60],0x0
LAB_0016063b:
CMP dword ptr [RBX + 0x5c],0x0
JZ 0x00160659
LEA RDI,[RBX + 0x28]
CALL 0x00128040
JMP 0x00160659
LAB_0016064c:
MOV RDI,RBX
CALL 0x001285c0
DEC dword ptr [RBX + 0x58]
JZ 0x0016063b
LAB_00160659:
MOV RDI,RBX
CALL 0x00128290
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_00160659;
}
else {
*(int1 *)((long)param_1 + 0x60) = 0;
}
if (*(int *)((long)param_1 + 0x5c) != 0) {
pthread_cond_signal((pthread_cond_t *)(param_1 + 1));
}
LAB_00160659:
pthread_mutex_unlock(param_1);
return 0;
}
| |
34,984 | fn_format | eloqsql/mysys/mf_format.c | char * fn_format(char * to, const char *name, const char *dir,
const char *extension, uint flag)
{
char dev[FN_REFLEN], buff[FN_REFLEN], *pos, *startpos;
const char *ext;
reg1 size_t length;
size_t dev_length;
DBUG_ENTER("fn_format");
DBUG_ASSERT(name != NULL);
DBUG_ASSERT(extension != NULL);
DBUG_PRINT("enter",("name: %s dir: %s extension: %s flag: %d",
name,dir,extension,flag));
/* Copy and skip directory */
name+=(length=dirname_part(dev, (startpos=(char *) name), &dev_length));
if (length == 0 || (flag & MY_REPLACE_DIR))
{
/* Use given directory */
convert_dirname(dev,dir,NullS); /* Fix to this OS */
}
else if ((flag & MY_RELATIVE_PATH) && !test_if_hard_path(dev))
{
/* Put 'dir' before the given path */
strmake_buf(buff, dev);
pos=convert_dirname(dev,dir,NullS);
strmake(pos,buff,sizeof(buff)-1- (int) (pos-dev));
}
if (flag & MY_PACK_FILENAME)
pack_dirname(dev,dev); /* Put in ./.. and ~/.. */
if (flag & MY_UNPACK_FILENAME)
(void) unpack_dirname(dev,dev); /* Replace ~/.. with dir */
if (!(flag & MY_APPEND_EXT) &&
(pos= (char*) strchr(name,FN_EXTCHAR)) != NullS)
{
if ((flag & MY_REPLACE_EXT) == 0) /* If we should keep old ext */
{
length=strlength(name); /* Use old extension */
ext = "";
}
else
{
length= (size_t) (pos-(char*) name); /* Change extension */
ext= extension;
}
}
else
{
length=strlength(name); /* No ext, use the now one */
ext=extension;
}
if (strlen(dev)+length+strlen(ext) >= FN_REFLEN || length >= FN_LEN )
{
/* To long path, return original or NULL */
size_t tmp_length;
if (flag & MY_SAFE_PATH)
DBUG_RETURN(NullS);
tmp_length= strlength(startpos);
DBUG_PRINT("error",("dev: '%s' ext: '%s' length: %u",dev,ext,
(uint) length));
(void) strmake(to,startpos,MY_MIN(tmp_length,FN_REFLEN-1));
}
else
{
if (to == startpos)
{
bmove(buff,(uchar*) name,length); /* Save name for last copy */
name=buff;
}
pos=strmake(strmov(to,dev),name,length);
(void) strmov(pos,ext); /* Don't convert extension */
}
if (flag & MY_RETURN_REAL_PATH)
(void) my_realpath(to, to, MYF(0));
else if (flag & MY_RESOLVE_SYMLINKS)
{
strmov(buff,to);
(void) my_readlink(to, buff, MYF(0));
}
DBUG_RETURN(to);
} | O0 | c | fn_format:
pushq %rbp
movq %rsp, %rbp
subq $0x6a0, %rsp # imm = 0x6A0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x620(%rbp)
movq %rsi, -0x628(%rbp)
movq %rdx, -0x630(%rbp)
movq %rcx, -0x638(%rbp)
movl %r8d, -0x63c(%rbp)
jmp 0xdf7cd
jmp 0xdf7cf
jmp 0xdf7d1
jmp 0xdf7d3
jmp 0xdf7d5
leaq -0x210(%rbp), %rdi
movq -0x628(%rbp), %rsi
movq %rsi, -0x650(%rbp)
leaq -0x668(%rbp), %rdx
callq 0xdf670
movq %rax, -0x660(%rbp)
addq -0x628(%rbp), %rax
movq %rax, -0x628(%rbp)
cmpq $0x0, -0x660(%rbp)
je 0xdf823
movl -0x63c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdf83f
leaq -0x210(%rbp), %rdi
movq -0x630(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xdf6d0
jmp 0xdf8ef
movl -0x63c(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xdf8ed
leaq -0x210(%rbp), %rdi
callq 0xf03b0
cmpl $0x0, %eax
jne 0xdf8ed
leaq -0x610(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx # imm = 0x200
callq 0x2a2c0
movb $0x2, -0x610(%rbp)
leaq -0x410(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14de30
movq %rax, -0x670(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x630(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xdf6d0
movq %rax, -0x648(%rbp)
movq -0x648(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movq -0x648(%rbp), %rax
leaq -0x210(%rbp), %rcx
subq %rcx, %rax
cltq
movl $0x1ff, %edx # imm = 0x1FF
subq %rax, %rdx
callq 0x14de30
jmp 0xdf8ef
movl -0x63c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xdf910
leaq -0x210(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xe88f0
movl -0x63c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xdf931
leaq -0x210(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0xe9370
movl -0x63c(%rbp), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
jne 0xdf9b8
movq -0x628(%rbp), %rdi
movl $0x2e, %esi
callq 0x2a410
movq %rax, -0x648(%rbp)
cmpq $0x0, %rax
je 0xdf9b8
movl -0x63c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xdf990
movq -0x628(%rbp), %rdi
callq 0xdfbe0
movq %rax, -0x660(%rbp)
leaq 0x7831d(%rip), %rax # 0x157ca4
movq %rax, -0x658(%rbp)
jmp 0xdf9b6
movq -0x648(%rbp), %rax
movq -0x628(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x660(%rbp)
movq -0x638(%rbp), %rax
movq %rax, -0x658(%rbp)
jmp 0xdf9d9
movq -0x628(%rbp), %rdi
callq 0xdfbe0
movq %rax, -0x660(%rbp)
movq -0x638(%rbp), %rax
movq %rax, -0x658(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2a350
addq -0x660(%rbp), %rax
movq %rax, -0x680(%rbp)
movq -0x658(%rbp), %rdi
callq 0x2a350
movq %rax, %rcx
movq -0x680(%rbp), %rax
addq %rcx, %rax
cmpq $0x200, %rax # imm = 0x200
jae 0xdfa25
cmpq $0x100, -0x660(%rbp) # imm = 0x100
jb 0xdfabd
movl -0x63c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xdfa45
jmp 0xdfa35
movq $0x0, -0x618(%rbp)
jmp 0xdfba9
movq -0x650(%rbp), %rdi
callq 0xdfbe0
movq %rax, -0x678(%rbp)
jmp 0xdfa5a
movq -0x620(%rbp), %rax
movq %rax, -0x690(%rbp)
movq -0x650(%rbp), %rax
movq %rax, -0x688(%rbp)
cmpq $0x1ff, -0x678(%rbp) # imm = 0x1FF
jae 0xdfa93
movq -0x678(%rbp), %rax
movq %rax, -0x698(%rbp)
jmp 0xdfaa1
movl $0x1ff, %eax # imm = 0x1FF
movq %rax, -0x698(%rbp)
jmp 0xdfaa1
movq -0x688(%rbp), %rsi
movq -0x690(%rbp), %rdi
movq -0x698(%rbp), %rdx
callq 0x14de30
jmp 0xdfb38
movq -0x620(%rbp), %rax
cmpq -0x650(%rbp), %rax
jne 0xdfaf5
leaq -0x410(%rbp), %rdi
movq -0x628(%rbp), %rsi
movq -0x660(%rbp), %rdx
callq 0x2a130
leaq -0x410(%rbp), %rax
movq %rax, -0x628(%rbp)
movq -0x620(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x2a730
movq %rax, %rdi
movq -0x628(%rbp), %rsi
movq -0x660(%rbp), %rdx
callq 0x14de30
movq %rax, -0x648(%rbp)
movq -0x648(%rbp), %rdi
movq -0x658(%rbp), %rsi
callq 0x2a730
movl -0x63c(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xdfb5f
movq -0x620(%rbp), %rdi
movq -0x620(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf5050
jmp 0xdfb99
movl -0x63c(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xdfb97
leaq -0x410(%rbp), %rdi
movq -0x620(%rbp), %rsi
callq 0x2a730
movq -0x620(%rbp), %rdi
leaq -0x410(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf4e50
jmp 0xdfb99
jmp 0xdfb9b
movq -0x620(%rbp), %rax
movq %rax, -0x618(%rbp)
movq -0x618(%rbp), %rax
movq %rax, -0x6a0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xdfbd9
movq -0x6a0(%rbp), %rax
addq $0x6a0, %rsp # imm = 0x6A0
popq %rbp
retq
callq 0x2a270
nop
| fn_format:
push rbp
mov rbp, rsp
sub rsp, 6A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_620], rdi
mov [rbp+var_628], rsi
mov [rbp+var_630], rdx
mov [rbp+var_638], rcx
mov [rbp+var_63C], r8d
jmp short $+2
loc_DF7CD:
jmp short $+2
loc_DF7CF:
jmp short $+2
loc_DF7D1:
jmp short $+2
loc_DF7D3:
jmp short $+2
loc_DF7D5:
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_628]
mov [rbp+var_650], rsi
lea rdx, [rbp+var_668]
call dirname_part
mov [rbp+var_660], rax
add rax, [rbp+var_628]
mov [rbp+var_628], rax
cmp [rbp+var_660], 0
jz short loc_DF823
mov eax, [rbp+var_63C]
and eax, 1
cmp eax, 0
jz short loc_DF83F
loc_DF823:
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_630]
xor eax, eax
mov edx, eax
call convert_dirname
jmp loc_DF8EF
loc_DF83F:
mov eax, [rbp+var_63C]
and eax, 80h
cmp eax, 0
jz loc_DF8ED
lea rdi, [rbp+var_210]
call test_if_hard_path
cmp eax, 0
jnz loc_DF8ED
lea rdi, [rbp+var_610]
xor esi, esi
mov edx, 200h
call _memset
mov [rbp+var_610], 2
lea rdi, [rbp+var_410]
lea rsi, [rbp+var_210]
mov edx, 1FFh
call strmake
mov [rbp+var_670], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_630]
xor eax, eax
mov edx, eax
call convert_dirname
mov [rbp+var_648], rax
mov rdi, [rbp+var_648]
lea rsi, [rbp+var_410]
mov rax, [rbp+var_648]
lea rcx, [rbp+var_210]
sub rax, rcx
cdqe
mov edx, 1FFh
sub rdx, rax
call strmake
loc_DF8ED:
jmp short $+2
loc_DF8EF:
mov eax, [rbp+var_63C]
and eax, 8
cmp eax, 0
jz short loc_DF910
lea rdi, [rbp+var_210]
lea rsi, [rbp+var_210]
call pack_dirname
loc_DF910:
mov eax, [rbp+var_63C]
and eax, 4
cmp eax, 0
jz short loc_DF931
lea rdi, [rbp+var_210]
lea rsi, [rbp+var_210]
call unpack_dirname
loc_DF931:
mov eax, [rbp+var_63C]
and eax, 100h
cmp eax, 0
jnz short loc_DF9B8
mov rdi, [rbp+var_628]
mov esi, 2Eh ; '.'
call _strchr
mov [rbp+var_648], rax
cmp rax, 0
jz short loc_DF9B8
mov eax, [rbp+var_63C]
and eax, 2
cmp eax, 0
jnz short loc_DF990
mov rdi, [rbp+var_628]
call strlength
mov [rbp+var_660], rax
lea rax, asc_157CA0+4; ""
mov [rbp+var_658], rax
jmp short loc_DF9B6
loc_DF990:
mov rax, [rbp+var_648]
mov rcx, [rbp+var_628]
sub rax, rcx
mov [rbp+var_660], rax
mov rax, [rbp+var_638]
mov [rbp+var_658], rax
loc_DF9B6:
jmp short loc_DF9D9
loc_DF9B8:
mov rdi, [rbp+var_628]
call strlength
mov [rbp+var_660], rax
mov rax, [rbp+var_638]
mov [rbp+var_658], rax
loc_DF9D9:
lea rdi, [rbp+var_210]
call _strlen
add rax, [rbp+var_660]
mov [rbp+var_680], rax
mov rdi, [rbp+var_658]
call _strlen
mov rcx, rax
mov rax, [rbp+var_680]
add rax, rcx
cmp rax, 200h
jnb short loc_DFA25
cmp [rbp+var_660], 100h
jb loc_DFABD
loc_DFA25:
mov eax, [rbp+var_63C]
and eax, 40h
cmp eax, 0
jz short loc_DFA45
jmp short $+2
loc_DFA35:
mov [rbp+var_618], 0
jmp loc_DFBA9
loc_DFA45:
mov rdi, [rbp+var_650]
call strlength
mov [rbp+var_678], rax
jmp short $+2
loc_DFA5A:
mov rax, [rbp+var_620]
mov [rbp+var_690], rax
mov rax, [rbp+var_650]
mov [rbp+var_688], rax
cmp [rbp+var_678], 1FFh
jnb short loc_DFA93
mov rax, [rbp+var_678]
mov [rbp+var_698], rax
jmp short loc_DFAA1
loc_DFA93:
mov eax, 1FFh
mov [rbp+var_698], rax
jmp short $+2
loc_DFAA1:
mov rsi, [rbp+var_688]
mov rdi, [rbp+var_690]
mov rdx, [rbp+var_698]
call strmake
jmp short loc_DFB38
loc_DFABD:
mov rax, [rbp+var_620]
cmp rax, [rbp+var_650]
jnz short loc_DFAF5
lea rdi, [rbp+var_410]
mov rsi, [rbp+var_628]
mov rdx, [rbp+var_660]
call _memmove
lea rax, [rbp+var_410]
mov [rbp+var_628], rax
loc_DFAF5:
mov rdi, [rbp+var_620]
lea rsi, [rbp+var_210]
call _stpcpy
mov rdi, rax
mov rsi, [rbp+var_628]
mov rdx, [rbp+var_660]
call strmake
mov [rbp+var_648], rax
mov rdi, [rbp+var_648]
mov rsi, [rbp+var_658]
call _stpcpy
loc_DFB38:
mov eax, [rbp+var_63C]
and eax, 20h
cmp eax, 0
jz short loc_DFB5F
mov rdi, [rbp+var_620]
mov rsi, [rbp+var_620]
xor eax, eax
mov edx, eax
call my_realpath
jmp short loc_DFB99
loc_DFB5F:
mov eax, [rbp+var_63C]
and eax, 10h
cmp eax, 0
jz short loc_DFB97
lea rdi, [rbp+var_410]
mov rsi, [rbp+var_620]
call _stpcpy
mov rdi, [rbp+var_620]
lea rsi, [rbp+var_410]
xor eax, eax
mov edx, eax
call my_readlink
loc_DFB97:
jmp short $+2
loc_DFB99:
jmp short $+2
loc_DFB9B:
mov rax, [rbp+var_620]
mov [rbp+var_618], rax
loc_DFBA9:
mov rax, [rbp+var_618]
mov [rbp+var_6A0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DFBD9
mov rax, [rbp+var_6A0]
add rsp, 6A0h
pop rbp
retn
loc_DFBD9:
call ___stack_chk_fail
| _BYTE * fn_format(_BYTE *a1, _BYTE *a2, long long a3, char *a4, int a5)
{
long long v5; // rax
long long v6; // rax
unsigned long long v8; // [rsp+20h] [rbp-680h]
unsigned long long v9; // [rsp+28h] [rbp-678h]
long long v10; // [rsp+38h] [rbp-668h] BYREF
unsigned long long v11; // [rsp+40h] [rbp-660h]
char *v12; // [rsp+48h] [rbp-658h]
_BYTE *v13; // [rsp+50h] [rbp-650h]
_BYTE *v14; // [rsp+58h] [rbp-648h]
int v15; // [rsp+64h] [rbp-63Ch]
char *v16; // [rsp+68h] [rbp-638h]
long long v17; // [rsp+70h] [rbp-630h]
_BYTE *v18; // [rsp+78h] [rbp-628h]
_BYTE *v19; // [rsp+80h] [rbp-620h]
char v21[512]; // [rsp+90h] [rbp-610h] BYREF
_BYTE v22[512]; // [rsp+290h] [rbp-410h] BYREF
_BYTE v23[520]; // [rsp+490h] [rbp-210h] BYREF
unsigned long long v24; // [rsp+698h] [rbp-8h]
v24 = __readfsqword(0x28u);
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v13 = a2;
v11 = dirname_part((long long)v23, a2, &v10);
v18 += v11;
if ( v11 && (v15 & 1) == 0 )
{
if ( (v15 & 0x80) != 0 && !(unsigned int)test_if_hard_path(v23) )
{
memset(v21, 0LL, sizeof(v21));
v21[0] = 2;
strmake(v22, v23, 511LL);
v14 = convert_dirname(v23, v17, 0LL);
strmake(v14, v22, 511LL - (int)((_DWORD)v14 - (unsigned int)v23));
}
}
else
{
convert_dirname(v23, v17, 0LL);
}
if ( (v15 & 8) != 0 )
pack_dirname(v23, v23);
if ( (v15 & 4) != 0 )
unpack_dirname(v23, v23);
if ( (v15 & 0x100) != 0 || (v14 = (_BYTE *)strchr(v18, 46LL)) == 0LL )
{
v11 = strlength(v18);
v12 = v16;
}
else if ( (v15 & 2) != 0 )
{
v11 = v14 - v18;
v12 = v16;
}
else
{
v11 = strlength(v18);
v12 = "";
}
v5 = strlen(v23);
v8 = v11 + v5;
if ( strlen(v12) + v8 < 0x200 && v11 < 0x100 )
{
if ( v19 == v13 )
{
memmove(v22, v18, v11);
v18 = v22;
}
v6 = stpcpy(v19, v23);
v14 = (_BYTE *)strmake(v6, v18, v11);
stpcpy(v14, v12);
}
else
{
if ( (v15 & 0x40) != 0 )
return 0LL;
v9 = strlength(v13);
if ( v9 >= 0x1FF )
strmake(v19, v13, 511LL);
else
strmake(v19, v13, v9);
}
if ( (v15 & 0x20) != 0 )
{
my_realpath(v19, v19, 0LL);
}
else if ( (v15 & 0x10) != 0 )
{
stpcpy(v22, v19);
my_readlink(v19, v22, 0LL);
}
return v19;
}
| fn_format:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x6a0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x620],RDI
MOV qword ptr [RBP + -0x628],RSI
MOV qword ptr [RBP + -0x630],RDX
MOV qword ptr [RBP + -0x638],RCX
MOV dword ptr [RBP + -0x63c],R8D
JMP 0x001df7cd
LAB_001df7cd:
JMP 0x001df7cf
LAB_001df7cf:
JMP 0x001df7d1
LAB_001df7d1:
JMP 0x001df7d3
LAB_001df7d3:
JMP 0x001df7d5
LAB_001df7d5:
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x628]
MOV qword ptr [RBP + -0x650],RSI
LEA RDX,[RBP + -0x668]
CALL 0x001df670
MOV qword ptr [RBP + -0x660],RAX
ADD RAX,qword ptr [RBP + -0x628]
MOV qword ptr [RBP + -0x628],RAX
CMP qword ptr [RBP + -0x660],0x0
JZ 0x001df823
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001df83f
LAB_001df823:
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x630]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001df6d0
JMP 0x001df8ef
LAB_001df83f:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001df8ed
LEA RDI,[RBP + -0x210]
CALL 0x001f03b0
CMP EAX,0x0
JNZ 0x001df8ed
LEA RDI,[RBP + -0x610]
XOR ESI,ESI
MOV EDX,0x200
CALL 0x0012a2c0
MOV byte ptr [RBP + -0x610],0x2
LEA RDI,[RBP + -0x410]
LEA RSI,[RBP + -0x210]
MOV EDX,0x1ff
CALL 0x0024de30
MOV qword ptr [RBP + -0x670],RAX
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x630]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001df6d0
MOV qword ptr [RBP + -0x648],RAX
MOV RDI,qword ptr [RBP + -0x648]
LEA RSI,[RBP + -0x410]
MOV RAX,qword ptr [RBP + -0x648]
LEA RCX,[RBP + -0x210]
SUB RAX,RCX
CDQE
MOV EDX,0x1ff
SUB RDX,RAX
CALL 0x0024de30
LAB_001df8ed:
JMP 0x001df8ef
LAB_001df8ef:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001df910
LEA RDI,[RBP + -0x210]
LEA RSI,[RBP + -0x210]
CALL 0x001e88f0
LAB_001df910:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001df931
LEA RDI,[RBP + -0x210]
LEA RSI,[RBP + -0x210]
CALL 0x001e9370
LAB_001df931:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x100
CMP EAX,0x0
JNZ 0x001df9b8
MOV RDI,qword ptr [RBP + -0x628]
MOV ESI,0x2e
CALL 0x0012a410
MOV qword ptr [RBP + -0x648],RAX
CMP RAX,0x0
JZ 0x001df9b8
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x001df990
MOV RDI,qword ptr [RBP + -0x628]
CALL 0x001dfbe0
MOV qword ptr [RBP + -0x660],RAX
LEA RAX,[0x257ca4]
MOV qword ptr [RBP + -0x658],RAX
JMP 0x001df9b6
LAB_001df990:
MOV RAX,qword ptr [RBP + -0x648]
MOV RCX,qword ptr [RBP + -0x628]
SUB RAX,RCX
MOV qword ptr [RBP + -0x660],RAX
MOV RAX,qword ptr [RBP + -0x638]
MOV qword ptr [RBP + -0x658],RAX
LAB_001df9b6:
JMP 0x001df9d9
LAB_001df9b8:
MOV RDI,qword ptr [RBP + -0x628]
CALL 0x001dfbe0
MOV qword ptr [RBP + -0x660],RAX
MOV RAX,qword ptr [RBP + -0x638]
MOV qword ptr [RBP + -0x658],RAX
LAB_001df9d9:
LEA RDI,[RBP + -0x210]
CALL 0x0012a350
ADD RAX,qword ptr [RBP + -0x660]
MOV qword ptr [RBP + -0x680],RAX
MOV RDI,qword ptr [RBP + -0x658]
CALL 0x0012a350
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x680]
ADD RAX,RCX
CMP RAX,0x200
JNC 0x001dfa25
CMP qword ptr [RBP + -0x660],0x100
JC 0x001dfabd
LAB_001dfa25:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x40
CMP EAX,0x0
JZ 0x001dfa45
JMP 0x001dfa35
LAB_001dfa35:
MOV qword ptr [RBP + -0x618],0x0
JMP 0x001dfba9
LAB_001dfa45:
MOV RDI,qword ptr [RBP + -0x650]
CALL 0x001dfbe0
MOV qword ptr [RBP + -0x678],RAX
JMP 0x001dfa5a
LAB_001dfa5a:
MOV RAX,qword ptr [RBP + -0x620]
MOV qword ptr [RBP + -0x690],RAX
MOV RAX,qword ptr [RBP + -0x650]
MOV qword ptr [RBP + -0x688],RAX
CMP qword ptr [RBP + -0x678],0x1ff
JNC 0x001dfa93
MOV RAX,qword ptr [RBP + -0x678]
MOV qword ptr [RBP + -0x698],RAX
JMP 0x001dfaa1
LAB_001dfa93:
MOV EAX,0x1ff
MOV qword ptr [RBP + -0x698],RAX
JMP 0x001dfaa1
LAB_001dfaa1:
MOV RSI,qword ptr [RBP + -0x688]
MOV RDI,qword ptr [RBP + -0x690]
MOV RDX,qword ptr [RBP + -0x698]
CALL 0x0024de30
JMP 0x001dfb38
LAB_001dfabd:
MOV RAX,qword ptr [RBP + -0x620]
CMP RAX,qword ptr [RBP + -0x650]
JNZ 0x001dfaf5
LEA RDI,[RBP + -0x410]
MOV RSI,qword ptr [RBP + -0x628]
MOV RDX,qword ptr [RBP + -0x660]
CALL 0x0012a130
LEA RAX,[RBP + -0x410]
MOV qword ptr [RBP + -0x628],RAX
LAB_001dfaf5:
MOV RDI,qword ptr [RBP + -0x620]
LEA RSI,[RBP + -0x210]
CALL 0x0012a730
MOV RDI,RAX
MOV RSI,qword ptr [RBP + -0x628]
MOV RDX,qword ptr [RBP + -0x660]
CALL 0x0024de30
MOV qword ptr [RBP + -0x648],RAX
MOV RDI,qword ptr [RBP + -0x648]
MOV RSI,qword ptr [RBP + -0x658]
CALL 0x0012a730
LAB_001dfb38:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001dfb5f
MOV RDI,qword ptr [RBP + -0x620]
MOV RSI,qword ptr [RBP + -0x620]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f5050
JMP 0x001dfb99
LAB_001dfb5f:
MOV EAX,dword ptr [RBP + -0x63c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001dfb97
LEA RDI,[RBP + -0x410]
MOV RSI,qword ptr [RBP + -0x620]
CALL 0x0012a730
MOV RDI,qword ptr [RBP + -0x620]
LEA RSI,[RBP + -0x410]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f4e50
LAB_001dfb97:
JMP 0x001dfb99
LAB_001dfb99:
JMP 0x001dfb9b
LAB_001dfb9b:
MOV RAX,qword ptr [RBP + -0x620]
MOV qword ptr [RBP + -0x618],RAX
LAB_001dfba9:
MOV RAX,qword ptr [RBP + -0x618]
MOV qword ptr [RBP + -0x6a0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001dfbd9
MOV RAX,qword ptr [RBP + -0x6a0]
ADD RSP,0x6a0
POP RBP
RET
LAB_001dfbd9:
CALL 0x0012a270
|
char * fn_format(char *param_1,char *param_2,int8 param_3,char *param_4,uint param_5)
{
int iVar1;
size_t sVar2;
long lVar3;
char *pcVar4;
long in_FS_OFFSET;
ulong local_6a0;
int1 local_670 [8];
ulong local_668;
char *local_660;
char *local_658;
char *local_650;
uint local_644;
char *local_640;
int8 local_638;
char *local_630;
char *local_628;
char *local_620;
int1 local_618 [512];
char local_418 [512];
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_658 = param_2;
local_644 = param_5;
local_640 = param_4;
local_638 = param_3;
local_630 = param_2;
local_628 = param_1;
local_668 = dirname_part(local_218,param_2,local_670);
local_630 = local_630 + local_668;
if ((local_668 == 0) || ((local_644 & 1) != 0)) {
convert_dirname(local_218,local_638,0);
}
else if (((local_644 & 0x80) != 0) && (iVar1 = test_if_hard_path(local_218), iVar1 == 0)) {
memset(local_618,0,0x200);
local_618[0] = 2;
strmake(local_418,local_218,0x1ff);
local_650 = (char *)convert_dirname(local_218,local_638,0);
strmake(local_650,local_418,0x1ff - (long)((int)local_650 - (int)local_218));
}
if ((local_644 & 8) != 0) {
pack_dirname(local_218,local_218);
}
if ((local_644 & 4) != 0) {
unpack_dirname(local_218,local_218);
}
if (((local_644 & 0x100) == 0) && (local_650 = strchr(local_630,0x2e), local_650 != (char *)0x0))
{
if ((local_644 & 2) == 0) {
local_668 = strlength(local_630);
local_660 = "";
}
else {
local_668 = (long)local_650 - (long)local_630;
local_660 = local_640;
}
}
else {
local_668 = strlength(local_630);
local_660 = local_640;
}
sVar2 = strlen(local_218);
lVar3 = sVar2 + local_668;
sVar2 = strlen(local_660);
if ((lVar3 + sVar2 < 0x200) && (local_668 < 0x100)) {
if (local_628 == local_658) {
memmove(local_418,local_630,local_668);
local_630 = local_418;
}
pcVar4 = stpcpy(local_628,local_218);
local_650 = (char *)strmake(pcVar4,local_630,local_668);
stpcpy(local_650,local_660);
}
else {
if ((local_644 & 0x40) != 0) {
local_620 = (char *)0x0;
goto LAB_001dfba9;
}
local_6a0 = strlength(local_658);
if (0x1fe < local_6a0) {
local_6a0 = 0x1ff;
}
strmake(local_628,local_658,local_6a0);
}
if ((local_644 & 0x20) == 0) {
if ((local_644 & 0x10) != 0) {
stpcpy(local_418,local_628);
my_readlink(local_628,local_418,0);
}
}
else {
my_realpath(local_628,local_628,0);
}
local_620 = local_628;
LAB_001dfba9:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_620;
}
| |
34,985 | my_strnncollsp_nchars_generic | eloqsql/strings/ctype.c | int my_strnncollsp_nchars_generic(CHARSET_INFO *cs,
const uchar *str1, size_t len1,
const uchar *str2, size_t len2,
size_t nchars)
{
int error;
len1= my_well_formed_length(cs, (const char *) str1,
(const char *) str1 + len1,
nchars, &error);
len2= my_well_formed_length(cs, (const char *) str2,
(const char *) str2 + len2,
nchars, &error);
DBUG_ASSERT((cs->state & MY_CS_NOPAD) == 0);
return cs->coll->strnncollsp(cs, str1, len1, str2, len2);
} | O3 | c | my_strnncollsp_nchars_generic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x30(%rbp)
movq %r8, %r13
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rdx
movq 0xb8(%rdi), %rax
leaq -0x40(%rbp), %r12
movq %r9, %rcx
movq %r12, %r8
callq *0xc8(%rax)
movq (%r12), %r12
subq %r14, %r12
addq %rbx, %r13
movq 0xb8(%r15), %rax
leaq -0x40(%rbp), %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq -0x30(%rbp), %rcx
movq %r8, %r13
callq *0xc8(%rax)
movq (%r13), %r8
subq %rbx, %r8
movq 0xc0(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x10(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnncollsp_nchars_generic:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_30], r9
mov r13, r8
mov rbx, rcx
mov r14, rsi
mov r15, rdi
add rdx, rsi
mov rax, [rdi+0B8h]
lea r12, [rbp+var_40]
mov rcx, r9
mov r8, r12
call qword ptr [rax+0C8h]
mov r12, [r12]
sub r12, r14
add r13, rbx
mov rax, [r15+0B8h]
lea r8, [rbp+var_40]
mov rdi, r15
mov rsi, rbx
mov rdx, r13
mov rcx, [rbp+var_30]
mov r13, r8
call qword ptr [rax+0C8h]
mov r8, [r13+0]
sub r8, rbx
mov rax, [r15+0C0h]
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, rbx
call qword ptr [rax+10h]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strnncollsp_nchars_generic(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
long long v8; // r12
long long v10; // [rsp+0h] [rbp-40h] BYREF
long long v11; // [rsp+10h] [rbp-30h]
v11 = a6;
(*(void ( **)(long long, long long, long long, long long, long long *))(*(_QWORD *)(a1 + 184) + 200LL))(
a1,
a2,
a2 + a3,
a6,
&v10);
v8 = v10 - a2;
(*(void ( **)(long long, long long, long long, long long))(*(_QWORD *)(a1 + 184) + 200LL))(a1, a4, a4 + a5, v11);
return (*(long long ( **)(long long, long long, long long, long long, long long))(*(_QWORD *)(a1 + 192) + 16LL))(
a1,
a2,
v8,
a4,
v10 - a4);
}
| my_strnncollsp_nchars_generic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x30],R9
MOV R13,R8
MOV RBX,RCX
MOV R14,RSI
MOV R15,RDI
ADD RDX,RSI
MOV RAX,qword ptr [RDI + 0xb8]
LEA R12,[RBP + -0x40]
MOV RCX,R9
MOV R8,R12
CALL qword ptr [RAX + 0xc8]
MOV R12,qword ptr [R12]
SUB R12,R14
ADD R13,RBX
MOV RAX,qword ptr [R15 + 0xb8]
LEA R8,[RBP + -0x40]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x30]
MOV R13,R8
CALL qword ptr [RAX + 0xc8]
MOV R8,qword ptr [R13]
SUB R8,RBX
MOV RAX,qword ptr [R15 + 0xc0]
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,RBX
CALL qword ptr [RAX + 0x10]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnncollsp_nchars_generic
(long param_1,long param_2,long param_3,long param_4,long param_5,int8 param_6)
{
long lVar1;
long local_48 [2];
int8 local_38;
local_38 = param_6;
(**(code **)(*(long *)(param_1 + 0xb8) + 200))(param_1,param_2,param_3 + param_2,param_6,local_48)
;
lVar1 = local_48[0] - param_2;
(**(code **)(*(long *)(param_1 + 0xb8) + 200))(param_1,param_4,param_5 + param_4,local_38);
(**(code **)(*(long *)(param_1 + 0xc0) + 0x10))
(param_1,param_2,lVar1,param_4,local_48[0] - param_4);
return;
}
| |
34,986 | httplib::detail::SocketStream::write(char const*, unsigned long) | hkr04[P]cpp-mcp/common/httplib.h | inline ssize_t SocketStream::write(const char *ptr, size_t size) {
if (!is_writable()) { return -1; }
#if defined(_WIN32) && !defined(_WIN64)
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#endif
return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
} | O1 | c | httplib::detail::SocketStream::write(char const*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x16806
movq $-0x1, %r13
testb %al, %al
je 0x16b79
movl 0x8(%r15), %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8290
movq %rax, %r13
testq %rax, %rax
jns 0x16b79
callq 0x8060
cmpl $0x4, (%rax)
jne 0x16b79
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%rsp)
movq $0x3e8, 0x10(%rsp) # imm = 0x3E8
movq %r12, %rdi
movq %r12, %rsi
callq 0x8130
cmpl $-0x1, %eax
jne 0x16b5c
cmpl $0x4, (%r15)
je 0x16b46
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8290
movq %rax, %r13
testq %rax, %rax
jns 0x16b79
cmpl $0x4, (%r15)
je 0x16b34
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN7httplib6detail12SocketStream5writeEPKcm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
call _ZNK7httplib6detail12SocketStream11is_writableEv; httplib::detail::SocketStream::is_writable(void)
mov r13, 0FFFFFFFFFFFFFFFFh
test al, al
jz short loc_16B79
mov ebp, [r15+8]
mov edi, ebp
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call _send
mov r13, rax
test rax, rax
jns short loc_16B79
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_16B79
mov r15, rax
lea r12, [rsp+48h+var_40]
loc_16B34:
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 3E8h
loc_16B46:
mov rdi, r12
mov rsi, r12
call _nanosleep
cmp eax, 0FFFFFFFFh
jnz short loc_16B5C
cmp dword ptr [r15], 4
jz short loc_16B46
loc_16B5C:
mov edi, ebp
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call _send
mov r13, rax
test rax, rax
jns short loc_16B79
cmp dword ptr [r15], 4
jz short loc_16B34
loc_16B79:
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long httplib::detail::SocketStream::write(
httplib::detail::SocketStream *this,
const char *a2,
long long a3)
{
long long v4; // r13
unsigned int v5; // ebp
_DWORD *v6; // rax
_DWORD *v7; // r15
_QWORD v9[8]; // [rsp+8h] [rbp-40h] BYREF
v4 = -1LL;
if ( (unsigned __int8)httplib::detail::SocketStream::is_writable(this) )
{
v5 = *((_DWORD *)this + 2);
v4 = send(v5, a2, a3, 0LL);
if ( v4 < 0 )
{
v6 = (_DWORD *)__errno_location(v5, a2);
if ( *v6 == 4 )
{
v7 = v6;
do
{
v9[0] = 0LL;
v9[1] = 1000LL;
while ( (unsigned int)nanosleep(v9, v9) == -1 && *v7 == 4 )
;
v4 = send(v5, a2, a3, 0LL);
}
while ( v4 < 0 && *v7 == 4 );
}
}
}
return v4;
}
| write:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CALL 0x00116806
MOV R13,-0x1
TEST AL,AL
JZ 0x00116b79
MOV EBP,dword ptr [R15 + 0x8]
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00108290
MOV R13,RAX
TEST RAX,RAX
JNS 0x00116b79
CALL 0x00108060
CMP dword ptr [RAX],0x4
JNZ 0x00116b79
MOV R15,RAX
LEA R12,[RSP + 0x8]
LAB_00116b34:
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x3e8
LAB_00116b46:
MOV RDI,R12
MOV RSI,R12
CALL 0x00108130
CMP EAX,-0x1
JNZ 0x00116b5c
CMP dword ptr [R15],0x4
JZ 0x00116b46
LAB_00116b5c:
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00108290
MOV R13,RAX
TEST RAX,RAX
JNS 0x00116b79
CMP dword ptr [R15],0x4
JZ 0x00116b34
LAB_00116b79:
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::SocketStream::write(char const*, unsigned long) */
ssize_t __thiscall
httplib::detail::SocketStream::write(SocketStream *this,char *param_1,ulong param_2)
{
int __fd;
char cVar1;
int iVar2;
int *piVar3;
ssize_t sVar4;
timespec local_40;
cVar1 = is_writable(this);
sVar4 = -1;
if (cVar1 != '\0') {
__fd = *(int *)(this + 8);
sVar4 = send(__fd,param_1,param_2,0);
if (sVar4 < 0) {
piVar3 = __errno_location();
if (*piVar3 == 4) {
do {
local_40.tv_sec = 0;
local_40.tv_nsec = 1000;
do {
iVar2 = nanosleep(&local_40,&local_40);
if (iVar2 != -1) break;
} while (*piVar3 == 4);
sVar4 = send(__fd,param_1,param_2,0);
} while ((sVar4 < 0) && (*piVar3 == 4));
}
}
}
return sVar4;
}
| |
34,987 | httplib::detail::SocketStream::write(char const*, unsigned long) | hkr04[P]cpp-mcp/common/httplib.h | inline ssize_t SocketStream::write(const char *ptr, size_t size) {
if (!is_writable()) { return -1; }
#if defined(_WIN32) && !defined(_WIN64)
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#endif
return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
} | O2 | c | httplib::detail::SocketStream::write(char const*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x13526
testb %al, %al
je 0x13651
movl 0x8(%r15), %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x2a594
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN7httplib6detail12SocketStream5writeEPKcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
call _ZNK7httplib6detail12SocketStream11is_writableEv; httplib::detail::SocketStream::is_writable(void)
test al, al
jz short loc_13651
mov edi, [r15+8]; this
mov rsi, r14; int
mov rdx, rbx; void *
xor ecx, ecx; unsigned __int64
pop rbx
pop r14
pop r15
jmp _ZN7httplib6detail11send_socketEiPKvmi; httplib::detail::send_socket(int,void const*,ulong,int)
loc_13651:
push 0FFFFFFFFFFFFFFFFh
pop rax
pop rbx
pop r14
pop r15
retn
| long long httplib::detail::SocketStream::write(
httplib::detail::SocketStream *this,
const char *a2,
const void *a3)
{
int v4; // r8d
if ( (unsigned __int8)httplib::detail::SocketStream::is_writable(this) )
return httplib::detail::send_socket((httplib::detail *)*((unsigned int *)this + 2), (int)a2, a3, 0LL, v4);
else
return -1LL;
}
| write:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CALL 0x00113526
TEST AL,AL
JZ 0x00113651
MOV EDI,dword ptr [R15 + 0x8]
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
POP RBX
POP R14
POP R15
JMP 0x0012a594
LAB_00113651:
PUSH -0x1
POP RAX
POP RBX
POP R14
POP R15
RET
|
/* httplib::detail::SocketStream::write(char const*, unsigned long) */
int8 __thiscall
httplib::detail::SocketStream::write(SocketStream *this,char *param_1,ulong param_2)
{
char cVar1;
int8 uVar2;
cVar1 = is_writable(this);
if (cVar1 != '\0') {
uVar2 = send_socket(*(int *)(this + 8),param_1,param_2,0);
return uVar2;
}
return 0xffffffffffffffff;
}
| |
34,988 | stbi__YCbCr_to_RGB_row | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
{
int i;
for (i=0; i < count; ++i) {
int y_fixed = (y[i] << 20) + (1<<19); // rounding
int r,g,b;
int cr = pcr[i] - 128;
int cb = pcb[i] - 128;
r = y_fixed + cr* stbi__float2fixed(1.40200f);
g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
b = y_fixed + cb* stbi__float2fixed(1.77200f);
r >>= 20;
g >>= 20;
b >>= 20;
if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
out[0] = (stbi_uc)r;
out[1] = (stbi_uc)g;
out[2] = (stbi_uc)b;
out[3] = 255;
out += step;
}
} | O1 | c | stbi__YCbCr_to_RGB_row:
testl %r8d, %r8d
jle 0x37343
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %r9d, %rax
movl %r8d, %r8d
addq $0x3, %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
movl $0xff, %ebp
movzbl (%rsi,%r10), %ebx
shll $0x14, %ebx
movzbl (%rcx,%r10), %r14d
addl $-0x80, %r14d
imull $0x166f00, %r14d, %r11d # imm = 0x166F00
addl %ebx, %r11d
addl $0x80000, %r11d # imm = 0x80000
sarl $0x14, %r11d
testl %r11d, %r11d
cmovlel %r9d, %r11d
cmpl %ebp, %r11d
jl 0x372b9
movl $0xff, %r11d
movzbl (%rdx,%r10), %r15d
addl $-0x80, %r15d
imull $0xfff49300, %r14d, %r14d # imm = 0xFFF49300
leal (%r14,%rbx), %r12d
addl $0x80000, %r12d # imm = 0x80000
imull $0xfffa7e00, %r15d, %r14d # imm = 0xFFFA7E00
andl $0xffff0000, %r14d # imm = 0xFFFF0000
addl %r12d, %r14d
sarl $0x14, %r14d
testl %r14d, %r14d
jg 0x372f1
xorl %r14d, %r14d
cmpl %ebp, %r14d
jl 0x372fc
movl $0xff, %r14d
imull $0x1c5a00, %r15d, %r15d # imm = 0x1C5A00
addl %r15d, %ebx
addl $0x80000, %ebx # imm = 0x80000
sarl $0x14, %ebx
testl %ebx, %ebx
cmovlel %r9d, %ebx
cmpl %ebp, %ebx
jl 0x3731e
movl $0xff, %ebx
movb %r11b, -0x3(%rdi)
movb %r14b, -0x2(%rdi)
movb %bl, -0x1(%rdi)
movb $-0x1, (%rdi)
incq %r10
addq %rax, %rdi
cmpq %r10, %r8
jne 0x37281
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| stbi__YCbCr_to_RGB_row:
test r8d, r8d
jle locret_37343
push rbp
push r15
push r14
push r12
push rbx
movsxd rax, r9d
mov r8d, r8d
add rdi, 3
xor r9d, r9d
xor r10d, r10d
mov ebp, 0FFh
loc_37281:
movzx ebx, byte ptr [rsi+r10]
shl ebx, 14h
movzx r14d, byte ptr [rcx+r10]
add r14d, 0FFFFFF80h
imul r11d, r14d, 166F00h
add r11d, ebx
add r11d, 80000h
sar r11d, 14h
test r11d, r11d
cmovle r11d, r9d
cmp r11d, ebp
jl short loc_372B9
mov r11d, 0FFh
loc_372B9:
movzx r15d, byte ptr [rdx+r10]
add r15d, 0FFFFFF80h
imul r14d, 0FFF49300h
lea r12d, [r14+rbx]
add r12d, 80000h
imul r14d, r15d, 0FFFA7E00h
and r14d, 0FFFF0000h
add r14d, r12d
sar r14d, 14h
test r14d, r14d
jg short loc_372F1
xor r14d, r14d
loc_372F1:
cmp r14d, ebp
jl short loc_372FC
mov r14d, 0FFh
loc_372FC:
imul r15d, 1C5A00h
add ebx, r15d
add ebx, 80000h
sar ebx, 14h
test ebx, ebx
cmovle ebx, r9d
cmp ebx, ebp
jl short loc_3731E
mov ebx, 0FFh
loc_3731E:
mov [rdi-3], r11b
mov [rdi-2], r14b
mov [rdi-1], bl
mov byte ptr [rdi], 0FFh
inc r10
add rdi, rax
cmp r8, r10
jnz loc_37281
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_37343:
retn
| void stbi__YCbCr_to_RGB_row(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
_BYTE *v6; // rdi
long long i; // r10
int v8; // ebx
int v9; // r14d
int v10; // r11d
int v11; // r15d
int v12; // r14d
int v13; // ebx
if ( a5 > 0 )
{
v6 = (_BYTE *)(a1 + 3);
for ( i = 0LL; i != a5; ++i )
{
v8 = *(unsigned __int8 *)(a2 + i) << 20;
v9 = *(unsigned __int8 *)(a4 + i) - 128;
v10 = (v8 + 1470208 * v9 + 0x80000) >> 20;
if ( v10 <= 0 )
v10 = 0;
if ( v10 >= 255 )
LOBYTE(v10) = -1;
v11 = *(unsigned __int8 *)(a3 + i) - 128;
v12 = (int)(-748800 * v9 + v8 + 0x80000 + ((-360960 * v11) & 0xFFFF0000)) >> 20;
if ( v12 <= 0 )
v12 = 0;
if ( v12 >= 255 )
LOBYTE(v12) = -1;
v13 = (1858048 * v11 + v8 + 0x80000) >> 20;
if ( v13 <= 0 )
v13 = 0;
if ( v13 >= 255 )
LOBYTE(v13) = -1;
*(v6 - 3) = v10;
*(v6 - 2) = v12;
*(v6 - 1) = v13;
*v6 = -1;
v6 += a6;
}
}
}
| stbi__YCbCr_to_RGB_row:
TEST R8D,R8D
JLE 0x00137343
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOVSXD RAX,R9D
MOV R8D,R8D
ADD RDI,0x3
XOR R9D,R9D
XOR R10D,R10D
MOV EBP,0xff
LAB_00137281:
MOVZX EBX,byte ptr [RSI + R10*0x1]
SHL EBX,0x14
MOVZX R14D,byte ptr [RCX + R10*0x1]
ADD R14D,-0x80
IMUL R11D,R14D,0x166f00
ADD R11D,EBX
ADD R11D,0x80000
SAR R11D,0x14
TEST R11D,R11D
CMOVLE R11D,R9D
CMP R11D,EBP
JL 0x001372b9
MOV R11D,0xff
LAB_001372b9:
MOVZX R15D,byte ptr [RDX + R10*0x1]
ADD R15D,-0x80
IMUL R14D,R14D,-0xb6d00
LEA R12D,[R14 + RBX*0x1]
ADD R12D,0x80000
IMUL R14D,R15D,-0x58200
AND R14D,0xffff0000
ADD R14D,R12D
SAR R14D,0x14
TEST R14D,R14D
JG 0x001372f1
XOR R14D,R14D
LAB_001372f1:
CMP R14D,EBP
JL 0x001372fc
MOV R14D,0xff
LAB_001372fc:
IMUL R15D,R15D,0x1c5a00
ADD EBX,R15D
ADD EBX,0x80000
SAR EBX,0x14
TEST EBX,EBX
CMOVLE EBX,R9D
CMP EBX,EBP
JL 0x0013731e
MOV EBX,0xff
LAB_0013731e:
MOV byte ptr [RDI + -0x3],R11B
MOV byte ptr [RDI + -0x2],R14B
MOV byte ptr [RDI + -0x1],BL
MOV byte ptr [RDI],0xff
INC R10
ADD RDI,RAX
CMP R8,R10
JNZ 0x00137281
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_00137343:
RET
|
void stbi__YCbCr_to_RGB_row
(long param_1,long param_2,long param_3,long param_4,uint param_5,int param_6)
{
int iVar1;
int1 *puVar2;
ulong uVar3;
int iVar4;
int iVar5;
int iVar6;
if (0 < (int)param_5) {
puVar2 = (int1 *)(param_1 + 3);
uVar3 = 0;
do {
iVar1 = (uint)*(byte *)(param_2 + uVar3) * 0x100000;
iVar5 = *(byte *)(param_4 + uVar3) - 0x80;
iVar4 = iVar5 * 0x166f00 + iVar1 + 0x80000 >> 0x14;
if (iVar4 < 1) {
iVar4 = 0;
}
if (0xfe < iVar4) {
iVar4 = 0xff;
}
iVar6 = *(byte *)(param_3 + uVar3) - 0x80;
iVar5 = (iVar6 * -0x58200 & 0xffff0000U) + iVar5 * -0xb6d00 + iVar1 + 0x80000;
if (iVar5 >> 0x14 < 1) {
iVar5 = 0;
}
iVar5 = iVar5 >> 0x14;
if (0xfe < iVar5) {
iVar5 = 0xff;
}
iVar1 = iVar1 + iVar6 * 0x1c5a00 + 0x80000 >> 0x14;
if (iVar1 < 1) {
iVar1 = 0;
}
if (0xfe < iVar1) {
iVar1 = 0xff;
}
puVar2[-3] = (char)iVar4;
puVar2[-2] = (char)iVar5;
puVar2[-1] = (char)iVar1;
*puVar2 = 0xff;
uVar3 = uVar3 + 1;
puVar2 = puVar2 + param_6;
} while (param_5 != uVar3);
}
return;
}
| |
34,989 | httplib::detail::MultipartFormDataParser::MultipartFormDataParser() | monkey531[P]llama/examples/server/httplib.h | MultipartFormDataParser() = default; | O3 | c | httplib::detail::MultipartFormDataParser::MultipartFormDataParser():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xdb0fa(%rip), %rsi # 0x1470b0
leaq 0xdb0f5(%rip), %rdx # 0x1470b2
callq 0x4b514
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0xdb10f(%rip), %rsi # 0x1470e4
leaq 0xdb10a(%rip), %rdx # 0x1470e6
callq 0x4b514
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movb %al, 0x90(%rbx)
movq %rax, 0xa0(%rbx)
movb %al, 0xa8(%rbx)
leaq 0xc0(%rbx), %rcx
movq %rcx, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movb %al, 0xc0(%rbx)
leaq 0xe0(%rbx), %rcx
movq %rcx, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
movb %al, 0xe0(%rbx)
leaq 0x100(%rbx), %rcx
movq %rcx, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
movb %al, 0x100(%rbx)
leaq 0x120(%rbx), %rcx
movq %rcx, 0x110(%rbx)
movq %rax, 0x118(%rbx)
movb %al, 0x120(%rbx)
leaq 0x140(%rbx), %rcx
movq %rcx, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movb %al, 0x140(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6c0d6
movq (%r15), %rsi
incq %rsi
callq 0x1fae0
movq %r14, %rdi
callq 0x20380
| _ZN7httplib6detail23MultipartFormDataParserC2Ev:
push r15
push r14
push rbx
mov rbx, rdi
lea r15, [rdi+10h]
mov [rdi], r15
lea rsi, asc_1470B0; "--"
lea rdx, asc_1470B0+2; ""
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, [rbx+20h]
lea rax, [rbx+30h]
mov [rbx+20h], rax
lea rsi, a0+1; "\r\n"
lea rdx, a0+3; ""
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 rax, [rbx+50h]
mov [rbx+40h], rax
xor eax, eax
mov [rbx+48h], rax
mov [rbx+50h], al
lea rcx, [rbx+70h]
mov [rbx+60h], rcx
mov [rbx+68h], rax
mov [rbx+70h], al
lea rcx, [rbx+90h]
mov [rbx+80h], rcx
mov [rbx+88h], rax
mov [rbx+90h], al
mov [rbx+0A0h], rax
mov [rbx+0A8h], al
lea rcx, [rbx+0C0h]
mov [rbx+0B0h], rcx
mov [rbx+0B8h], rax
mov [rbx+0C0h], al
lea rcx, [rbx+0E0h]
mov [rbx+0D0h], rcx
mov [rbx+0D8h], rax
mov [rbx+0E0h], al
lea rcx, [rbx+100h]
mov [rbx+0F0h], rcx
mov [rbx+0F8h], rax
mov [rbx+100h], al
lea rcx, [rbx+120h]
mov [rbx+110h], rcx
mov [rbx+118h], rax
mov [rbx+120h], al
lea rcx, [rbx+140h]
mov [rbx+130h], rcx
mov [rbx+138h], rax
mov [rbx+140h], al
xorps xmm0, xmm0
movups xmmword ptr [rbx+150h], xmm0
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r15
jz short loc_6C0D6
mov rsi, [r15]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6C0D6:
mov rdi, r14
call __Unwind_Resume
| long long httplib::detail::MultipartFormDataParser::MultipartFormDataParser(
httplib::detail::MultipartFormDataParser *this)
{
long long result; // rax
*(_QWORD *)this = (char *)this + 16;
std::string::_M_construct<char const*>((long long)this, "--", (long long)"");
*((_QWORD *)this + 4) = (char *)this + 48;
std::string::_M_construct<char const*>((long long)this + 32, "\r\n", (long long)"");
*((_QWORD *)this + 8) = (char *)this + 80;
result = 0LL;
*((_QWORD *)this + 9) = 0LL;
*((_BYTE *)this + 80) = 0;
*((_QWORD *)this + 12) = (char *)this + 112;
*((_QWORD *)this + 13) = 0LL;
*((_BYTE *)this + 112) = 0;
*((_QWORD *)this + 16) = (char *)this + 144;
*((_QWORD *)this + 17) = 0LL;
*((_BYTE *)this + 144) = 0;
*((_QWORD *)this + 20) = 0LL;
*((_BYTE *)this + 168) = 0;
*((_QWORD *)this + 22) = (char *)this + 192;
*((_QWORD *)this + 23) = 0LL;
*((_BYTE *)this + 192) = 0;
*((_QWORD *)this + 26) = (char *)this + 224;
*((_QWORD *)this + 27) = 0LL;
*((_BYTE *)this + 224) = 0;
*((_QWORD *)this + 30) = (char *)this + 256;
*((_QWORD *)this + 31) = 0LL;
*((_BYTE *)this + 256) = 0;
*((_QWORD *)this + 34) = (char *)this + 288;
*((_QWORD *)this + 35) = 0LL;
*((_BYTE *)this + 288) = 0;
*((_QWORD *)this + 38) = (char *)this + 320;
*((_QWORD *)this + 39) = 0LL;
*((_BYTE *)this + 320) = 0;
*((_OWORD *)this + 21) = 0LL;
return result;
}
| MultipartFormDataParser:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
LEA RSI,[0x2470b0]
LEA RDX,[0x2470b2]
CALL 0x0014b514
LEA RDI,[RBX + 0x20]
LEA RAX,[RBX + 0x30]
MOV qword ptr [RBX + 0x20],RAX
LAB_0016bfce:
LEA RSI,[0x2470e4]
LEA RDX,[0x2470e6]
CALL 0x0014b514
LAB_0016bfe1:
LEA RAX,[RBX + 0x50]
MOV qword ptr [RBX + 0x40],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x48],RAX
MOV byte ptr [RBX + 0x50],AL
LEA RCX,[RBX + 0x70]
MOV qword ptr [RBX + 0x60],RCX
MOV qword ptr [RBX + 0x68],RAX
MOV byte ptr [RBX + 0x70],AL
LEA RCX,[RBX + 0x90]
MOV qword ptr [RBX + 0x80],RCX
MOV qword ptr [RBX + 0x88],RAX
MOV byte ptr [RBX + 0x90],AL
MOV qword ptr [RBX + 0xa0],RAX
MOV byte ptr [RBX + 0xa8],AL
LEA RCX,[RBX + 0xc0]
MOV qword ptr [RBX + 0xb0],RCX
MOV qword ptr [RBX + 0xb8],RAX
MOV byte ptr [RBX + 0xc0],AL
LEA RCX,[RBX + 0xe0]
MOV qword ptr [RBX + 0xd0],RCX
MOV qword ptr [RBX + 0xd8],RAX
MOV byte ptr [RBX + 0xe0],AL
LEA RCX,[RBX + 0x100]
MOV qword ptr [RBX + 0xf0],RCX
MOV qword ptr [RBX + 0xf8],RAX
MOV byte ptr [RBX + 0x100],AL
LEA RCX,[RBX + 0x120]
MOV qword ptr [RBX + 0x110],RCX
MOV qword ptr [RBX + 0x118],RAX
MOV byte ptr [RBX + 0x120],AL
LEA RCX,[RBX + 0x140]
MOV qword ptr [RBX + 0x130],RCX
MOV qword ptr [RBX + 0x138],RAX
MOV byte ptr [RBX + 0x140],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x150],XMM0
POP RBX
POP R14
POP R15
RET
|
/* httplib::detail::MultipartFormDataParser::MultipartFormDataParser() */
void __thiscall
httplib::detail::MultipartFormDataParser::MultipartFormDataParser(MultipartFormDataParser *this)
{
*(MultipartFormDataParser **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,&DAT_002470b0,&DAT_002470b2);
*(MultipartFormDataParser **)(this + 0x20) = this + 0x30;
/* try { // try from 0016bfce to 0016bfe0 has its CatchHandler @ 0016c0c0 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x20,&DAT_002470e4,&DAT_002470e6);
*(MultipartFormDataParser **)(this + 0x40) = this + 0x50;
*(int8 *)(this + 0x48) = 0;
this[0x50] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x60) = this + 0x70;
*(int8 *)(this + 0x68) = 0;
this[0x70] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x80) = this + 0x90;
*(int8 *)(this + 0x88) = 0;
this[0x90] = (MultipartFormDataParser)0x0;
*(int8 *)(this + 0xa0) = 0;
this[0xa8] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xb0) = this + 0xc0;
*(int8 *)(this + 0xb8) = 0;
this[0xc0] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xd0) = this + 0xe0;
*(int8 *)(this + 0xd8) = 0;
this[0xe0] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0xf0) = this + 0x100;
*(int8 *)(this + 0xf8) = 0;
this[0x100] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x110) = this + 0x120;
*(int8 *)(this + 0x118) = 0;
this[0x120] = (MultipartFormDataParser)0x0;
*(MultipartFormDataParser **)(this + 0x130) = this + 0x140;
*(int8 *)(this + 0x138) = 0;
this[0x140] = (MultipartFormDataParser)0x0;
*(int8 *)(this + 0x150) = 0;
*(int8 *)(this + 0x158) = 0;
return;
}
| |
34,990 | 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>::at<char const (&) [9], 0>(char const (&) [9]) const | monkey531[P]llama/common/json.hpp | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
} | O0 | 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>::at<char const (&) [9], 0>(char const (&) [9]) const:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd0590
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x183848
jmp 0x183924
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x5e6d0
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xd7360
movq %rax, 0x90(%rsp)
leaq 0xaf1a7(%rip), %rsi # 0x232a1f
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x18b3a0
jmp 0x18388f
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdi
movl $0x130, %esi # imm = 0x130
leaq 0x98(%rsp), %rdx
callq 0x1341c0
jmp 0x1838ad
movq 0x18(%rsp), %rdi
movb $0x0, 0x83(%rsp)
leaq 0x1434c7(%rip), %rsi # 0x2c6d88
leaq -0xac4b8(%rip), %rdx # 0xd7410
callq 0x5eb70
jmp 0x183aa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x183909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5f628
testb $0x1, 0x83(%rsp)
jne 0x183915
jmp 0x18391f
movq 0x18(%rsp), %rdi
callq 0x5f010
jmp 0x183a94
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0x18d2c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq 0x8(%rax), %rdi
callq 0xd5d90
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xd6d30
testb $0x1, %al
jne 0x18396d
jmp 0x183a7e
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0x5e6d0
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5f190
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x77040
jmp 0x1839b2
leaq 0xaf096(%rip), %rsi # 0x232a4f
leaq 0xaf095(%rip), %rcx # 0x232a55
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x18c5c0
jmp 0x1839d1
movq 0x20(%rsp), %rcx
movq (%rsp), %rdi
movl $0x193, %esi # imm = 0x193
leaq 0x50(%rsp), %rdx
callq 0x18d4b0
jmp 0x1839eb
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x14330d(%rip), %rsi # 0x2c6d08
leaq -0xb4312(%rip), %rdx # 0xcf6f0
callq 0x5eb70
jmp 0x183aa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x183a60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x183a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5f628
leaq 0x30(%rsp), %rdi
callq 0x5f628
leaq 0x2f(%rsp), %rdi
callq 0x5f600
testb $0x1, 0x2e(%rsp)
jne 0x183a73
jmp 0x183a7c
movq (%rsp), %rdi
callq 0x5f010
jmp 0x183a94
leaq 0x78(%rsp), %rdi
callq 0xd6f30
addq $0x20, %rax
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5ec30
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov qword ptr [rsp+0C8h+var_10], rsi
mov rdi, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_183848
jmp loc_183924
loc_183848:
mov [rsp+0C8h+var_45], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_B0], rax; char
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+0C8h+var_38], rax; char
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+0C8h+var_30]; int
lea rdx, [rsp+0C8h+var_38]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
jmp short $+2
loc_18388F:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_B0]; int
mov esi, 130h
lea rdx, [rsp+0C8h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_1838AD:
mov rdi, [rsp+0C8h+var_B0]; void *
mov [rsp+0C8h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_183AA1
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_183909
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_183909:
test [rsp+arg_7B], 1
jnz short loc_183915
jmp short loc_18391F
loc_183915:
mov rdi, [rsp+arg_10]; void *
call ___cxa_free_exception
loc_18391F:
jmp loc_183A94
loc_183924:
mov rax, [rsp+0C8h+var_A8]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+0C8h+var_10]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, rax
mov rax, [rsp+0C8h+var_A8]
mov qword ptr [rsp+0C8h+var_50], rcx; int
mov rdi, [rax+8]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov qword ptr [rsp+0C8h+var_58], rax; char
lea rdi, [rsp+0C8h+var_50]
lea rsi, [rsp+0C8h+var_58]
call _ZN9__gnu_cxxeqIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator==<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_18396D
jmp loc_183A7E
loc_18396D:
mov [rsp+0C8h+var_9A], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0C8h+var_C8], rax; int
mov rax, qword ptr [rsp+0C8h+var_10]
mov qword ptr [rsp+0C8h+var_C0], rax; int
lea rdi, [rsp+0C8h+var_99]
mov qword ptr [rsp+0C8h+var_B8], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, qword ptr [rsp+0C8h+var_C0]
mov rdx, qword ptr [rsp+0C8h+var_B8]
lea rdi, [rsp+0C8h+var_99+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_1839B2:
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+0C8h+var_78]; int
lea rdx, [rsp+0C8h+var_99+1]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
jmp short $+2
loc_1839D1:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C8]; int
mov esi, 193h
lea rdx, [rsp+0C8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_1839EB:
mov rdi, [rsp+0C8h+var_C8]; void *
mov [rsp+0C8h+var_9A], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_183AA1
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_183A60
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_183A56
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_183A56:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_183A60:
lea rdi, [rsp+arg_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_26], 1
jnz short loc_183A73
jmp short loc_183A7C
loc_183A73:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_183A7C:
jmp short loc_183A94
loc_183A7E:
lea rdi, [rsp+0C8h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
add rax, 20h ; ' '
add rsp, 0C8h
retn
loc_183A94:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
loc_183AA1:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
| long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
int v8; // [rsp+0h] [rbp-C8h]
void *v9; // [rsp+0h] [rbp-C8h]
int v10; // [rsp+0h] [rbp-C8h]
void *v11; // [rsp+0h] [rbp-C8h]
void *v12; // [rsp+8h] [rbp-C0h]
long long v13; // [rsp+8h] [rbp-C0h]
int v14; // [rsp+8h] [rbp-C0h]
int v15; // [rsp+10h] [rbp-B8h]
int v16; // [rsp+10h] [rbp-B8h]
int v17; // [rsp+18h] [rbp-B0h]
void *exception; // [rsp+18h] [rbp-B0h]
nlohmann::json_abi_v3_11_3::detail::type_error *v19; // [rsp+18h] [rbp-B0h]
char v20; // [rsp+18h] [rbp-B0h]
int v21; // [rsp+20h] [rbp-A8h]
int v22; // [rsp+28h] [rbp-A0h]
char v23; // [rsp+2Fh] [rbp-99h] BYREF
int v24[4]; // [rsp+30h] [rbp-98h] BYREF
long long v25; // [rsp+40h] [rbp-88h]
int v26; // [rsp+48h] [rbp-80h]
int v27[8]; // [rsp+50h] [rbp-78h] BYREF
char v28[8]; // [rsp+70h] [rbp-58h] BYREF
int v29[2]; // [rsp+78h] [rbp-50h] BYREF
int v30; // [rsp+80h] [rbp-48h]
int v31; // [rsp+88h] [rbp-40h]
char v32[8]; // [rsp+90h] [rbp-38h] BYREF
int v33[8]; // [rsp+98h] [rbp-30h] BYREF
int v34[2]; // [rsp+B8h] [rbp-10h]
long long v35; // [rsp+C0h] [rbp-8h]
v35 = a1;
*(_QWORD *)v34 = a2;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_object((_BYTE *)a1) )
{
exception = __cxa_allocate_exception(0x20uLL);
*(_QWORD *)v32 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(int)v33,
(int)"cannot use at() with ",
(int)v32,
v2,
v3,
v4,
v8,
v12,
v15,
(long long)exception);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v19,
304,
(long long)v33,
a1);
HIBYTE(v30) = 0;
__cxa_throw(
v19,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
*(_QWORD *)v29 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
*(_QWORD *)(a1 + 8),
*(_QWORD *)v34);
*(_QWORD *)v28 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(*(_QWORD *)(a1 + 8));
if ( __gnu_cxx::operator==<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)v29,
(long long)v28) )
{
v9 = __cxa_allocate_exception(0x20uLL);
v13 = *(_QWORD *)v34;
std::allocator<char>::allocator(&v23, v28);
std::string::basic_string<std::allocator<char>>((long long)v24, v13, (long long)&v23);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(int)v27,
(int)"key '",
(int)v24,
(int)"' not found",
v5,
v6,
v9,
v13,
(int)&v23,
v17,
a1);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v10,
v10,
v14,
v16,
v20,
v21,
v22,
v24[0],
v24[2],
v25,
v26,
v27[0],
v27[2],
v27[4],
v27[6],
v28[0],
v29[0],
v30,
v31,
v32[0]);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::out_of_range::~out_of_range);
}
return __gnu_cxx::__normal_iterator<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::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)v29)
+ 32;
}
| |||
34,991 | 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>::at<char const (&) [9], 0>(char const (&) [9]) const | monkey531[P]llama/common/json.hpp | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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>::at<char const (&) [9], 0>(char const (&) [9]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xba49a
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xba47f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b220
testl %eax, %eax
je 0xba47c
addq $0x30, %rbx
jmp 0xba45d
movq %rbx, %rax
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xba4f6
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b450
movq %rax, %rbx
movq %r14, %rdi
callq 0x6c4fa
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x46bb6(%rip), %rsi # 0x101074
movq %rsp, %rdi
callq 0xb9341
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x9487c
xorl %ebp, %ebp
leaq 0x80a23(%rip), %rsi # 0x13af08
leaq -0x51eb0(%rip), %rdx # 0x6863c
movq %rbx, %rdi
callq 0x1bf90
jmp 0xba56f
movl $0x20, %edi
callq 0x1b450
movq %rax, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1b3f0
leaq (%rax,%r15), %rdx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2d748
leaq 0x46b77(%rip), %rsi # 0x1010a4
leaq 0x46b76(%rip), %rcx # 0x1010aa
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xb994a
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xb9cc4
xorl %ebp, %ebp
leaq 0x80928(%rip), %rsi # 0x13ae88
leaq -0x51f2b(%rip), %rdx # 0x6863c
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba595
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xba595
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xba5ce
movq 0x30(%rsp), %rsi
jmp 0xba5be
jmp 0xba5c8
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba5ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xba5ce
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xba5db
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x1c020
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_BA49A
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
loc_BA45D:
mov rax, [r12+8]
cmp rbx, rax
jz short loc_BA47F
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_BA47C
add rbx, 30h ; '0'
jmp short loc_BA45D
loc_BA47C:
mov rax, rbx
loc_BA47F:
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_BA4F6
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BA49A:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
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
jmp short loc_BA56F
loc_BA4F6:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
lea rdi, [rsp+68h+var_48]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
mov rdi, rsp
lea rdx, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_BA56F:
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BA595
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BA595
mov r14, rax
mov bpl, 1
loc_BA595:
mov rdi, [rsp+68h+var_48]
cmp rdi, r12
jz short loc_BA5CE
mov rsi, [rsp+68h+var_38]
jmp short loc_BA5BE
jmp short loc_BA5C8
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BA5CE
mov rsi, [rsp+68h+var_58]
loc_BA5BE:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BA5CE
loc_BA5C8:
mov r14, rax
mov bpl, 1
loc_BA5CE:
test bpl, bpl
jz short loc_BA5DB
mov rdi, rbx; void *
call ___cxa_free_exception
loc_BA5DB:
mov rdi, r14
call __Unwind_Resume
| long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long i; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
_QWORD v9[2]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v10[2]; // [rsp+20h] [rbp-48h] BYREF
long long v11; // [rsp+30h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v10[0] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(long long)v9,
(long long)"cannot use at() with ",
v10);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
304,
v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = *(long long **)(a1 + 8);
for ( i = *v2; ; i += 48LL )
{
v4 = v2[1];
if ( i == v4 )
break;
if ( !(unsigned int)std::string::compare(i, a2) )
{
v4 = i;
break;
}
}
if ( v4 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v10[0] = &v11;
v8 = strlen(a2);
std::string::_M_construct<char const*>(v10, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(long long)v9,
(long long)"key '",
v10,
(long long)"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v7,
403,
v9);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001ba49a
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
LAB_001ba45d:
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001ba47f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b220
TEST EAX,EAX
JZ 0x001ba47c
ADD RBX,0x30
JMP 0x001ba45d
LAB_001ba47c:
MOV RAX,RBX
LAB_001ba47f:
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x001ba4f6
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001ba49a:
MOV EDI,0x20
CALL 0x0011b450
MOV RBX,RAX
MOV RDI,R14
CALL 0x0016c4fa
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001ba4b7:
LEA RSI,[0x201074]
MOV RDI,RSP
CALL 0x001b9341
MOV BPL,0x1
LAB_001ba4c9:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0019487c
XOR EBP,EBP
LEA RSI,[0x23af08]
LEA RDX,[0x16863c]
MOV RDI,RBX
CALL 0x0011bf90
LAB_001ba4f6:
MOV EDI,0x20
CALL 0x0011b450
MOV RBX,RAX
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011b3f0
LEA RDX,[RAX + R15*0x1]
LAB_001ba519:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x0012d748
LAB_001ba526:
LEA RSI,[0x2010a4]
LEA RCX,[0x2010aa]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x001b994a
MOV BPL,0x1
LAB_001ba544:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001b9cc4
XOR EBP,EBP
LEA RSI,[0x23ae88]
LEA RDX,[0x16863c]
MOV RDI,RBX
CALL 0x0011bf90
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,char *param_2)
{
int8 *puVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
detail adStack_68 [32];
char *local_48 [2];
char local_38 [16];
if (*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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_48[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_1);
/* try { // try from 001ba4b7 to 001ba4c5 has its CatchHandler @ 001ba5c8 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(adStack_68,"cannot use at() with ",local_48);
/* try { // try from 001ba4c9 to 001ba4f3 has its CatchHandler @ 001ba5a8 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,adStack_68,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
puVar1 = *(int8 **)(param_1 + 8);
pcVar6 = (char *)*puVar1;
while ((pcVar3 = (char *)puVar1[1], pcVar6 != pcVar3 &&
(iVar2 = std::__cxx11::string::compare(pcVar6), pcVar3 = pcVar6, iVar2 != 0))) {
pcVar6 = pcVar6 + 0x30;
}
if (pcVar3 == *(char **)(*(long *)(param_1 + 8) + 8)) {
uVar4 = __cxa_allocate_exception(0x20);
local_48[0] = local_38;
sVar5 = strlen(param_2);
/* try { // try from 001ba519 to 001ba525 has its CatchHandler @ 001ba5a6 */
std::__cxx11::string::_M_construct<char_const*>(local_48,param_2,param_2 + sVar5);
/* try { // try from 001ba526 to 001ba540 has its CatchHandler @ 001ba58f */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(adStack_68,"key \'",(string *)local_48,"\' not found");
/* try { // try from 001ba544 to 001ba56e has its CatchHandler @ 001ba56f */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,adStack_68,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
| |
34,992 | 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>::at<char const (&) [9], 0>(char const (&) [9]) const | monkey531[P]llama/common/json.hpp | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
} | 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>::at<char const (&) [9], 0>(char const (&) [9]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb9b2d
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb9b17
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b220
testl %eax, %eax
je 0xb9b0c
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xb9aed
jmp 0xb9b0f
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xb9b8b
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b450
movq %rax, %rbx
movq %r14, %rdi
callq 0x6cbae
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x45515(%rip), %rsi # 0xff064
leaq 0x20(%rsp), %rdi
callq 0xb89f9
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x9435e
xorl %ebp, %ebp
leaq 0x7f3ce(%rip), %rsi # 0x138f48
leaq -0x50d9d(%rip), %rdx # 0x68de4
movq %rbx, %rdi
callq 0x1bf90
jmp 0xb9c04
movl $0x20, %edi
callq 0x1b450
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1b3f0
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2d630
leaq 0x454d4(%rip), %rsi # 0xff094
leaq 0x454d3(%rip), %rcx # 0xff09a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb8fd6
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xb934e
xorl %ebp, %ebp
leaq 0x7f2d3(%rip), %rsi # 0x138ec8
leaq -0x50e18(%rip), %rdx # 0x68de4
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9c22
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb9c6d
movq 0x10(%rsp), %rsi
jmp 0xb9c65
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb9c77
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xb9c77
jmp 0xb9c74
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9c6d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8f0
testb %bpl, %bpl
jne 0xb9c77
jmp 0xb9c7f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x1c020
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_B9B2D
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_B9B17
loc_B9AED:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_B9B0C
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_B9AED
jmp short loc_B9B0F
loc_B9B0C:
mov rax, rbx
loc_B9B0F:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_B9B17:
cmp rax, rbx
jz short loc_B9B8B
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B9B2D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
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
jmp short loc_B9C04
loc_B9B8B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_B9C04:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B9C22
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B9C22:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_B9C6D
mov rsi, [rsp+68h+var_58]
jmp short loc_B9C65
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_B9C77
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B9C77
jmp short loc_B9C74
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B9C6D
mov rsi, [rsp+68h+var_38]
loc_B9C65:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B9C6D:
test bpl, bpl
jnz short loc_B9C77
jmp short loc_B9C7F
loc_B9C74:
mov r14, rax
loc_B9C77:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B9C7F:
mov rdi, r14
call __Unwind_Resume
| long long ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
void *v9[2]; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+10h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-48h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = (void *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(long long)v11,
(long long)"cannot use at() with ",
v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
304,
v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
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 )
goto LABEL_7;
}
v4 = v3;
LABEL_7:
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
if ( v4 == v3 )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = &v10;
v8 = strlen(a2);
std::string::_M_construct<char const*>((long long)v9, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(long long)v11,
(long long)"key '",
v9,
(long long)"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v7,
403,
v11);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001b9b2d
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001b9b17
LAB_001b9aed:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b220
TEST EAX,EAX
JZ 0x001b9b0c
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001b9aed
JMP 0x001b9b0f
LAB_001b9b0c:
MOV RAX,RBX
LAB_001b9b0f:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001b9b17:
CMP RAX,RBX
JZ 0x001b9b8b
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b9b2d:
MOV EDI,0x20
CALL 0x0011b450
MOV RBX,RAX
MOV RDI,R14
CALL 0x0016cbae
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001b9b48:
LEA RSI,[0x1ff064]
LEA RDI,[RSP + 0x20]
CALL 0x001b89f9
MOV BPL,0x1
LAB_001b9b5c:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0019435e
XOR EBP,EBP
LEA RSI,[0x238f48]
LEA RDX,[0x168de4]
MOV RDI,RBX
CALL 0x0011bf90
LAB_001b9b8b:
MOV EDI,0x20
CALL 0x0011b450
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011b3f0
LEA RDX,[RAX + R15*0x1]
LAB_001b9bae:
MOV RDI,RSP
MOV RSI,R15
CALL 0x0012d630
LAB_001b9bb9:
LEA RSI,[0x1ff094]
LEA RCX,[0x1ff09a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001b8fd6
MOV BPL,0x1
LAB_001b9bd7:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001b934e
XOR EBP,EBP
LEA RSI,[0x238ec8]
LEA RDX,[0x168de4]
MOV RDI,RBX
CALL 0x0011bf90
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_1);
/* try { // try from 001b9b48 to 001b9b58 has its CatchHandler @ 001b9c74 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001b9b5c to 001b9b88 has its CatchHandler @ 001b9c4f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001b9bae to 001b9bb8 has its CatchHandler @ 001b9c4d */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001b9bb9 to 001b9bd3 has its CatchHandler @ 001b9c32 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001b9bd7 to 001b9c03 has its CatchHandler @ 001b9c04 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
| |
34,993 | OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(float const*, float*) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/surface.h | inline int
Surface<REAL>::EvaluateStencil(REAL const uv[2], REAL sP[]) const {
REAL * derivativeStencils[6] = { sP, 0, 0, 0, 0, 0 };
return evaluateStencils(uv, derivativeStencils);
} | O1 | c | OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(float const*, float*) const:
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdx, (%rsp)
movb 0x6c(%rdi), %al
movq %rsp, %rdx
testb $0x4, %al
jne 0x96a0e
testb $0x8, %al
jne 0x96a15
callq 0x39050
jmp 0x96a1a
callq 0x3a070
jmp 0x96a1a
callq 0x3bd50
addq $0x38, %rsp
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIfE15EvaluateStencilEPKfPf:
sub rsp, 38h
xorps xmm0, xmm0
movaps [rsp+38h+var_38], xmm0
movaps [rsp+38h+var_18], xmm0
movaps [rsp+38h+var_28], xmm0
mov qword ptr [rsp+38h+var_38], rdx
mov al, [rdi+6Ch]
mov rdx, rsp
test al, 4
jnz short loc_96A0E
test al, 8
jnz short loc_96A15
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIfE21evalIrregularStencilsEPKfPPf; OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalIrregularStencils(float const*,float **)
jmp short loc_96A1A
loc_96A0E:
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIfE19evalRegularStencilsEPKfPPf; OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalRegularStencils(float const*,float **)
jmp short loc_96A1A
loc_96A15:
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIfE23evalMultiLinearStencilsEPKfPPf; OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalMultiLinearStencils(float const*,float **)
loc_96A1A:
add rsp, 38h
retn
| long long OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
long long a5,
long long a6)
{
char v6; // al
__int128 v8; // [rsp+0h] [rbp-38h] BYREF
__int128 v9; // [rsp+10h] [rbp-28h]
__int128 v10; // [rsp+20h] [rbp-18h]
v10 = 0LL;
v9 = 0LL;
v8 = a3;
v6 = *(_BYTE *)(a1 + 108);
if ( (v6 & 4) != 0 )
return OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalRegularStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
if ( (v6 & 8) != 0 )
return OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalMultiLinearStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
return OpenSubdiv::v3_6_0::Bfr::Surface<float>::evalIrregularStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
}
| EvaluateStencil:
SUB RSP,0x38
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP],RDX
MOV AL,byte ptr [RDI + 0x6c]
MOV RDX,RSP
TEST AL,0x4
JNZ 0x00196a0e
TEST AL,0x8
JNZ 0x00196a15
CALL 0x00139050
JMP 0x00196a1a
LAB_00196a0e:
CALL 0x0013a070
JMP 0x00196a1a
LAB_00196a15:
CALL 0x0013bd50
LAB_00196a1a:
ADD RSP,0x38
RET
|
/* OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(float const*, float*) const */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil
(Surface<float> *this,float *param_1,float *param_2)
{
float *local_38;
int8 uStack_30;
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 uStack_10;
uStack_30 = 0;
local_18 = 0;
uStack_10 = 0;
local_28 = 0;
uStack_20 = 0;
local_38 = param_2;
if (((byte)this[0x6c] & 4) == 0) {
if (((byte)this[0x6c] & 8) == 0) {
evalIrregularStencils(this,param_1,&local_38);
}
else {
evalMultiLinearStencils(this,param_1,&local_38);
}
}
else {
evalRegularStencils(this,param_1,&local_38);
}
return;
}
| |
34,994 | OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(float const*, float*) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/../bfr/surface.h | inline int
Surface<REAL>::EvaluateStencil(REAL const uv[2], REAL sP[]) const {
REAL * derivativeStencils[6] = { sP, 0, 0, 0, 0, 0 };
return evaluateStencils(uv, derivativeStencils);
} | O3 | c | OpenSubdiv::v3_6_0::Bfr::Surface<float>::EvaluateStencil(float const*, float*) const:
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdx, (%rsp)
movb 0x6c(%rdi), %al
movq %rsp, %rdx
testb $0x4, %al
jne 0x9a7d2
testb $0x8, %al
jne 0x9a7d9
callq 0x3a690
jmp 0x9a7de
callq 0x3ac00
jmp 0x9a7de
callq 0x3a660
addq $0x38, %rsp
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE15EvaluateStencilEPKdPd:
sub rsp, 38h
xorps xmm0, xmm0
movaps [rsp+38h+var_38], xmm0
movaps [rsp+38h+var_18], xmm0
movaps [rsp+38h+var_28], xmm0
mov qword ptr [rsp+38h+var_38], rdx
mov al, [rdi+6Ch]
mov rdx, rsp
test al, 4
jnz short loc_9A7D2
test al, 8
jnz short loc_9A7D9
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE21evalIrregularStencilsEPKdPPd; OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalIrregularStencils(double const*,double **)
jmp short loc_9A7DE
loc_9A7D2:
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE19evalRegularStencilsEPKdPPd; OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalRegularStencils(double const*,double **)
jmp short loc_9A7DE
loc_9A7D9:
call __ZNK10OpenSubdiv6v3_6_03Bfr7SurfaceIdE23evalMultiLinearStencilsEPKdPPd; OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalMultiLinearStencils(double const*,double **)
loc_9A7DE:
add rsp, 38h
retn
| long long OpenSubdiv::v3_6_0::Bfr::Surface<double>::EvaluateStencil(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
long long a5,
long long a6)
{
char v6; // al
__int128 v8; // [rsp+0h] [rbp-38h] BYREF
__int128 v9; // [rsp+10h] [rbp-28h]
__int128 v10; // [rsp+20h] [rbp-18h]
v10 = 0LL;
v9 = 0LL;
v8 = a3;
v6 = *(_BYTE *)(a1 + 108);
if ( (v6 & 4) != 0 )
return OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalRegularStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
if ( (v6 & 8) != 0 )
return OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalMultiLinearStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
return OpenSubdiv::v3_6_0::Bfr::Surface<double>::evalIrregularStencils(
a1,
a2,
&v8,
a4,
a5,
a6,
v8,
*((_QWORD *)&v8 + 1),
v9,
*((_QWORD *)&v9 + 1),
v10,
*((_QWORD *)&v10 + 1));
}
| EvaluateStencil:
SUB RSP,0x38
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP],RDX
MOV AL,byte ptr [RDI + 0x6c]
MOV RDX,RSP
TEST AL,0x4
JNZ 0x0019a7d2
TEST AL,0x8
JNZ 0x0019a7d9
CALL 0x0013a690
JMP 0x0019a7de
LAB_0019a7d2:
CALL 0x0013ac00
JMP 0x0019a7de
LAB_0019a7d9:
CALL 0x0013a660
LAB_0019a7de:
ADD RSP,0x38
RET
|
/* OpenSubdiv::v3_6_0::Bfr::Surface<double>::EvaluateStencil(double const*, double*) const */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::Surface<double>::EvaluateStencil
(Surface<double> *this,double *param_1,double *param_2)
{
double *local_38;
int8 uStack_30;
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 uStack_10;
uStack_30 = 0;
local_18 = 0;
uStack_10 = 0;
local_28 = 0;
uStack_20 = 0;
local_38 = param_2;
if (((byte)this[0x6c] & 4) == 0) {
if (((byte)this[0x6c] & 8) == 0) {
evalIrregularStencils(this,param_1,&local_38);
}
else {
evalMultiLinearStencils(this,param_1,&local_38);
}
}
else {
evalRegularStencils(this,param_1,&local_38);
}
return;
}
| |
34,995 | testing::internal::StreamingListener::SocketWriter::CloseConnection() | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | O1 | c | testing::internal::StreamingListener::SocketWriter::CloseConnection():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x3c783
leaq 0x7ce1(%rip), %rdx # 0x44416
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x44f, %ecx # imm = 0x44F
callq 0x1b13e
movq 0x1d898(%rip), %rdi # 0x59fe8
leaq 0x7eb2(%rip), %rsi # 0x44609
movl $0x20, %edx
callq 0x95a0
movq 0x1d880(%rip), %rdi # 0x59fe8
leaq 0x7f18(%rip), %rsi # 0x44687
movl $0x40, %edx
callq 0x95a0
leaq 0xc(%rsp), %rdi
callq 0x1b280
movl 0x8(%rbx), %edi
callq 0x9a90
movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1b280
movq %rbx, %rdi
callq 0x99a0
nop
| _ZN7testing8internal17StreamingListener12SocketWriter15CloseConnectionEv:
push rbx
sub rsp, 10h
mov rbx, rdi
cmp dword ptr [rdi+8], 0FFFFFFFFh
jnz short loc_3C783
lea rdx, aWorkspaceLlm4b_6; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+18h+var_C]
mov esi, 3
mov ecx, 44Fh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aConditionSockf_0; "Condition sockfd_ != -1 failed. "
mov edx, 20h ; ' '
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aCloseconnectio; "CloseConnection() can be called only wh"...
mov edx, 40h ; '@'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+18h+var_C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_3C783:
mov edi, [rbx+8]
call _close
mov dword ptr [rbx+8], 0FFFFFFFFh
add rsp, 10h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::StreamingListener::SocketWriter::CloseConnection(
testing::internal::StreamingListener::SocketWriter *this)
{
long long result; // rax
_DWORD v2[3]; // [rsp+Ch] [rbp-Ch] BYREF
if ( *((_DWORD *)this + 2) == -1 )
{
testing::internal::GTestLog::GTestLog(
v2,
3,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/"
"gtest-internal-inl.h",
1103);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "Condition sockfd_ != -1 failed. ", 32LL);
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"CloseConnection() can be called only when there is a connection.",
64LL);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v2);
}
result = close(*((unsigned int *)this + 2));
*((_DWORD *)this + 2) = -1;
return result;
}
| CloseConnection:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],-0x1
JNZ 0x0013c783
LEA RDX,[0x144416]
LEA RDI,[RSP + 0xc]
MOV ESI,0x3
MOV ECX,0x44f
CALL 0x0011b13e
LAB_0013c749:
MOV RDI,qword ptr [0x00159fe8]
LEA RSI,[0x144609]
MOV EDX,0x20
CALL 0x001095a0
MOV RDI,qword ptr [0x00159fe8]
LEA RSI,[0x144687]
MOV EDX,0x40
CALL 0x001095a0
LAB_0013c779:
LEA RDI,[RSP + 0xc]
CALL 0x0011b280
LAB_0013c783:
MOV EDI,dword ptr [RBX + 0x8]
CALL 0x00109a90
MOV dword ptr [RBX + 0x8],0xffffffff
ADD RSP,0x10
POP RBX
RET
|
/* testing::internal::StreamingListener::SocketWriter::CloseConnection() */
void __thiscall
testing::internal::StreamingListener::SocketWriter::CloseConnection(SocketWriter *this)
{
GTestLog local_c [4];
if (*(int *)(this + 8) == -1) {
GTestLog::GTestLog(local_c,3,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest-internal-inl.h"
,0x44f);
/* try { // try from 0013c749 to 0013c778 has its CatchHandler @ 0013c798 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00159fe8,"Condition sockfd_ != -1 failed. ",0x20);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00159fe8,
"CloseConnection() can be called only when there is a connection.",0x40);
GTestLog::~GTestLog(local_c);
}
close(*(int *)(this + 8));
*(int4 *)(this + 8) = 0xffffffff;
return;
}
| |
34,996 | inline_mysql_file_chsize | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_chsize(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t newlength, int filler, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CHSIZE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) newlength, src_file,
src_line);
result= my_chsize(file, newlength, filler, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) newlength);
return result;
}
#endif
result= my_chsize(file, newlength, filler, flags);
return result;
} | O0 | c | inline_mysql_file_chsize:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x2b4ca8(%rip), %rax # 0x2f5a60
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0xd, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x40e52
leaq 0x2b4c62(%rip), %rax # 0x2f5a60
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x1171a0
movl %eax, -0x34(%rbp)
leaq 0x2b4c2a(%rip), %rax # 0x2f5a60
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x40e6e
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x1171a0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_chsize_0:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 0Dh
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 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_40E52
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_chsize
mov [rbp+var_34], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_20]
call rax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_40E6E
loc_40E52:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_chsize
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_40E6E:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_chsize_0(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h]
unsigned int v9; // [rsp+5Ch] [rbp-34h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+78h] [rbp-18h]
unsigned int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a3, 13LL);
if ( v8 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v8, v12, v15, v14);
v9 = my_chsize(v13, v12, v11, v10);
((void ( *)(long long, long long))PSI_server[67])(v8, v12);
}
else
{
return (unsigned int)my_chsize(v13, v12, v11, v10);
}
return v9;
}
| inline_mysql_file_chsize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3f5a60]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0xd
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],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 0x00140e52
LEA RAX,[0x3f5a60]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x002171a0
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x3f5a60]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x20]
CALL RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00140e6e
LAB_00140e52:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x002171a0
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_00140e6e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
inline_mysql_file_chsize
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int4 local_3c;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,0xd);
if (local_48 == 0) {
local_c = my_chsize(local_20,local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_28,local_18,local_1c);
local_3c = my_chsize(local_20,local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x218))(local_48,local_28);
local_c = local_3c;
}
return local_c;
}
| |
34,997 | inline_mysql_file_chsize | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_chsize(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t newlength, int filler, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CHSIZE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) newlength, src_file,
src_line);
result= my_chsize(file, newlength, filler, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) newlength);
return result;
}
#endif
result= my_chsize(file, newlength, filler, flags);
return result;
} | O3 | c | inline_mysql_file_chsize:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x35996b(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
movl %r14d, %esi
movl $0xd, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x550e4
movl $0x10, %ecx
movl %r14d, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xba94c
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %r15
movq %rax, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x2dd7e
movl (%r15), %eax
jmp 0x550d9
| inline_mysql_file_chsize_0:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 58h
mov rbx, rsi
mov r14d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_68]
mov esi, r14d
mov edx, 0Dh
call qword ptr [rax+158h]
test rax, rax
jnz short loc_550E4
mov ecx, 10h
mov edi, r14d
mov rsi, rbx
xor edx, edx
call my_chsize
loc_550D9:
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_550E4:
lea r15, [rbp+var_1C]
mov rdi, rax
mov rsi, rbx
mov edx, r14d
mov rcx, r15
call inline_mysql_file_chsize_cold_1
mov eax, [r15]
jmp short loc_550D9
| long long inline_mysql_file_chsize_0(unsigned int a1, long long a2)
{
long long v2; // rax
_BYTE v4[76]; // [rsp+8h] [rbp-68h] BYREF
_DWORD v5[7]; // [rsp+54h] [rbp-1Ch] BYREF
v2 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v4, a1, 13LL);
if ( !v2 )
return my_chsize(a1, a2, 0LL, 16LL);
inline_mysql_file_chsize_cold_1(v2, a2, a1, v5);
return v5[0];
}
| inline_mysql_file_chsize:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV RBX,RSI
MOV R14D,EDI
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x68]
MOV ESI,R14D
MOV EDX,0xd
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001550e4
MOV ECX,0x10
MOV EDI,R14D
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001ba94c
LAB_001550d9:
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001550e4:
LEA R15,[RBP + -0x1c]
MOV RDI,RAX
MOV RSI,RBX
MOV EDX,R14D
MOV RCX,R15
CALL 0x0012dd7e
MOV EAX,dword ptr [R15]
JMP 0x001550d9
|
ulong inline_mysql_file_chsize(int4 param_1,int8 param_2)
{
long lVar1;
ulong uVar2;
int1 local_70 [76];
uint local_24;
lVar1 = (**(code **)(PSI_server + 0x158))(local_70,param_1,0xd);
if (lVar1 == 0) {
uVar2 = my_chsize(param_1,param_2,0,0x10);
}
else {
inline_mysql_file_chsize_cold_1(lVar1,param_2,param_1,&local_24);
uVar2 = (ulong)local_24;
}
return uVar2;
}
| |
34,998 | 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);
} | O3 | c | my_load_path:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpb $0x7e, (%rsi)
jne 0x64292
cmpb $0x2f, 0x1(%r14)
je 0x6429e
movq %r14, %rdi
callq 0x5a892
testl %eax, %eax
je 0x642d9
movq %r14, %r12
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %r12, %rsi
callq 0x92cd8
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x64380
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x2e, (%r14)
jne 0x642ec
movl $0x2, %r13d
cmpb $0x2f, 0x1(%r14)
je 0x6432b
leaq 0x318ab(%rip), %rsi # 0x95b9e
movq %r14, %rdi
callq 0x9139c
xorl %r13d, %r13d
testq %r15, %r15
je 0x6432b
testl %eax, %eax
jne 0x6432b
leaq -0x240(%rbp), %r12
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x92df8
jmp 0x642a1
movq %r14, %rdi
callq 0x28150
leal 0x200(%r13), %esi
subl %eax, %esi
leaq -0x240(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x5a6fc
testl %eax, %eax
jne 0x6429e
movq %r12, %rdi
callq 0x28150
leaq (%rax,%rbp), %rdi
addq $-0x240, %rdi # imm = 0xFDC0
addq %r13, %r14
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
movq %r14, %rsi
callq 0x92cd8
jmp 0x642a1
callq 0x28440
nopl (%rax)
| my_load_path:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp byte ptr [rsi], 7Eh ; '~'
jnz short loc_64292
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_6429E
loc_64292:
mov rdi, r14
call test_if_hard_path
test eax, eax
jz short loc_642D9
loc_6429E:
mov r12, r14
loc_642A1:
mov edx, 1FFh
mov rdi, rbx
mov rsi, r12
call strmake
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_64380
mov rax, rbx
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_642D9:
cmp byte ptr [r14], 2Eh ; '.'
jnz short loc_642EC
mov r13d, 2
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_6432B
loc_642EC:
lea rsi, asc_95B9E; ".."
mov rdi, r14
call is_prefix
xor r13d, r13d
test r15, r15
jz short loc_6432B
test eax, eax
jnz short loc_6432B
lea r12, [rbp+var_240]
mov esi, 200h
mov rdi, r12
mov rdx, r15
mov rcx, r14
xor r8d, r8d
xor eax, eax
call strxnmov
jmp loc_642A1
loc_6432B:
mov rdi, r14
call _strlen
lea esi, [r13+200h]
sub esi, eax
lea r12, [rbp+var_240]
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jnz loc_6429E
mov rdi, r12
call _strlen
lea rdi, [rax+rbp]
add rdi, 0FFFFFFFFFFFFFDC0h
add r14, r13
mov edx, 200h
sub rdx, rax
mov rsi, r14
call strmake
jmp loc_642A1
loc_64380:
call ___stack_chk_fail
| long long my_load_path(long long a1, char *a2, long long a3)
{
char *v4; // r12
long long v6; // r13
int v7; // eax
int v8; // r9d
int v9; // eax
long long v10; // rax
char v11[528]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+210h] [rbp-30h]
v12 = __readfsqword(0x28u);
if ( (*a2 != 126 || a2[1] != 47) && !test_if_hard_path(a2) )
{
if ( *a2 != 46 || (v6 = 2LL, a2[1] != 47) )
{
v7 = is_prefix(a2, "..");
v6 = 0LL;
if ( a3 )
{
if ( !v7 )
{
v4 = v11;
strxnmov((unsigned int)v11, 512, a3, (_DWORD)a2, 0, v8, v11[0]);
goto LABEL_5;
}
}
}
v9 = strlen(a2);
v4 = v11;
if ( !(unsigned int)my_getwd(v11, (unsigned int)(v6 + 512 - v9), 0) )
{
v10 = strlen(v11);
strmake(&v11[v10], &a2[v6], 512 - v10);
goto LABEL_5;
}
}
v4 = a2;
LABEL_5:
strmake(a1, v4, 511LL);
return a1;
}
| my_load_path:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP byte ptr [RSI],0x7e
JNZ 0x00164292
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x0016429e
LAB_00164292:
MOV RDI,R14
CALL 0x0015a892
TEST EAX,EAX
JZ 0x001642d9
LAB_0016429e:
MOV R12,R14
LAB_001642a1:
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,R12
CALL 0x00192cd8
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00164380
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001642d9:
CMP byte ptr [R14],0x2e
JNZ 0x001642ec
MOV R13D,0x2
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x0016432b
LAB_001642ec:
LEA RSI,[0x195b9e]
MOV RDI,R14
CALL 0x0019139c
XOR R13D,R13D
TEST R15,R15
JZ 0x0016432b
TEST EAX,EAX
JNZ 0x0016432b
LEA R12,[RBP + -0x240]
MOV ESI,0x200
MOV RDI,R12
MOV RDX,R15
MOV RCX,R14
XOR R8D,R8D
XOR EAX,EAX
CALL 0x00192df8
JMP 0x001642a1
LAB_0016432b:
MOV RDI,R14
CALL 0x00128150
LEA ESI,[R13 + 0x200]
SUB ESI,EAX
LEA R12,[RBP + -0x240]
MOV RDI,R12
XOR EDX,EDX
CALL 0x0015a6fc
TEST EAX,EAX
JNZ 0x0016429e
MOV RDI,R12
CALL 0x00128150
LEA RDI,[RAX + RBP*0x1]
ADD RDI,-0x240
ADD R14,R13
MOV EDX,0x200
SUB RDX,RAX
MOV RSI,R14
CALL 0x00192cd8
JMP 0x001642a1
LAB_00164380:
CALL 0x00128440
|
int8 my_load_path(int8 param_1,char *param_2,long param_3)
{
int iVar1;
size_t sVar2;
long lVar3;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (((*param_2 != '~') || (param_2[1] != '/')) && (iVar1 = test_if_hard_path(param_2), iVar1 == 0)
) {
if ((*param_2 != '.') || (lVar3 = 2, param_2[1] != '/')) {
iVar1 = is_prefix(param_2,&DAT_00195b9e);
lVar3 = 0;
if ((param_3 != 0) && (iVar1 == 0)) {
strxnmov(local_248,0x200,param_3,param_2,0);
param_2 = local_248;
goto LAB_001642a1;
}
}
sVar2 = strlen(param_2);
iVar1 = my_getwd(local_248,((int)lVar3 + 0x200) - (int)sVar2,0);
if (iVar1 == 0) {
sVar2 = strlen(local_248);
strmake(local_248 + sVar2,param_2 + lVar3,0x200 - sVar2);
param_2 = local_248;
}
}
LAB_001642a1:
strmake(param_1,param_2,0x1ff);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
| |
34,999 | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::apply(PFS_buffer_processor<PFS_program>&) | eloqsql/storage/perfschema/pfs_buffer_container.h | void apply(processor_type & proc)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
if (pfs->m_lock.is_populated())
{
proc(pfs);
}
pfs++;
}
}
}
} | O0 | c | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::apply(PFS_buffer_processor<PFS_program>&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0x47870
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47860
movq -0x20(%rbp), %rdi
callq 0x46610
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x46630
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x4785e
movq -0x28(%rbp), %rdi
addq $0x7e0, %rdi # imm = 0x7E0
callq 0x32dd0
testb $0x1, %al
jne 0x47840
jmp 0x4784e
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x9c0, %rax # imm = 0x9C0
movq %rax, -0x28(%rbp)
jmp 0x47820
jmp 0x47860
jmp 0x47862
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x477df
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI8PFS_userLi128ELi128E14PFS_user_array18PFS_user_allocatorE5applyER20PFS_buffer_processorIS0_E:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_14], 0
loc_477DF:
cmp [rbp+var_14], 80h
jnb loc_47870
mov rax, [rbp+var_38]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8+0A8h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_47860
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI8PFS_userE9get_firstEv; PFS_buffer_default_array<PFS_user>::get_first(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI8PFS_userE8get_lastEv; PFS_buffer_default_array<PFS_user>::get_last(void)
mov [rbp+var_30], rax
loc_47820:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_4785E
mov rdi, [rbp+var_28]
add rdi, 7E0h; this
call _ZN8pfs_lock12is_populatedEv; pfs_lock::is_populated(void)
test al, 1
jnz short loc_47840
jmp short loc_4784E
loc_47840:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rax, [rdi]
call qword ptr [rax+10h]
loc_4784E:
mov rax, [rbp+var_28]
add rax, 9C0h
mov [rbp+var_28], rax
jmp short loc_47820
loc_4785E:
jmp short $+2
loc_47860:
jmp short $+2
loc_47862:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_477DF
loc_47870:
add rsp, 40h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::apply(
long long a1,
unsigned int *a2)
{
long long result; // rax
unsigned long long last; // [rsp+10h] [rbp-30h]
unsigned long long first; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
unsigned int *v7; // [rsp+30h] [rbp-10h]
v7 = a2;
result = a1;
for ( i = 0; i < 0x80; ++i )
{
v5 = *(_QWORD *)(a1 + 8LL * i + 168);
if ( v5 )
{
first = PFS_buffer_default_array<PFS_user>::get_first(v5);
last = PFS_buffer_default_array<PFS_user>::get_last(v5);
while ( first < last )
{
if ( pfs_lock::is_populated((pfs_lock *)(first + 2016), a2) )
{
a2 = (unsigned int *)first;
(*(void ( **)(unsigned int *, unsigned long long))(*(_QWORD *)v7 + 16LL))(v7, first);
}
first += 2496LL;
}
}
result = i + 1;
}
return result;
}
| apply:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_001477df:
CMP dword ptr [RBP + -0x14],0x80
JNC 0x00147870
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00147860
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00146610
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00146630
MOV qword ptr [RBP + -0x30],RAX
LAB_00147820:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0014785e
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x7e0
CALL 0x00132dd0
TEST AL,0x1
JNZ 0x00147840
JMP 0x0014784e
LAB_00147840:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
LAB_0014784e:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x9c0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00147820
LAB_0014785e:
JMP 0x00147860
LAB_00147860:
JMP 0x00147862
LAB_00147862:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001477df
LAB_00147870:
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array,
PFS_user_allocator>::apply(PFS_buffer_processor<PFS_user>&) */
void __thiscall
PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::apply
(PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator> *this,
PFS_buffer_processor *param_1)
{
PFS_buffer_default_array<PFS_user> *this_00;
ulong uVar1;
ulong uVar2;
ulong local_30;
uint local_1c;
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
this_00 = *(PFS_buffer_default_array<PFS_user> **)(this + (ulong)local_1c * 8 + 0xa8);
if (this_00 != (PFS_buffer_default_array<PFS_user> *)0x0) {
local_30 = PFS_buffer_default_array<PFS_user>::get_first(this_00);
uVar1 = PFS_buffer_default_array<PFS_user>::get_last(this_00);
for (; local_30 < uVar1; local_30 = local_30 + 0x9c0) {
uVar2 = pfs_lock::is_populated((pfs_lock *)(local_30 + 0x7e0));
if ((uVar2 & 1) != 0) {
(**(code **)(*(long *)param_1 + 0x10))(param_1,local_30);
}
}
}
}
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.