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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
63,100 |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
|
monkey531[P]llama/common/json.hpp
|
static diyfp mul(const diyfp& x, const diyfp& y) noexcept
{
static_assert(kPrecision == 64, "internal error");
// Computes:
// f = round((x.f * y.f) / 2^q)
// e = x.e + y.e + q
// Emulate the 64-bit * 64-bit multiplication:
//
// p = u * v
// = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
// = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
// = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
// = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
// = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
// = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
// = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
//
// (Since Q might be larger than 2^32 - 1)
//
// = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
//
// (Q_hi + H does not overflow a 64-bit int)
//
// = p_lo + 2^64 p_hi
const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
const std::uint64_t u_hi = x.f >> 32u;
const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
const std::uint64_t v_hi = y.f >> 32u;
const std::uint64_t p0 = u_lo * v_lo;
const std::uint64_t p1 = u_lo * v_hi;
const std::uint64_t p2 = u_hi * v_lo;
const std::uint64_t p3 = u_hi * v_hi;
const std::uint64_t p0_hi = p0 >> 32u;
const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
const std::uint64_t p1_hi = p1 >> 32u;
const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
const std::uint64_t p2_hi = p2 >> 32u;
std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
// p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
// p_lo = p0_lo + (Q << 32)
//
// But in this particular case here, the full p_lo is not required.
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&):
movq (%rdi), %rax
movl %eax, %ecx
shrq $0x20, %rax
movq (%rsi), %r8
movl %r8d, %edx
shrq $0x20, %r8
movq %rdx, %r9
imulq %rcx, %r9
imulq %r8, %rcx
imulq %rax, %rdx
imulq %rax, %r8
shrq $0x20, %r9
movl %ecx, %r10d
addq %r9, %r10
shrq $0x20, %rcx
movl %edx, %eax
addq %r10, %rax
shrq $0x20, %rdx
addq %r8, %rdx
addq %rcx, %rdx
subq $-0x80000000, %rax # imm = 0x80000000
shrq $0x20, %rax
addq %rdx, %rax
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
addl %ecx, %edx
addl $0x40, %edx
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_:
mov rax, [rdi]
mov ecx, eax
shr rax, 20h
mov r8, [rsi]
mov edx, r8d
shr r8, 20h
mov r9, rdx
imul r9, rcx
imul rcx, r8
imul rdx, rax
imul r8, rax
shr r9, 20h
mov r10d, ecx
add r10, r9
shr rcx, 20h
mov eax, edx
add rax, r10
shr rdx, 20h
add rdx, r8
add rdx, rcx
sub rax, 0FFFFFFFF80000000h
shr rax, 20h
add rax, rdx
mov ecx, [rdi+8]
mov edx, [rsi+8]
add edx, ecx
add edx, 40h ; '@'
retn
|
unsigned long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(_QWORD *a1, _QWORD *a2)
{
long long v2; // rcx
v2 = (unsigned int)*a1;
return ((unsigned long long)(HIDWORD(*a2) * v2) >> 32)
+ HIDWORD(*a1) * HIDWORD(*a2)
+ ((HIDWORD(*a1) * (unsigned long long)(unsigned int)*a2) >> 32)
+ ((((v2 * (unsigned long long)(unsigned int)*a2) >> 32)
+ (unsigned int)(HIDWORD(*a2) * v2)
+ (unsigned int)(HIDWORD(*a1) * *a2)
+ 0x80000000) >> 32);
}
|
mul:
MOV RAX,qword ptr [RDI]
MOV ECX,EAX
SHR RAX,0x20
MOV R8,qword ptr [RSI]
MOV EDX,R8D
SHR R8,0x20
MOV R9,RDX
IMUL R9,RCX
IMUL RCX,R8
IMUL RDX,RAX
IMUL R8,RAX
SHR R9,0x20
MOV R10D,ECX
ADD R10,R9
SHR RCX,0x20
MOV EAX,EDX
ADD RAX,R10
SHR RDX,0x20
ADD RDX,R8
ADD RDX,RCX
SUB RAX,-0x80000000
SHR RAX,0x20
ADD RAX,RDX
MOV ECX,dword ptr [RDI + 0x8]
MOV EDX,dword ptr [RSI + 0x8]
ADD EDX,ECX
ADD EDX,0x40
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp
const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&) */
int1 [16]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(diyfp *param_1,diyfp *param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int1 auVar7 [16];
uVar2 = *(ulong *)param_1 & 0xffffffff;
uVar1 = *(ulong *)param_1 >> 0x20;
uVar4 = *(ulong *)param_2 & 0xffffffff;
uVar6 = *(ulong *)param_2 >> 0x20;
uVar3 = uVar2 * uVar6;
uVar5 = uVar4 * uVar1;
auVar7._0_8_ = ((uVar5 & 0xffffffff) + (uVar3 & 0xffffffff) + (uVar4 * uVar2 >> 0x20) + 0x80000000
>> 0x20) + (uVar5 >> 0x20) + uVar6 * uVar1 + (uVar3 >> 0x20);
auVar7._8_4_ = *(int *)(param_2 + 8) + *(int *)(param_1 + 8) + 0x40;
auVar7._12_4_ = 0;
return auVar7;
}
|
|
63,101 |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
|
monkey531[P]llama/common/json.hpp
|
static diyfp mul(const diyfp& x, const diyfp& y) noexcept
{
static_assert(kPrecision == 64, "internal error");
// Computes:
// f = round((x.f * y.f) / 2^q)
// e = x.e + y.e + q
// Emulate the 64-bit * 64-bit multiplication:
//
// p = u * v
// = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
// = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
// = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
// = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
// = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
// = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
// = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
//
// (Since Q might be larger than 2^32 - 1)
//
// = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
//
// (Q_hi + H does not overflow a 64-bit int)
//
// = p_lo + 2^64 p_hi
const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
const std::uint64_t u_hi = x.f >> 32u;
const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
const std::uint64_t v_hi = y.f >> 32u;
const std::uint64_t p0 = u_lo * v_lo;
const std::uint64_t p1 = u_lo * v_hi;
const std::uint64_t p2 = u_hi * v_lo;
const std::uint64_t p3 = u_hi * v_hi;
const std::uint64_t p0_hi = p0 >> 32u;
const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
const std::uint64_t p1_hi = p1 >> 32u;
const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
const std::uint64_t p2_hi = p2 >> 32u;
std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
// p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
// p_lo = p0_lo + (Q << 32)
//
// But in this particular case here, the full p_lo is not required.
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&):
movq (%rdi), %rax
movl %eax, %ecx
shrq $0x20, %rax
movq (%rsi), %r8
movl %r8d, %edx
shrq $0x20, %r8
movq %rdx, %r9
imulq %rcx, %r9
imulq %r8, %rcx
imulq %rax, %rdx
imulq %rax, %r8
shrq $0x20, %r9
movl %ecx, %r10d
addq %r9, %r10
shrq $0x20, %rcx
movl %edx, %eax
addq %r10, %rax
shrq $0x20, %rdx
addq %r8, %rdx
addq %rcx, %rdx
subq $-0x80000000, %rax # imm = 0x80000000
shrq $0x20, %rax
addq %rdx, %rax
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
addl %ecx, %edx
addl $0x40, %edx
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_:
mov rax, [rdi]
mov ecx, eax
shr rax, 20h
mov r8, [rsi]
mov edx, r8d
shr r8, 20h
mov r9, rdx
imul r9, rcx
imul rcx, r8
imul rdx, rax
imul r8, rax
shr r9, 20h
mov r10d, ecx
add r10, r9
shr rcx, 20h
mov eax, edx
add rax, r10
shr rdx, 20h
add rdx, r8
add rdx, rcx
sub rax, 0FFFFFFFF80000000h
shr rax, 20h
add rax, rdx
mov ecx, [rdi+8]
mov edx, [rsi+8]
add edx, ecx
add edx, 40h ; '@'
retn
|
unsigned long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(_QWORD *a1, _QWORD *a2)
{
long long v2; // rcx
v2 = (unsigned int)*a1;
return ((unsigned long long)(HIDWORD(*a2) * v2) >> 32)
+ HIDWORD(*a1) * HIDWORD(*a2)
+ ((HIDWORD(*a1) * (unsigned long long)(unsigned int)*a2) >> 32)
+ ((((v2 * (unsigned long long)(unsigned int)*a2) >> 32)
+ (unsigned int)(HIDWORD(*a2) * v2)
+ (unsigned int)(HIDWORD(*a1) * *a2)
+ 0x80000000) >> 32);
}
|
mul:
MOV RAX,qword ptr [RDI]
MOV ECX,EAX
SHR RAX,0x20
MOV R8,qword ptr [RSI]
MOV EDX,R8D
SHR R8,0x20
MOV R9,RDX
IMUL R9,RCX
IMUL RCX,R8
IMUL RDX,RAX
IMUL R8,RAX
SHR R9,0x20
MOV R10D,ECX
ADD R10,R9
SHR RCX,0x20
MOV EAX,EDX
ADD RAX,R10
SHR RDX,0x20
ADD RDX,R8
ADD RDX,RCX
SUB RAX,-0x80000000
SHR RAX,0x20
ADD RAX,RDX
MOV ECX,dword ptr [RDI + 0x8]
MOV EDX,dword ptr [RSI + 0x8]
ADD EDX,ECX
ADD EDX,0x40
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp
const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&) */
int1 [16]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(diyfp *param_1,diyfp *param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int1 auVar7 [16];
uVar2 = *(ulong *)param_1 & 0xffffffff;
uVar1 = *(ulong *)param_1 >> 0x20;
uVar4 = *(ulong *)param_2 & 0xffffffff;
uVar6 = *(ulong *)param_2 >> 0x20;
uVar3 = uVar2 * uVar6;
uVar5 = uVar4 * uVar1;
auVar7._0_8_ = ((uVar5 & 0xffffffff) + (uVar3 & 0xffffffff) + (uVar4 * uVar2 >> 0x20) + 0x80000000
>> 0x20) + (uVar5 >> 0x20) + uVar6 * uVar1 + (uVar3 >> 0x20);
auVar7._8_4_ = *(int *)(param_2 + 8) + *(int *)(param_1 + 8) + 0x40;
auVar7._12_4_ = 0;
return auVar7;
}
|
|
63,102 |
gamepad::update_late()
|
untodesu[P]voxelius/game/client/gamepad.cc
|
void gamepad::update_late(void)
{
if(active_gamepad_id == INVALID_GAMEPAD_ID) {
// No active gamepad found
return;
}
if(glfwGetGamepadState(active_gamepad_id, &gamepad::state)) {
for(int i = 0; i < NUM_AXES; ++i) {
if((cxpr::abs(gamepad::state.axes[i]) > GAMEPAD_AXIS_EVENT_THRESHOLD) && (cxpr::abs(gamepad::last_state.axes[i]) <= GAMEPAD_AXIS_EVENT_THRESHOLD)) {
GamepadAxisEvent event;
event.action = GLFW_PRESS;
event.axis = i;
globals::dispatcher.enqueue(event);
continue;
}
if((cxpr::abs(gamepad::state.axes[i]) <= GAMEPAD_AXIS_EVENT_THRESHOLD) && (cxpr::abs(gamepad::last_state.axes[i]) > GAMEPAD_AXIS_EVENT_THRESHOLD)) {
GamepadAxisEvent event;
event.action = GLFW_RELEASE;
event.axis = i;
globals::dispatcher.enqueue(event);
continue;
}
}
for(int i = 0; i < NUM_BUTTONS; ++i) {
if(gamepad::state.buttons[i] == gamepad::last_state.buttons[i]) {
// Nothing happens
continue;
}
GamepadButtonEvent event;
event.action = gamepad::state.buttons[i];
event.button = i;
globals::dispatcher.enqueue(event);
}
}
gamepad::last_state = gamepad::state;
}
|
O0
|
cpp
|
gamepad::update_late():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x7fffffff, 0x452ce6(%rip) # imm = 0x7FFFFFFF
jne 0xbb4a9
jmp 0xbb63b
movl 0x452cd9(%rip), %edi # 0x50e188
leaq 0x452c82(%rip), %rsi # 0x50e138
callq 0x1a5340
cmpl $0x0, %eax
je 0xbb623
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x6, %rax
jae 0xbb5b9
movslq -0x4(%rbp), %rcx
leaq 0x452c54(%rip), %rax # 0x50e138
movss 0x10(%rax,%rcx,4), %xmm0
callq 0xbb650
movss 0x2b2e41(%rip), %xmm1 # 0x36e338
ucomiss %xmm1, %xmm0
jbe 0xbb541
movslq -0x4(%rbp), %rcx
leaq 0x452c59(%rip), %rax # 0x50e160
movss 0x10(%rax,%rcx,4), %xmm0
callq 0xbb650
movaps %xmm0, %xmm1
movss 0x2b2e1b(%rip), %xmm0 # 0x36e338
ucomiss %xmm1, %xmm0
jb 0xbb541
movl $0x1, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x45551a(%rip), %rdi # 0x510a50
leaq -0xc(%rbp), %rsi
callq 0xbc330
jmp 0xbb5ab
movslq -0x4(%rbp), %rcx
leaq 0x452bec(%rip), %rax # 0x50e138
movss 0x10(%rax,%rcx,4), %xmm0
callq 0xbb650
movaps %xmm0, %xmm1
movss 0x2b2dd6(%rip), %xmm0 # 0x36e338
ucomiss %xmm1, %xmm0
jb 0xbb5a9
movslq -0x4(%rbp), %rcx
leaq 0x452bee(%rip), %rax # 0x50e160
movss 0x10(%rax,%rcx,4), %xmm0
callq 0xbb650
movss 0x2b2db3(%rip), %xmm1 # 0x36e338
ucomiss %xmm1, %xmm0
jbe 0xbb5a9
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0x4554b2(%rip), %rdi # 0x510a50
leaq -0x14(%rbp), %rsi
callq 0xbc330
jmp 0xbb5ab
jmp 0xbb5ab
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbb4cb
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0xf, %rax
jae 0xbb621
movslq -0x18(%rbp), %rcx
leaq 0x452b63(%rip), %rax # 0x50e138
movzbl (%rax,%rcx), %eax
movslq -0x18(%rbp), %rdx
leaq 0x452b7c(%rip), %rcx # 0x50e160
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xbb5ee
jmp 0xbb616
movslq -0x18(%rbp), %rcx
leaq 0x452b3f(%rip), %rax # 0x50e138
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq 0x455443(%rip), %rdi # 0x510a50
leaq -0x20(%rbp), %rsi
callq 0xbc370
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbb5c0
jmp 0xbb623
leaq 0x452b36(%rip), %rdi # 0x50e160
leaq 0x452b07(%rip), %rsi # 0x50e138
movl $0x28, %edx
callq 0x2c110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN7gamepad11update_lateEv:
push rbp
mov rbp, rsp
sub rsp, 20h
cmp cs:_ZL17active_gamepad_id, 7FFFFFFFh; active_gamepad_id
jnz short loc_BB4A9
jmp loc_BB63B
loc_BB4A9:
mov edi, cs:_ZL17active_gamepad_id; active_gamepad_id
lea rsi, _ZN7gamepad5stateE; gamepad::state
call glfwGetGamepadState
cmp eax, 0
jz loc_BB623
mov [rbp+var_4], 0
loc_BB4CB:
movsxd rax, [rbp+var_4]
cmp rax, 6
jnb loc_BB5B9
movsxd rcx, [rbp+var_4]
lea rax, _ZN7gamepad5stateE; gamepad::state
movss xmm0, dword ptr [rax+rcx*4+10h]
call _ZN4cxprL3absIfEEKT_S1__0; cxpr::abs<float>(float)
movss xmm1, cs:flt_36E338
ucomiss xmm0, xmm1
jbe short loc_BB541
movsxd rcx, [rbp+var_4]
lea rax, _ZN7gamepad10last_stateE; gamepad::last_state
movss xmm0, dword ptr [rax+rcx*4+10h]
call _ZN4cxprL3absIfEEKT_S1__0; cxpr::abs<float>(float)
movaps xmm1, xmm0
movss xmm0, cs:flt_36E338
ucomiss xmm0, xmm1
jb short loc_BB541
mov [rbp+var_C], 1
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
lea rsi, [rbp+var_C]
call _ZN4entt16basic_dispatcherISaIvEE7enqueueIR16GamepadAxisEventEEvOT_; entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent &>(GamepadAxisEvent &)
jmp short loc_BB5AB
loc_BB541:
movsxd rcx, [rbp+var_4]
lea rax, _ZN7gamepad5stateE; gamepad::state
movss xmm0, dword ptr [rax+rcx*4+10h]
call _ZN4cxprL3absIfEEKT_S1__0; cxpr::abs<float>(float)
movaps xmm1, xmm0
movss xmm0, cs:flt_36E338
ucomiss xmm0, xmm1
jb short loc_BB5A9
movsxd rcx, [rbp+var_4]
lea rax, _ZN7gamepad10last_stateE; gamepad::last_state
movss xmm0, dword ptr [rax+rcx*4+10h]
call _ZN4cxprL3absIfEEKT_S1__0; cxpr::abs<float>(float)
movss xmm1, cs:flt_36E338
ucomiss xmm0, xmm1
jbe short loc_BB5A9
mov [rbp+var_14], 0
mov eax, [rbp+var_4]
mov [rbp+var_10], eax
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
lea rsi, [rbp+var_14]
call _ZN4entt16basic_dispatcherISaIvEE7enqueueIR16GamepadAxisEventEEvOT_; entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent &>(GamepadAxisEvent &)
jmp short loc_BB5AB
loc_BB5A9:
jmp short $+2
loc_BB5AB:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_4], eax
jmp loc_BB4CB
loc_BB5B9:
mov [rbp+var_18], 0
loc_BB5C0:
movsxd rax, [rbp+var_18]
cmp rax, 0Fh
jnb short loc_BB621
movsxd rcx, [rbp+var_18]
lea rax, _ZN7gamepad5stateE; gamepad::state
movzx eax, byte ptr [rax+rcx]
movsxd rdx, [rbp+var_18]
lea rcx, _ZN7gamepad10last_stateE; gamepad::last_state
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jnz short loc_BB5EE
jmp short loc_BB616
loc_BB5EE:
movsxd rcx, [rbp+var_18]
lea rax, _ZN7gamepad5stateE; gamepad::state
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_20], eax
mov eax, [rbp+var_18]
mov [rbp+var_1C], eax
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
lea rsi, [rbp+var_20]
call _ZN4entt16basic_dispatcherISaIvEE7enqueueIR18GamepadButtonEventEEvOT_; entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadButtonEvent &>(GamepadButtonEvent &)
loc_BB616:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
jmp short loc_BB5C0
loc_BB621:
jmp short $+2
loc_BB623:
lea rdi, _ZN7gamepad10last_stateE; gamepad::last_state
lea rsi, _ZN7gamepad5stateE; gamepad::state
mov edx, 28h ; '('
call _memcpy
loc_BB63B:
add rsp, 20h
pop rbp
retn
|
void gamepad::update_late(gamepad *this)
{
_DWORD v1[2]; // [rsp+0h] [rbp-20h] BYREF
int j; // [rsp+8h] [rbp-18h]
_DWORD v3[2]; // [rsp+Ch] [rbp-14h] BYREF
_DWORD v4[2]; // [rsp+14h] [rbp-Ch] BYREF
int i; // [rsp+1Ch] [rbp-4h]
if ( active_gamepad_id != 0x7FFFFFFF )
{
if ( (unsigned int)glfwGetGamepadState((unsigned int)active_gamepad_id, &gamepad::state) )
{
for ( i = 0; (unsigned long long)i < 6; ++i )
{
if ( cxpr::abs<float>(*((float *)&gamepad::state + i + 4)) <= 0.5
|| cxpr::abs<float>(*((float *)&gamepad::last_state + i + 4)) > 0.5 )
{
if ( cxpr::abs<float>(*((float *)&gamepad::state + i + 4)) <= 0.5
&& cxpr::abs<float>(*((float *)&gamepad::last_state + i + 4)) > 0.5 )
{
v3[0] = 0;
v3[1] = i;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent &>(&globals::dispatcher, v3);
}
}
else
{
v4[0] = 1;
v4[1] = i;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent &>(&globals::dispatcher, v4);
}
}
for ( j = 0; (unsigned long long)j < 0xF; ++j )
{
if ( *((unsigned __int8 *)&gamepad::state + j) != *((unsigned __int8 *)&gamepad::last_state + j) )
{
v1[0] = *((unsigned __int8 *)&gamepad::state + j);
v1[1] = j;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadButtonEvent &>(&globals::dispatcher, v1);
}
}
}
memcpy(&gamepad::last_state, &gamepad::state, 40LL);
}
}
|
update_late:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
CMP dword ptr [0x0060e188],0x7fffffff
JNZ 0x001bb4a9
JMP 0x001bb63b
LAB_001bb4a9:
MOV EDI,dword ptr [0x0060e188]
LEA RSI,[0x60e138]
CALL 0x002a5340
CMP EAX,0x0
JZ 0x001bb623
MOV dword ptr [RBP + -0x4],0x0
LAB_001bb4cb:
MOVSXD RAX,dword ptr [RBP + -0x4]
CMP RAX,0x6
JNC 0x001bb5b9
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x60e138]
MOVSS XMM0,dword ptr [RAX + RCX*0x4 + 0x10]
CALL 0x001bb650
MOVSS XMM1,dword ptr [0x0046e338]
UCOMISS XMM0,XMM1
JBE 0x001bb541
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x60e160]
MOVSS XMM0,dword ptr [RAX + RCX*0x4 + 0x10]
CALL 0x001bb650
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [0x0046e338]
UCOMISS XMM0,XMM1
JC 0x001bb541
MOV dword ptr [RBP + -0xc],0x1
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
LEA RDI,[0x610a50]
LEA RSI,[RBP + -0xc]
CALL 0x001bc330
JMP 0x001bb5ab
LAB_001bb541:
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x60e138]
MOVSS XMM0,dword ptr [RAX + RCX*0x4 + 0x10]
CALL 0x001bb650
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [0x0046e338]
UCOMISS XMM0,XMM1
JC 0x001bb5a9
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x60e160]
MOVSS XMM0,dword ptr [RAX + RCX*0x4 + 0x10]
CALL 0x001bb650
MOVSS XMM1,dword ptr [0x0046e338]
UCOMISS XMM0,XMM1
JBE 0x001bb5a9
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x10],EAX
LEA RDI,[0x610a50]
LEA RSI,[RBP + -0x14]
CALL 0x001bc330
JMP 0x001bb5ab
LAB_001bb5a9:
JMP 0x001bb5ab
LAB_001bb5ab:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001bb4cb
LAB_001bb5b9:
MOV dword ptr [RBP + -0x18],0x0
LAB_001bb5c0:
MOVSXD RAX,dword ptr [RBP + -0x18]
CMP RAX,0xf
JNC 0x001bb621
MOVSXD RCX,dword ptr [RBP + -0x18]
LEA RAX,[0x60e138]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVSXD RDX,dword ptr [RBP + -0x18]
LEA RCX,[0x60e160]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JNZ 0x001bb5ee
JMP 0x001bb616
LAB_001bb5ee:
MOVSXD RCX,dword ptr [RBP + -0x18]
LEA RAX,[0x60e138]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x1c],EAX
LEA RDI,[0x610a50]
LEA RSI,[RBP + -0x20]
CALL 0x001bc370
LAB_001bb616:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001bb5c0
LAB_001bb621:
JMP 0x001bb623
LAB_001bb623:
LEA RDI,[0x60e160]
LEA RSI,[0x60e138]
MOV EDX,0x28
CALL 0x0012c110
LAB_001bb63b:
ADD RSP,0x20
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* gamepad::update_late() */
void gamepad::update_late(void)
{
int iVar1;
float fVar2;
uint local_28;
uint local_24;
uint local_20;
int4 local_1c;
uint local_18;
int4 local_14;
uint local_10;
uint local_c;
if (active_gamepad_id != 0x7fffffff) {
iVar1 = glfwGetGamepadState(active_gamepad_id,state);
if (iVar1 != 0) {
for (local_c = 0; local_c < 6; local_c = local_c + 1) {
fVar2 = cxpr::abs<float>(*(float *)(state + (long)(int)local_c * 4 + 0x10));
if ((fVar2 <= _DAT_0046e338) ||
(fVar2 = cxpr::abs<float>(*(float *)(last_state + (long)(int)local_c * 4 + 0x10)),
_DAT_0046e338 < fVar2)) {
fVar2 = cxpr::abs<float>(*(float *)(state + (long)(int)local_c * 4 + 0x10));
if ((fVar2 <= _DAT_0046e338) &&
(fVar2 = cxpr::abs<float>(*(float *)(last_state + (long)(int)local_c * 4 + 0x10)),
_DAT_0046e338 < fVar2)) {
local_1c = 0;
local_18 = local_c;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent&>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
(GamepadAxisEvent *)&local_1c);
}
}
else {
local_14 = 1;
local_10 = local_c;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadAxisEvent&>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
(GamepadAxisEvent *)&local_14);
}
}
for (local_20 = 0; local_20 < 0xf; local_20 = local_20 + 1) {
if (state[(int)local_20] != last_state[(int)local_20]) {
local_28 = (uint)(byte)state[(int)local_20];
local_24 = local_20;
entt::basic_dispatcher<std::allocator<void>>::enqueue<GamepadButtonEvent&>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
(GamepadButtonEvent *)&local_28);
}
}
}
memcpy(last_state,state,0x28);
}
return;
}
|
|
63,103 |
gamepad::update_late()
|
untodesu[P]voxelius/game/client/gamepad.cc
|
void gamepad::update_late(void)
{
if(active_gamepad_id == INVALID_GAMEPAD_ID) {
// No active gamepad found
return;
}
if(glfwGetGamepadState(active_gamepad_id, &gamepad::state)) {
for(int i = 0; i < NUM_AXES; ++i) {
if((cxpr::abs(gamepad::state.axes[i]) > GAMEPAD_AXIS_EVENT_THRESHOLD) && (cxpr::abs(gamepad::last_state.axes[i]) <= GAMEPAD_AXIS_EVENT_THRESHOLD)) {
GamepadAxisEvent event;
event.action = GLFW_PRESS;
event.axis = i;
globals::dispatcher.enqueue(event);
continue;
}
if((cxpr::abs(gamepad::state.axes[i]) <= GAMEPAD_AXIS_EVENT_THRESHOLD) && (cxpr::abs(gamepad::last_state.axes[i]) > GAMEPAD_AXIS_EVENT_THRESHOLD)) {
GamepadAxisEvent event;
event.action = GLFW_RELEASE;
event.axis = i;
globals::dispatcher.enqueue(event);
continue;
}
}
for(int i = 0; i < NUM_BUTTONS; ++i) {
if(gamepad::state.buttons[i] == gamepad::last_state.buttons[i]) {
// Nothing happens
continue;
}
GamepadButtonEvent event;
event.action = gamepad::state.buttons[i];
event.button = i;
globals::dispatcher.enqueue(event);
}
}
gamepad::last_state = gamepad::state;
}
|
O3
|
cpp
|
gamepad::update_late():
movl 0x20b1f9(%rip), %edi # 0x259f58
cmpl $0x7fffffff, %edi # imm = 0x7FFFFFFF
je 0x4eed3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x20b18b(%rip), %rbx # 0x259f08
movq %rbx, %rsi
callq 0x9b3c0
testl %eax, %eax
je 0x4ee9b
movabsq $0x100000000, %r12 # imm = 0x100000000
xorl %ebp, %ebp
movaps 0x142a20(%rip), %xmm3 # 0x1917c0
movss 0x142a80(%rip), %xmm4 # 0x191828
leaq 0x20b181(%rip), %r13 # 0x259f30
movq %rsp, %r15
xorl %r14d, %r14d
movss 0x10(%rbx,%r14,4), %xmm1
movaps %xmm1, %xmm0
xorps %xmm3, %xmm0
maxss %xmm1, %xmm0
ucomiss %xmm4, %xmm0
jbe 0x4ede1
movss 0x10(%r13,%r14,4), %xmm1
movaps %xmm1, %xmm2
xorps %xmm3, %xmm2
maxss %xmm1, %xmm2
ucomiss %xmm2, %xmm4
jae 0x4ee17
ucomiss %xmm0, %xmm4
jb 0x4ee4b
movss 0x10(%r13,%r14,4), %xmm0
movaps %xmm0, %xmm1
xorps %xmm3, %xmm1
maxss %xmm0, %xmm1
ucomiss %xmm4, %xmm1
jbe 0x4ee4b
leaq 0x20da1d(%rip), %rdi # 0x25c820
movl $0xbe4a6243, %esi # imm = 0xBE4A6243
callq 0x504ba
leaq 0x20(%rax), %rdi
movq %rbp, (%rsp)
jmp 0x4ee34
leaq 0x20da02(%rip), %rdi # 0x25c820
movl $0xbe4a6243, %esi # imm = 0xBE4A6243
callq 0x504ba
leaq 0x20(%rax), %rdi
leaq 0x1(%rbp), %rax
movq %rax, (%rsp)
movq %r15, %rsi
callq 0x507ee
movss 0x1429e4(%rip), %xmm4 # 0x191828
movaps 0x142975(%rip), %xmm3 # 0x1917c0
incq %r14
addq %r12, %rbp
cmpq $0x6, %r14
jne 0x4edb5
xorl %ebp, %ebp
xorl %r14d, %r14d
movzbl (%r14,%rbx), %r15d
cmpb (%r14,%r13), %r15b
je 0x4ee8f
leaq 0x20d9ae(%rip), %rdi # 0x25c820
movl $0x13bbac74, %esi # imm = 0x13BBAC74
callq 0x50962
leaq 0x20(%rax), %rdi
addq %rbp, %r15
movq %r15, (%rsp)
movq %rsp, %rsi
callq 0x50c96
incq %r14
addq %r12, %rbp
cmpq $0xf, %r14
jne 0x4ee60
movq 0x20b086(%rip), %rax # 0x259f28
movq %rax, 0x20b0a7(%rip) # 0x259f50
movups 0x20b068(%rip), %xmm0 # 0x259f18
movups %xmm0, 0x20b089(%rip) # 0x259f40
movups 0x20b04a(%rip), %xmm0 # 0x259f08
movups %xmm0, 0x20b06b(%rip) # 0x259f30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN7gamepad11update_lateEv:
mov edi, cs:_ZL17active_gamepad_id; active_gamepad_id
cmp edi, 7FFFFFFFh
jz locret_4EED3
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
lea rbx, _ZN7gamepad5stateE; gamepad::state
mov rsi, rbx
call glfwGetGamepadState
test eax, eax
jz loc_4EE9B
mov r12, 100000000h
xor ebp, ebp
movaps xmm3, cs:xmmword_1917C0
movss xmm4, cs:flt_191828
lea r13, _ZN7gamepad10last_stateE; gamepad::last_state
mov r15, rsp
xor r14d, r14d
loc_4EDB5:
movss xmm1, dword ptr [rbx+r14*4+10h]
movaps xmm0, xmm1
xorps xmm0, xmm3
maxss xmm0, xmm1
ucomiss xmm0, xmm4
jbe short loc_4EDE1
movss xmm1, dword ptr [r13+r14*4+10h]
movaps xmm2, xmm1
xorps xmm2, xmm3
maxss xmm2, xmm1
ucomiss xmm4, xmm2
jnb short loc_4EE17
loc_4EDE1:
ucomiss xmm4, xmm0
jb short loc_4EE4B
movss xmm0, dword ptr [r13+r14*4+10h]
movaps xmm1, xmm0
xorps xmm1, xmm3
maxss xmm1, xmm0
ucomiss xmm1, xmm4
jbe short loc_4EE4B
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
mov esi, 0BE4A6243h
call _ZN4entt16basic_dispatcherISaIvEE6assureI16GamepadAxisEventEERNS_8internal18dispatcher_handlerIT_S1_EEj; entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>(uint)
lea rdi, [rax+20h]
mov [rsp+38h+var_38], rbp
jmp short loc_4EE34
loc_4EE17:
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
mov esi, 0BE4A6243h
call _ZN4entt16basic_dispatcherISaIvEE6assureI16GamepadAxisEventEERNS_8internal18dispatcher_handlerIT_S1_EEj; entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>(uint)
lea rdi, [rax+20h]
lea rax, [rbp+1]
mov [rsp+38h+var_38], rax
loc_4EE34:
mov rsi, r15
call _ZNSt6vectorI16GamepadAxisEventSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<GamepadAxisEvent>::emplace_back<GamepadAxisEvent>(GamepadAxisEvent &&)
movss xmm4, cs:flt_191828
movaps xmm3, cs:xmmword_1917C0
loc_4EE4B:
inc r14
add rbp, r12
cmp r14, 6
jnz loc_4EDB5
xor ebp, ebp
xor r14d, r14d
loc_4EE60:
movzx r15d, byte ptr [r14+rbx]
cmp r15b, [r14+r13]
jz short loc_4EE8F
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
mov esi, 13BBAC74h
call _ZN4entt16basic_dispatcherISaIvEE6assureI18GamepadButtonEventEERNS_8internal18dispatcher_handlerIT_S1_EEj; entt::basic_dispatcher<std::allocator<void>>::assure<GamepadButtonEvent>(uint)
lea rdi, [rax+20h]
add r15, rbp
mov [rsp+38h+var_38], r15
mov rsi, rsp
call _ZNSt6vectorI18GamepadButtonEventSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<GamepadButtonEvent>::emplace_back<GamepadButtonEvent>(GamepadButtonEvent &&)
loc_4EE8F:
inc r14
add rbp, r12
cmp r14, 0Fh
jnz short loc_4EE60
loc_4EE9B:
mov rax, cs:qword_259F28
mov cs:qword_259F50, rax
movups xmm0, cs:xmmword_259F18
movups cs:xmmword_259F40, xmm0
movups xmm0, cs:_ZN7gamepad5stateE; gamepad::state
movups cs:_ZN7gamepad10last_stateE, xmm0; gamepad::last_state
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_4EED3:
retn
|
long long gamepad::update_late(gamepad *this, double a2, double a3, double a4)
{
long long result; // rax
long long v5; // rbp
long long v6; // xmm4_8
long long i; // r14
double v8; // xmm1_8
double v9; // xmm0_8
long long v10; // rdi
long long v11; // rbp
long long j; // r14
long long v13; // r15
long long v14; // rax
_QWORD v15[7]; // [rsp+0h] [rbp-38h] BYREF
if ( active_gamepad_id == 0x7FFFFFFF )
return result;
v15[0] = result;
if ( !(unsigned int)glfwGetGamepadState((unsigned int)active_gamepad_id, &gamepad::state) )
goto LABEL_16;
v5 = 0LL;
v6 = 1056964608LL;
for ( i = 0LL; i != 6; ++i )
{
*(_QWORD *)&v8 = *((unsigned int *)&gamepad::state + i + 4);
HIDWORD(v9) = HIDWORD(v8) ^ 0x80000000;
*(float *)&v9 = fmaxf(COERCE_FLOAT(LODWORD(v8) ^ 0x80000000), *(float *)&v8);
if ( *(float *)&v9 > 0.5 )
{
*(_QWORD *)&v8 = *((unsigned int *)&gamepad::last_state + i + 4);
HIDWORD(a4) = HIDWORD(v8) ^ 0x80000000;
*(float *)&a4 = fmaxf(COERCE_FLOAT(LODWORD(v8) ^ 0x80000000), *(float *)&v8);
if ( *(float *)&a4 <= 0.5 )
{
v10 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>(globals::dispatcher, 3192545859LL)
+ 32;
v15[0] = v5 + 1;
goto LABEL_10;
}
}
if ( *(float *)&v9 <= 0.5 )
{
*(_QWORD *)&v9 = *((unsigned int *)&gamepad::last_state + i + 4);
HIDWORD(v8) = HIDWORD(v9) ^ 0x80000000;
*(float *)&v8 = fmaxf(COERCE_FLOAT(LODWORD(v9) ^ 0x80000000), *(float *)&v9);
if ( *(float *)&v8 > 0.5 )
{
v10 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>(globals::dispatcher, 3192545859LL)
+ 32;
v15[0] = v5;
LABEL_10:
std::vector<GamepadAxisEvent>::emplace_back<GamepadAxisEvent>(v10, v15);
v6 = 1056964608LL;
}
}
v5 += 0x100000000LL;
}
v11 = 0LL;
for ( j = 0LL; j != 15; ++j )
{
v13 = *((unsigned __int8 *)&gamepad::state + j);
if ( (_BYTE)v13 != *((_BYTE *)&gamepad::last_state + j) )
{
v14 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadButtonEvent>(
globals::dispatcher,
331066484LL,
v9,
v8,
a4,
COERCE_DOUBLE(0x8000000080000000LL),
*(double *)&v6);
v15[0] = v11 + v13;
std::vector<GamepadButtonEvent>::emplace_back<GamepadButtonEvent>(v14 + 32, v15);
}
v11 += 0x100000000LL;
}
LABEL_16:
result = qword_259F28;
qword_259F50 = qword_259F28;
xmmword_259F40 = xmmword_259F18;
gamepad::last_state = gamepad::state;
return result;
}
|
update_late:
MOV EDI,dword ptr [0x00359f58]
CMP EDI,0x7fffffff
JZ 0x0014eed3
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
LEA RBX,[0x359f08]
MOV RSI,RBX
CALL 0x0019b3c0
TEST EAX,EAX
JZ 0x0014ee9b
MOV R12,0x100000000
XOR EBP,EBP
MOVAPS XMM3,xmmword ptr [0x002917c0]
MOVSS XMM4,dword ptr [0x00291828]
LEA R13,[0x359f30]
MOV R15,RSP
XOR R14D,R14D
LAB_0014edb5:
MOVSS XMM1,dword ptr [RBX + R14*0x4 + 0x10]
MOVAPS XMM0,XMM1
XORPS XMM0,XMM3
MAXSS XMM0,XMM1
UCOMISS XMM0,XMM4
JBE 0x0014ede1
MOVSS XMM1,dword ptr [R13 + R14*0x4 + 0x10]
MOVAPS XMM2,XMM1
XORPS XMM2,XMM3
MAXSS XMM2,XMM1
UCOMISS XMM4,XMM2
JNC 0x0014ee17
LAB_0014ede1:
UCOMISS XMM4,XMM0
JC 0x0014ee4b
MOVSS XMM0,dword ptr [R13 + R14*0x4 + 0x10]
MOVAPS XMM1,XMM0
XORPS XMM1,XMM3
MAXSS XMM1,XMM0
UCOMISS XMM1,XMM4
JBE 0x0014ee4b
LEA RDI,[0x35c820]
MOV ESI,0xbe4a6243
CALL 0x001504ba
LEA RDI,[RAX + 0x20]
MOV qword ptr [RSP],RBP
JMP 0x0014ee34
LAB_0014ee17:
LEA RDI,[0x35c820]
MOV ESI,0xbe4a6243
CALL 0x001504ba
LEA RDI,[RAX + 0x20]
LEA RAX,[RBP + 0x1]
MOV qword ptr [RSP],RAX
LAB_0014ee34:
MOV RSI,R15
CALL 0x001507ee
MOVSS XMM4,dword ptr [0x00291828]
MOVAPS XMM3,xmmword ptr [0x002917c0]
LAB_0014ee4b:
INC R14
ADD RBP,R12
CMP R14,0x6
JNZ 0x0014edb5
XOR EBP,EBP
XOR R14D,R14D
LAB_0014ee60:
MOVZX R15D,byte ptr [R14 + RBX*0x1]
CMP R15B,byte ptr [R14 + R13*0x1]
JZ 0x0014ee8f
LEA RDI,[0x35c820]
MOV ESI,0x13bbac74
CALL 0x00150962
LEA RDI,[RAX + 0x20]
ADD R15,RBP
MOV qword ptr [RSP],R15
MOV RSI,RSP
CALL 0x00150c96
LAB_0014ee8f:
INC R14
ADD RBP,R12
CMP R14,0xf
JNZ 0x0014ee60
LAB_0014ee9b:
MOV RAX,qword ptr [0x00359f28]
MOV qword ptr [0x00359f50],RAX
MOVUPS XMM0,xmmword ptr [0x00359f18]
MOVUPS xmmword ptr [0x00359f40],XMM0
MOVUPS XMM0,xmmword ptr [0x00359f08]
MOVUPS xmmword ptr [0x00359f30],XMM0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0014eed3:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* gamepad::update_late() */
void gamepad::update_late(void)
{
float fVar1;
byte bVar2;
int iVar3;
long in_RAX;
dispatcher_handler *pdVar4;
long lVar5;
long lVar6;
float fVar7;
float fVar8;
uint uVar9;
float fVar10;
long local_38;
if (active_gamepad_id != 0x7fffffff) {
local_38 = in_RAX;
iVar3 = glfwGetGamepadState(active_gamepad_id,&state);
if (iVar3 != 0) {
lVar5 = 0;
lVar6 = 0;
uVar9 = _DAT_002917c0;
fVar10 = DAT_00291828;
do {
fVar1 = *(float *)(&DAT_00359f18 + lVar6 * 4);
fVar7 = (float)((uint)fVar1 ^ uVar9);
if ((float)((uint)fVar1 ^ uVar9) <= fVar1) {
fVar7 = fVar1;
}
if (fVar7 <= fVar10) {
LAB_0014ede1:
if (fVar7 <= fVar10) {
fVar1 = *(float *)(&DAT_00359f40 + lVar6 * 4);
fVar7 = (float)((uint)fVar1 ^ uVar9);
if ((float)((uint)fVar1 ^ uVar9) <= fVar1) {
fVar7 = fVar1;
}
if (fVar10 < fVar7) {
pdVar4 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
0xbe4a6243);
local_38 = lVar5;
goto LAB_0014ee34;
}
}
}
else {
fVar1 = *(float *)(&DAT_00359f40 + lVar6 * 4);
fVar8 = (float)((uint)fVar1 ^ uVar9);
if ((float)((uint)fVar1 ^ uVar9) <= fVar1) {
fVar8 = fVar1;
}
if (fVar10 < fVar8) goto LAB_0014ede1;
pdVar4 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadAxisEvent>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
0xbe4a6243);
local_38 = lVar5 + 1;
LAB_0014ee34:
std::vector<GamepadAxisEvent,std::allocator<GamepadAxisEvent>>::
emplace_back<GamepadAxisEvent>
((vector<GamepadAxisEvent,std::allocator<GamepadAxisEvent>> *)(pdVar4 + 0x20),
(GamepadAxisEvent *)&local_38);
uVar9 = _DAT_002917c0;
fVar10 = DAT_00291828;
}
lVar6 = lVar6 + 1;
lVar5 = lVar5 + 0x100000000;
} while (lVar6 != 6);
lVar5 = 0;
lVar6 = 0;
do {
bVar2 = (&state)[lVar6];
if (bVar2 != (&last_state)[lVar6]) {
pdVar4 = entt::basic_dispatcher<std::allocator<void>>::assure<GamepadButtonEvent>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,
0x13bbac74);
local_38 = (ulong)bVar2 + lVar5;
std::vector<GamepadButtonEvent,std::allocator<GamepadButtonEvent>>::
emplace_back<GamepadButtonEvent>
((vector<GamepadButtonEvent,std::allocator<GamepadButtonEvent>> *)
(pdVar4 + 0x20),(GamepadButtonEvent *)&local_38);
}
lVar6 = lVar6 + 1;
lVar5 = lVar5 + 0x100000000;
} while (lVar6 != 0xf);
}
_DAT_00359f50 = DAT_00359f28;
_DAT_00359f40 = _DAT_00359f18;
uRam0000000000359f48 = uRam0000000000359f20;
_last_state = _state;
uRam0000000000359f38 = uRam0000000000359f10;
}
return;
}
|
|
63,104 |
mysql_stmt_attr_set
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, const void *value)
{
switch (attr_type) {
case STMT_ATTR_UPDATE_MAX_LENGTH:
stmt->update_max_length= *(my_bool *)value;
break;
case STMT_ATTR_CURSOR_TYPE:
if (*(ulong *)value > (unsigned long) CURSOR_TYPE_READ_ONLY)
{
SET_CLIENT_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, SQLSTATE_UNKNOWN, 0);
return(1);
}
stmt->flags = *(ulong *)value;
break;
case STMT_ATTR_PREFETCH_ROWS:
if (*(ulong *)value == 0)
*(long *)value= MYSQL_DEFAULT_PREFETCH_ROWS;
else
stmt->prefetch_rows= *(long *)value;
break;
case STMT_ATTR_PREBIND_PARAMS:
if (stmt->state > MYSQL_STMT_INITTED)
{
mysql_stmt_internal_reset(stmt, 1);
net_stmt_close(stmt, 0);
stmt->state= MYSQL_STMT_INITTED;
stmt->params= 0;
}
stmt->prebind_params= stmt->param_count= *(unsigned int *)value;
break;
case STMT_ATTR_ARRAY_SIZE:
stmt->array_size= *(unsigned int *)value;
break;
case STMT_ATTR_ROW_SIZE:
stmt->row_size= *(size_t *)value;
break;
case STMT_ATTR_CB_RESULT:
stmt->result_callback= (ps_result_callback)value;
break;
case STMT_ATTR_CB_PARAM:
stmt->param_callback= (ps_param_callback)value;
break;
case STMT_ATTR_CB_USER_DATA:
stmt->user_data= (void *)value;
break;
default:
SET_CLIENT_STMT_ERROR(stmt, CR_NOT_IMPLEMENTED, SQLSTATE_UNKNOWN, 0);
return(1);
}
return(0);
}
|
O0
|
c
|
mysql_stmt_attr_set:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xb0a12
jmp 0xb0993
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xb0a27
jmp 0xb09a1
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xb0ab6
jmp 0xb09af
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0xb0ae4
jmp 0xb09bf
movl -0x24(%rbp), %eax
subl $0xc9, %eax
je 0xb0b3a
jmp 0xb09cf
movl -0x24(%rbp), %eax
subl $0xca, %eax
je 0xb0b4f
jmp 0xb09df
movl -0x24(%rbp), %eax
subl $0xcc, %eax
je 0xb0b8b
jmp 0xb09ef
movl -0x24(%rbp), %eax
subl $0xcd, %eax
je 0xb0b7a
jmp 0xb09ff
movl -0x24(%rbp), %eax
subl $0xce, %eax
je 0xb0b66
jmp 0xb0b9c
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x313(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rax
cmpq $0x1, (%rax)
jbe 0xb0aa2
jmp 0xb0a33
movq -0x10(%rbp), %rax
movl $0x806, 0x108(%rax) # imm = 0x806
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x201f9d(%rip), %rax # 0x2b29f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a140
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x201f83(%rip), %rax # 0x2b2a00
movq 0x1b0(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x3a140
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xb0c0e
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb0acd
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
jmp 0xb0adf
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x318(%rax)
jmp 0xb0c0a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jbe 0xb0b1e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xb0c20
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb0e30
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x378(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x368(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x370(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x388(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x390(%rax)
jmp 0xb0c0a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x380(%rax)
jmp 0xb0c0a
jmp 0xb0b9e
movq -0x10(%rbp), %rax
movl $0x806, 0x108(%rax) # imm = 0x806
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x201e32(%rip), %rax # 0x2b29f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x3a140
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x201e18(%rip), %rax # 0x2b2a00
movq 0x1b0(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x3a140
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xb0c0e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_attr_set:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
test eax, eax
jz loc_B0A12
jmp short $+2
loc_B0993:
mov eax, [rbp+var_24]
sub eax, 1
jz loc_B0A27
jmp short $+2
loc_B09A1:
mov eax, [rbp+var_24]
sub eax, 2
jz loc_B0AB6
jmp short $+2
loc_B09AF:
mov eax, [rbp+var_24]
sub eax, 0C8h
jz loc_B0AE4
jmp short $+2
loc_B09BF:
mov eax, [rbp+var_24]
sub eax, 0C9h
jz loc_B0B3A
jmp short $+2
loc_B09CF:
mov eax, [rbp+var_24]
sub eax, 0CAh
jz loc_B0B4F
jmp short $+2
loc_B09DF:
mov eax, [rbp+var_24]
sub eax, 0CCh
jz loc_B0B8B
jmp short $+2
loc_B09EF:
mov eax, [rbp+var_24]
sub eax, 0CDh
jz loc_B0B7A
jmp short $+2
loc_B09FF:
mov eax, [rbp+var_24]
sub eax, 0CEh
jz loc_B0B66
jmp loc_B0B9C
loc_B0A12:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_10]
mov [rax+313h], cl
jmp loc_B0C0A
loc_B0A27:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 1
jbe short loc_B0AA2
jmp short $+2
loc_B0A33:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 806h
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+1B0h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_1], 1
jmp loc_B0C0E
loc_B0AA2:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+48h], rcx
jmp loc_B0C0A
loc_B0AB6:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jnz short loc_B0ACD
mov rax, [rbp+var_20]
mov qword ptr [rax], 1
jmp short loc_B0ADF
loc_B0ACD:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+318h], rcx
loc_B0ADF:
jmp loc_B0C0A
loc_B0AE4:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 0
jbe short loc_B0B1E
mov rdi, [rbp+var_10]
mov esi, 1
call mysql_stmt_internal_reset
mov rdi, [rbp+var_10]
xor esi, esi
call net_stmt_close
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+70h], 0
loc_B0B1E:
mov rax, [rbp+var_20]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+64h], ecx
mov rax, [rbp+var_10]
mov [rax+378h], ecx
jmp loc_B0C0A
loc_B0B3A:
mov rax, [rbp+var_20]
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+368h], ecx
jmp loc_B0C0A
loc_B0B4F:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+370h], rcx
jmp loc_B0C0A
loc_B0B66:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+388h], rcx
jmp loc_B0C0A
loc_B0B7A:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+390h], rcx
jmp short loc_B0C0A
loc_B0B8B:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+380h], rcx
jmp short loc_B0C0A
loc_B0B9C:
jmp short $+2
loc_B0B9E:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 806h
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+1B0h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_1], 1
jmp short loc_B0C0E
loc_B0C0A:
mov [rbp+var_1], 0
loc_B0C0E:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char mysql_stmt_attr_set(long long a1, int a2, _BYTE *a3)
{
int v3; // ecx
if ( !a2 )
{
*(_BYTE *)(a1 + 787) = *a3;
return 0;
}
if ( a2 != 1 )
{
switch ( a2 )
{
case 2:
if ( *(_QWORD *)a3 )
*(_QWORD *)(a1 + 792) = *(_QWORD *)a3;
else
*(_QWORD *)a3 = 1LL;
break;
case 200:
if ( *(_DWORD *)(a1 + 80) )
{
mysql_stmt_internal_reset(a1, 1LL);
net_stmt_close(a1, 0LL);
*(_DWORD *)(a1 + 80) = 0;
*(_QWORD *)(a1 + 112) = 0LL;
}
v3 = *(_DWORD *)a3;
*(_DWORD *)(a1 + 100) = *(_DWORD *)a3;
*(_DWORD *)(a1 + 888) = v3;
break;
case 201:
*(_DWORD *)(a1 + 872) = *(_DWORD *)a3;
break;
case 202:
*(_QWORD *)(a1 + 880) = *(_QWORD *)a3;
break;
case 204:
*(_QWORD *)(a1 + 896) = a3;
break;
case 205:
*(_QWORD *)(a1 + 912) = a3;
break;
case 206:
*(_QWORD *)(a1 + 904) = a3;
break;
default:
goto LABEL_13;
}
return 0;
}
if ( *(_QWORD *)a3 <= 1uLL )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)a3;
return 0;
}
LABEL_13:
*(_DWORD *)(a1 + 264) = 2054;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[54], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
|
mysql_stmt_attr_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
TEST EAX,EAX
JZ 0x001b0a12
JMP 0x001b0993
LAB_001b0993:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
JZ 0x001b0a27
JMP 0x001b09a1
LAB_001b09a1:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x001b0ab6
JMP 0x001b09af
LAB_001b09af:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
JZ 0x001b0ae4
JMP 0x001b09bf
LAB_001b09bf:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc9
JZ 0x001b0b3a
JMP 0x001b09cf
LAB_001b09cf:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xca
JZ 0x001b0b4f
JMP 0x001b09df
LAB_001b09df:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcc
JZ 0x001b0b8b
JMP 0x001b09ef
LAB_001b09ef:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcd
JZ 0x001b0b7a
JMP 0x001b09ff
LAB_001b09ff:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xce
JZ 0x001b0b66
JMP 0x001b0b9c
LAB_001b0a12:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x313],CL
JMP 0x001b0c0a
LAB_001b0a27:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x1
JBE 0x001b0aa2
JMP 0x001b0a33
LAB_001b0a33:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x806
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x3b29f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x3b2a00]
MOV RSI,qword ptr [RAX + 0x1b0]
MOV EDX,0x200
CALL 0x0013a140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001b0c0e
LAB_001b0aa2:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
JMP 0x001b0c0a
LAB_001b0ab6:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001b0acd
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x1
JMP 0x001b0adf
LAB_001b0acd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x318],RCX
LAB_001b0adf:
JMP 0x001b0c0a
LAB_001b0ae4:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x0
JBE 0x001b0b1e
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x001b0c20
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001b0e30
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x70],0x0
LAB_001b0b1e:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x64],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x378],ECX
JMP 0x001b0c0a
LAB_001b0b3a:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x368],ECX
JMP 0x001b0c0a
LAB_001b0b4f:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x370],RCX
JMP 0x001b0c0a
LAB_001b0b66:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x388],RCX
JMP 0x001b0c0a
LAB_001b0b7a:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x390],RCX
JMP 0x001b0c0a
LAB_001b0b8b:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x380],RCX
JMP 0x001b0c0a
LAB_001b0b9c:
JMP 0x001b0b9e
LAB_001b0b9e:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x806
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x3b29f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x0013a140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x3b2a00]
MOV RSI,qword ptr [RAX + 0x1b0]
MOV EDX,0x200
CALL 0x0013a140
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001b0c0e
LAB_001b0c0a:
MOV byte ptr [RBP + -0x1],0x0
LAB_001b0c0e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 mysql_stmt_attr_set(long param_1,int param_2,ulong *param_3)
{
ulong uVar1;
if (param_2 == 0) {
*(char *)(param_1 + 0x313) = (char)*param_3;
}
else if (param_2 == 1) {
if (1 < *param_3) {
*(int4 *)(param_1 + 0x108) = 0x806;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_This_feature_is_not_implemented_o_003b2bb0,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
*(ulong *)(param_1 + 0x48) = *param_3;
}
else if (param_2 == 2) {
if (*param_3 == 0) {
*param_3 = 1;
}
else {
*(ulong *)(param_1 + 0x318) = *param_3;
}
}
else if (param_2 == 200) {
if (*(int *)(param_1 + 0x50) != 0) {
mysql_stmt_internal_reset(param_1,1);
net_stmt_close(param_1,0);
*(int4 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x70) = 0;
}
uVar1 = *param_3;
*(int *)(param_1 + 100) = (int)uVar1;
*(int *)(param_1 + 0x378) = (int)uVar1;
}
else if (param_2 == 0xc9) {
*(int *)(param_1 + 0x368) = (int)*param_3;
}
else if (param_2 == 0xca) {
*(ulong *)(param_1 + 0x370) = *param_3;
}
else if (param_2 == 0xcc) {
*(ulong **)(param_1 + 0x380) = param_3;
}
else if (param_2 == 0xcd) {
*(ulong **)(param_1 + 0x390) = param_3;
}
else {
if (param_2 != 0xce) {
*(int4 *)(param_1 + 0x108) = 0x806;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_This_feature_is_not_implemented_o_003b2bb0,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
*(ulong **)(param_1 + 0x388) = param_3;
}
return 0;
}
|
|
63,105 |
Cache::printStatistics()
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::printStatistics() {
printf("-------- STATISTICS ----------\n");
printf("Num Read: %d\n", this->statistics.numRead);
printf("Num Write: %d\n", this->statistics.numWrite);
printf("Num Hit: %d\n", this->statistics.numHit);
printf("Num Miss: %d\n", this->statistics.numMiss);
printf("Total Cycles: %llu\n", this->statistics.totalCycles);
if (this->lowerCache != nullptr) {
printf("---------- LOWER CACHE ----------\n");
this->lowerCache->printStatistics();
}
}
|
O0
|
cpp
|
Cache::printStatistics():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x39a4(%rip), %rdi # 0x2a52e
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl (%rax), %esi
leaq 0x39af(%rip), %rdi # 0x2a54e
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
leaq 0x39a7(%rip), %rdi # 0x2a55c
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
leaq 0x39a0(%rip), %rdi # 0x2a56b
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
leaq 0x3997(%rip), %rdi # 0x2a578
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x398e(%rip), %rdi # 0x2a586
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x26c27
leaq 0x3988(%rip), %rdi # 0x2a59a
movb $0x0, %al
callq 0x15050
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x26b70
addq $0x18, %rsp
retq
nopl (%rax)
|
_ZN5Cache15printStatisticsEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_10], rax
lea rdi, aStatistics_0; "-------- STATISTICS ----------\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov esi, [rax]
lea rdi, aNumReadD; "Num Read: %d\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov esi, [rax+4]
lea rdi, aNumWriteD; "Num Write: %d\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov esi, [rax+8]
lea rdi, aNumHitD; "Num Hit: %d\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov esi, [rax+0Ch]
lea rdi, aNumMissD; "Num Miss: %d\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov rsi, [rax+10h]
lea rdi, aTotalCyclesLlu; "Total Cycles: %llu\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
cmp qword ptr [rax+28h], 0
jz short loc_26C27
lea rdi, aLowerCache; "---------- LOWER CACHE ----------\n"
mov al, 0
call _printf
mov rax, [rsp+18h+var_10]
mov rdi, [rax+28h]; this
call _ZN5Cache15printStatisticsEv; Cache::printStatistics(void)
loc_26C27:
add rsp, 18h
retn
|
Cache * Cache::printStatistics(Cache *this)
{
Cache *result; // rax
printf("-------- STATISTICS ----------\n");
printf("Num Read: %d\n", *(_DWORD *)this);
printf("Num Write: %d\n", *((_DWORD *)this + 1));
printf("Num Hit: %d\n", *((_DWORD *)this + 2));
printf("Num Miss: %d\n", *((_DWORD *)this + 3));
printf("Total Cycles: %llu\n", *((_QWORD *)this + 2));
result = this;
if ( *((_QWORD *)this + 5) )
{
printf("---------- LOWER CACHE ----------\n");
return (Cache *)Cache::printStatistics(*((Cache **)this + 5));
}
return result;
}
|
printStatistics:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[0x12a52e]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX]
LEA RDI,[0x12a54e]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x4]
LEA RDI,[0x12a55c]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x8]
LEA RDI,[0x12a56b]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0xc]
LEA RDI,[0x12a578]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
LEA RDI,[0x12a586]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x00126c27
LEA RDI,[0x12a59a]
MOV AL,0x0
CALL 0x00115050
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x28]
CALL 0x00126b70
LAB_00126c27:
ADD RSP,0x18
RET
|
/* Cache::printStatistics() */
void __thiscall Cache::printStatistics(Cache *this)
{
printf("-------- STATISTICS ----------\n");
printf("Num Read: %d\n",(ulong)*(uint *)this);
printf("Num Write: %d\n",(ulong)*(uint *)(this + 4));
printf("Num Hit: %d\n",(ulong)*(uint *)(this + 8));
printf("Num Miss: %d\n",(ulong)*(uint *)(this + 0xc));
printf("Total Cycles: %llu\n",*(int8 *)(this + 0x10));
if (*(long *)(this + 0x28) != 0) {
printf("---------- LOWER CACHE ----------\n");
printStatistics(*(Cache **)(this + 0x28));
}
return;
}
|
|
63,106 |
allocate_dynamic
|
eloqsql/mysys/array.c
|
my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
{
DBUG_ENTER("allocate_dynamic");
if (max_elements >= array->max_element)
{
uint size;
uchar *new_ptr;
size= (max_elements + array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this senerio, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (uchar *) my_malloc(array->m_psi_key, size *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr= (uchar*) my_realloc(array->m_psi_key,
array->buffer,size *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(TRUE);
array->buffer= new_ptr;
array->max_element= size;
}
DBUG_RETURN(FALSE);
}
|
O0
|
c
|
allocate_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0xdad45
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0xdacee
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0xf3830
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xdacb3
jmp 0xdacaa
movb $0x0, -0x1(%rbp)
jmp 0xdad4b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a090
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0xdad30
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0xf3a00
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xdad2e
jmp 0xdad28
movb $0x1, -0x1(%rbp)
jmp 0xdad4b
jmp 0xdad30
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0xdad47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
allocate_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb loc_DAD45
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
xor edx, edx
div dword ptr [rcx+10h]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
imul eax, [rbp+var_18]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_DACEE
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_DACB3
jmp short $+2
loc_DACAA:
mov [rbp+var_1], 0
jmp loc_DAD4B
loc_DACB3:
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_DAD30
loc_DACEE:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_DAD2E
jmp short $+2
loc_DAD28:
mov [rbp+var_1], 1
jmp short loc_DAD4B
loc_DAD2E:
jmp short $+2
loc_DAD30:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
loc_DAD45:
jmp short $+2
loc_DAD47:
mov [rbp+var_1], 0
loc_DAD4B:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char allocate_dynamic(long long a1, unsigned int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
unsigned int v4; // [rsp+8h] [rbp-18h]
if ( a2 < *(_DWORD *)(a1 + 12) )
return 0;
v4 = (*(_DWORD *)(a1 + 16) + a2) / *(_DWORD *)(a1 + 16) * *(_DWORD *)(a1 + 16);
if ( (*(_QWORD *)(a1 + 32) & 0x100LL) == 0 )
{
v3 = my_realloc(*(unsigned int *)(a1 + 24), *(_QWORD *)a1, *(_DWORD *)(a1 + 20) * v4, *(_QWORD *)(a1 + 32) | 0x50LL);
if ( !v3 )
return 1;
goto LABEL_8;
}
v3 = my_malloc(*(unsigned int *)(a1 + 24), *(_DWORD *)(a1 + 20) * v4, *(_QWORD *)(a1 + 32) | 0x10LL);
if ( v3 )
{
memcpy(v3, *(_QWORD *)a1, (unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)));
*(_QWORD *)(a1 + 32) &= 0xFFFFFEFFuLL;
LABEL_8:
*(_QWORD *)a1 = v3;
*(_DWORD *)(a1 + 12) = v4;
return 0;
}
return 0;
}
|
allocate_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x001dad45
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV dword ptr [RCX + 0x10]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
IMUL EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x001dacee
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x001f3830
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001dacb3
JMP 0x001dacaa
LAB_001dacaa:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001dad4b
LAB_001dacb3:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x001dad30
LAB_001dacee:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x001f3a00
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001dad2e
JMP 0x001dad28
LAB_001dad28:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001dad4b
LAB_001dad2e:
JMP 0x001dad30
LAB_001dad30:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
LAB_001dad45:
JMP 0x001dad47
LAB_001dad47:
MOV byte ptr [RBP + -0x1],0x0
LAB_001dad4b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 allocate_dynamic(int8 *param_1,uint param_2)
{
int iVar1;
void *local_28;
if (*(uint *)((long)param_1 + 0xc) <= param_2) {
iVar1 = *(int *)(param_1 + 2) * ((param_2 + *(int *)(param_1 + 2)) / *(uint *)(param_1 + 2));
if ((param_1[4] & 0x100) == 0) {
local_28 = (void *)my_realloc(*(int4 *)(param_1 + 3),*param_1,
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_28 == (void *)0x0) {
return 1;
}
}
else {
local_28 = (void *)my_malloc(*(int4 *)(param_1 + 3),
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_28 == (void *)0x0) {
return 0;
}
memcpy(local_28,(void *)*param_1,
(ulong)(uint)(*(int *)(param_1 + 1) * *(int *)((long)param_1 + 0x14)));
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = local_28;
*(int *)((long)param_1 + 0xc) = iVar1;
}
return 0;
}
|
|
63,107 |
bf_set_nan
|
bluesky950520[P]quickjs/libbf.c
|
void bf_set_nan(bf_t *r)
{
bf_resize(r, 0); /* cannot fail */
r->expn = BF_EXP_NAN;
r->sign = 0;
}
|
O1
|
c
|
bf_set_nan:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x83fb2
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
popq %rbx
retq
|
bf_set_nan:
push rbx
mov rbx, rdi
cmp qword ptr [rdi+18h], 0
jz short loc_83FB2
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_83FB2:
mov rax, 7FFFFFFFFFFFFFFFh
mov [rbx+10h], rax
mov dword ptr [rbx+8], 0
pop rbx
retn
|
long long bf_set_nan(_QWORD *a1)
{
long long result; // rax
if ( a1[3] )
{
a1[4] = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, a1[4], 0LL);
a1[3] = 0LL;
}
result = 0x7FFFFFFFFFFFFFFFLL;
a1[2] = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return result;
}
|
bf_set_nan:
PUSH RBX
MOV RBX,RDI
CMP qword ptr [RDI + 0x18],0x0
JZ 0x00183fb2
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_00183fb2:
MOV RAX,0x7fffffffffffffff
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],0x0
POP RBX
RET
|
void bf_set_nan(long *param_1)
{
long lVar1;
if (param_1[3] != 0) {
lVar1 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar1;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
return;
}
|
|
63,108 |
mi_update_static_record
|
eloqsql/storage/myisam/mi_statrec.c
|
int _mi_update_static_record(MI_INFO *info, my_off_t pos, const uchar *record)
{
info->rec_cache.seek_not_done=1; /* We have done a seek */
return (info->s->file_write(info,
record, info->s->base.reclength,
pos,
MYF(MY_NABP)) != 0);
}
|
O3
|
c
|
mi_update_static_record:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movl $0x1, 0x300(%rdi)
movq (%rdi), %r9
movq 0x140(%r9), %rax
movl $0x4, %r8d
movq %rdx, %rsi
movq %rax, %rdx
callq *0x2e8(%r9)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, %eax
popq %rbp
retq
|
_mi_update_static_record:
push rbp
mov rbp, rsp
mov rcx, rsi
mov dword ptr [rdi+300h], 1
mov r9, [rdi]
mov rax, [r9+140h]
mov r8d, 4
mov rsi, rdx
mov rdx, rax
call qword ptr [r9+2E8h]
xor ecx, ecx
test rax, rax
setnz cl
mov eax, ecx
pop rbp
retn
|
_BOOL8 mi_update_static_record(_DWORD *a1, long long a2, long long a3)
{
a1[192] = 1;
return (*(long long ( **)(_DWORD *, long long, _QWORD, long long, long long))(*(_QWORD *)a1 + 744LL))(
a1,
a3,
*(_QWORD *)(*(_QWORD *)a1 + 320LL),
a2,
4LL) != 0;
}
|
_mi_update_static_record:
PUSH RBP
MOV RBP,RSP
MOV RCX,RSI
MOV dword ptr [RDI + 0x300],0x1
MOV R9,qword ptr [RDI]
MOV RAX,qword ptr [R9 + 0x140]
MOV R8D,0x4
MOV RSI,RDX
MOV RDX,RAX
CALL qword ptr [R9 + 0x2e8]
XOR ECX,ECX
TEST RAX,RAX
SETNZ CL
MOV EAX,ECX
POP RBP
RET
|
bool _mi_update_static_record(long *param_1,int8 param_2,int8 param_3)
{
long lVar1;
*(int4 *)(param_1 + 0x60) = 1;
lVar1 = (**(code **)(*param_1 + 0x2e8))
(param_1,param_3,*(int8 *)(*param_1 + 0x140),param_2,4);
return lVar1 != 0;
}
|
|
63,109 |
check_and_set_lsn
|
eloqsql/storage/maria/ma_pagecache.c
|
static void check_and_set_lsn(PAGECACHE *pagecache,
LSN lsn, PAGECACHE_BLOCK_LINK *block)
{
LSN old;
DBUG_ENTER("check_and_set_lsn");
/*
In recovery, we can _ma_unpin_all_pages() to put a LSN on page, though
page would be PAGECACHE_PLAIN_PAGE (transactionality temporarily disabled
to not log REDOs).
*/
DBUG_ASSERT((block->type == PAGECACHE_LSN_PAGE) || maria_in_recovery);
old= lsn_korr(block->buffer);
DBUG_PRINT("info", ("old lsn: " LSN_FMT " new lsn: " LSN_FMT,
LSN_IN_PARTS(old), LSN_IN_PARTS(lsn)));
if (cmp_translog_addr(lsn, old) > 0)
{
DBUG_ASSERT(block->type != PAGECACHE_READ_UNKNOWN_PAGE);
lsn_store(block->buffer, lsn);
/* we stored LSN in page so we dirtied it */
if (!(block->status & PCBLOCK_CHANGED))
link_to_changed_list(pagecache, block);
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
check_and_set_lsn:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x54486
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x544cd
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
cmpq $0x0, %rax
jle 0x54574
jmp 0x544e1
jmp 0x544e3
jmp 0x544e5
jmp 0x544e7
movq -0x10(%rbp), %rax
sarq $0x20, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movb %cl, 0x2(%rax)
jmp 0x5452d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x54555
movq -0x18(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x54572
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x54580
jmp 0x54574
jmp 0x54576
jmp 0x54578
addq $0x30, %rsp
popq %rbp
retq
nop
|
check_and_set_lsn:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_54486:
mov rax, [rbp+var_18]
mov rax, [rax+30h]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
mov rcx, [rcx+30h]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
mov rcx, [rcx+30h]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_18]
mov rcx, [rcx+30h]
mov ecx, [rcx+3]
or rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_544CD:
mov rax, [rbp+var_10]
sub rax, [rbp+var_20]
cmp rax, 0
jle loc_54574
jmp short $+2
loc_544E1:
jmp short $+2
loc_544E3:
jmp short $+2
loc_544E5:
jmp short $+2
loc_544E7:
mov rax, [rbp+var_10]
sar rax, 20h
mov cl, al
mov rax, [rbp+var_18]
mov rax, [rax+30h]
mov [rax], cl
mov rax, [rbp+var_10]
sar rax, 20h
shr eax, 8
mov cl, al
mov rax, [rbp+var_18]
mov rax, [rax+30h]
mov [rax+1], cl
mov rax, [rbp+var_10]
sar rax, 20h
shr eax, 10h
mov cl, al
mov rax, [rbp+var_18]
mov rax, [rax+30h]
mov [rax+2], cl
jmp short $+2
loc_5452D:
mov rax, [rbp+var_18]
mov rax, [rax+30h]
add rax, 3
mov [rbp+var_28], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_10]
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax], ecx
jmp short $+2
loc_54555:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+74h]
and eax, 20h
cmp eax, 0
jnz short loc_54572
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call link_to_changed_list
loc_54572:
jmp short $+2
loc_54574:
jmp short $+2
loc_54576:
jmp short $+2
loc_54578:
add rsp, 30h
pop rbp
retn
|
long long check_and_set_lsn(long long a1, long long a2, long long a3)
{
long long result; // rax
result = a2
- (*(unsigned int *)(*(_QWORD *)(a3 + 48) + 3LL) | ((unsigned long long)((*(unsigned __int8 *)(*(_QWORD *)(a3 + 48) + 2LL) << 16) | (unsigned int)**(unsigned __int16 **)(a3 + 48)) << 32));
if ( result > 0 )
{
**(_WORD **)(a3 + 48) = WORD2(a2);
*(_BYTE *)(*(_QWORD *)(a3 + 48) + 2LL) = BYTE6(a2);
*(_DWORD *)(*(_QWORD *)(a3 + 48) + 3LL) = a2;
result = *(_WORD *)(a3 + 116) & 0x20;
if ( !(_DWORD)result )
return link_to_changed_list(a1, a3);
}
return result;
}
|
check_and_set_lsn:
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
JMP 0x00154486
LAB_00154486:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x30]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001544cd
LAB_001544cd:
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RBP + -0x20]
CMP RAX,0x0
JLE 0x00154574
JMP 0x001544e1
LAB_001544e1:
JMP 0x001544e3
LAB_001544e3:
JMP 0x001544e5
LAB_001544e5:
JMP 0x001544e7
LAB_001544e7:
MOV RAX,qword ptr [RBP + -0x10]
SAR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
SAR RAX,0x20
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x10]
SAR RAX,0x20
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV byte ptr [RAX + 0x2],CL
JMP 0x0015452d
LAB_0015452d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
ADD RAX,0x3
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x10]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
JMP 0x00154555
LAB_00154555:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x20
CMP EAX,0x0
JNZ 0x00154572
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00154580
LAB_00154572:
JMP 0x00154574
LAB_00154574:
JMP 0x00154576
LAB_00154576:
JMP 0x00154578
LAB_00154578:
ADD RSP,0x30
POP RBP
RET
|
void check_and_set_lsn(int8 param_1,long param_2,long param_3)
{
if (0 < (long)(param_2 -
(ulong)CONCAT34(CONCAT12(*(int1 *)(*(long *)(param_3 + 0x30) + 2),
CONCAT11(*(int1 *)(*(long *)(param_3 + 0x30) + 1),
**(int1 **)(param_3 + 0x30))),
*(int4 *)(*(long *)(param_3 + 0x30) + 3)))) {
**(int1 **)(param_3 + 0x30) = (char)((ulong)param_2 >> 0x20);
*(char *)(*(long *)(param_3 + 0x30) + 1) = (char)((ulong)param_2 >> 0x28);
*(char *)(*(long *)(param_3 + 0x30) + 2) = (char)((ulong)param_2 >> 0x30);
*(int *)(*(long *)(param_3 + 0x30) + 3) = (int)param_2;
if ((*(ushort *)(param_3 + 0x74) & 0x20) == 0) {
link_to_changed_list(param_1,param_3);
}
}
return;
}
|
|
63,110 |
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*)
|
serhmarch[P]ModbusBridge/modbus/src/ModbusClientPort.cpp
|
Modbus::StatusCode ModbusClientPort::readCoilsAsBoolArray(ModbusObject *client, uint8_t unit, uint16_t offset, uint16_t count, bool *values)
{
ModbusClientPortPrivate *d = d_ModbusClientPort(d_ptr);
Modbus::StatusCode r = readCoils(client, unit, offset, count, d->buff);
if ((r != Status_Good) || d->isBroadcast())
return r;
for (int i = 0; i < count; ++i)
values[i] = (d->buff[i / 8] & static_cast<uint8_t>(1 << (i % 8))) != 0;
return Status_Good;
}
|
O0
|
cpp
|
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %r8w, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movw %cx, -0x1c(%rbp)
movw %ax, -0x1e(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0x199f0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %dl
movw -0x1c(%rbp), %cx
movw -0x1e(%rbp), %ax
movq -0x30(%rbp), %r9
addq $0x84, %r9
movzbl %dl, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x138f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x182fd
movq -0x30(%rbp), %rdi
callq 0x19b30
testb $0x1, %al
jne 0x182fd
jmp 0x18305
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18382
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movzwl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1837b
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
movzbl 0x84(%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movl -0x38(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x44(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %dl
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1830c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN16ModbusClientPort20readCoilsAsBoolArrayEP12ModbusObjecthttPb:
push rbp
mov rbp, rsp
sub rsp, 50h
mov ax, r8w
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_19], dl
mov [rbp+var_1C], cx
mov [rbp+var_1E], ax
mov [rbp+var_28], r9
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov rdi, [rax+8]
call _Z18d_ModbusClientPortP19ModbusObjectPrivate; d_ModbusClientPort(ModbusObjectPrivate *)
mov rdi, [rbp+var_40]; this
mov [rbp+var_30], rax
mov rsi, [rbp+var_18]; ModbusObject *
mov dl, [rbp+var_19]
mov cx, [rbp+var_1C]
mov ax, [rbp+var_1E]
mov r9, [rbp+var_30]
add r9, 84h; void *
movzx edx, dl; unsigned __int8
movzx ecx, cx; unsigned __int16
movzx r8d, ax; unsigned __int16
call _ZN16ModbusClientPort9readCoilsEP12ModbusObjecthttPv; ModbusClientPort::readCoils(ModbusObject *,uchar,ushort,ushort,void *)
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jnz short loc_182FD
mov rdi, [rbp+var_30]; this
call _ZNK23ModbusClientPortPrivate11isBroadcastEv; ModbusClientPortPrivate::isBroadcast(void)
test al, 1
jnz short loc_182FD
jmp short loc_18305
loc_182FD:
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_18382
loc_18305:
mov [rbp+var_38], 0
loc_1830C:
mov eax, [rbp+var_38]
movzx ecx, [rbp+var_1E]
cmp eax, ecx
jge short loc_1837B
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
mov eax, [rbp+var_38]
mov ecx, 8
cdq
idiv ecx
mov ecx, eax
mov rax, [rbp+var_50]
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx+84h]
mov [rbp+var_44], eax
mov eax, [rbp+var_38]
mov ecx, 8
cdq
idiv ecx
mov eax, [rbp+var_44]
mov ecx, edx
mov edx, 1
shl edx, cl
mov ecx, edx
movzx ecx, cl
and eax, ecx
cmp eax, 0
setnz dl
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_38]
and dl, 1
mov [rax+rcx], dl
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
jmp short loc_1830C
loc_1837B:
mov [rbp+var_4], 0
loc_18382:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long ModbusClientPort::readCoilsAsBoolArray(
ModbusObjectPrivate **this,
ModbusObject *a2,
unsigned __int8 a3,
unsigned __int16 a4,
unsigned __int16 a5,
bool *a6)
{
int i; // [rsp+18h] [rbp-38h]
unsigned int Coils; // [rsp+1Ch] [rbp-34h]
ModbusClientPortPrivate *v9; // [rsp+20h] [rbp-30h]
v9 = (ModbusClientPortPrivate *)d_ModbusClientPort(this[1]);
Coils = ModbusClientPort::readCoils(this, a2, a3, a4, a5, (char *)v9 + 132);
if ( Coils || (ModbusClientPortPrivate::isBroadcast(v9) & 1) != 0 )
{
return Coils;
}
else
{
for ( i = 0; i < a5; ++i )
a6[i] = (unsigned __int8)((1 << (i % 8)) & *((_BYTE *)v9 + i / 8 + 132)) != 0;
return 0;
}
}
|
readCoilsAsBoolArray:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AX,R8W
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x19],DL
MOV word ptr [RBP + -0x1c],CX
MOV word ptr [RBP + -0x1e],AX
MOV qword ptr [RBP + -0x28],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001199f0
MOV RDI,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x30],RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV DL,byte ptr [RBP + -0x19]
MOV CX,word ptr [RBP + -0x1c]
MOV AX,word ptr [RBP + -0x1e]
MOV R9,qword ptr [RBP + -0x30]
ADD R9,0x84
MOVZX EDX,DL
MOVZX ECX,CX
MOVZX R8D,AX
CALL 0x001138f0
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001182fd
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00119b30
TEST AL,0x1
JNZ 0x001182fd
JMP 0x00118305
LAB_001182fd:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00118382
LAB_00118305:
MOV dword ptr [RBP + -0x38],0x0
LAB_0011830c:
MOV EAX,dword ptr [RBP + -0x38]
MOVZX ECX,word ptr [RBP + -0x1e]
CMP EAX,ECX
JGE 0x0011837b
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,0x8
CDQ
IDIV ECX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x84]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,0x8
CDQ
IDIV ECX
MOV EAX,dword ptr [RBP + -0x44]
MOV ECX,EDX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,0x0
SETNZ DL
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x38]
AND DL,0x1
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011830c
LAB_0011837b:
MOV dword ptr [RBP + -0x4],0x0
LAB_00118382:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
/* ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned
short, bool*) */
int __thiscall
ModbusClientPort::readCoilsAsBoolArray
(ModbusClientPort *this,ModbusObject *param_1,uchar param_2,ushort param_3,ushort param_4,
bool *param_5)
{
ModbusClientPortPrivate *this_00;
ulong uVar1;
int local_40;
int local_c;
this_00 = (ModbusClientPortPrivate *)d_ModbusClientPort(*(ModbusObjectPrivate **)(this + 8));
local_c = readCoils(this,param_1,param_2,param_3,param_4,this_00 + 0x84);
if ((local_c == 0) && (uVar1 = ModbusClientPortPrivate::isBroadcast(this_00), (uVar1 & 1) == 0)) {
for (local_40 = 0; local_40 < (int)(uint)param_4; local_40 = local_40 + 1) {
param_5[local_40] =
((uint)(byte)this_00[(long)(local_40 / 8) + 0x84] &
1 << ((byte)((long)local_40 % 8) & 0x1f) & 0xffU) != 0;
}
local_c = 0;
}
return local_c;
}
|
|
63,111 |
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*)
|
serhmarch[P]ModbusBridge/modbus/src/ModbusClientPort.cpp
|
Modbus::StatusCode ModbusClientPort::readCoilsAsBoolArray(ModbusObject *client, uint8_t unit, uint16_t offset, uint16_t count, bool *values)
{
ModbusClientPortPrivate *d = d_ModbusClientPort(d_ptr);
Modbus::StatusCode r = readCoils(client, unit, offset, count, d->buff);
if ((r != Status_Good) || d->isBroadcast())
return r;
for (int i = 0; i < count; ++i)
values[i] = (d->buff[i / 8] & static_cast<uint8_t>(1 << (i % 8))) != 0;
return Status_Good;
}
|
O2
|
cpp
|
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq 0x8(%rdi), %r15
leaq 0x84(%r15), %r14
movq %r14, %r9
callq 0x995a
testl %eax, %eax
jne 0xb839
cmpb $0x0, 0x6c(%r15)
jne 0xb844
xorl %eax, %eax
testb $0x1, 0x1c4(%r15)
je 0xb844
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzwl %bp, %ecx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xb839
movl %edx, %esi
shrl $0x3, %esi
movzbl (%r14,%rsi), %esi
movl %edx, %edi
andl $0x7, %edi
btl %edi, %esi
setb (%rbx,%rdx)
incq %rdx
jmp 0xb84b
nop
|
_ZN16ModbusClientPort20readCoilsAsBoolArrayEP12ModbusObjecthttPb:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, r9
mov ebp, r8d
mov r15, [rdi+8]
lea r14, [r15+84h]
mov r9, r14; void *
call _ZN16ModbusClientPort9readCoilsEP12ModbusObjecthttPv; ModbusClientPort::readCoils(ModbusObject *,uchar,ushort,ushort,void *)
test eax, eax
jnz short loc_B839
cmp byte ptr [r15+6Ch], 0
jnz short loc_B844
xor eax, eax
test byte ptr [r15+1C4h], 1
jz short loc_B844
loc_B839:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_B844:
movzx ecx, bp
xor eax, eax
xor edx, edx
loc_B84B:
cmp rcx, rdx
jz short loc_B839
mov esi, edx
shr esi, 3
movzx esi, byte ptr [r14+rsi]
mov edi, edx
and edi, 7
bt esi, edi
setb byte ptr [rbx+rdx]
inc rdx
jmp short loc_B84B
|
long long ModbusClientPort::readCoilsAsBoolArray(
ModbusClientPort *this,
ModbusObject *a2,
unsigned __int8 a3,
unsigned __int16 a4,
unsigned __int16 a5,
bool *a6)
{
_BYTE *v8; // r15
long long result; // rax
long long i; // rdx
int v11; // esi
v8 = (_BYTE *)*((_QWORD *)this + 1);
result = ModbusClientPort::readCoils(this, a2, a3, a4, a5, v8 + 132);
if ( !(_DWORD)result )
{
if ( v8[108] || (result = 0LL, (v8[452] & 1) == 0) )
{
result = 0LL;
for ( i = 0LL; a5 != i; ++i )
{
v11 = (unsigned __int8)v8[((unsigned int)i >> 3) + 132];
a6[i] = _bittest(&v11, i & 7);
}
}
}
return result;
}
|
readCoilsAsBoolArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R9
MOV EBP,R8D
MOV R15,qword ptr [RDI + 0x8]
LEA R14,[R15 + 0x84]
MOV R9,R14
CALL 0x0010995a
TEST EAX,EAX
JNZ 0x0010b839
CMP byte ptr [R15 + 0x6c],0x0
JNZ 0x0010b844
XOR EAX,EAX
TEST byte ptr [R15 + 0x1c4],0x1
JZ 0x0010b844
LAB_0010b839:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0010b844:
MOVZX ECX,BP
XOR EAX,EAX
XOR EDX,EDX
LAB_0010b84b:
CMP RCX,RDX
JZ 0x0010b839
MOV ESI,EDX
SHR ESI,0x3
MOVZX ESI,byte ptr [R14 + RSI*0x1]
MOV EDI,EDX
AND EDI,0x7
BT ESI,EDI
SETC byte ptr [RBX + RDX*0x1]
INC RDX
JMP 0x0010b84b
|
/* ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned
short, bool*) */
int8 __thiscall
ModbusClientPort::readCoilsAsBoolArray
(ModbusClientPort *this,ModbusObject *param_1,uchar param_2,ushort param_3,ushort param_4,
bool *param_5)
{
long lVar1;
int8 uVar2;
ulong uVar3;
lVar1 = *(long *)(this + 8);
uVar2 = readCoils(this,param_1,param_2,param_3,param_4,(void *)(lVar1 + 0x84));
if (((int)uVar2 == 0) &&
((*(char *)(lVar1 + 0x6c) != '\0' || (uVar2 = 0, (*(byte *)(lVar1 + 0x1c4) & 1) == 0)))) {
uVar2 = 0;
for (uVar3 = 0; param_4 != uVar3; uVar3 = uVar3 + 1) {
param_5[uVar3] =
(*(byte *)(lVar1 + 0x84 + (uVar3 >> 3 & 0x1fffffff)) >> ((uint)uVar3 & 7) & 1) != 0;
}
}
return uVar2;
}
|
|
63,112 |
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*)
|
serhmarch[P]ModbusBridge/modbus/src/ModbusClientPort.cpp
|
Modbus::StatusCode ModbusClientPort::readCoilsAsBoolArray(ModbusObject *client, uint8_t unit, uint16_t offset, uint16_t count, bool *values)
{
ModbusClientPortPrivate *d = d_ModbusClientPort(d_ptr);
Modbus::StatusCode r = readCoils(client, unit, offset, count, d->buff);
if ((r != Status_Good) || d->isBroadcast())
return r;
for (int i = 0; i < count; ++i)
values[i] = (d->buff[i / 8] & static_cast<uint8_t>(1 << (i % 8))) != 0;
return Status_Good;
}
|
O3
|
cpp
|
ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned short, bool*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq 0x8(%rdi), %r15
leaq 0x84(%r15), %r14
movq %r14, %r9
callq 0xa252
testl %eax, %eax
jne 0xceb0
cmpb $0x0, 0x6c(%r15)
sete %cl
andb 0x1c4(%r15), %cl
testw %bp, %bp
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xceb0
movzwl %bp, %ecx
xorl %eax, %eax
xorl %edx, %edx
movl %edx, %esi
shrl $0x3, %esi
movzbl (%r14,%rsi), %esi
movl %edx, %edi
andl $0x7, %edi
btl %edi, %esi
setb (%rbx,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0xce92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN16ModbusClientPort20readCoilsAsBoolArrayEP12ModbusObjecthttPb:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, r9
mov ebp, r8d
mov r15, [rdi+8]
lea r14, [r15+84h]
mov r9, r14; void *
call _ZN16ModbusClientPort9readCoilsEP12ModbusObjecthttPv; ModbusClientPort::readCoils(ModbusObject *,uchar,ushort,ushort,void *)
test eax, eax
jnz short loc_CEB0
cmp byte ptr [r15+6Ch], 0
setz cl
and cl, [r15+1C4h]
test bp, bp
setz dl
xor eax, eax
or dl, cl
jnz short loc_CEB0
movzx ecx, bp
xor eax, eax
xor edx, edx
loc_CE92:
mov esi, edx
shr esi, 3
movzx esi, byte ptr [r14+rsi]
mov edi, edx
and edi, 7
bt esi, edi
setb byte ptr [rbx+rdx]
inc rdx
cmp rcx, rdx
jnz short loc_CE92
loc_CEB0:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long ModbusClientPort::readCoilsAsBoolArray(
ModbusClientPort *this,
ModbusObject *a2,
unsigned __int8 a3,
unsigned __int16 a4,
unsigned __int16 a5,
bool *a6)
{
_BYTE *v8; // r15
long long result; // rax
long long v10; // rdx
int v11; // esi
v8 = (_BYTE *)*((_QWORD *)this + 1);
result = ModbusClientPort::readCoils(this, a2, a3, a4, a5, v8 + 132);
if ( !(_DWORD)result )
{
result = 0LL;
if ( !(v8[452] & (v8[108] == 0) | (a5 == 0)) )
{
result = 0LL;
v10 = 0LL;
do
{
v11 = (unsigned __int8)v8[((unsigned int)v10 >> 3) + 132];
a6[v10] = _bittest(&v11, v10 & 7);
++v10;
}
while ( a5 != v10 );
}
}
return result;
}
|
readCoilsAsBoolArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R9
MOV EBP,R8D
MOV R15,qword ptr [RDI + 0x8]
LEA R14,[R15 + 0x84]
MOV R9,R14
CALL 0x0010a252
TEST EAX,EAX
JNZ 0x0010ceb0
CMP byte ptr [R15 + 0x6c],0x0
SETZ CL
AND CL,byte ptr [R15 + 0x1c4]
TEST BP,BP
SETZ DL
XOR EAX,EAX
OR DL,CL
JNZ 0x0010ceb0
MOVZX ECX,BP
XOR EAX,EAX
XOR EDX,EDX
LAB_0010ce92:
MOV ESI,EDX
SHR ESI,0x3
MOVZX ESI,byte ptr [R14 + RSI*0x1]
MOV EDI,EDX
AND EDI,0x7
BT ESI,EDI
SETC byte ptr [RBX + RDX*0x1]
INC RDX
CMP RCX,RDX
JNZ 0x0010ce92
LAB_0010ceb0:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* ModbusClientPort::readCoilsAsBoolArray(ModbusObject*, unsigned char, unsigned short, unsigned
short, bool*) */
int8 __thiscall
ModbusClientPort::readCoilsAsBoolArray
(ModbusClientPort *this,ModbusObject *param_1,uchar param_2,ushort param_3,ushort param_4,
bool *param_5)
{
long lVar1;
int8 uVar2;
ulong uVar3;
lVar1 = *(long *)(this + 8);
uVar2 = readCoils(this,param_1,param_2,param_3,param_4,(void *)(lVar1 + 0x84));
if (((int)uVar2 == 0) &&
(uVar2 = 0, param_4 != 0 && (*(char *)(lVar1 + 0x6c) == '\0' & *(byte *)(lVar1 + 0x1c4)) == 0))
{
uVar2 = 0;
uVar3 = 0;
do {
param_5[uVar3] =
(*(byte *)(lVar1 + 0x84 + (uVar3 >> 3 & 0x1fffffff)) >> ((uint)uVar3 & 7) & 1) != 0;
uVar3 = uVar3 + 1;
} while (param_4 != uVar3);
}
return uVar2;
}
|
|
63,113 |
js_object_defineProperty
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_defineProperty(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue obj, prop, desc;
int ret, flags;
JSAtom atom;
obj = argv[0];
prop = argv[1];
desc = argv[2];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
flags = JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY;
if (magic)
flags = JS_PROP_REFLECT_DEFINE_PROPERTY;
ret = JS_DefinePropertyDesc(ctx, obj, atom, desc, flags);
JS_FreeAtom(ctx, atom);
if (ret < 0) {
return JS_EXCEPTION;
} else if (magic) {
return js_bool(ret);
} else {
return js_dup(obj);
}
}
|
O1
|
c
|
js_object_defineProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x8(%r8), %r15
cmpl $-0x1, %r15d
jne 0x125f6
movl %r9d, %ebp
movq (%r8), %rbx
movq 0x20(%r8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%r8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r8), %rsi
movq 0x18(%r8), %rdx
movq %r12, %rdi
callq 0x280ef
pushq $0x6
popq %r14
testl %eax, %eax
je 0x1260f
movl %eax, %r13d
testl %ebp, %ebp
movl $0x44000, %eax # imm = 0x44000
movl $0x80000, %ecx # imm = 0x80000
cmovel %eax, %ecx
movl %ecx, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r13d, %ecx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x752cb
movl %ebp, 0x8(%rsp)
movl %eax, %ebp
movq %r12, %rdi
movl %r13d, %esi
callq 0x24834
testl %ebp, %ebp
js 0x1260f
cmpl $0x0, 0x8(%rsp)
je 0x1262a
xorl %ebx, %ebx
testl %ebp, %ebp
setne %bl
pushq $0x1
jmp 0x1260b
leaq 0x90ca0(%rip), %rsi # 0xa329d
xorl %ebx, %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x265c3
pushq $0x6
popq %r14
jmp 0x12611
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movq %r15, %r14
jmp 0x12613
|
js_object_defineProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdi
mov r15, [r8+8]
cmp r15d, 0FFFFFFFFh
jnz loc_125F6
mov ebp, r9d
mov rbx, [r8]
mov rax, [r8+20h]
mov [rsp+48h+var_40], rax
mov rax, [r8+28h]
mov [rsp+48h+var_38], rax
mov rsi, [r8+10h]
mov rdx, [r8+18h]
mov rdi, r12
call JS_ValueToAtom
push 6
pop r14
test eax, eax
jz short loc_1260F
mov r13d, eax
test ebp, ebp
mov eax, offset loc_44000
mov ecx, offset loc_80000
cmovz ecx, eax
mov [rsp+48h+var_48], ecx
mov rdi, r12
mov rsi, rbx
mov rdx, r15
mov ecx, r13d
mov r8, [rsp+48h+var_40]
mov r9, [rsp+48h+var_38]
call JS_DefinePropertyDesc
mov dword ptr [rsp+48h+var_40], ebp
mov ebp, eax
mov rdi, r12
mov esi, r13d
call JS_FreeAtom
test ebp, ebp
js short loc_1260F
cmp dword ptr [rsp+48h+var_40], 0
jz short loc_1262A
xor ebx, ebx
test ebp, ebp
setnz bl
push 1
jmp short loc_1260B
loc_125F6:
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
push 6
loc_1260B:
pop r14
jmp short loc_12611
loc_1260F:
xor ebx, ebx
loc_12611:
xor ecx, ecx
loc_12613:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1262A:
inc dword ptr [rbx]
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov r14, r15
jmp short loc_12613
|
unsigned long long js_object_defineProperty(
long long a1,
long long a2,
int a3,
int a4,
unsigned long long *a5,
int a6)
{
unsigned long long v7; // rbx
unsigned int v8; // eax
unsigned int v9; // r13d
void *v10; // rcx
int v11; // eax
int v12; // ebp
unsigned long long v13; // rcx
unsigned long long v15; // [rsp+8h] [rbp-40h]
int v16; // [rsp+8h] [rbp-40h]
unsigned long long v17; // [rsp+10h] [rbp-38h]
if ( (unsigned int)a5[1] == -1 )
{
v7 = *a5;
v15 = a5[4];
v17 = a5[5];
v8 = JS_ValueToAtom(a1, a5[2], a5[3]);
if ( !v8 )
goto LABEL_9;
v9 = v8;
v10 = &loc_80000;
if ( !a6 )
LODWORD(v10) = (unsigned int)&loc_44000;
v11 = JS_DefinePropertyDesc(a1, v7, -1, v8, v15, v17, (_DWORD)v10);
v16 = a6;
v12 = v11;
JS_FreeAtom(a1, v9);
if ( v12 >= 0 )
{
if ( !v16 )
{
++*(_DWORD *)v7;
v13 = v7 & 0xFFFFFFFF00000000LL;
return v13 | (unsigned int)v7;
}
LODWORD(v7) = v12 != 0;
}
else
{
LABEL_9:
LODWORD(v7) = 0;
}
}
else
{
LODWORD(v7) = 0;
JS_ThrowTypeError(a1, (unsigned int)"not an object", a3, a4, (_DWORD)a5, a6);
}
v13 = 0LL;
return v13 | (unsigned int)v7;
}
|
js_object_defineProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV R15,qword ptr [R8 + 0x8]
CMP R15D,-0x1
JNZ 0x001125f6
MOV EBP,R9D
MOV RBX,qword ptr [R8]
MOV RAX,qword ptr [R8 + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [R8 + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [R8 + 0x10]
MOV RDX,qword ptr [R8 + 0x18]
MOV RDI,R12
CALL 0x001280ef
PUSH 0x6
POP R14
TEST EAX,EAX
JZ 0x0011260f
MOV R13D,EAX
TEST EBP,EBP
MOV EAX,0x44000
MOV ECX,0x80000
CMOVZ ECX,EAX
MOV dword ptr [RSP],ECX
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
MOV ECX,R13D
MOV R8,qword ptr [RSP + 0x8]
MOV R9,qword ptr [RSP + 0x10]
CALL 0x001752cb
MOV dword ptr [RSP + 0x8],EBP
MOV EBP,EAX
MOV RDI,R12
MOV ESI,R13D
CALL 0x00124834
TEST EBP,EBP
JS 0x0011260f
CMP dword ptr [RSP + 0x8],0x0
JZ 0x0011262a
XOR EBX,EBX
TEST EBP,EBP
SETNZ BL
PUSH 0x1
JMP 0x0011260b
LAB_001125f6:
LEA RSI,[0x1a329d]
XOR EBX,EBX
MOV RDI,R12
XOR EAX,EAX
CALL 0x001265c3
PUSH 0x6
LAB_0011260b:
POP R14
JMP 0x00112611
LAB_0011260f:
XOR EBX,EBX
LAB_00112611:
XOR ECX,ECX
LAB_00112613:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011262a:
INC dword ptr [RBX]
MOV RCX,-0x100000000
AND RCX,RBX
MOV R14,R15
JMP 0x00112613
|
int1 [16] js_object_defineProperty(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int iVar4;
int4 uVar5;
ulong uVar6;
int *piVar7;
int8 *in_R8;
int in_R9D;
int1 auVar8 [16];
int8 uStackY_50;
uStackY_50 = in_R8[1];
if ((int)uStackY_50 == -1) {
piVar7 = (int *)*in_R8;
uVar1 = in_R8[4];
uVar2 = in_R8[5];
iVar3 = JS_ValueToAtom(param_1,in_R8[2],in_R8[3]);
if (iVar3 != 0) {
uVar5 = 0x80000;
if (in_R9D == 0) {
uVar5 = 0x44000;
}
iVar4 = JS_DefinePropertyDesc(param_1,piVar7,uStackY_50,iVar3,uVar1,uVar2,uVar5);
JS_FreeAtom(param_1,iVar3);
if (-1 < iVar4) {
if (in_R9D == 0) {
*piVar7 = *piVar7 + 1;
uVar6 = (ulong)piVar7 & 0xffffffff00000000;
goto LAB_00112613;
}
piVar7 = (int *)(ulong)(iVar4 != 0);
uStackY_50 = 1;
goto LAB_00112611;
}
}
piVar7 = (int *)0x0;
uStackY_50 = 6;
}
else {
piVar7 = (int *)0x0;
JS_ThrowTypeError(param_1,"not an object");
uStackY_50 = 6;
}
LAB_00112611:
uVar6 = 0;
LAB_00112613:
auVar8._0_8_ = (ulong)piVar7 & 0xffffffff | uVar6;
auVar8._8_8_ = uStackY_50;
return auVar8;
}
|
|
63,114 |
js_object_defineProperty
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_defineProperty(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue obj, prop, desc;
int ret, flags;
JSAtom atom;
obj = argv[0];
prop = argv[1];
desc = argv[2];
if (JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
atom = JS_ValueToAtom(ctx, prop);
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
flags = JS_PROP_THROW | JS_PROP_DEFINE_PROPERTY;
if (magic)
flags = JS_PROP_REFLECT_DEFINE_PROPERTY;
ret = JS_DefinePropertyDesc(ctx, obj, atom, desc, flags);
JS_FreeAtom(ctx, atom);
if (ret < 0) {
return JS_EXCEPTION;
} else if (magic) {
return js_bool(ret);
} else {
return js_dup(obj);
}
}
|
O2
|
c
|
js_object_defineProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x8(%r8), %r15
cmpl $-0x1, %r15d
jne 0x61ea0
movl %r9d, %ebp
movq (%r8), %rbx
movq 0x20(%r8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%r8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r8), %rsi
movq 0x18(%r8), %rdx
movq %r12, %rdi
callq 0x21c6c
pushq $0x6
popq %r14
testl %eax, %eax
je 0x61eac
movl %eax, %r13d
testl %ebp, %ebp
movl $0x44000, %eax # imm = 0x44000
movl $0x80000, %ecx # imm = 0x80000
cmovel %eax, %ecx
movl %ecx, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r13d, %ecx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x62f31
movl %ebp, 0x8(%rsp)
movl %eax, %ebp
movq %r12, %rdi
movl %r13d, %esi
callq 0x1e545
testl %ebp, %ebp
js 0x61eac
cmpl $0x0, 0x8(%rsp)
je 0x61ec7
xorl %ebx, %ebx
testl %ebp, %ebp
setne %bl
pushq $0x1
popq %r14
jmp 0x61eae
movq %r12, %rdi
callq 0x21191
pushq $0x6
popq %r14
xorl %ebx, %ebx
xorl %ecx, %ecx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movq %r15, %r14
jmp 0x61eb0
|
js_object_defineProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdi
mov r15, [r8+8]
cmp r15d, 0FFFFFFFFh
jnz loc_61EA0
mov ebp, r9d
mov rbx, [r8]
mov rax, [r8+20h]
mov [rsp+48h+var_40], rax
mov rax, [r8+28h]
mov [rsp+48h+var_38], rax
mov rsi, [r8+10h]
mov rdx, [r8+18h]
mov rdi, r12
call JS_ValueToAtom
push 6
pop r14
test eax, eax
jz short loc_61EAC
mov r13d, eax
test ebp, ebp
mov eax, offset loc_44000
mov ecx, 80000h
cmovz ecx, eax
mov [rsp+48h+var_48], ecx
mov rdi, r12
mov rsi, rbx
mov rdx, r15
mov ecx, r13d
mov r8, [rsp+48h+var_40]
mov r9, [rsp+48h+var_38]
call JS_DefinePropertyDesc
mov dword ptr [rsp+48h+var_40], ebp
mov ebp, eax
mov rdi, r12
mov esi, r13d
call JS_FreeAtom
test ebp, ebp
js short loc_61EAC
cmp dword ptr [rsp+48h+var_40], 0
jz short loc_61EC7
xor ebx, ebx
test ebp, ebp
setnz bl
push 1
pop r14
jmp short loc_61EAE
loc_61EA0:
mov rdi, r12
call JS_ThrowTypeErrorNotAnObject
push 6
pop r14
loc_61EAC:
xor ebx, ebx
loc_61EAE:
xor ecx, ecx
loc_61EB0:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_61EC7:
inc dword ptr [rbx]
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov r14, r15
jmp short loc_61EB0
|
unsigned long long js_object_defineProperty(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v14; // ebp
unsigned long long v15; // rbx
int v16; // eax
int v17; // r13d
unsigned int v18; // ecx
int v19; // eax
int v20; // ebp
unsigned long long v21; // rcx
char v23; // [rsp+0h] [rbp-48h]
unsigned long long v24; // [rsp+8h] [rbp-40h]
int v25; // [rsp+8h] [rbp-40h]
unsigned long long v26; // [rsp+10h] [rbp-38h]
if ( (unsigned int)a5[1] != -1 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, (long long)a5, a6, v23);
LABEL_9:
LODWORD(v15) = 0;
goto LABEL_10;
}
v14 = a6;
v15 = *a5;
v24 = a5[4];
v26 = a5[5];
v16 = JS_ValueToAtom(a1, a5[2], a5[3]);
if ( !v16 )
goto LABEL_9;
v17 = v16;
v18 = 0x80000;
if ( !v14 )
v18 = (unsigned int)&loc_44000;
v19 = JS_DefinePropertyDesc(a1, v15, -1, v16, v24, v26, v18);
v25 = v14;
v20 = v19;
JS_FreeAtom(a1, v17);
if ( v20 < 0 )
goto LABEL_9;
if ( !v25 )
{
++*(_DWORD *)v15;
v21 = v15 & 0xFFFFFFFF00000000LL;
return v21 | (unsigned int)v15;
}
LODWORD(v15) = v20 != 0;
LABEL_10:
v21 = 0LL;
return v21 | (unsigned int)v15;
}
|
js_object_defineProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV R15,qword ptr [R8 + 0x8]
CMP R15D,-0x1
JNZ 0x00161ea0
MOV EBP,R9D
MOV RBX,qword ptr [R8]
MOV RAX,qword ptr [R8 + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [R8 + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [R8 + 0x10]
MOV RDX,qword ptr [R8 + 0x18]
MOV RDI,R12
CALL 0x00121c6c
PUSH 0x6
POP R14
TEST EAX,EAX
JZ 0x00161eac
MOV R13D,EAX
TEST EBP,EBP
MOV EAX,0x44000
MOV ECX,0x80000
CMOVZ ECX,EAX
MOV dword ptr [RSP],ECX
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
MOV ECX,R13D
MOV R8,qword ptr [RSP + 0x8]
MOV R9,qword ptr [RSP + 0x10]
CALL 0x00162f31
MOV dword ptr [RSP + 0x8],EBP
MOV EBP,EAX
MOV RDI,R12
MOV ESI,R13D
CALL 0x0011e545
TEST EBP,EBP
JS 0x00161eac
CMP dword ptr [RSP + 0x8],0x0
JZ 0x00161ec7
XOR EBX,EBX
TEST EBP,EBP
SETNZ BL
PUSH 0x1
POP R14
JMP 0x00161eae
LAB_00161ea0:
MOV RDI,R12
CALL 0x00121191
PUSH 0x6
POP R14
LAB_00161eac:
XOR EBX,EBX
LAB_00161eae:
XOR ECX,ECX
LAB_00161eb0:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00161ec7:
INC dword ptr [RBX]
MOV RCX,-0x100000000
AND RCX,RBX
MOV R14,R15
JMP 0x00161eb0
|
int1 [16] js_object_defineProperty(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int iVar3;
int iVar4;
int4 uVar5;
ulong uVar6;
int *piVar7;
int8 *in_R8;
int in_R9D;
int8 uVar8;
int1 auVar9 [16];
uVar8 = in_R8[1];
if ((int)uVar8 == -1) {
piVar7 = (int *)*in_R8;
uVar1 = in_R8[4];
uVar2 = in_R8[5];
iVar3 = JS_ValueToAtom(param_1,in_R8[2],in_R8[3]);
if (iVar3 == 0) goto LAB_00161eac;
uVar5 = 0x80000;
if (in_R9D == 0) {
uVar5 = 0x44000;
}
iVar4 = JS_DefinePropertyDesc(param_1,piVar7,uVar8,iVar3,uVar1,uVar2,uVar5);
JS_FreeAtom(param_1,iVar3);
if (iVar4 < 0) goto LAB_00161eac;
if (in_R9D == 0) {
*piVar7 = *piVar7 + 1;
uVar6 = (ulong)piVar7 & 0xffffffff00000000;
goto LAB_00161eb0;
}
piVar7 = (int *)(ulong)(iVar4 != 0);
uVar8 = 1;
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
LAB_00161eac:
uVar8 = 6;
piVar7 = (int *)0x0;
}
uVar6 = 0;
LAB_00161eb0:
auVar9._0_8_ = (ulong)piVar7 & 0xffffffff | uVar6;
auVar9._8_8_ = uVar8;
return auVar9;
}
|
|
63,115 |
common_init()::$_0::__invoke(ggml_log_level, char const*, void*)
|
monkey531[P]llama/common/common.cpp
|
void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
}
|
O0
|
cpp
|
common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0xf(%rsp), %rdi
callq 0xf77e0
addq $0x28, %rsp
retq
nop
|
_ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv:
sub rsp, 28h
mov [rsp+28h+var_4], edi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov esi, [rsp+28h+var_4]
mov rdx, [rsp+28h+var_10]
mov rcx, [rsp+28h+var_18]
lea rdi, [rsp+28h+var_19]
call _ZZ11common_initvENK3$_0clE14ggml_log_levelPKcPv; common_init(void)::$_0::operator()(ggml_log_level,char const*,void *)
add rsp, 28h
retn
|
long long common_init(void)::$_0::__invoke(unsigned int a1, long long a2, long long a3)
{
char v4; // [rsp+Fh] [rbp-19h] BYREF
long long v5; // [rsp+10h] [rbp-18h]
long long v6; // [rsp+18h] [rbp-10h]
unsigned int v7; // [rsp+24h] [rbp-4h]
v7 = a1;
v6 = a2;
v5 = a3;
return common_init(void)::$_0::operator()(&v4, a1, a2, a3);
}
|
__invoke:
SUB RSP,0x28
MOV dword ptr [RSP + 0x24],EDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV ESI,dword ptr [RSP + 0x24]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0xf]
CALL 0x001f77e0
ADD RSP,0x28
RET
|
/* __invoke(ggml_log_level, char const*, void*) */
void common_init()::$_0::__invoke(int4 param_1,int8 param_2,int8 param_3)
{
int1 local_19;
int8 local_18;
int8 local_10;
int4 local_4;
local_18 = param_3;
local_10 = param_2;
local_4 = param_1;
operator()(&local_19,param_1,param_2,param_3);
return;
}
|
|
63,116 |
common_init()::$_0::__invoke(ggml_log_level, char const*, void*)
|
monkey531[P]llama/common/common.cpp
|
void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
}
|
O3
|
cpp
|
common_init()::$_0::__invoke(ggml_log_level, char const*, void*):
pushq %rax
leaq 0x5e7f(%rip), %rdi # 0x787de
xorl %esi, %esi
callq 0x1afa0
leaq 0xbaa6b(%rip), %rax # 0x12d3d8
cmpl $0x0, (%rax)
js 0x729c1
callq 0xcc71b
leaq 0xba35a(%rip), %rcx # 0x12ccd8
movl (%rcx), %ecx
leaq 0xba359(%rip), %rdx # 0x12cce0
movq (%rdx), %r8
leaq 0xba357(%rip), %rdx # 0x12cce8
movq (%rdx), %r9
leaq 0xba355(%rip), %r10 # 0x12ccf0
leaq 0x79450(%rip), %r11 # 0xebdf2
leaq 0x7c574(%rip), %rdx # 0xeef1d
movq %rax, %rdi
movl $0x2, %esi
xorl %eax, %eax
pushq %r11
pushq (%r10)
callq 0xcc7b8
addq $0x10, %rsp
popq %rax
retq
|
_Z11common_initv:
push rax
lea rdi, _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv; common_init(void)::$_0::__invoke(ggml_log_level,char const*,void *)
xor esi, esi
call _llama_log_set
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_729C1
call _Z15common_log_mainv; common_log_main(void)
lea rcx, LLAMA_BUILD_NUMBER
mov ecx, [rcx]
lea rdx, LLAMA_COMMIT
mov r8, [rdx]
lea rdx, LLAMA_COMPILER
mov r9, [rdx]
lea r10, LLAMA_BUILD_TARGET
lea r11, aErrorWhileHand_0+34h; ""
lea rdx, aBuildDSWithSFo; "build: %d (%s) with %s for %s%s\n"
mov rdi, rax
mov esi, 2
xor eax, eax
push r11
push qword ptr [r10]
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
add rsp, 10h
loc_729C1:
pop rax
retn
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> common_init(void)
{
int v0; // eax
llama_log_set(common_init(void)::$_0::__invoke, 0LL);
if ( common_log_verbosity_thold >= 0 )
{
v0 = common_log_main();
common_log_add(
v0,
2,
(unsigned int)"build: %d (%s) with %s for %s%s\n",
LLAMA_BUILD_NUMBER,
LLAMA_COMMIT[0],
LLAMA_COMPILER[0]);
}
}
|
common_init:
PUSH RAX
LEA RDI,[0x1787de]
XOR ESI,ESI
CALL 0x0011afa0
LEA RAX,[0x22d3d8]
CMP dword ptr [RAX],0x0
JS 0x001729c1
CALL 0x001cc71b
LEA RCX,[0x22ccd8]
MOV ECX,dword ptr [RCX]
LEA RDX,[0x22cce0]
MOV R8,qword ptr [RDX]
LEA RDX,[0x22cce8]
MOV R9,qword ptr [RDX]
LEA R10,[0x22ccf0]
LEA R11,[0x1ebdf2]
LEA RDX,[0x1eef1d]
MOV RDI,RAX
MOV ESI,0x2
XOR EAX,EAX
PUSH R11
PUSH qword ptr [R10]
CALL 0x001cc7b8
ADD RSP,0x10
LAB_001729c1:
POP RAX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_init() */
int8 common_init(void)
{
int8 in_RAX;
int8 uVar1;
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,LLAMA_COMMIT,
LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return in_RAX;
}
|
|
63,117 |
evmone::instr::core::sar(evmone::StackTop)
|
corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline void sar(StackTop stack) noexcept
{
const auto& y = stack.pop();
auto& x = stack.top();
const bool is_neg = static_cast<int64_t>(x[3]) < 0; // Inspect the top bit (words are LE).
const auto sign_mask = is_neg ? ~uint256{} : uint256{};
const auto mask_shift = (y < 256) ? (256 - y[0]) : 0;
x = (x >> y) | (sign_mask << mask_shift);
}
|
O0
|
cpp
|
evmone::instr::core::sar(evmone::StackTop):
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5fb60
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5fb80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x5fe00
cmpq $0x0, (%rax)
setl %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x66bd1
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
leaq -0x60(%rbp), %rdi
callq 0x5fd40
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63a50
jmp 0x66bea
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x23140
leaq -0x40(%rbp), %rdi
callq 0x5fd40
movq -0x10(%rbp), %rdi
movl $0x100, -0x6c(%rbp) # imm = 0x100
leaq -0x6c(%rbp), %rsi
callq 0x66010
testb $0x1, %al
jne 0x66c04
jmp 0x66c25
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5fde0
movq %rax, %rcx
movl $0x100, %eax # imm = 0x100
subq (%rcx), %rax
movq %rax, -0xd8(%rbp)
jmp 0x66c30
xorl %eax, %eax
movq %rax, -0xd8(%rbp)
jmp 0x66c30
movq -0xd8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x66ac0
movq -0x68(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x63470
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x666b0
movq -0x18(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xe0, %rsp
popq %rbp
retq
nop
|
_ZN6evmone5instr4core3sarENS_8StackTopE:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_8], rdi
lea rdi, [rbp+var_8]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_10], rax
lea rdi, [rbp+var_8]; this
call _ZN6evmone8StackTop3topEv; evmone::StackTop::top(void)
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
mov esi, 3
call _ZN4intx4uintILj256EEixEm; intx::uint<256u>::operator[](ulong)
cmp qword ptr [rax], 0
setl al
and al, 1
mov [rbp+var_19], al
test [rbp+var_19], 1
jz short loc_66BD1
lea rdi, [rbp+var_60]
xor esi, esi
mov edx, 20h ; ' '
call _memset
lea rdi, [rbp+var_60]
call _ZN4intx4uintILj256EEC2Ev; intx::uint<256u>::uint(void)
lea rdi, [rbp+var_40]
lea rsi, [rbp+var_60]
call _ZNK4intx4uintILj256EEcoEv; intx::uint<256u>::operator~(void)
jmp short loc_66BEA
loc_66BD1:
lea rdi, [rbp+var_40]
xor esi, esi
mov edx, 20h ; ' '
call _memset
lea rdi, [rbp+var_40]
call _ZN4intx4uintILj256EEC2Ev; intx::uint<256u>::uint(void)
loc_66BEA:
mov rdi, [rbp+var_10]
mov [rbp+var_6C], 100h
lea rsi, [rbp+var_6C]
call _ZN4intxltILj256EivEEbRKNS_4uintIXT_EEERKT0_; intx::operator<<256u,int,void>(intx::uint<256u> const&,int const&)
test al, 1
jnz short loc_66C04
jmp short loc_66C25
loc_66C04:
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call _ZNK4intx4uintILj256EEixEm; intx::uint<256u>::operator[](ulong)
mov rcx, rax
mov eax, 100h
sub rax, [rcx]
mov [rbp+var_D8], rax
jmp short loc_66C30
loc_66C25:
xor eax, eax
mov [rbp+var_D8], rax
jmp short $+2
loc_66C30:
mov rax, [rbp+var_D8]
mov [rbp+var_68], rax
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
lea rdi, [rbp+var_B0]
call _ZN4intxrsILj256EEENS_4uintIXT_EEERKS2_S4_; intx::operator>><256u>(intx::uint<256u> const&,intx::uint<256u> const&)
mov rdx, [rbp+var_68]
lea rdi, [rbp+var_D0]
lea rsi, [rbp+var_40]
call _ZN4intxlsERKNS_4uintILj256EEEm; intx::operator<<(intx::uint<256u> const&,ulong)
lea rdi, [rbp+var_90]
lea rsi, [rbp+var_B0]
lea rdx, [rbp+var_D0]
call _ZN4intxorERKNS_4uintILj256EEES3_; intx::operator|(intx::uint<256u> const&,intx::uint<256u> const&)
mov rax, [rbp+var_18]
mov rcx, [rbp+var_90]
mov [rax], rcx
mov rcx, [rbp+var_88]
mov [rax+8], rcx
mov rcx, [rbp+var_80]
mov [rax+10h], rcx
mov rcx, [rbp+var_78]
mov [rax+18h], rcx
add rsp, 0E0h
pop rbp
retn
|
_QWORD * evmone::instr::core::sar(long long a1)
{
_QWORD *result; // rax
long long v2; // [rsp+8h] [rbp-D8h]
_QWORD v3[4]; // [rsp+10h] [rbp-D0h] BYREF
_QWORD v4[4]; // [rsp+30h] [rbp-B0h] BYREF
_QWORD v5[4]; // [rsp+50h] [rbp-90h] BYREF
int v6; // [rsp+74h] [rbp-6Ch] BYREF
unsigned long long v7; // [rsp+78h] [rbp-68h]
_QWORD v8[4]; // [rsp+80h] [rbp-60h] BYREF
_QWORD v9[4]; // [rsp+A0h] [rbp-40h] BYREF
_QWORD *v11; // [rsp+C8h] [rbp-18h]
long long v12; // [rsp+D0h] [rbp-10h]
long long v13; // [rsp+D8h] [rbp-8h] BYREF
v13 = a1;
v12 = evmone::StackTop::pop((evmone::StackTop *)&v13);
v11 = (_QWORD *)evmone::StackTop::top((evmone::StackTop *)&v13);
if ( *(long long *)intx::uint<256u>::operator[]((long long)v11, 3LL) < 0 )
{
memset(v8, 0LL, sizeof(v8));
intx::uint<256u>::uint(v8);
intx::uint<256u>::operator~(v9, (long long)v8);
}
else
{
memset(v9, 0LL, sizeof(v9));
intx::uint<256u>::uint(v9);
}
v6 = 256;
if ( (intx::operator<<256u,int,void>(v12, &v6) & 1) != 0 )
v2 = 256LL - *(_QWORD *)intx::uint<256u>::operator[](v12, 0LL);
else
v2 = 0LL;
v7 = v2;
intx::operator>><256u>(v4, (long long)v11, v12);
intx::operator<<(v3, (long long)v9, v7);
intx::operator|(v5, (long long)v4, (long long)v3);
result = v11;
*v11 = v5[0];
result[1] = v5[1];
result[2] = v5[2];
result[3] = v5[3];
return result;
}
|
sar:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[RBP + -0x8]
CALL 0x0015fb60
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[RBP + -0x8]
CALL 0x0015fb80
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x3
CALL 0x0015fe00
CMP qword ptr [RAX],0x0
SETL AL
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
TEST byte ptr [RBP + -0x19],0x1
JZ 0x00166bd1
LEA RDI,[RBP + -0x60]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
LEA RDI,[RBP + -0x60]
CALL 0x0015fd40
LEA RDI,[RBP + -0x40]
LEA RSI,[RBP + -0x60]
CALL 0x00163a50
JMP 0x00166bea
LAB_00166bd1:
LEA RDI,[RBP + -0x40]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00123140
LEA RDI,[RBP + -0x40]
CALL 0x0015fd40
LAB_00166bea:
MOV RDI,qword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x6c],0x100
LEA RSI,[RBP + -0x6c]
CALL 0x00166010
TEST AL,0x1
JNZ 0x00166c04
JMP 0x00166c25
LAB_00166c04:
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015fde0
MOV RCX,RAX
MOV EAX,0x100
SUB RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0xd8],RAX
JMP 0x00166c30
LAB_00166c25:
XOR EAX,EAX
MOV qword ptr [RBP + -0xd8],RAX
JMP 0x00166c30
LAB_00166c30:
MOV RAX,qword ptr [RBP + -0xd8]
MOV qword ptr [RBP + -0x68],RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0xb0]
CALL 0x00166ac0
MOV RDX,qword ptr [RBP + -0x68]
LEA RDI,[RBP + -0xd0]
LEA RSI,[RBP + -0x40]
CALL 0x00163470
LEA RDI,[RBP + -0x90]
LEA RSI,[RBP + -0xb0]
LEA RDX,[RBP + -0xd0]
CALL 0x001666b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x78]
MOV qword ptr [RAX + 0x18],RCX
ADD RSP,0xe0
POP RBP
RET
|
/* evmone::instr::core::sar(evmone::StackTop) */
void evmone::instr::core::sar(int8 param_1)
{
bool bVar1;
long *plVar2;
ulong local_e0;
intx local_d8 [32];
intx local_b8 [32];
int8 local_98;
int8 local_90;
int8 local_88;
int8 local_80;
int local_74;
ulong local_70;
uint<256u> local_68 [32];
uint<256u> local_48 [39];
int1 local_21;
uint<256u> *local_20;
uint *local_18;
int8 local_10;
local_10 = param_1;
local_18 = (uint *)StackTop::pop((StackTop *)&local_10);
local_20 = (uint<256u> *)StackTop::top((StackTop *)&local_10);
plVar2 = (long *)intx::uint<256u>::operator[](local_20,3);
local_21 = *plVar2 < 0;
if ((bool)local_21) {
memset(local_68,0,0x20);
intx::uint<256u>::uint(local_68);
intx::uint<256u>::operator~(local_48);
}
else {
memset(local_48,0,0x20);
intx::uint<256u>::uint(local_48);
}
local_74 = 0x100;
bVar1 = intx::operator<(local_18,&local_74);
if (bVar1) {
plVar2 = (long *)intx::uint<256u>::operator[]((uint<256u> *)local_18,0);
local_e0 = 0x100 - *plVar2;
}
else {
local_e0 = 0;
}
local_70 = local_e0;
intx::operator>>(local_b8,(uint *)local_20,local_18);
intx::operator<<(local_d8,(uint *)local_48,local_70);
intx::operator|((intx *)&local_98,(uint *)local_b8,(uint *)local_d8);
*(int8 *)local_20 = local_98;
*(int8 *)(local_20 + 8) = local_90;
*(int8 *)(local_20 + 0x10) = local_88;
*(int8 *)(local_20 + 0x18) = local_80;
return;
}
|
|
63,118 |
minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
}
|
O2
|
cpp
|
minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x7ea62
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7eb66
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x7eaae
leaq 0x5132d(%rip), %rcx # 0xcfd38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7ec90
jmp 0x7ea4d
leaq 0x8(%rsp), %rdi
callq 0x7ed3c
xorb $0x1, %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x7edd8
jmp 0x7ea4d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7ece8
leaq 0x8(%rsp), %rdi
callq 0x7edf6
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x52558(%rip), %rsi # 0xd0fcc
movq %rax, %rdi
callq 0x26420
movq 0xa2565(%rip), %rsi # 0x120fe8
movq 0xa24be(%rip), %rdx # 0x120f48
movq %r14, %rdi
callq 0x275b0
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x52541(%rip), %rsi # 0xd0fe5
movq %rax, %rdi
callq 0x26420
jmp 0x7eac8
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x5256c(%rip), %rsi # 0xd102c
movq %rax, %rdi
callq 0x26420
movq 0xa2519(%rip), %rsi # 0x120fe8
movq 0xa2472(%rip), %rdx # 0x120f48
movq %r14, %rdi
callq 0x275b0
jmp 0x7eae2
jmp 0x7eafc
movq %rax, %rbx
movq %r14, %rdi
callq 0x268f0
jmp 0x7eaff
movq %rax, %rbx
movq %r14, %rdi
callq 0x268f0
jmp 0x7eb09
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7edf6
movq %rbx, %rdi
callq 0x27660
nop
|
_ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r14
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_7EA62
mov rbx, rdi
lea rdi, [rsp+68h+var_60]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_7EA12; jumptable 000000000007EA12 default case
lea rcx, jpt_7EA12
movsxd rax, ds:(jpt_7EA12 - 0CFD38h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7EA14:
lea rsi, [rsp+68h+var_60]; jumptable 000000000007EA12 case 0
mov rdi, rbx
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
jmp short loc_7EA4D
loc_7EA23:
lea rdi, [rsp+68h+var_60]; jumptable 000000000007EA12 case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea rsi, [rsp+68h+var_61]; bool *
mov [rsi], al
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKb; minja::Value::Value(bool const&)
jmp short loc_7EA4D
loc_7EA40:
lea rsi, [rsp+68h+var_60]; jumptable 000000000007EA12 case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_7EA4D:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 58h
pop rbx
pop r14
retn
loc_7EA62:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_7EA92:
push 10h; jumptable 000000000007EA12 cases 3,4
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_7EAC8
def_7EA12:
push 10h; jumptable 000000000007EA12 default case
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_7EAC8:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_7EAE2
jmp short loc_7EAFC
loc_7EAE2:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7EAFF
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7EB09
loc_7EAFC:
mov rbx, rax
loc_7EAFF:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_7EB09:
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::UnaryOpExpr::do_evaluate(
minja::Value *this,
long long a2,
int a3,
int a4,
int a5,
int a6)
{
long long v7; // rsi
std::runtime_error *exception; // r14
std::runtime_error *v10; // r14
bool v11; // [rsp+7h] [rbp-61h] BYREF
_BYTE v12[96]; // [rsp+8h] [rbp-60h] BYREF
v7 = *(_QWORD *)(a2 + 32);
if ( !v7 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "UnaryOpExpr.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((unsigned int)v12, v7, a3, a4, a5, a6);
switch ( *(_DWORD *)(a2 + 48) )
{
case 0:
minja::Value::Value(this, v12);
goto LABEL_6;
case 1:
minja::Value::operator-(this);
goto LABEL_6;
case 2:
v11 = minja::Value::to_bool((minja::Value *)v12) ^ 1;
minja::Value::Value(this, &v11);
LABEL_6:
minja::Value::~Value((minja::Value *)v12);
return this;
case 3:
case 4:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Expansion operator is only supported in function calls and collections");
break;
default:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Unknown unary operator");
break;
}
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
|
do_evaluate:
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0017ea62
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0017eb66
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x0017eaae
LEA RCX,[0x1cfd38]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0017ec90
JMP 0x0017ea4d
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x0017ed3c
XOR AL,0x1
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
MOV RDI,RBX
CALL 0x0017edd8
JMP 0x0017ea4d
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0017ece8
LAB_0017ea4d:
LEA RDI,[RSP + 0x8]
CALL 0x0017edf6
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R14
RET
LAB_0017ea62:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017ea6d:
LEA RSI,[0x1d0fcc]
MOV RDI,RAX
CALL 0x00126420
LAB_0017ea7c:
MOV RSI,qword ptr [0x00220fe8]
MOV RDX,qword ptr [0x00220f48]
MOV RDI,R14
CALL 0x001275b0
caseD_3:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017ea9d:
LEA RSI,[0x1d0fe5]
MOV RDI,RAX
CALL 0x00126420
LAB_0017eaac:
JMP 0x0017eac8
default:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017eab9:
LEA RSI,[0x1d102c]
MOV RDI,RAX
CALL 0x00126420
LAB_0017eac8:
MOV RSI,qword ptr [0x00220fe8]
MOV RDX,qword ptr [0x00220f48]
MOV RDI,R14
CALL 0x001275b0
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
runtime_error *prVar1;
bool local_61;
Expression local_60 [80];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017ea6d to 0017ea7b has its CatchHandler @ 0017eaef */
std::runtime_error::runtime_error(prVar1,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00220fe8,PTR__runtime_error_00220f48);
}
Expression::evaluate(local_60,*(shared_ptr **)(param_1 + 0x20));
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
Value::Value((Value *)this,(Value *)local_60);
break;
case 1:
/* try { // try from 0017ea40 to 0017ea4c has its CatchHandler @ 0017eafc */
Value::operator-((Value *)this);
break;
case 2:
/* try { // try from 0017ea23 to 0017ea2c has its CatchHandler @ 0017eae0 */
local_61 = (bool)Value::to_bool((Value *)local_60);
local_61 = (bool)(local_61 ^ 1);
Value::Value((Value *)this,&local_61);
break;
case 3:
case 4:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017ea9d to 0017eaab has its CatchHandler @ 0017eae2 */
std::runtime_error::runtime_error
(prVar1,"Expansion operator is only supported in function calls and collections");
goto LAB_0017eac8;
default:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017eab9 to 0017eac7 has its CatchHandler @ 0017eade */
std::runtime_error::runtime_error(prVar1,"Unknown unary operator");
LAB_0017eac8:
/* try { // try from 0017eac8 to 0017eadd has its CatchHandler @ 0017eafc */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_00220fe8,PTR__runtime_error_00220f48);
}
Value::~Value((Value *)local_60);
return this;
}
|
|
63,119 |
my_instr_bin
|
eloqsql/strings/ctype-bin.c
|
static
uint my_instr_bin(CHARSET_INFO *cs __attribute__((unused)),
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if ( (*str++) == (*search))
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if ((*i++) != (*j++))
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
}
|
O3
|
c
|
my_instr_bin:
xorl %eax, %eax
cmpq %rdx, %r8
ja 0x684ee
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x10(%rbp), %r10d
testq %r8, %r8
je 0x684b9
addq %rsi, %rdx
subq %r8, %rdx
incq %rdx
movq %rsi, %rdi
cmpq %rdx, %rdi
je 0x684e8
movq %rdi, %r11
incq %rdi
movb (%r11), %bl
cmpb (%rcx), %bl
jne 0x68450
movl $0x1, %ebx
cmpq %rbx, %r8
je 0x68483
movb (%r11,%rbx), %r14b
leaq 0x1(%rbx), %r15
cmpb (%rcx,%rbx), %r14b
movq %r15, %rbx
je 0x6846b
jmp 0x68450
movl $0x2, %eax
testl %r10d, %r10d
je 0x684e8
movl $0x0, (%r9)
notl %esi
addl %esi, %edi
movl %edi, 0x4(%r9)
movl %edi, 0x8(%r9)
cmpl $0x1, %r10d
je 0x684e8
movl %edi, 0xc(%r9)
addl %r8d, %edi
movl $0x14, %ecx
movl $0x10, %edx
jmp 0x684d9
testl %r10d, %r10d
je 0x684e3
movl $0x0, (%r9)
movl $0x1, %eax
movl $0x8, %ecx
xorl %edi, %edi
movl $0x4, %edx
xorl %r8d, %r8d
movl %edi, (%r9,%rdx)
movl %r8d, (%r9,%rcx)
jmp 0x684e8
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_instr_bin:
xor eax, eax
cmp r8, rdx
ja locret_684EE
push rbp
mov rbp, rsp
push r15
push r14
push rbx
mov r10d, [rbp+10h]
test r8, r8
jz short loc_684B9
add rdx, rsi
sub rdx, r8
inc rdx
mov rdi, rsi
loc_68450:
cmp rdi, rdx
jz loc_684E8
mov r11, rdi
inc rdi
mov bl, [r11]
cmp bl, [rcx]
jnz short loc_68450
mov ebx, 1
loc_6846B:
cmp r8, rbx
jz short loc_68483
mov r14b, [r11+rbx]
lea r15, [rbx+1]
cmp r14b, [rcx+rbx]
mov rbx, r15
jz short loc_6846B
jmp short loc_68450
loc_68483:
mov eax, 2
test r10d, r10d
jz short loc_684E8
mov dword ptr [r9], 0
not esi
add edi, esi
mov [r9+4], edi
mov [r9+8], edi
cmp r10d, 1
jz short loc_684E8
mov [r9+0Ch], edi
add edi, r8d
mov ecx, 14h
mov edx, 10h
jmp short loc_684D9
loc_684B9:
test r10d, r10d
jz short loc_684E3
mov dword ptr [r9], 0
mov eax, 1
mov ecx, 8
xor edi, edi
mov edx, 4
xor r8d, r8d
loc_684D9:
mov [r9+rdx], edi
mov [r9+rcx], r8d
jmp short loc_684E8
loc_684E3:
mov eax, 1
loc_684E8:
pop rbx
pop r14
pop r15
pop rbp
locret_684EE:
retn
|
long long my_instr_bin(
long long a1,
_BYTE *a2,
unsigned long long a3,
_BYTE *a4,
unsigned long long a5,
_DWORD *a6,
int a7)
{
long long result; // rax
long long v8; // rdx
_BYTE *v9; // rdi
_BYTE *v10; // r11
long long v11; // rbx
bool v12; // zf
int v13; // edi
int v14; // edi
long long v15; // rcx
long long v16; // rdx
result = 0LL;
if ( a5 <= a3 )
{
if ( a5 )
{
v8 = (long long)&a2[a3 - a5 + 1];
v9 = a2;
LABEL_4:
while ( v9 != (_BYTE *)v8 )
{
v10 = v9++;
if ( *v10 == *a4 )
{
v11 = 1LL;
while ( a5 != v11 )
{
v12 = v10[v11] == a4[v11];
++v11;
if ( !v12 )
goto LABEL_4;
}
result = 2LL;
if ( a7 )
{
*a6 = 0;
v13 = ~(_DWORD)a2 + (_DWORD)v9;
a6[1] = v13;
a6[2] = v13;
if ( a7 != 1 )
{
a6[3] = v13;
v14 = a5 + v13;
v15 = 5LL;
v16 = 4LL;
goto LABEL_15;
}
}
return result;
}
}
}
else if ( a7 )
{
*a6 = 0;
result = 1LL;
v15 = 2LL;
v14 = 0;
v16 = 1LL;
LODWORD(a5) = 0;
LABEL_15:
a6[v16] = v14;
a6[v15] = a5;
}
else
{
return 1LL;
}
}
return result;
}
|
my_instr_bin:
XOR EAX,EAX
CMP R8,RDX
JA 0x001684ee
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
MOV R10D,dword ptr [RBP + 0x10]
TEST R8,R8
JZ 0x001684b9
ADD RDX,RSI
SUB RDX,R8
INC RDX
MOV RDI,RSI
LAB_00168450:
CMP RDI,RDX
JZ 0x001684e8
MOV R11,RDI
INC RDI
MOV BL,byte ptr [R11]
CMP BL,byte ptr [RCX]
JNZ 0x00168450
MOV EBX,0x1
LAB_0016846b:
CMP R8,RBX
JZ 0x00168483
MOV R14B,byte ptr [R11 + RBX*0x1]
LEA R15,[RBX + 0x1]
CMP R14B,byte ptr [RCX + RBX*0x1]
MOV RBX,R15
JZ 0x0016846b
JMP 0x00168450
LAB_00168483:
MOV EAX,0x2
TEST R10D,R10D
JZ 0x001684e8
MOV dword ptr [R9],0x0
NOT ESI
ADD EDI,ESI
MOV dword ptr [R9 + 0x4],EDI
MOV dword ptr [R9 + 0x8],EDI
CMP R10D,0x1
JZ 0x001684e8
MOV dword ptr [R9 + 0xc],EDI
ADD EDI,R8D
MOV ECX,0x14
MOV EDX,0x10
JMP 0x001684d9
LAB_001684b9:
TEST R10D,R10D
JZ 0x001684e3
MOV dword ptr [R9],0x0
MOV EAX,0x1
MOV ECX,0x8
XOR EDI,EDI
MOV EDX,0x4
XOR R8D,R8D
LAB_001684d9:
MOV dword ptr [R9 + RDX*0x1],EDI
MOV dword ptr [R9 + RCX*0x1],R8D
JMP 0x001684e8
LAB_001684e3:
MOV EAX,0x1
LAB_001684e8:
POP RBX
POP R14
POP R15
POP RBP
LAB_001684ee:
RET
|
int8
my_instr_bin(int8 param_1,char *param_2,ulong param_3,char *param_4,ulong param_5,
int4 *param_6,int param_7)
{
char *pcVar1;
char *pcVar2;
int8 uVar3;
long lVar4;
long lVar5;
ulong uVar6;
int iVar7;
char *pcVar8;
char *pcVar9;
uVar3 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 == 0) {
uVar3 = 1;
}
else {
*param_6 = 0;
uVar3 = 1;
lVar4 = 8;
iVar7 = 0;
lVar5 = 4;
param_5 = 0;
LAB_001684d9:
*(int *)((long)param_6 + lVar5) = iVar7;
*(int *)((long)param_6 + lVar4) = (int)param_5;
}
}
else {
pcVar9 = param_2;
while (pcVar8 = pcVar9, pcVar8 != param_2 + (param_3 - param_5) + 1) {
pcVar9 = pcVar8 + 1;
if (*pcVar8 == *param_4) {
uVar6 = 1;
do {
if (param_5 == uVar6) {
uVar3 = 2;
if (param_7 == 0) {
return 2;
}
*param_6 = 0;
iVar7 = (int)pcVar9 + ~(uint)param_2;
param_6[1] = iVar7;
param_6[2] = iVar7;
if (param_7 == 1) {
return 2;
}
param_6[3] = iVar7;
iVar7 = iVar7 + (int)param_5;
lVar4 = 0x14;
lVar5 = 0x10;
goto LAB_001684d9;
}
pcVar1 = pcVar8 + uVar6;
pcVar2 = param_4 + uVar6;
uVar6 = uVar6 + 1;
} while (*pcVar1 == *pcVar2);
}
}
}
}
return uVar3;
}
|
|
63,120 |
common_sampler_clone(common_sampler*)
|
monkey531[P]llama/common/sampling.cpp
|
struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
return new common_sampler {
/* .params = */ gsmpl->params,
/* .grmr = */ llama_sampler_clone(gsmpl->grmr),
/* .chain = */ llama_sampler_clone(gsmpl->chain),
/* .prev = */ gsmpl->prev,
/* .cur = */ gsmpl->cur,
/* .cur_p = */ gsmpl->cur_p,
};
}
|
O2
|
cpp
|
common_sampler_clone(common_sampler*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1b8, %edi # imm = 0x1B8
callq 0x238d0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3999a
movq 0x138(%r14), %rdi
callq 0x23650
movq %rax, 0x138(%rbx)
movq 0x140(%r14), %rdi
callq 0x23650
movq %rax, 0x140(%rbx)
movl $0x148, %esi # imm = 0x148
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x98bb4
movl $0x180, %esi # imm = 0x180
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x98bd0
movups 0x198(%r14), %xmm0
movups 0x1a8(%r14), %xmm1
movups %xmm1, 0x1a8(%rbx)
movups %xmm0, 0x198(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x27e7a
jmp 0x97e2e
movq %rax, %r14
jmp 0x97e36
movq %rax, %r14
movq %rbx, %rdi
callq 0x2778e
movl $0x1b8, %esi # imm = 0x1B8
movq %rbx, %rdi
callq 0x238f0
movq %r14, %rdi
callq 0x23fc0
|
_Z20common_sampler_cloneP14common_sampler:
push r14
push rbx
push rax
mov r14, rdi
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax; this
mov rsi, r14; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov rdi, [r14+138h]
call _llama_sampler_clone
mov [rbx+138h], rax
mov rdi, [r14+140h]
call _llama_sampler_clone
mov [rbx+140h], rax
mov esi, 148h
lea rdi, [rbx+rsi]
add rsi, r14
call _ZN11ring_bufferIiEC2ERKS0_; ring_buffer<int>::ring_buffer(ring_buffer<int> const&)
mov esi, 180h
lea rdi, [rbx+rsi]
add rsi, r14
call _ZNSt6vectorI16llama_token_dataSaIS0_EEC2ERKS2_; std::vector<llama_token_data>::vector(std::vector<llama_token_data> const&)
movups xmm0, xmmword ptr [r14+198h]
movups xmm1, xmmword ptr [r14+1A8h]
movups xmmword ptr [rbx+1A8h], xmm1
movups xmmword ptr [rbx+198h], xmm0
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx
add rdi, 168h
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
jmp short loc_97E2E
mov r14, rax
jmp short loc_97E36
mov r14, rax
loc_97E2E:
mov rdi, rbx; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
loc_97E36:
mov esi, 1B8h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
|
long long common_sampler_clone(common_sampler *a1)
{
long long v1; // rbx
__int128 v2; // xmm0
v1 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v1, a1);
*(_QWORD *)(v1 + 312) = llama_sampler_clone(*((_QWORD *)a1 + 39));
*(_QWORD *)(v1 + 320) = llama_sampler_clone(*((_QWORD *)a1 + 40));
ring_buffer<int>::ring_buffer(v1 + 328, (char *)a1 + 328);
std::vector<llama_token_data>::vector(v1 + 384, (char *)a1 + 384);
v2 = *(_OWORD *)((char *)a1 + 408);
*(_OWORD *)(v1 + 424) = *(_OWORD *)((char *)a1 + 424);
*(_OWORD *)(v1 + 408) = v2;
return v1;
}
|
common_sampler_clone:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x1b8
CALL 0x001238d0
MOV RBX,RAX
LAB_00197d96:
MOV RDI,RAX
MOV RSI,R14
CALL 0x0013999a
MOV RDI,qword ptr [R14 + 0x138]
LAB_00197da8:
CALL 0x00123650
MOV qword ptr [RBX + 0x138],RAX
MOV RDI,qword ptr [R14 + 0x140]
CALL 0x00123650
MOV qword ptr [RBX + 0x140],RAX
MOV ESI,0x148
LEA RDI,[RBX + RSI*0x1]
ADD RSI,R14
CALL 0x00198bb4
MOV ESI,0x180
LEA RDI,[RBX + RSI*0x1]
ADD RSI,R14
LAB_00197de4:
CALL 0x00198bd0
LAB_00197de9:
MOVUPS XMM0,xmmword ptr [R14 + 0x198]
MOVUPS XMM1,xmmword ptr [R14 + 0x1a8]
MOVUPS xmmword ptr [RBX + 0x1a8],XMM1
MOVUPS xmmword ptr [RBX + 0x198],XMM0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_sampler_clone(common_sampler*) */
common_params_sampling * common_sampler_clone(common_sampler *param_1)
{
int8 uVar1;
int8 uVar2;
common_params_sampling *this;
int8 uVar3;
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 00197d96 to 00197da0 has its CatchHandler @ 00197e26 */
common_params_sampling::common_params_sampling(this,(common_params_sampling *)param_1);
/* try { // try from 00197da8 to 00197dd7 has its CatchHandler @ 00197e2b */
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x138));
*(int8 *)(this + 0x138) = uVar3;
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x140));
*(int8 *)(this + 0x140) = uVar3;
ring_buffer<int>::ring_buffer((ring_buffer<int> *)(this + 0x148),(ring_buffer *)(param_1 + 0x148))
;
/* try { // try from 00197de4 to 00197de8 has its CatchHandler @ 00197e12 */
std::vector<llama_token_data,std::allocator<llama_token_data>>::vector
((vector<llama_token_data,std::allocator<llama_token_data>> *)(this + 0x180),
param_1 + 0x180);
uVar3 = *(int8 *)(param_1 + 0x198);
uVar1 = *(int8 *)(param_1 + 0x1a0);
uVar2 = *(int8 *)(param_1 + 0x1b0);
*(int8 *)(this + 0x1a8) = *(int8 *)(param_1 + 0x1a8);
*(int8 *)(this + 0x1b0) = uVar2;
*(int8 *)(this + 0x198) = uVar3;
*(int8 *)(this + 0x1a0) = uVar1;
return this;
}
|
|
63,121 |
common_sampler_clone(common_sampler*)
|
monkey531[P]llama/common/sampling.cpp
|
struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
return new common_sampler {
/* .params = */ gsmpl->params,
/* .grmr = */ llama_sampler_clone(gsmpl->grmr),
/* .chain = */ llama_sampler_clone(gsmpl->chain),
/* .prev = */ gsmpl->prev,
/* .cur = */ gsmpl->cur,
/* .cur_p = */ gsmpl->cur_p,
};
}
|
O3
|
cpp
|
common_sampler_clone(common_sampler*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1b8, %edi # imm = 0x1B8
callq 0x1a8b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x54462
movq 0x138(%r14), %rdi
callq 0x1a620
movq %rax, 0x138(%rbx)
movq 0x140(%r14), %rdi
callq 0x1a620
movq %rax, 0x140(%rbx)
movups 0x148(%r14), %xmm0
movups 0x158(%r14), %xmm1
movups %xmm0, 0x148(%rbx)
movups %xmm1, 0x158(%rbx)
movl $0x168, %esi # imm = 0x168
leaq (%rbx,%rsi), %r15
addq %r14, %rsi
movq %r15, %rdi
callq 0x54aa8
movl $0x180, %esi # imm = 0x180
movq %rbx, %rdi
addq %rsi, %rdi
addq %r14, %rsi
callq 0xce550
movups 0x198(%r14), %xmm0
movups 0x1a8(%r14), %xmm1
movups %xmm1, 0x1a8(%rbx)
movups %xmm0, 0x198(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0xcd47e
movq 0x178(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a8d0
jmp 0xcd47e
movq %rax, %r14
jmp 0xcd486
movq %rax, %r14
movq %rbx, %rdi
callq 0x218fc
movl $0x1b8, %esi # imm = 0x1B8
movq %rbx, %rdi
callq 0x1a8d0
movq %r14, %rdi
callq 0x1afc0
|
_Z20common_sampler_cloneP14common_sampler:
push r15
push r14
push rbx
mov r14, rdi
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax; this
mov rsi, r14; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov rdi, [r14+138h]
call _llama_sampler_clone
mov [rbx+138h], rax
mov rdi, [r14+140h]
call _llama_sampler_clone
mov [rbx+140h], rax
movups xmm0, xmmword ptr [r14+148h]
movups xmm1, xmmword ptr [r14+158h]
movups xmmword ptr [rbx+148h], xmm0
movups xmmword ptr [rbx+158h], xmm1
mov esi, 168h
lea r15, [rbx+rsi]
add rsi, r14
mov rdi, r15
call _ZNSt6vectorIiSaIiEEC2ERKS1_; std::vector<int>::vector(std::vector<int> const&)
mov esi, 180h
mov rdi, rbx
add rdi, rsi
add rsi, r14
call _ZNSt6vectorI16llama_token_dataSaIS0_EEC2ERKS2_; std::vector<llama_token_data>::vector(std::vector<llama_token_data> const&)
movups xmm0, xmmword ptr [r14+198h]
movups xmm1, xmmword ptr [r14+1A8h]
movups xmmword ptr [rbx+1A8h], xmm1
movups xmmword ptr [rbx+198h], xmm0
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [r15]; void *
test rdi, rdi
jz short loc_CD47E
mov rsi, [rbx+178h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CD47E
mov r14, rax
jmp short loc_CD486
mov r14, rax
loc_CD47E:
mov rdi, rbx; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
loc_CD486:
mov esi, 1B8h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
|
long long common_sampler_clone(common_params_sampling *a1)
{
long long v1; // rbx
__int128 v2; // xmm1
__int128 v3; // xmm0
v1 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v1, a1);
*(_QWORD *)(v1 + 312) = llama_sampler_clone(*((_QWORD *)a1 + 39));
*(_QWORD *)(v1 + 320) = llama_sampler_clone(*((_QWORD *)a1 + 40));
v2 = *(_OWORD *)((char *)a1 + 344);
*(_OWORD *)(v1 + 328) = *(_OWORD *)((char *)a1 + 328);
*(_OWORD *)(v1 + 344) = v2;
std::vector<int>::vector(v1 + 360, (long long *)a1 + 45);
std::vector<llama_token_data>::vector(v1 + 384, (char *)a1 + 384);
v3 = *(_OWORD *)((char *)a1 + 408);
*(_OWORD *)(v1 + 424) = *(_OWORD *)((char *)a1 + 424);
*(_OWORD *)(v1 + 408) = v3;
return v1;
}
|
common_sampler_clone:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
MOV EDI,0x1b8
CALL 0x0011a8b0
MOV RBX,RAX
LAB_001cd3bd:
MOV RDI,RAX
MOV RSI,R14
CALL 0x00154462
MOV RDI,qword ptr [R14 + 0x138]
LAB_001cd3cf:
CALL 0x0011a620
MOV qword ptr [RBX + 0x138],RAX
MOV RDI,qword ptr [R14 + 0x140]
CALL 0x0011a620
MOV qword ptr [RBX + 0x140],RAX
MOVUPS XMM0,xmmword ptr [R14 + 0x148]
MOVUPS XMM1,xmmword ptr [R14 + 0x158]
MOVUPS xmmword ptr [RBX + 0x148],XMM0
MOVUPS xmmword ptr [RBX + 0x158],XMM1
MOV ESI,0x168
LEA R15,[RBX + RSI*0x1]
ADD RSI,R14
MOV RDI,R15
CALL 0x00154aa8
MOV ESI,0x180
MOV RDI,RBX
ADD RDI,RSI
ADD RSI,R14
LAB_001cd42e:
CALL 0x001ce550
LAB_001cd433:
MOVUPS XMM0,xmmword ptr [R14 + 0x198]
MOVUPS XMM1,xmmword ptr [R14 + 0x1a8]
MOVUPS xmmword ptr [RBX + 0x1a8],XMM1
MOVUPS xmmword ptr [RBX + 0x198],XMM0
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* common_sampler_clone(common_sampler*) */
common_params_sampling * common_sampler_clone(common_sampler *param_1)
{
int8 uVar1;
int8 uVar2;
common_params_sampling *this;
int8 uVar3;
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 001cd3bd to 001cd3c7 has its CatchHandler @ 001cd476 */
common_params_sampling::common_params_sampling(this,(common_params_sampling *)param_1);
/* try { // try from 001cd3cf to 001cd41f has its CatchHandler @ 001cd47b */
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x138));
*(int8 *)(this + 0x138) = uVar3;
uVar3 = llama_sampler_clone(*(int8 *)(param_1 + 0x140));
*(int8 *)(this + 0x140) = uVar3;
uVar3 = *(int8 *)(param_1 + 0x150);
uVar1 = *(int8 *)(param_1 + 0x158);
uVar2 = *(int8 *)(param_1 + 0x160);
*(int8 *)(this + 0x148) = *(int8 *)(param_1 + 0x148);
*(int8 *)(this + 0x150) = uVar3;
*(int8 *)(this + 0x158) = uVar1;
*(int8 *)(this + 0x160) = uVar2;
std::vector<int,std::allocator<int>>::vector
((vector<int,std::allocator<int>> *)(this + 0x168),(vector *)(param_1 + 0x168));
/* try { // try from 001cd42e to 001cd432 has its CatchHandler @ 001cd45a */
std::vector<llama_token_data,std::allocator<llama_token_data>>::vector
((vector<llama_token_data,std::allocator<llama_token_data>> *)(this + 0x180),
(vector *)(param_1 + 0x180));
uVar3 = *(int8 *)(param_1 + 0x198);
uVar1 = *(int8 *)(param_1 + 0x1a0);
uVar2 = *(int8 *)(param_1 + 0x1b0);
*(int8 *)(this + 0x1a8) = *(int8 *)(param_1 + 0x1a8);
*(int8 *)(this + 0x1b0) = uVar2;
*(int8 *)(this + 0x198) = uVar3;
*(int8 *)(this + 0x1a0) = uVar1;
return this;
}
|
|
63,122 |
OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(int*) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/regularPatchBuilder.cpp
|
void
RegularPatchBuilder::gatherBoundaryPatchPoints4(Index P[]) const {
Index const * fvIndices = &_surface.GetIndices()[0];
//
// For each of the 4 corners -- whether boundary or interior -- one
// incident face contains all indices that will contribute to the points
// of the corresponding patch. Identify it first and then retrieve and
// assign the indices accordingly:
//
for (int i = 0; i < 4; ++i) {
FaceVertex const & cTop = _surface.GetCornerTopology(i);
FaceVertexSubset const & cSub = _surface.GetCornerSubset(i);
int faceCorner = cTop.GetFace();
int faceOther = faceCorner;
if (!cSub.IsBoundary()) {
faceOther = cTop.GetFaceAfter(2);
} else if (cSub._numFacesAfter) {
faceOther = cTop.GetFaceNext(faceCorner);
} else if (cSub._numFacesBefore) {
faceOther = cTop.GetFacePrevious(faceCorner);
}
Index const * fvOther = fvIndices + cTop.GetFaceIndexOffset(faceOther);
Index fvPhantom = fvOther[0];
switch (i) {
case 0:
P[5] = fvOther[0];
if (!cSub.IsBoundary()) {
P[4] = fvOther[1];
P[0] = fvOther[2];
P[1] = fvOther[3];
} else {
P[4] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[0] = fvPhantom;
P[1] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 1:
P[6] = fvOther[0];
if (!cSub.IsBoundary()) {
P[2] = fvOther[1];
P[3] = fvOther[2];
P[7] = fvOther[3];
} else {
P[2] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[3] = fvPhantom;
P[7] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 2:
P[10] = fvOther[0];
if (!cSub.IsBoundary()) {
P[11] = fvOther[1];
P[15] = fvOther[2];
P[14] = fvOther[3];
} else {
P[11] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[15] = fvPhantom;
P[14] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 3:
P[ 9] = fvOther[0];
if (!cSub.IsBoundary()) {
P[13] = fvOther[1];
P[12] = fvOther[2];
P[ 8] = fvOther[3];
} else {
P[13] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[12] = fvPhantom;
P[ 8] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
}
fvIndices += cTop.GetNumFaceVertices();
}
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(int*) const:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0xd3500
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1aabc2
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xc9dd0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xc87d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd0500
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc73d0
testb $0x1, %al
jne 0x1aa883
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0xd6500
movl %eax, -0x38(%rbp)
jmp 0x1aa8bd
movq -0x30(%rbp), %rax
cmpw $0x0, 0x4(%rax)
je 0x1aa89f
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xd23f0
movl %eax, -0x38(%rbp)
jmp 0x1aa8bb
movq -0x30(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x1aa8b9
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0xcfb40
movl %eax, -0x38(%rbp)
jmp 0x1aa8bb
jmp 0x1aa8bd
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0xceb30
movl %eax, %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x58(%rbp)
subq $0x3, %rax
ja 0x1aab97
movq -0x58(%rbp), %rax
leaq 0x4fa69(%rip), %rcx # 0x1fa370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x30(%rbp), %rdi
callq 0xc73d0
testb $0x1, %al
jne 0x1aa955
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x1aa9ac
movq -0x30(%rbp), %rax
cmpw $0x0, 0x4(%rax)
je 0x1aa96c
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x64(%rbp)
jmp 0x1aa972
movl -0x44(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x1aa99c
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x68(%rbp)
jmp 0x1aa9a2
movl -0x44(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x1aab97
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rdi
callq 0xc73d0
testb $0x1, %al
jne 0x1aa9f7
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x1aaa4f
movq -0x30(%rbp), %rax
cmpw $0x0, 0x4(%rax)
je 0x1aaa0e
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x6c(%rbp)
jmp 0x1aaa14
movl -0x44(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x30(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x1aaa3f
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x70(%rbp)
jmp 0x1aaa45
movl -0x44(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x1aab97
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x30(%rbp), %rdi
callq 0xc73d0
testb $0x1, %al
jne 0x1aaa9a
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x1aaaf2
movq -0x30(%rbp), %rax
cmpw $0x0, 0x4(%rax)
je 0x1aaab1
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x74(%rbp)
jmp 0x1aaab7
movl -0x44(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x30(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x1aaae2
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x78(%rbp)
jmp 0x1aaae8
movl -0x44(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x1aab97
movq -0x40(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x30(%rbp), %rdi
callq 0xc73d0
testb $0x1, %al
jne 0x1aab3d
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x1aab95
movq -0x30(%rbp), %rax
cmpw $0x0, 0x4(%rax)
je 0x1aab54
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x7c(%rbp)
jmp 0x1aab5a
movl -0x44(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x1aab85
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x80(%rbp)
jmp 0x1aab8b
movl -0x44(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x1aab97
movq -0x28(%rbp), %rdi
callq 0xd2a20
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1aa81e
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZNK10OpenSubdiv6v3_6_03Bfr19RegularPatchBuilder26gatherBoundaryPatchPoints4EPi:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
mov rdi, [rax]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr11FaceSurface10GetIndicesEv; OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetIndices(void)
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
loc_1AA81E:
cmp [rbp+var_1C], 4
jge loc_1AABC2
mov rax, [rbp+var_50]
mov rdi, [rax]; this
mov esi, [rbp+var_1C]; int
call __ZNK10OpenSubdiv6v3_6_03Bfr11FaceSurface17GetCornerTopologyEi; OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetCornerTopology(int)
mov rcx, rax
mov rax, [rbp+var_50]
mov [rbp+var_28], rcx
mov rdi, [rax]; this
mov esi, [rbp+var_1C]; int
call __ZNK10OpenSubdiv6v3_6_03Bfr11FaceSurface15GetCornerSubsetEi; OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetCornerSubset(int)
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex7GetFaceEv; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFace(void)
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_38], eax
mov rdi, [rbp+var_30]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr16FaceVertexSubset10IsBoundaryEv; OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(void)
test al, 1
jnz short loc_1AA883
mov rdi, [rbp+var_28]; this
mov esi, 2; int
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex12GetFaceAfterEi; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceAfter(int)
mov [rbp+var_38], eax
jmp short loc_1AA8BD
loc_1AA883:
mov rax, [rbp+var_30]
cmp word ptr [rax+4], 0
jz short loc_1AA89F
mov rdi, [rbp+var_28]; this
mov esi, [rbp+var_34]; int
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex11GetFaceNextEi; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceNext(int)
mov [rbp+var_38], eax
jmp short loc_1AA8BB
loc_1AA89F:
mov rax, [rbp+var_30]
cmp word ptr [rax+2], 0
jz short loc_1AA8B9
mov rdi, [rbp+var_28]; this
mov esi, [rbp+var_34]; int
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex15GetFacePreviousEi; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFacePrevious(int)
mov [rbp+var_38], eax
loc_1AA8B9:
jmp short $+2
loc_1AA8BB:
jmp short $+2
loc_1AA8BD:
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rdi, [rbp+var_28]; this
mov esi, [rbp+var_38]; int
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex18GetFaceIndexOffsetEi; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceIndexOffset(int)
mov ecx, eax
mov rax, [rbp+var_60]
movsxd rcx, ecx
lea rax, [rax+rcx*4]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov eax, [rax]
mov [rbp+var_44], eax
mov eax, [rbp+var_1C]
mov [rbp+var_58], rax
sub rax, 3; switch 4 cases
ja def_1AA90E; jumptable 00000000001AA90E default case
mov rax, [rbp+var_58]
lea rcx, jpt_1AA90E
movsxd rax, ds:(jpt_1AA90E - 1FA370h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1AA910:
mov rax, [rbp+var_40]; jumptable 00000000001AA90E case 0
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov rdi, [rbp+var_30]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr16FaceVertexSubset10IsBoundaryEv; OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(void)
test al, 1
jnz short loc_1AA955
mov rax, [rbp+var_40]
mov ecx, [rax+4]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_10]
mov [rax+4], ecx
jmp short loc_1AA9AC
loc_1AA955:
mov rax, [rbp+var_30]
cmp word ptr [rax+4], 0
jz short loc_1AA96C
mov rax, [rbp+var_40]
mov eax, [rax+0Ch]
mov [rbp+var_64], eax
jmp short loc_1AA972
loc_1AA96C:
mov eax, [rbp+var_44]
mov [rbp+var_64], eax
loc_1AA972:
mov ecx, [rbp+var_64]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_30]
cmp word ptr [rax+2], 0
jz short loc_1AA99C
mov rax, [rbp+var_40]
mov eax, [rax+4]
mov [rbp+var_68], eax
jmp short loc_1AA9A2
loc_1AA99C:
mov eax, [rbp+var_44]
mov [rbp+var_68], eax
loc_1AA9A2:
mov ecx, [rbp+var_68]
mov rax, [rbp+var_10]
mov [rax+4], ecx
loc_1AA9AC:
jmp def_1AA90E; jumptable 00000000001AA90E default case
loc_1AA9B1:
mov rax, [rbp+var_40]; jumptable 00000000001AA90E case 1
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+18h], ecx
mov rdi, [rbp+var_30]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr16FaceVertexSubset10IsBoundaryEv; OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(void)
test al, 1
jnz short loc_1AA9F7
mov rax, [rbp+var_40]
mov ecx, [rax+4]
mov rax, [rbp+var_10]
mov [rax+8], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_10]
mov [rax+1Ch], ecx
jmp short loc_1AAA4F
loc_1AA9F7:
mov rax, [rbp+var_30]
cmp word ptr [rax+4], 0
jz short loc_1AAA0E
mov rax, [rbp+var_40]
mov eax, [rax+0Ch]
mov [rbp+var_6C], eax
jmp short loc_1AAA14
loc_1AAA0E:
mov eax, [rbp+var_44]
mov [rbp+var_6C], eax
loc_1AAA14:
mov ecx, [rbp+var_6C]
mov rax, [rbp+var_10]
mov [rax+8], ecx
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
mov rax, [rbp+var_30]
cmp word ptr [rax+2], 0
jz short loc_1AAA3F
mov rax, [rbp+var_40]
mov eax, [rax+4]
mov [rbp+var_70], eax
jmp short loc_1AAA45
loc_1AAA3F:
mov eax, [rbp+var_44]
mov [rbp+var_70], eax
loc_1AAA45:
mov ecx, [rbp+var_70]
mov rax, [rbp+var_10]
mov [rax+1Ch], ecx
loc_1AAA4F:
jmp def_1AA90E; jumptable 00000000001AA90E default case
loc_1AAA54:
mov rax, [rbp+var_40]; jumptable 00000000001AA90E case 2
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+28h], ecx
mov rdi, [rbp+var_30]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr16FaceVertexSubset10IsBoundaryEv; OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(void)
test al, 1
jnz short loc_1AAA9A
mov rax, [rbp+var_40]
mov ecx, [rax+4]
mov rax, [rbp+var_10]
mov [rax+2Ch], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+3Ch], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_10]
mov [rax+38h], ecx
jmp short loc_1AAAF2
loc_1AAA9A:
mov rax, [rbp+var_30]
cmp word ptr [rax+4], 0
jz short loc_1AAAB1
mov rax, [rbp+var_40]
mov eax, [rax+0Ch]
mov [rbp+var_74], eax
jmp short loc_1AAAB7
loc_1AAAB1:
mov eax, [rbp+var_44]
mov [rbp+var_74], eax
loc_1AAAB7:
mov ecx, [rbp+var_74]
mov rax, [rbp+var_10]
mov [rax+2Ch], ecx
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
mov [rax+3Ch], ecx
mov rax, [rbp+var_30]
cmp word ptr [rax+2], 0
jz short loc_1AAAE2
mov rax, [rbp+var_40]
mov eax, [rax+4]
mov [rbp+var_78], eax
jmp short loc_1AAAE8
loc_1AAAE2:
mov eax, [rbp+var_44]
mov [rbp+var_78], eax
loc_1AAAE8:
mov ecx, [rbp+var_78]
mov rax, [rbp+var_10]
mov [rax+38h], ecx
loc_1AAAF2:
jmp def_1AA90E; jumptable 00000000001AA90E default case
loc_1AAAF7:
mov rax, [rbp+var_40]; jumptable 00000000001AA90E case 3
mov ecx, [rax]
mov rax, [rbp+var_10]
mov [rax+24h], ecx
mov rdi, [rbp+var_30]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr16FaceVertexSubset10IsBoundaryEv; OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(void)
test al, 1
jnz short loc_1AAB3D
mov rax, [rbp+var_40]
mov ecx, [rax+4]
mov rax, [rbp+var_10]
mov [rax+34h], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+30h], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+0Ch]
mov rax, [rbp+var_10]
mov [rax+20h], ecx
jmp short loc_1AAB95
loc_1AAB3D:
mov rax, [rbp+var_30]
cmp word ptr [rax+4], 0
jz short loc_1AAB54
mov rax, [rbp+var_40]
mov eax, [rax+0Ch]
mov [rbp+var_7C], eax
jmp short loc_1AAB5A
loc_1AAB54:
mov eax, [rbp+var_44]
mov [rbp+var_7C], eax
loc_1AAB5A:
mov ecx, [rbp+var_7C]
mov rax, [rbp+var_10]
mov [rax+34h], ecx
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
mov [rax+30h], ecx
mov rax, [rbp+var_30]
cmp word ptr [rax+2], 0
jz short loc_1AAB85
mov rax, [rbp+var_40]
mov eax, [rax+4]
mov [rbp+var_80], eax
jmp short loc_1AAB8B
loc_1AAB85:
mov eax, [rbp+var_44]
mov [rbp+var_80], eax
loc_1AAB8B:
mov ecx, [rbp+var_80]
mov rax, [rbp+var_10]
mov [rax+20h], ecx
loc_1AAB95:
jmp short $+2; jumptable 00000000001AA90E default case
def_1AA90E:
mov rdi, [rbp+var_28]; jumptable 00000000001AA90E default case
call __ZNK10OpenSubdiv6v3_6_03Bfr10FaceVertex18GetNumFaceVerticesEv; OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetNumFaceVertices(void)
mov ecx, eax
mov rax, [rbp+var_18]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp loc_1AA81E
loc_1AABC2:
add rsp, 80h
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(
OpenSubdiv::v3_6_0::Bfr::FaceSurface **this,
int *a2)
{
long long result; // rax
int v3; // [rsp+0h] [rbp-80h]
int v4; // [rsp+4h] [rbp-7Ch]
int v5; // [rsp+8h] [rbp-78h]
int v6; // [rsp+Ch] [rbp-74h]
int v7; // [rsp+10h] [rbp-70h]
int v8; // [rsp+14h] [rbp-6Ch]
int v9; // [rsp+18h] [rbp-68h]
int v10; // [rsp+1Ch] [rbp-64h]
int v11; // [rsp+3Ch] [rbp-44h]
int *v12; // [rsp+40h] [rbp-40h]
int FaceNext; // [rsp+48h] [rbp-38h]
int Face; // [rsp+4Ch] [rbp-34h]
OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset *CornerSubset; // [rsp+50h] [rbp-30h]
OpenSubdiv::v3_6_0::Bfr::FaceVertex *CornerTopology; // [rsp+58h] [rbp-28h]
int i; // [rsp+64h] [rbp-1Ch]
long long v18; // [rsp+68h] [rbp-18h]
result = OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetIndices(*this);
v18 = result;
for ( i = 0; i < 4; ++i )
{
CornerTopology = (OpenSubdiv::v3_6_0::Bfr::FaceVertex *)OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetCornerTopology(
*this,
i);
CornerSubset = (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset *)OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetCornerSubset(
*this,
i);
Face = OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFace(CornerTopology);
FaceNext = Face;
if ( (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(CornerSubset) & 1) != 0 )
{
if ( *((_WORD *)CornerSubset + 2) )
{
FaceNext = OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceNext(CornerTopology, Face);
}
else if ( *((_WORD *)CornerSubset + 1) )
{
FaceNext = OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFacePrevious(CornerTopology, Face);
}
}
else
{
FaceNext = OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceAfter(CornerTopology, 2);
}
v12 = (int *)(v18 + 4LL * (int)OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetFaceIndexOffset(CornerTopology, FaceNext));
v11 = *v12;
switch ( i )
{
case 0:
a2[5] = *v12;
if ( (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(CornerSubset) & 1) != 0 )
{
if ( *((_WORD *)CornerSubset + 2) )
v10 = v12[3];
else
v10 = v11;
a2[4] = v10;
*a2 = v11;
if ( *((_WORD *)CornerSubset + 1) )
v9 = v12[1];
else
v9 = v11;
a2[1] = v9;
}
else
{
a2[4] = v12[1];
*a2 = v12[2];
a2[1] = v12[3];
}
break;
case 1:
a2[6] = *v12;
if ( (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(CornerSubset) & 1) != 0 )
{
if ( *((_WORD *)CornerSubset + 2) )
v8 = v12[3];
else
v8 = v11;
a2[2] = v8;
a2[3] = v11;
if ( *((_WORD *)CornerSubset + 1) )
v7 = v12[1];
else
v7 = v11;
a2[7] = v7;
}
else
{
a2[2] = v12[1];
a2[3] = v12[2];
a2[7] = v12[3];
}
break;
case 2:
a2[10] = *v12;
if ( (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(CornerSubset) & 1) != 0 )
{
if ( *((_WORD *)CornerSubset + 2) )
v6 = v12[3];
else
v6 = v11;
a2[11] = v6;
a2[15] = v11;
if ( *((_WORD *)CornerSubset + 1) )
v5 = v12[1];
else
v5 = v11;
a2[14] = v5;
}
else
{
a2[11] = v12[1];
a2[15] = v12[2];
a2[14] = v12[3];
}
break;
case 3:
a2[9] = *v12;
if ( (OpenSubdiv::v3_6_0::Bfr::FaceVertexSubset::IsBoundary(CornerSubset) & 1) != 0 )
{
if ( *((_WORD *)CornerSubset + 2) )
v4 = v12[3];
else
v4 = v11;
a2[13] = v4;
a2[12] = v11;
if ( *((_WORD *)CornerSubset + 1) )
v3 = v12[1];
else
v3 = v11;
a2[8] = v3;
}
else
{
a2[13] = v12[1];
a2[12] = v12[2];
a2[8] = v12[3];
}
break;
default:
break;
}
v18 += 4LL * (int)OpenSubdiv::v3_6_0::Bfr::FaceVertex::GetNumFaceVertices(CornerTopology);
result = (unsigned int)(i + 1);
}
return result;
}
| |||
63,123 |
OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(int*) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/regularPatchBuilder.cpp
|
void
RegularPatchBuilder::gatherBoundaryPatchPoints4(Index P[]) const {
Index const * fvIndices = &_surface.GetIndices()[0];
//
// For each of the 4 corners -- whether boundary or interior -- one
// incident face contains all indices that will contribute to the points
// of the corresponding patch. Identify it first and then retrieve and
// assign the indices accordingly:
//
for (int i = 0; i < 4; ++i) {
FaceVertex const & cTop = _surface.GetCornerTopology(i);
FaceVertexSubset const & cSub = _surface.GetCornerSubset(i);
int faceCorner = cTop.GetFace();
int faceOther = faceCorner;
if (!cSub.IsBoundary()) {
faceOther = cTop.GetFaceAfter(2);
} else if (cSub._numFacesAfter) {
faceOther = cTop.GetFaceNext(faceCorner);
} else if (cSub._numFacesBefore) {
faceOther = cTop.GetFacePrevious(faceCorner);
}
Index const * fvOther = fvIndices + cTop.GetFaceIndexOffset(faceOther);
Index fvPhantom = fvOther[0];
switch (i) {
case 0:
P[5] = fvOther[0];
if (!cSub.IsBoundary()) {
P[4] = fvOther[1];
P[0] = fvOther[2];
P[1] = fvOther[3];
} else {
P[4] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[0] = fvPhantom;
P[1] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 1:
P[6] = fvOther[0];
if (!cSub.IsBoundary()) {
P[2] = fvOther[1];
P[3] = fvOther[2];
P[7] = fvOther[3];
} else {
P[2] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[3] = fvPhantom;
P[7] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 2:
P[10] = fvOther[0];
if (!cSub.IsBoundary()) {
P[11] = fvOther[1];
P[15] = fvOther[2];
P[14] = fvOther[3];
} else {
P[11] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[15] = fvPhantom;
P[14] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
case 3:
P[ 9] = fvOther[0];
if (!cSub.IsBoundary()) {
P[13] = fvOther[1];
P[12] = fvOther[2];
P[ 8] = fvOther[3];
} else {
P[13] = cSub._numFacesAfter ? fvOther[3] : fvPhantom;
P[12] = fvPhantom;
P[ 8] = cSub._numFacesBefore ? fvOther[1] : fvPhantom;
}
break;
}
fvIndices += cTop.GetNumFaceVertices();
}
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(int*) const:
movq (%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
addq $0x4, %rdi
movl $0xa8, %r8d
addq 0x18(%rdx), %r8
xorl %r9d, %r9d
leaq 0x2b5d0(%rip), %r10 # 0xc1080
movswl -0xe(%r8), %eax
movslq %eax, %rdx
testb $0x1, -0x4(%rdi)
jne 0x95ad8
testb $0x1, -0xf(%r8)
jne 0x95b00
addl $0x2, %eax
movswl -0xa6(%r8), %r11d
cltd
idivl %r11d
movl %edx, %eax
jmp 0x95b37
cmpw $0x0, (%rdi)
je 0x95b0b
movswl -0x10(%r8), %r11d
btl $0x8, %r11d
jb 0x95b2f
movswl -0xa6(%r8), %edx
decl %edx
cmpl %eax, %edx
jle 0x95cb0
incl %eax
jmp 0x95b37
movq (%r8), %rax
movswq 0x2(%rax,%rdx,4), %rdx
jmp 0x95b32
cmpw $0x0, -0x2(%rdi)
je 0x95b37
movzwl -0x10(%r8), %r11d
btl $0x8, %r11d
jb 0x95cbf
testw %ax, %ax
je 0x95ccb
decl %eax
jmp 0x95b37
movq (%r8), %rax
movswl 0x2(%rax,%rdx,4), %eax
movswl -0xc(%r8), %edx
testl %edx, %edx
je 0x95b45
imull %edx, %eax
jmp 0x95b4e
movq -0x48(%r8), %rdx
cltq
movl (%rdx,%rax,4), %eax
cmpl $0x3, %r9d
ja 0x95c8e
cltq
movl (%rcx,%rax,4), %edx
movl %r9d, %r11d
movslq (%r10,%r11,4), %r11
addq %r10, %r11
jmpq *%r11
movl %edx, 0x14(%rsi)
testb $0x1, -0x4(%rdi)
jne 0x95c47
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x10(%rsi)
movl 0x8(%rcx,%rax,4), %edx
movl %edx, (%rsi)
movl 0xc(%rcx,%rax,4), %eax
movl %eax, 0x4(%rsi)
jmp 0x95c8e
movl %edx, 0x28(%rsi)
testb $0x1, -0x4(%rdi)
jne 0x95bfd
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x2c(%rsi)
movl 0x8(%rcx,%rax,4), %edx
movl %edx, 0x3c(%rsi)
movl 0xc(%rcx,%rax,4), %eax
movl %eax, 0x38(%rsi)
jmp 0x95c8e
movl %edx, 0x24(%rsi)
testb $0x1, -0x4(%rdi)
jne 0x95c22
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x34(%rsi)
movl 0x8(%rcx,%rax,4), %edx
movl %edx, 0x30(%rsi)
movl 0xc(%rcx,%rax,4), %eax
movl %eax, 0x20(%rsi)
jmp 0x95c8e
movl %edx, 0x18(%rsi)
testb $0x1, -0x4(%rdi)
jne 0x95c6b
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x8(%rsi)
movl 0x8(%rcx,%rax,4), %edx
movl %edx, 0xc(%rsi)
movl 0xc(%rcx,%rax,4), %eax
movl %eax, 0x1c(%rsi)
jmp 0x95c8e
cmpw $0x0, (%rdi)
movl %edx, %r11d
je 0x95c0b
movl 0xc(%rcx,%rax,4), %r11d
movl %r11d, 0x2c(%rsi)
movl %edx, 0x3c(%rsi)
cmpw $0x0, -0x2(%rdi)
je 0x95c1d
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x38(%rsi)
jmp 0x95c8e
cmpw $0x0, (%rdi)
movl %edx, %r11d
je 0x95c30
movl 0xc(%rcx,%rax,4), %r11d
movl %r11d, 0x34(%rsi)
movl %edx, 0x30(%rsi)
cmpw $0x0, -0x2(%rdi)
je 0x95c42
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x20(%rsi)
jmp 0x95c8e
cmpw $0x0, (%rdi)
movl %edx, %r11d
je 0x95c55
movl 0xc(%rcx,%rax,4), %r11d
movl %r11d, 0x10(%rsi)
movl %edx, (%rsi)
cmpw $0x0, -0x2(%rdi)
je 0x95c66
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x4(%rsi)
jmp 0x95c8e
cmpw $0x0, (%rdi)
movl %edx, %r11d
je 0x95c79
movl 0xc(%rcx,%rax,4), %r11d
movl %r11d, 0x8(%rsi)
movl %edx, 0xc(%rsi)
cmpw $0x0, -0x2(%rdi)
je 0x95c8b
movl 0x4(%rcx,%rax,4), %edx
movl %edx, 0x1c(%rsi)
movslq -0x8(%r8), %rax
leaq (%rcx,%rax,4), %rcx
incq %r9
addq $0xc, %rdi
addq $0xe0, %r8
cmpq $0x4, %r9
jne 0x95ab0
jmp 0x95ceb
andl $0x1, %r11d
negl %r11d
movl %r11d, %eax
jmp 0x95b37
movq (%r8), %rax
movswl (%rax,%rdx,4), %eax
jmp 0x95b37
andl $0x1, %r11d
movswl -0xa6(%r8), %edx
decl %edx
negw %r11w
movl $0x0, %eax
sbbl %eax, %eax
orl %edx, %eax
jmp 0x95b37
retq
|
_ZNK10OpenSubdiv6v3_6_03Bfr19RegularPatchBuilder26gatherBoundaryPatchPoints4EPi:
mov rax, [rdi]
mov rdx, [rax]
mov rcx, [rax+8]
mov rdi, [rax+10h]
add rdi, 4
mov r8d, 0A8h
add r8, [rdx+18h]
xor r9d, r9d
lea r10, jpt_95B67
loc_95AB0:
movsx eax, word ptr [r8-0Eh]
movsxd rdx, eax
test byte ptr [rdi-4], 1
jnz short loc_95AD8
test byte ptr [r8-0Fh], 1
jnz short loc_95B00
add eax, 2
movsx r11d, word ptr [r8-0A6h]
cdq
idiv r11d
mov eax, edx
jmp short loc_95B37
loc_95AD8:
cmp word ptr [rdi], 0
jz short loc_95B0B
movsx r11d, word ptr [r8-10h]
bt r11d, 8
jb short loc_95B2F
movsx edx, word ptr [r8-0A6h]
dec edx
cmp edx, eax
jle loc_95CB0
inc eax
jmp short loc_95B37
loc_95B00:
mov rax, [r8]
movsx rdx, word ptr [rax+rdx*4+2]
jmp short loc_95B32
loc_95B0B:
cmp word ptr [rdi-2], 0
jz short loc_95B37
movzx r11d, word ptr [r8-10h]
bt r11d, 8
jb loc_95CBF
test ax, ax
jz loc_95CCB
dec eax
jmp short loc_95B37
loc_95B2F:
mov rax, [r8]
loc_95B32:
movsx eax, word ptr [rax+rdx*4+2]
loc_95B37:
movsx edx, word ptr [r8-0Ch]
test edx, edx
jz short loc_95B45
imul eax, edx
jmp short loc_95B4E
loc_95B45:
mov rdx, [r8-48h]
cdqe
mov eax, [rdx+rax*4]
loc_95B4E:
cmp r9d, 3; switch 4 cases
ja def_95B67; jumptable 0000000000095B67 default case
cdqe
mov edx, [rcx+rax*4]
mov r11d, r9d
movsxd r11, ds:(jpt_95B67 - 0C1080h)[r10+r11*4]
add r11, r10
jmp r11; switch jump
loc_95B6A:
mov [rsi+14h], edx; jumptable 0000000000095B67 case 0
test byte ptr [rdi-4], 1
jnz loc_95C47
mov edx, [rcx+rax*4+4]
mov [rsi+10h], edx
mov edx, [rcx+rax*4+8]
mov [rsi], edx
mov eax, [rcx+rax*4+0Ch]
mov [rsi+4], eax
jmp def_95B67; jumptable 0000000000095B67 default case
loc_95B90:
mov [rsi+28h], edx; jumptable 0000000000095B67 case 2
test byte ptr [rdi-4], 1
jnz short loc_95BFD
mov edx, [rcx+rax*4+4]
mov [rsi+2Ch], edx
mov edx, [rcx+rax*4+8]
mov [rsi+3Ch], edx
mov eax, [rcx+rax*4+0Ch]
mov [rsi+38h], eax
jmp def_95B67; jumptable 0000000000095B67 default case
loc_95BB3:
mov [rsi+24h], edx; jumptable 0000000000095B67 case 3
test byte ptr [rdi-4], 1
jnz short loc_95C22
mov edx, [rcx+rax*4+4]
mov [rsi+34h], edx
mov edx, [rcx+rax*4+8]
mov [rsi+30h], edx
mov eax, [rcx+rax*4+0Ch]
mov [rsi+20h], eax
jmp def_95B67; jumptable 0000000000095B67 default case
loc_95BD6:
mov [rsi+18h], edx; jumptable 0000000000095B67 case 1
test byte ptr [rdi-4], 1
jnz loc_95C6B
mov edx, [rcx+rax*4+4]
mov [rsi+8], edx
mov edx, [rcx+rax*4+8]
mov [rsi+0Ch], edx
mov eax, [rcx+rax*4+0Ch]
mov [rsi+1Ch], eax
jmp def_95B67; jumptable 0000000000095B67 default case
loc_95BFD:
cmp word ptr [rdi], 0
mov r11d, edx
jz short loc_95C0B
mov r11d, [rcx+rax*4+0Ch]
loc_95C0B:
mov [rsi+2Ch], r11d
mov [rsi+3Ch], edx
cmp word ptr [rdi-2], 0
jz short loc_95C1D
mov edx, [rcx+rax*4+4]
loc_95C1D:
mov [rsi+38h], edx
jmp short def_95B67; jumptable 0000000000095B67 default case
loc_95C22:
cmp word ptr [rdi], 0
mov r11d, edx
jz short loc_95C30
mov r11d, [rcx+rax*4+0Ch]
loc_95C30:
mov [rsi+34h], r11d
mov [rsi+30h], edx
cmp word ptr [rdi-2], 0
jz short loc_95C42
mov edx, [rcx+rax*4+4]
loc_95C42:
mov [rsi+20h], edx
jmp short def_95B67; jumptable 0000000000095B67 default case
loc_95C47:
cmp word ptr [rdi], 0
mov r11d, edx
jz short loc_95C55
mov r11d, [rcx+rax*4+0Ch]
loc_95C55:
mov [rsi+10h], r11d
mov [rsi], edx
cmp word ptr [rdi-2], 0
jz short loc_95C66
mov edx, [rcx+rax*4+4]
loc_95C66:
mov [rsi+4], edx
jmp short def_95B67; jumptable 0000000000095B67 default case
loc_95C6B:
cmp word ptr [rdi], 0
mov r11d, edx
jz short loc_95C79
mov r11d, [rcx+rax*4+0Ch]
loc_95C79:
mov [rsi+8], r11d
mov [rsi+0Ch], edx
cmp word ptr [rdi-2], 0
jz short loc_95C8B
mov edx, [rcx+rax*4+4]
loc_95C8B:
mov [rsi+1Ch], edx
def_95B67:
movsxd rax, dword ptr [r8-8]; jumptable 0000000000095B67 default case
lea rcx, [rcx+rax*4]
inc r9
add rdi, 0Ch
add r8, 0E0h
cmp r9, 4
jnz loc_95AB0
jmp short locret_95CEB
loc_95CB0:
and r11d, 1
neg r11d
mov eax, r11d
jmp loc_95B37
loc_95CBF:
mov rax, [r8]
movsx eax, word ptr [rax+rdx*4]
jmp loc_95B37
loc_95CCB:
and r11d, 1
movsx edx, word ptr [r8-0A6h]
dec edx
neg r11w
mov eax, 0
sbb eax, eax
or eax, edx
jmp loc_95B37
locret_95CEB:
retn
|
long long OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(long long **this, int *a2)
{
long long v2; // rdx
long long v3; // rcx
_WORD *v4; // rdi
_QWORD *v5; // r8
long long i; // r9
int v7; // eax
long long v8; // rdx
__int16 v9; // r11
long long v10; // rax
__int16 v11; // r11
int v12; // eax
int v13; // edx
int v14; // r11d
int v15; // r11d
int v16; // r11d
int v17; // r11d
long long result; // rax
v2 = **this;
v3 = (*this)[1];
v4 = (_WORD *)((*this)[2] + 4);
v5 = (_QWORD *)(*(_QWORD *)(v2 + 24) + 168LL);
for ( i = 0LL; i != 4; ++i )
{
v7 = *((__int16 *)v5 - 7);
v8 = *((__int16 *)v5 - 7);
if ( (*(_BYTE *)(v4 - 2) & 1) == 0 )
{
if ( (*((_BYTE *)v5 - 15) & 1) == 0 )
{
v7 = (v7 + 2) % *((__int16 *)v5 - 83);
goto LABEL_16;
}
v10 = *v5;
v8 = *(__int16 *)(*v5 + 4 * v8 + 2);
goto LABEL_15;
}
if ( *v4 )
{
v9 = *((_WORD *)v5 - 8);
if ( (v9 & 0x100) == 0 )
{
if ( *((__int16 *)v5 - 83) - 1 <= v7 )
v7 = -(v9 & 1);
else
++v7;
goto LABEL_16;
}
v10 = *v5;
LABEL_15:
v7 = *(__int16 *)(v10 + 4 * v8 + 2);
goto LABEL_16;
}
if ( *(v4 - 1) )
{
v11 = *((_WORD *)v5 - 8);
if ( (v11 & 0x100) != 0 )
{
v7 = *(__int16 *)(*v5 + 4 * v8);
}
else if ( (_WORD)v7 )
{
--v7;
}
else
{
v7 = (v11 & 1) != 0 ? -1 : *((__int16 *)v5 - 83) - 1;
}
}
LABEL_16:
if ( *((_WORD *)v5 - 6) )
v12 = *((__int16 *)v5 - 6) * v7;
else
v12 = *(_DWORD *)(*(v5 - 9) + 4LL * v7);
v13 = *(_DWORD *)(v3 + 4LL * v12);
switch ( (int)i )
{
case 0:
a2[5] = v13;
if ( (*(_BYTE *)(v4 - 2) & 1) != 0 )
{
v16 = v13;
if ( *v4 )
v16 = *(_DWORD *)(v3 + 4LL * v12 + 12);
a2[4] = v16;
*a2 = v13;
if ( *(v4 - 1) )
v13 = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[1] = v13;
}
else
{
a2[4] = *(_DWORD *)(v3 + 4LL * v12 + 4);
*a2 = *(_DWORD *)(v3 + 4LL * v12 + 8);
a2[1] = *(_DWORD *)(v3 + 4LL * v12 + 12);
}
break;
case 1:
a2[6] = v13;
if ( (*(_BYTE *)(v4 - 2) & 1) != 0 )
{
v17 = v13;
if ( *v4 )
v17 = *(_DWORD *)(v3 + 4LL * v12 + 12);
a2[2] = v17;
a2[3] = v13;
if ( *(v4 - 1) )
v13 = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[7] = v13;
}
else
{
a2[2] = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[3] = *(_DWORD *)(v3 + 4LL * v12 + 8);
a2[7] = *(_DWORD *)(v3 + 4LL * v12 + 12);
}
break;
case 2:
a2[10] = v13;
if ( (*(_BYTE *)(v4 - 2) & 1) != 0 )
{
v14 = v13;
if ( *v4 )
v14 = *(_DWORD *)(v3 + 4LL * v12 + 12);
a2[11] = v14;
a2[15] = v13;
if ( *(v4 - 1) )
v13 = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[14] = v13;
}
else
{
a2[11] = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[15] = *(_DWORD *)(v3 + 4LL * v12 + 8);
a2[14] = *(_DWORD *)(v3 + 4LL * v12 + 12);
}
break;
case 3:
a2[9] = v13;
if ( (*(_BYTE *)(v4 - 2) & 1) != 0 )
{
v15 = v13;
if ( *v4 )
v15 = *(_DWORD *)(v3 + 4LL * v12 + 12);
a2[13] = v15;
a2[12] = v13;
if ( *(v4 - 1) )
v13 = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[8] = v13;
}
else
{
a2[13] = *(_DWORD *)(v3 + 4LL * v12 + 4);
a2[12] = *(_DWORD *)(v3 + 4LL * v12 + 8);
a2[8] = *(_DWORD *)(v3 + 4LL * v12 + 12);
}
break;
default:
break;
}
result = *((int *)v5 - 2);
v3 += 4 * result;
v4 += 6;
v5 += 28;
}
return result;
}
|
gatherBoundaryPatchPoints4:
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX + 0x10]
ADD RDI,0x4
MOV R8D,0xa8
ADD R8,qword ptr [RDX + 0x18]
XOR R9D,R9D
LEA R10,[0x1c1080]
LAB_00195ab0:
MOVSX EAX,word ptr [R8 + -0xe]
MOVSXD RDX,EAX
TEST byte ptr [RDI + -0x4],0x1
JNZ 0x00195ad8
TEST byte ptr [R8 + -0xf],0x1
JNZ 0x00195b00
ADD EAX,0x2
MOVSX R11D,word ptr [R8 + -0xa6]
CDQ
IDIV R11D
MOV EAX,EDX
JMP 0x00195b37
LAB_00195ad8:
CMP word ptr [RDI],0x0
JZ 0x00195b0b
MOVSX R11D,word ptr [R8 + -0x10]
BT R11D,0x8
JC 0x00195b2f
MOVSX EDX,word ptr [R8 + -0xa6]
DEC EDX
CMP EDX,EAX
JLE 0x00195cb0
INC EAX
JMP 0x00195b37
LAB_00195b00:
MOV RAX,qword ptr [R8]
MOVSX RDX,word ptr [RAX + RDX*0x4 + 0x2]
JMP 0x00195b32
LAB_00195b0b:
CMP word ptr [RDI + -0x2],0x0
JZ 0x00195b37
MOVZX R11D,word ptr [R8 + -0x10]
BT R11D,0x8
JC 0x00195cbf
TEST AX,AX
JZ 0x00195ccb
DEC EAX
JMP 0x00195b37
LAB_00195b2f:
MOV RAX,qword ptr [R8]
LAB_00195b32:
MOVSX EAX,word ptr [RAX + RDX*0x4 + 0x2]
LAB_00195b37:
MOVSX EDX,word ptr [R8 + -0xc]
TEST EDX,EDX
JZ 0x00195b45
IMUL EAX,EDX
JMP 0x00195b4e
LAB_00195b45:
MOV RDX,qword ptr [R8 + -0x48]
CDQE
MOV EAX,dword ptr [RDX + RAX*0x4]
LAB_00195b4e:
CMP R9D,0x3
JA 0x00195c8e
CDQE
MOV EDX,dword ptr [RCX + RAX*0x4]
MOV R11D,R9D
MOVSXD R11,dword ptr [R10 + R11*0x4]
ADD R11,R10
switchD:
JMP R11
caseD_0:
MOV dword ptr [RSI + 0x14],EDX
TEST byte ptr [RDI + -0x4],0x1
JNZ 0x00195c47
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RSI + 0x10],EDX
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x8]
MOV dword ptr [RSI],EDX
MOV EAX,dword ptr [RCX + RAX*0x4 + 0xc]
MOV dword ptr [RSI + 0x4],EAX
JMP 0x00195c8e
caseD_2:
MOV dword ptr [RSI + 0x28],EDX
TEST byte ptr [RDI + -0x4],0x1
JNZ 0x00195bfd
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RSI + 0x2c],EDX
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x8]
MOV dword ptr [RSI + 0x3c],EDX
MOV EAX,dword ptr [RCX + RAX*0x4 + 0xc]
MOV dword ptr [RSI + 0x38],EAX
JMP 0x00195c8e
caseD_3:
MOV dword ptr [RSI + 0x24],EDX
TEST byte ptr [RDI + -0x4],0x1
JNZ 0x00195c22
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RSI + 0x34],EDX
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x8]
MOV dword ptr [RSI + 0x30],EDX
MOV EAX,dword ptr [RCX + RAX*0x4 + 0xc]
MOV dword ptr [RSI + 0x20],EAX
JMP 0x00195c8e
caseD_1:
MOV dword ptr [RSI + 0x18],EDX
TEST byte ptr [RDI + -0x4],0x1
JNZ 0x00195c6b
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV dword ptr [RSI + 0x8],EDX
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x8]
MOV dword ptr [RSI + 0xc],EDX
MOV EAX,dword ptr [RCX + RAX*0x4 + 0xc]
MOV dword ptr [RSI + 0x1c],EAX
JMP 0x00195c8e
LAB_00195bfd:
CMP word ptr [RDI],0x0
MOV R11D,EDX
JZ 0x00195c0b
MOV R11D,dword ptr [RCX + RAX*0x4 + 0xc]
LAB_00195c0b:
MOV dword ptr [RSI + 0x2c],R11D
MOV dword ptr [RSI + 0x3c],EDX
CMP word ptr [RDI + -0x2],0x0
JZ 0x00195c1d
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_00195c1d:
MOV dword ptr [RSI + 0x38],EDX
JMP 0x00195c8e
LAB_00195c22:
CMP word ptr [RDI],0x0
MOV R11D,EDX
JZ 0x00195c30
MOV R11D,dword ptr [RCX + RAX*0x4 + 0xc]
LAB_00195c30:
MOV dword ptr [RSI + 0x34],R11D
MOV dword ptr [RSI + 0x30],EDX
CMP word ptr [RDI + -0x2],0x0
JZ 0x00195c42
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_00195c42:
MOV dword ptr [RSI + 0x20],EDX
JMP 0x00195c8e
LAB_00195c47:
CMP word ptr [RDI],0x0
MOV R11D,EDX
JZ 0x00195c55
MOV R11D,dword ptr [RCX + RAX*0x4 + 0xc]
LAB_00195c55:
MOV dword ptr [RSI + 0x10],R11D
MOV dword ptr [RSI],EDX
CMP word ptr [RDI + -0x2],0x0
JZ 0x00195c66
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_00195c66:
MOV dword ptr [RSI + 0x4],EDX
JMP 0x00195c8e
LAB_00195c6b:
CMP word ptr [RDI],0x0
MOV R11D,EDX
JZ 0x00195c79
MOV R11D,dword ptr [RCX + RAX*0x4 + 0xc]
LAB_00195c79:
MOV dword ptr [RSI + 0x8],R11D
MOV dword ptr [RSI + 0xc],EDX
CMP word ptr [RDI + -0x2],0x0
JZ 0x00195c8b
MOV EDX,dword ptr [RCX + RAX*0x4 + 0x4]
LAB_00195c8b:
MOV dword ptr [RSI + 0x1c],EDX
LAB_00195c8e:
MOVSXD RAX,dword ptr [R8 + -0x8]
LEA RCX,[RCX + RAX*0x4]
INC R9
ADD RDI,0xc
ADD R8,0xe0
CMP R9,0x4
JNZ 0x00195ab0
JMP 0x00195ceb
LAB_00195cb0:
AND R11D,0x1
NEG R11D
MOV EAX,R11D
JMP 0x00195b37
LAB_00195cbf:
MOV RAX,qword ptr [R8]
MOVSX EAX,word ptr [RAX + RDX*0x4]
JMP 0x00195b37
LAB_00195ccb:
AND R11D,0x1
MOVSX EDX,word ptr [R8 + -0xa6]
DEC EDX
NEG R11W
MOV EAX,0x0
SBB EAX,EAX
OR EAX,EDX
JMP 0x00195b37
LAB_00195ceb:
RET
|
/* OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4(int*) const */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::RegularPatchBuilder::gatherBoundaryPatchPoints4
(RegularPatchBuilder *this,int *param_1)
{
uint uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
short *psVar6;
long *plVar7;
ulong uVar8;
int iVar9;
plVar7 = *(long **)this;
lVar4 = plVar7[1];
psVar6 = (short *)(plVar7[2] + 4);
plVar7 = (long *)(*(long *)(*plVar7 + 0x18) + 0xa8);
uVar8 = 0;
do {
uVar1 = (uint)*(short *)((long)plVar7 + -0xe);
lVar5 = (long)(int)uVar1;
if ((*(byte *)(psVar6 + -2) & 1) == 0) {
if ((*plVar7 & 0x100) == 0) {
uVar1 = (int)(uVar1 + 2) % (int)*(short *)((long)plVar7 + -0xa6);
}
else {
lVar3 = *plVar7;
lVar5 = (long)*(short *)(lVar3 + 2 + lVar5 * 4);
LAB_00195b32:
uVar1 = (uint)*(short *)(lVar3 + 2 + lVar5 * 4);
}
}
else if (*psVar6 == 0) {
if (psVar6[-1] != 0) {
if ((*(ushort *)(plVar7 + -2) >> 8 & 1) == 0) {
if (*(short *)((long)plVar7 + -0xe) == 0) {
uVar1 = -(uint)((*(ushort *)(plVar7 + -2) & 1) != 0) |
(int)*(short *)((long)plVar7 + -0xa6) - 1U;
}
else {
uVar1 = uVar1 - 1;
}
}
else {
uVar1 = (uint)*(short *)(*plVar7 + lVar5 * 4);
}
}
}
else {
if (((uint)(int)(short)plVar7[-2] >> 8 & 1) != 0) {
lVar3 = *plVar7;
goto LAB_00195b32;
}
if ((int)uVar1 < *(short *)((long)plVar7 + -0xa6) + -1) {
uVar1 = uVar1 + 1;
}
else {
uVar1 = -((int)(short)plVar7[-2] & 1U);
}
}
if (*(short *)((long)plVar7 + -0xc) == 0) {
iVar2 = *(int *)(plVar7[-9] + (long)(int)uVar1 * 4);
}
else {
iVar2 = uVar1 * (int)*(short *)((long)plVar7 + -0xc);
}
if ((uint)uVar8 < 4) {
lVar5 = (long)iVar2;
iVar2 = *(int *)(lVar4 + lVar5 * 4);
switch(uVar8 & 0xffffffff) {
case 0:
param_1[5] = iVar2;
if ((*(byte *)(psVar6 + -2) & 1) == 0) {
param_1[4] = *(int *)(lVar4 + 4 + lVar5 * 4);
*param_1 = *(int *)(lVar4 + 8 + lVar5 * 4);
param_1[1] = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
else {
iVar9 = iVar2;
if (*psVar6 != 0) {
iVar9 = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
param_1[4] = iVar9;
*param_1 = iVar2;
if (psVar6[-1] != 0) {
iVar2 = *(int *)(lVar4 + 4 + lVar5 * 4);
}
param_1[1] = iVar2;
}
break;
case 1:
param_1[6] = iVar2;
if ((*(byte *)(psVar6 + -2) & 1) == 0) {
param_1[2] = *(int *)(lVar4 + 4 + lVar5 * 4);
param_1[3] = *(int *)(lVar4 + 8 + lVar5 * 4);
param_1[7] = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
else {
iVar9 = iVar2;
if (*psVar6 != 0) {
iVar9 = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
param_1[2] = iVar9;
param_1[3] = iVar2;
if (psVar6[-1] != 0) {
iVar2 = *(int *)(lVar4 + 4 + lVar5 * 4);
}
param_1[7] = iVar2;
}
break;
case 2:
param_1[10] = iVar2;
if ((*(byte *)(psVar6 + -2) & 1) == 0) {
param_1[0xb] = *(int *)(lVar4 + 4 + lVar5 * 4);
param_1[0xf] = *(int *)(lVar4 + 8 + lVar5 * 4);
param_1[0xe] = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
else {
iVar9 = iVar2;
if (*psVar6 != 0) {
iVar9 = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
param_1[0xb] = iVar9;
param_1[0xf] = iVar2;
if (psVar6[-1] != 0) {
iVar2 = *(int *)(lVar4 + 4 + lVar5 * 4);
}
param_1[0xe] = iVar2;
}
break;
case 3:
param_1[9] = iVar2;
if ((*(byte *)(psVar6 + -2) & 1) == 0) {
param_1[0xd] = *(int *)(lVar4 + 4 + lVar5 * 4);
param_1[0xc] = *(int *)(lVar4 + 8 + lVar5 * 4);
param_1[8] = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
else {
iVar9 = iVar2;
if (*psVar6 != 0) {
iVar9 = *(int *)(lVar4 + 0xc + lVar5 * 4);
}
param_1[0xd] = iVar9;
param_1[0xc] = iVar2;
if (psVar6[-1] != 0) {
iVar2 = *(int *)(lVar4 + 4 + lVar5 * 4);
}
param_1[8] = iVar2;
}
}
}
lVar4 = lVar4 + (long)(int)plVar7[-1] * 4;
uVar8 = uVar8 + 1;
psVar6 = psVar6 + 6;
plVar7 = plVar7 + 0x1c;
if (uVar8 == 4) {
return;
}
} while( true );
}
|
|
63,124 |
lunasvg::SVGBlendInfo::SVGBlendInfo(lunasvg::SVGElement const*)
|
dmazzella[P]pylunasvg/lunasvg/source/svgelement.h
|
float opacity() const { return m_opacity; }
|
O1
|
c
|
lunasvg::SVGBlendInfo::SVGBlendInfo(lunasvg::SVGElement const*):
movq 0x28(%rsi), %rax
movq %rax, (%rdi)
movq 0x30(%rsi), %rax
movq %rax, 0x8(%rdi)
movss 0x38(%rsi), %xmm0
movss %xmm0, 0x10(%rdi)
retq
|
_ZN7lunasvg12SVGBlendInfoC2EPKNS_10SVGElementE:
mov rax, [rsi+28h]
mov [rdi], rax
mov rax, [rsi+30h]
mov [rdi+8], rax
movss xmm0, dword ptr [rsi+38h]
movss dword ptr [rdi+10h], xmm0
retn
|
long long lunasvg::SVGBlendInfo::SVGBlendInfo(lunasvg::SVGBlendInfo *this, const lunasvg::SVGElement *a2)
{
long long result; // rax
*(_QWORD *)this = *((_QWORD *)a2 + 5);
result = *((_QWORD *)a2 + 6);
*((_QWORD *)this + 1) = result;
*((_DWORD *)this + 4) = *((_DWORD *)a2 + 14);
return result;
}
|
SVGBlendInfo:
MOV RAX,qword ptr [RSI + 0x28]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI + 0x30]
MOV qword ptr [RDI + 0x8],RAX
MOVSS XMM0,dword ptr [RSI + 0x38]
MOVSS dword ptr [RDI + 0x10],XMM0
RET
|
/* lunasvg::SVGBlendInfo::SVGBlendInfo(lunasvg::SVGElement const*) */
void __thiscall lunasvg::SVGBlendInfo::SVGBlendInfo(SVGBlendInfo *this,SVGElement *param_1)
{
*(int8 *)this = *(int8 *)(param_1 + 0x28);
*(int8 *)(this + 8) = *(int8 *)(param_1 + 0x30);
*(int4 *)(this + 0x10) = *(int4 *)(param_1 + 0x38);
return;
}
|
|
63,125 |
change_victim
|
eloqsql/mysys/waiting_threads.c
|
static void change_victim(WT_THD* found, struct deadlock_arg *arg)
{
if (found->weight < arg->victim->weight)
{
if (arg->victim != arg->thd)
{
rc_unlock(arg->victim->waiting_for); /* release the previous victim */
DBUG_ASSERT(arg->last_locked_rc == found->waiting_for);
}
arg->victim= found;
arg->last_locked_rc= 0;
}
}
|
O3
|
c
|
change_victim:
movq 0x58(%rdi), %rcx
movq 0x10(%rsi), %rax
cmpq 0x58(%rax), %rcx
jae 0xa7462
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq (%rsi), %rax
je 0xa7452
movq 0x28(%rax), %rdi
addq $0x18, %rdi
callq 0xa4476
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
|
change_victim:
mov rcx, [rdi+58h]
mov rax, [rsi+10h]
cmp rcx, [rax+58h]
jnb short locret_A7462
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
cmp rax, [rsi]
jz short loc_A7452
mov rdi, [rax+28h]
add rdi, 18h
call my_rw_unlock
loc_A7452:
mov [rbx+10h], r14
mov qword ptr [rbx+18h], 0
pop rbx
pop r14
pop rbp
locret_A7462:
retn
|
long long change_victim(long long a1, _QWORD *a2)
{
long long result; // rax
result = a2[2];
if ( *(_QWORD *)(a1 + 88) < *(_QWORD *)(result + 88) )
{
if ( result != *a2 )
result = my_rw_unlock(*(_QWORD *)(result + 40) + 24LL);
a2[2] = a1;
a2[3] = 0LL;
}
return result;
}
|
change_victim:
MOV RCX,qword ptr [RDI + 0x58]
MOV RAX,qword ptr [RSI + 0x10]
CMP RCX,qword ptr [RAX + 0x58]
JNC 0x001a7462
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CMP RAX,qword ptr [RSI]
JZ 0x001a7452
MOV RDI,qword ptr [RAX + 0x28]
ADD RDI,0x18
CALL 0x001a4476
LAB_001a7452:
MOV qword ptr [RBX + 0x10],R14
MOV qword ptr [RBX + 0x18],0x0
POP RBX
POP R14
POP RBP
LAB_001a7462:
RET
|
void change_victim(long param_1,long *param_2)
{
long lVar1;
lVar1 = param_2[2];
if (*(ulong *)(param_1 + 0x58) < *(ulong *)(lVar1 + 0x58)) {
if (lVar1 != *param_2) {
my_rw_unlock(*(long *)(lVar1 + 0x28) + 0x18);
}
param_2[2] = param_1;
param_2[3] = 0;
}
return;
}
|
|
63,126 |
my_l10tostr_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_l10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *db, *de;
long int new_val;
int sl= 0;
unsigned long int uval = (unsigned long int) val;
p= &buffer[sizeof(buffer) - 1];
*p= '\0';
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val= new_val;
while (val != 0)
{
new_val= val / 10;
*--p= '0' + (char) (val - new_val * 10);
val= new_val;
}
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst - db);
}
|
O3
|
c
|
my_l10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %r13
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %dil
orb %al, %dil
movq %r8, %rsi
negq %rsi
testb %dil, %dil
cmovneq %r8, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
movq %rdx, %rcx
movb $0x0, 0x1(%r13)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %esi, %eax
addb $0x30, %al
movb %al, (%r13)
cmpq $0xa, %rsi
jb 0xcbe66
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r13)
decq %r13
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0xcbe42
testb %dil, %dil
jne 0xcbe73
movb $0x2d, -0x1(%r13)
decq %r13
movq %rbx, %r12
testq %r14, %r14
jle 0xcbeaf
addq %rbx, %r14
movq %rbx, %r12
movsbq (%r13), %rsi
testq %rsi, %rsi
je 0xcbeaf
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *0x30(%rax)
testl %eax, %eax
jle 0xcbeaf
movl %eax, %eax
addq %rax, %r12
incq %r13
cmpq %r14, %r12
jb 0xcbe81
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xcbed3
subl %ebx, %r12d
movslq %r12d, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
|
my_l10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_40]
test ecx, ecx
setns al
test r8, r8
setns dil
or dil, al
mov rsi, r8
neg rsi
test dil, dil
cmovnz rsi, r8
mov r8, 0CCCCCCCCCCCCCCCDh
mov rax, rsi
mul r8
mov rcx, rdx
mov byte ptr [r13+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, esi
add al, 30h ; '0'
mov [r13+0], al
cmp rsi, 0Ah
jb short loc_CBE66
loc_CBE42:
mov rax, rcx
mul r8
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r13-1], al
dec r13
cmp rcx, 9
mov rcx, rdx
ja short loc_CBE42
loc_CBE66:
test dil, dil
jnz short loc_CBE73
mov byte ptr [r13-1], 2Dh ; '-'
dec r13
loc_CBE73:
mov r12, rbx
test r14, r14
jle short loc_CBEAF
add r14, rbx
mov r12, rbx
loc_CBE81:
movsx rsi, byte ptr [r13+0]
test rsi, rsi
jz short loc_CBEAF
mov rax, [r15+0B8h]
mov rdi, r15
mov rdx, r12
mov rcx, r14
call qword ptr [rax+30h]
test eax, eax
jle short loc_CBEAF
mov eax, eax
add r12, rax
inc r13
cmp r12, r14
jb short loc_CBE81
loc_CBEAF:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_CBED3
sub r12d, ebx
movsxd rax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CBED3:
call ___stack_chk_fail
|
long long my_l10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, signed long long a5)
{
_BYTE *v7; // r13
bool v8; // di
unsigned long long v9; // rsi
unsigned long long v10; // rcx
bool v11; // cc
unsigned long long v12; // r12
unsigned long long v13; // r14
int v14; // eax
_BYTE v16[16]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v17; // [rsp+50h] [rbp-30h]
v17 = __readfsqword(0x28u);
v7 = v16;
v8 = a4 >= 0 || a5 >= 0;
v9 = -a5;
if ( v8 )
v9 = a5;
v16[1] = 0;
v10 = v9 / 0xA;
v16[0] = v9 % 0xA + 48;
if ( v9 >= 0xA )
{
do
{
*--v7 = v10 % 0xA + 48;
v11 = v10 <= 9;
v10 /= 0xAuLL;
}
while ( !v11 );
}
if ( !v8 )
*--v7 = 45;
LODWORD(v12) = a2;
if ( a3 > 0 )
{
v13 = a2 + a3;
v12 = a2;
do
{
if ( !*v7 )
break;
v14 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
(char)*v7,
v12,
v13);
if ( v14 <= 0 )
break;
v12 += (unsigned int)v14;
++v7;
}
while ( v12 < v13 );
}
return (int)v12 - (int)a2;
}
|
my_l10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0x40]
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS DIL
OR DIL,AL
MOV RSI,R8
NEG RSI
TEST DIL,DIL
CMOVNZ RSI,R8
MOV R8,-0x3333333333333333
MOV RAX,RSI
MUL R8
MOV RCX,RDX
MOV byte ptr [R13 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,ESI
ADD AL,0x30
MOV byte ptr [R13],AL
CMP RSI,0xa
JC 0x001cbe66
LAB_001cbe42:
MOV RAX,RCX
MUL R8
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R13 + -0x1],AL
DEC R13
CMP RCX,0x9
MOV RCX,RDX
JA 0x001cbe42
LAB_001cbe66:
TEST DIL,DIL
JNZ 0x001cbe73
MOV byte ptr [R13 + -0x1],0x2d
DEC R13
LAB_001cbe73:
MOV R12,RBX
TEST R14,R14
JLE 0x001cbeaf
ADD R14,RBX
MOV R12,RBX
LAB_001cbe81:
MOVSX RSI,byte ptr [R13]
TEST RSI,RSI
JZ 0x001cbeaf
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RAX + 0x30]
TEST EAX,EAX
JLE 0x001cbeaf
MOV EAX,EAX
ADD R12,RAX
INC R13
CMP R12,R14
JC 0x001cbe81
LAB_001cbeaf:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001cbed3
SUB R12D,EBX
MOVSXD RAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cbed3:
CALL 0x0012a240
|
long my_l10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
ulong uVar1;
ulong uVar2;
uint uVar3;
ulong uVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_49 [17];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_49 + 1;
uVar4 = -param_5;
if ((long)param_5 >= 0 || param_4 >= 0) {
uVar4 = param_5;
}
local_49[2] = 0;
local_49[1] = (char)(uVar4 / 10) * -10 + (char)uVar4 + '0';
uVar2 = uVar4 / 10;
while (uVar1 = uVar2, 9 < uVar4) {
pcVar5[-1] = (char)(uVar1 / 10) * -10 + (char)uVar1 + '0';
pcVar5 = pcVar5 + -1;
uVar2 = uVar1 / 10;
uVar4 = uVar1;
}
if ((long)param_5 < 0 && param_4 < 0) {
pcVar5[-1] = '-';
pcVar5 = pcVar5 + -1;
}
uVar4 = param_2;
if (0 < param_3) {
do {
if (((long)*pcVar5 == 0) ||
(uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*pcVar5,uVar4,param_3 + param_2), (int)uVar3 < 1)) break;
uVar4 = uVar4 + uVar3;
pcVar5 = pcVar5 + 1;
} while (uVar4 < param_3 + param_2);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)((int)uVar4 - (int)param_2);
}
|
|
63,127 |
js_create_resolving_functions
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_create_resolving_functions(JSContext *ctx,
JSValue *resolving_funcs,
JSValue promise)
{
JSValue obj;
JSPromiseFunctionData *s;
JSPromiseFunctionDataResolved *sr;
int i, ret;
sr = js_malloc(ctx, sizeof(*sr));
if (!sr)
return -1;
sr->ref_count = 1;
sr->already_resolved = FALSE; /* must be shared between the two functions */
ret = 0;
for(i = 0; i < 2; i++) {
obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_PROMISE_RESOLVE_FUNCTION + i);
if (JS_IsException(obj))
goto fail;
s = js_malloc(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, obj);
fail:
if (i != 0)
JS_FreeValue(ctx, resolving_funcs[0]);
ret = -1;
break;
}
sr->ref_count++;
s->presolved = sr;
s->promise = js_dup(promise);
JS_SetOpaqueInternal(obj, s);
js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
resolving_funcs[i] = obj;
}
js_promise_resolve_function_free_resolved(ctx->rt, sr);
return ret;
}
|
O1
|
c
|
js_create_resolving_functions:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0xede6
testq %rax, %rax
je 0x11901
movq %rax, %r14
movq $0x1, (%rax)
movq %r15, 0x18(%rsp)
leaq 0x8(%r15), %r13
xorl %r12d, %r12d
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movl %r12d, %ecx
orl $0x32, %ecx
movq %rbx, %rdi
callq 0x20f05
movq %rdx, %rbp
cmpl $0x6, %ebp
je 0x11915
movq %rax, %r15
movq %rbx, %rdi
pushq $0x18
popq %rsi
callq 0xede6
testq %rax, %rax
je 0x11906
incl (%r14)
movq %r14, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
cmpl $-0x9, 0x10(%rsp)
jb 0x118ba
movq 0x20(%rsp), %rcx
incl (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
pushq $0x2f
popq %rcx
pushq $0x1
popq %r8
callq 0x211fc
movq %r15, -0x8(%r13)
movq %rbp, (%r13)
incq %r12
addq $0x10, %r13
cmpq $0x1, %r12
je 0x11866
xorl %ebp, %ebp
jmp 0x11932
pushq $-0x1
popq %rbp
jmp 0x1193e
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1d8c6
pushq $-0x1
popq %rbp
testq %r12, %r12
je 0x11932
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x52b4e
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_create_resolving_functions:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_48], rcx
mov [rsp+58h+var_50], rdx
mov r15, rsi
mov rbx, rdi
push 8
pop rsi
call js_malloc
test rax, rax
jz loc_11901
mov r14, rax
mov qword ptr [rax], 1
mov [rsp+58h+var_40], r15
lea r13, [r15+8]
xor r12d, r12d
loc_11866:
mov rsi, [rbx+48h]
mov rdx, [rbx+50h]
mov ecx, r12d
or ecx, 32h
mov rdi, rbx
call JS_NewObjectProtoClass
mov rbp, rdx
cmp ebp, 6
jz loc_11915
mov r15, rax
mov rdi, rbx
push 18h
pop rsi
call js_malloc
test rax, rax
jz short loc_11906
inc dword ptr [r14]
mov [rax+10h], r14
mov rcx, [rsp+58h+var_50]
mov [rsp+58h+var_38], rcx
cmp dword ptr [rsp+58h+var_48], 0FFFFFFF7h
jb short loc_118BA
mov rcx, [rsp+58h+var_38]
inc dword ptr [rcx]
loc_118BA:
mov rcx, [rsp+58h+var_50]
mov [rax], rcx
mov rcx, [rsp+58h+var_48]
mov [rax+8], rcx
mov [r15+30h], rax
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
push 2Fh ; '/'
pop rcx
push 1
pop r8
call js_function_set_properties
mov [r13-8], r15
mov [r13+0], rbp
inc r12
add r13, 10h
cmp r12, 1
jz loc_11866
xor ebp, ebp
jmp short loc_11932
loc_11901:
push 0FFFFFFFFFFFFFFFFh
pop rbp
jmp short loc_1193E
loc_11906:
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, rbp
call JS_FreeValueRT
loc_11915:
push 0FFFFFFFFFFFFFFFFh
pop rbp
test r12, r12
jz short loc_11932
mov rax, [rsp+58h+var_40]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, [rbx+18h]
call JS_FreeValueRT
loc_11932:
mov rdi, [rbx+18h]
mov rsi, r14
call js_promise_resolve_function_free_resolved
loc_1193E:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_create_resolving_functions(_QWORD *a1, _QWORD *a2, _DWORD *a3, long long a4)
{
_QWORD *v4; // rax
_DWORD *v5; // r14
_QWORD *v6; // r13
long long v7; // r12
long long v8; // rax
long long v9; // rdx
long long v10; // rbp
long long v11; // r15
_QWORD *v12; // rax
unsigned int v13; // ebp
v4 = (_QWORD *)js_malloc((long long)a1, 8LL);
if ( v4 )
{
v5 = v4;
*v4 = 1LL;
v6 = a2 + 1;
v7 = 0LL;
while ( 1 )
{
v8 = JS_NewObjectProtoClass(a1, a1[9], a1[10], (unsigned int)v7 | 0x32);
v10 = v9;
if ( (_DWORD)v9 == 6 )
break;
v11 = v8;
v12 = (_QWORD *)js_malloc((long long)a1, 24LL);
if ( !v12 )
{
JS_FreeValueRT(a1[3], v11);
break;
}
++*v5;
v12[2] = v5;
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
*v12 = a3;
v12[1] = a4;
*(_QWORD *)(v11 + 48) = v12;
js_function_set_properties(a1, v11, v10, 47LL, 1LL);
*(v6 - 1) = v11;
*v6 = v10;
++v7;
v6 += 2;
if ( v7 != 1 )
{
v13 = 0;
goto LABEL_13;
}
}
v13 = -1;
if ( v7 )
JS_FreeValueRT(a1[3], *a2);
LABEL_13:
js_promise_resolve_function_free_resolved(a1[3], v5);
}
else
{
return (unsigned int)-1;
}
return v13;
}
| |||
63,128 |
js_create_resolving_functions
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_create_resolving_functions(JSContext *ctx,
JSValue *resolving_funcs,
JSValue promise)
{
JSValue obj;
JSPromiseFunctionData *s;
JSPromiseFunctionDataResolved *sr;
int i, ret;
sr = js_malloc(ctx, sizeof(*sr));
if (!sr)
return -1;
sr->ref_count = 1;
sr->already_resolved = FALSE; /* must be shared between the two functions */
ret = 0;
for(i = 0; i < 2; i++) {
obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_PROMISE_RESOLVE_FUNCTION + i);
if (JS_IsException(obj))
goto fail;
s = js_malloc(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, obj);
fail:
if (i != 0)
JS_FreeValue(ctx, resolving_funcs[0]);
ret = -1;
break;
}
sr->ref_count++;
s->presolved = sr;
s->promise = js_dup(promise);
JS_SetOpaqueInternal(obj, s);
js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
resolving_funcs[i] = obj;
}
js_promise_resolve_function_free_resolved(ctx->rt, sr);
return ret;
}
|
O2
|
c
|
js_create_resolving_functions:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x17214
testq %rax, %rax
je 0x47412
movq %rax, (%rsp)
movq $0x1, (%rax)
movq %r14, 0x10(%rsp)
addq $0x8, %r14
xorl %ebp, %ebp
cmpq $0x2, %rbp
je 0x47418
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movl %ebp, %ecx
orl $0x32, %ecx
movq %rbx, %rdi
callq 0x1b069
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x4742f
movq %rax, %r12
movq %rbx, %rdi
pushq $0x18
popq %rsi
callq 0x17214
testq %rax, %rax
je 0x47421
movq (%rsp), %rcx
incl (%rcx)
movq %rcx, 0x10(%rax)
cmpl $-0x9, %r13d
jb 0x473d9
movq 0x8(%rsp), %rcx
incl (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq %rax, 0x30(%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
pushq $0x2f
popq %rcx
pushq $0x1
popq %r8
callq 0x1b4ad
movq %r12, -0x8(%r14)
movq %r15, (%r14)
incq %rbp
addq $0x10, %r14
jmp 0x47383
pushq $-0x1
popq %r15
jmp 0x4745c
movq (%rsp), %r14
xorl %r15d, %r15d
jmp 0x47450
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1801e
pushq $-0x1
popq %r15
testq %rbp, %rbp
movq (%rsp), %r14
je 0x47450
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x1801e
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x46f56
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_create_resolving_functions:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov [rsp+48h+var_40], rdx
mov r14, rsi
mov rbx, rdi
push 8
pop rsi
call js_malloc
test rax, rax
jz loc_47412
mov [rsp+48h+var_48], rax
mov qword ptr [rax], 1
mov [rsp+48h+var_38], r14
add r14, 8
xor ebp, ebp
loc_47383:
cmp rbp, 2
jz loc_47418
mov rsi, [rbx+48h]
mov rdx, [rbx+50h]
mov ecx, ebp
or ecx, 32h
mov rdi, rbx
call JS_NewObjectProtoClass
mov r15, rdx
cmp r15d, 6
jz loc_4742F
mov r12, rax
mov rdi, rbx
push 18h
pop rsi
call js_malloc
test rax, rax
jz short loc_47421
mov rcx, [rsp+48h+var_48]
inc dword ptr [rcx]
mov [rax+10h], rcx
cmp r13d, 0FFFFFFF7h
jb short loc_473D9
mov rcx, [rsp+48h+var_40]
inc dword ptr [rcx]
loc_473D9:
mov rcx, [rsp+48h+var_40]
mov [rax], rcx
mov [rax+8], r13
mov [r12+30h], rax
mov rdi, rbx
mov rsi, r12
mov rdx, r15
push 2Fh ; '/'
pop rcx
push 1
pop r8
call js_function_set_properties
mov [r14-8], r12
mov [r14], r15
inc rbp
add r14, 10h
jmp loc_47383
loc_47412:
push 0FFFFFFFFFFFFFFFFh
pop r15
jmp short loc_4745C
loc_47418:
mov r14, [rsp+48h+var_48]
xor r15d, r15d
jmp short loc_47450
loc_47421:
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call JS_FreeValue
loc_4742F:
push 0FFFFFFFFFFFFFFFFh
pop r15
test rbp, rbp
mov r14, [rsp+48h+var_48]
jz short loc_47450
mov rax, [rsp+48h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, rbx
call JS_FreeValue
loc_47450:
mov rdi, [rbx+18h]
mov rsi, r14
call js_promise_resolve_function_free_resolved
loc_4745C:
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_create_resolving_functions(long long *a1, long long *a2, _DWORD *a3, long long a4)
{
_QWORD *v5; // rax
long long *v6; // r14
long long i; // rbp
long long v8; // rax
long long v9; // rdx
long long v10; // r15
long long v11; // r12
_QWORD *v12; // rax
unsigned int v13; // r15d
long long v14; // r14
_DWORD *v16; // [rsp+0h] [rbp-48h]
v5 = (_QWORD *)js_malloc((long long)a1, 8LL);
if ( v5 )
{
v16 = v5;
*v5 = 1LL;
v6 = a2 + 1;
for ( i = 0LL; ; ++i )
{
if ( i == 2 )
{
v14 = (long long)v16;
v13 = 0;
goto LABEL_14;
}
v8 = JS_NewObjectProtoClass((long long)a1, a1[9], a1[10], (unsigned int)i | 0x32);
v10 = v9;
if ( (_DWORD)v9 == 6 )
break;
v11 = v8;
v12 = (_QWORD *)js_malloc((long long)a1, 24LL);
if ( !v12 )
{
JS_FreeValue((long long)a1, v11, v10);
break;
}
++*v16;
v12[2] = v16;
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
*v12 = a3;
v12[1] = a4;
*(_QWORD *)(v11 + 48) = v12;
js_function_set_properties((long long)a1, v11, v10, 47, 1);
*(v6 - 1) = v11;
*v6 = v10;
v6 += 2;
}
v13 = -1;
v14 = (long long)v16;
if ( i )
JS_FreeValue((long long)a1, *a2, a2[1]);
LABEL_14:
js_promise_resolve_function_free_resolved(a1[3], v14);
}
else
{
return (unsigned int)-1;
}
return v13;
}
|
js_create_resolving_functions:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV qword ptr [RSP + 0x8],RDX
MOV R14,RSI
MOV RBX,RDI
PUSH 0x8
POP RSI
CALL 0x00117214
TEST RAX,RAX
JZ 0x00147412
MOV qword ptr [RSP],RAX
MOV qword ptr [RAX],0x1
MOV qword ptr [RSP + 0x10],R14
ADD R14,0x8
XOR EBP,EBP
LAB_00147383:
CMP RBP,0x2
JZ 0x00147418
MOV RSI,qword ptr [RBX + 0x48]
MOV RDX,qword ptr [RBX + 0x50]
MOV ECX,EBP
OR ECX,0x32
MOV RDI,RBX
CALL 0x0011b069
MOV R15,RDX
CMP R15D,0x6
JZ 0x0014742f
MOV R12,RAX
MOV RDI,RBX
PUSH 0x18
POP RSI
CALL 0x00117214
TEST RAX,RAX
JZ 0x00147421
MOV RCX,qword ptr [RSP]
INC dword ptr [RCX]
MOV qword ptr [RAX + 0x10],RCX
CMP R13D,-0x9
JC 0x001473d9
MOV RCX,qword ptr [RSP + 0x8]
INC dword ptr [RCX]
LAB_001473d9:
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R13
MOV qword ptr [R12 + 0x30],RAX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
PUSH 0x2f
POP RCX
PUSH 0x1
POP R8
CALL 0x0011b4ad
MOV qword ptr [R14 + -0x8],R12
MOV qword ptr [R14],R15
INC RBP
ADD R14,0x10
JMP 0x00147383
LAB_00147412:
PUSH -0x1
POP R15
JMP 0x0014745c
LAB_00147418:
MOV R14,qword ptr [RSP]
XOR R15D,R15D
JMP 0x00147450
LAB_00147421:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL 0x0011801e
LAB_0014742f:
PUSH -0x1
POP R15
TEST RBP,RBP
MOV R14,qword ptr [RSP]
JZ 0x00147450
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
CALL 0x0011801e
LAB_00147450:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
CALL 0x00146f56
LAB_0014745c:
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
js_create_resolving_functions(long param_1,int8 *param_2,int *param_3,int8 param_4)
{
int *piVar1;
long lVar2;
int8 *puVar3;
int8 uVar4;
long lVar5;
int8 *puVar6;
int4 uVar7;
int1 auVar8 [16];
piVar1 = (int *)js_malloc(param_1,8);
if (piVar1 == (int *)0x0) {
uVar7 = 0xffffffff;
}
else {
piVar1[0] = 1;
piVar1[1] = 0;
puVar6 = param_2 + 1;
for (lVar5 = 0; lVar5 != 2; lVar5 = lVar5 + 1) {
auVar8 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x48),*(int8 *)(param_1 + 0x50),
(uint)lVar5 | 0x32);
uVar4 = auVar8._8_8_;
lVar2 = auVar8._0_8_;
if (auVar8._8_4_ == 6) {
LAB_0014742f:
uVar7 = 0xffffffff;
if (lVar5 != 0) {
JS_FreeValue(param_1,*param_2,param_2[1]);
}
goto LAB_00147450;
}
puVar3 = (int8 *)js_malloc(param_1,0x18);
if (puVar3 == (int8 *)0x0) {
JS_FreeValue(param_1,lVar2,uVar4);
goto LAB_0014742f;
}
*piVar1 = *piVar1 + 1;
puVar3[2] = piVar1;
if (0xfffffff6 < (uint)param_4) {
*param_3 = *param_3 + 1;
}
*puVar3 = param_3;
puVar3[1] = param_4;
*(int8 **)(lVar2 + 0x30) = puVar3;
js_function_set_properties(param_1,lVar2,uVar4,0x2f,1);
puVar6[-1] = lVar2;
*puVar6 = uVar4;
puVar6 = puVar6 + 2;
}
uVar7 = 0;
LAB_00147450:
js_promise_resolve_function_free_resolved(*(int8 *)(param_1 + 0x18),piVar1);
}
return uVar7;
}
|
|
63,129 |
testing::FormatWordList(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
static std::string FormatWordList(const std::vector<std::string>& words) {
Message word_list;
for (size_t i = 0; i < words.size(); ++i) {
if (i > 0 && words.size() > 2) {
word_list << ", ";
}
if (i == words.size() - 1) {
word_list << "and ";
}
word_list << "'" << words[i] << "'";
}
return word_list.GetString();
}
|
O0
|
cpp
|
testing::FormatWordList(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&):
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc0620
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe3190
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0xde20a
cmpq $0x0, 0x48(%rsp)
jbe 0xde16d
movq 0x58(%rsp), %rdi
callq 0xe3190
cmpq $0x2, %rax
jbe 0xde16d
leaq 0x36e60(%rip), %rsi # 0x114fa2
leaq 0x50(%rsp), %rdi
callq 0x21130
jmp 0xde14e
jmp 0xde16d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1acd0
jmp 0xde22f
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0xe3190
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0xde1a7
leaq 0x351b4(%rip), %rsi # 0x11334d
leaq 0x50(%rsp), %rdi
callq 0x211b0
jmp 0xde1a5
jmp 0xde1a7
leaq 0x2f461(%rip), %rsi # 0x10d60f
leaq 0x50(%rsp), %rdi
callq 0xe2990
movq %rax, 0x10(%rsp)
jmp 0xde1bf
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xe5ba0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x21170
movq %rax, 0x8(%rsp)
jmp 0xde1e2
movq 0x8(%rsp), %rdi
leaq 0x2f421(%rip), %rsi # 0x10d60f
callq 0xe2990
jmp 0xde1f5
jmp 0xde1f7
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0xde0fe
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb2630
jmp 0xde21b
leaq 0x50(%rsp), %rdi
callq 0x1acd0
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x14c80
nopl (%rax)
|
_ZN7testingL14FormatWordListERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
sub rsp, 68h
mov qword ptr [rsp+68h+var_40], rdi
mov rax, rdi
mov [rsp+68h+var_38], rax
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
lea rdi, [rsp+68h+var_18]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov [rsp+68h+var_20], 0
loc_DE0FE:
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_48], rax
mov rdi, [rsp+68h+var_10]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+68h+var_48]
cmp rax, rcx
jnb loc_DE20A
cmp [rsp+68h+var_20], 0
jbe short loc_DE16D
mov rdi, [rsp+68h+var_10]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
cmp rax, 2
jbe short loc_DE16D
lea rsi, aMustBeInRange0+15h; ", "
lea rdi, [rsp+68h+var_18]
call _ZN7testing7MessagelsIA3_cEERS0_RKT_; testing::Message::operator<<<char [3]>(char [3] const&)
jmp short $+2
loc_DE14E:
jmp short loc_DE16D
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_48]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp loc_DE22F
loc_DE16D:
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_50], rax
mov rdi, [rsp+68h+var_10]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+68h+var_50]
sub rcx, 1
cmp rax, rcx
jnz short loc_DE1A7
lea rsi, aAnd+1; "and "
lea rdi, [rsp+68h+var_18]
call _ZN7testing7MessagelsIA5_cEERS0_RKT_; testing::Message::operator<<<char [5]>(char [5] const&)
jmp short $+2
loc_DE1A5:
jmp short $+2
loc_DE1A7:
lea rsi, aLoggerWithName+11h; "'"
lea rdi, [rsp+68h+var_18]
call _ZN7testing7MessagelsIA2_cEERS0_RKT_; testing::Message::operator<<<char [2]>(char [2] const&)
mov [rsp+68h+var_58], rax
jmp short $+2
loc_DE1BF:
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_20]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, [rsp+68h+var_58]
mov rsi, rax
call _ZN7testing7MessagelsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS0_RKT_; testing::Message::operator<<<std::string>(std::string const&)
mov [rsp+68h+var_60], rax
jmp short $+2
loc_DE1E2:
mov rdi, [rsp+68h+var_60]
lea rsi, aLoggerWithName+11h; "'"
call _ZN7testing7MessagelsIA2_cEERS0_RKT_; testing::Message::operator<<<char [2]>(char [2] const&)
jmp short $+2
loc_DE1F5:
jmp short $+2
loc_DE1F7:
mov rax, [rsp+68h+var_20]
add rax, 1
mov [rsp+68h+var_20], rax
jmp loc_DE0FE
loc_DE20A:
mov rdi, qword ptr [rsp+68h+var_40]; int
lea rsi, [rsp+68h+var_18]; int
call _ZNK7testing7Message9GetStringB5cxx11Ev; testing::Message::GetString(void)
jmp short $+2
loc_DE21B:
lea rdi, [rsp+68h+var_18]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
mov rax, [rsp+68h+var_38]
add rsp, 68h
retn
loc_DE22F:
mov rdi, [rsp+arg_38]
call __Unwind_Resume
|
long long testing::FormatWordList(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+10h] [rbp-58h]
unsigned long long i; // [rsp+48h] [rbp-20h]
int v7; // [rsp+50h] [rbp-18h] BYREF
long long v8; // [rsp+58h] [rbp-10h]
long long v9; // [rsp+60h] [rbp-8h]
v9 = a1;
v8 = a2;
testing::Message::Message((testing::Message *)&v7);
for ( i = 0LL; i < std::vector<std::string>::size(v8); ++i )
{
if ( i && (unsigned long long)std::vector<std::string>::size(v8) > 2 )
testing::Message::operator<<<char [3]>((long long)&v7, (long long)", ");
if ( i == std::vector<std::string>::size(v8) - 1 )
testing::Message::operator<<<char [5]>((long long)&v7, (long long)"and ");
v5 = testing::Message::operator<<<char [2]>(&v7, "'");
v2 = std::vector<std::string>::operator[](v8, i);
v4 = testing::Message::operator<<<std::string>(v5, v2);
testing::Message::operator<<<char [2]>(v4, "'");
}
testing::Message::GetString[abi:cxx11](a1, (int)&v7);
testing::Message::~Message((testing::Message *)&v7);
return a1;
}
|
FormatWordList:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
LEA RDI,[RSP + 0x50]
CALL 0x001c0620
MOV qword ptr [RSP + 0x48],0x0
LAB_001de0fe:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001e3190
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,RCX
JNC 0x001de20a
CMP qword ptr [RSP + 0x48],0x0
JBE 0x001de16d
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001e3190
CMP RAX,0x2
JBE 0x001de16d
LAB_001de13b:
LEA RSI,[0x214fa2]
LEA RDI,[RSP + 0x50]
CALL 0x00121130
JMP 0x001de14e
LAB_001de14e:
JMP 0x001de16d
LAB_001de16d:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001e3190
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
SUB RCX,0x1
CMP RAX,RCX
JNZ 0x001de1a7
LEA RSI,[0x21334d]
LEA RDI,[RSP + 0x50]
CALL 0x001211b0
JMP 0x001de1a5
LAB_001de1a5:
JMP 0x001de1a7
LAB_001de1a7:
LEA RSI,[0x20d60f]
LEA RDI,[RSP + 0x50]
CALL 0x001e2990
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001de1bf
LAB_001de1bf:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x001e5ba0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00121170
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001de1e2
LAB_001de1e2:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x20d60f]
CALL 0x001e2990
JMP 0x001de1f5
LAB_001de1f5:
JMP 0x001de1f7
LAB_001de1f7:
MOV RAX,qword ptr [RSP + 0x48]
ADD RAX,0x1
MOV qword ptr [RSP + 0x48],RAX
JMP 0x001de0fe
LAB_001de20a:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x50]
CALL 0x001b2630
LAB_001de219:
JMP 0x001de21b
LAB_001de21b:
LEA RDI,[RSP + 0x50]
CALL 0x0011acd0
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x68
RET
|
/* testing::FormatWordList(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&) */
testing * __thiscall testing::FormatWordList(testing *this,vector *param_1)
{
ulong uVar1;
long lVar2;
Message *pMVar3;
string *psVar4;
ulong local_20;
Message local_18 [8];
vector *local_10;
testing *local_8;
local_10 = param_1;
local_8 = this;
Message::Message(local_18);
local_20 = 0;
while( true ) {
uVar1 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_10
);
if (uVar1 <= local_20) break;
if (local_20 != 0) {
uVar1 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_10);
if (2 < uVar1) {
/* try { // try from 001de13b to 001de218 has its CatchHandler @ 001de150 */
Message::operator<<(local_18,", ");
}
}
lVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_10
);
if (local_20 == lVar2 - 1U) {
Message::operator<<(local_18,"and ");
}
pMVar3 = Message::operator<<(local_18,"\'");
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_10,local_20);
pMVar3 = Message::operator<<(pMVar3,psVar4);
Message::operator<<(pMVar3,"\'");
local_20 = local_20 + 1;
}
Message::GetString_abi_cxx11_();
Message::~Message(local_18);
return this;
}
|
|
63,130 |
rlglClose
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h
|
void rlglClose(void)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
rlUnloadRenderBatch(RLGL.defaultBatch);
rlUnloadShaderDefault(); // Unload default shader
glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture
TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId);
#endif
}
|
O3
|
c
|
rlglClose:
subq $0x28, %rsp
movups 0xd72d5(%rip), %xmm0 # 0x13b130
movups %xmm0, 0x10(%rsp)
movups 0xd72b9(%rip), %xmm0 # 0x13b120
movups %xmm0, (%rsp)
callq 0x63f14
xorl %edi, %edi
callq *0xd6e20(%rip) # 0x13ac98
movl 0xd7bce(%rip), %edi # 0x13ba4c
movl 0xd7bc0(%rip), %esi # 0x13ba44
callq *0xd589e(%rip) # 0x139728
movl 0xd7bbc(%rip), %edi # 0x13ba4c
movl 0xd7bb2(%rip), %esi # 0x13ba48
callq *0xd588c(%rip) # 0x139728
movl 0xd7ba2(%rip), %edi # 0x13ba44
callq *0xd5818(%rip) # 0x1396c0
movl 0xd7b9a(%rip), %edi # 0x13ba48
callq *0xd580c(%rip) # 0x1396c0
movl 0xd7b92(%rip), %edi # 0x13ba4c
callq *0xd57c0(%rip) # 0x139680
movq 0xd7b89(%rip), %rdi # 0x13ba50
callq 0xa650
movl 0xd7b7a(%rip), %edx # 0x13ba4c
leaq 0x8272f(%rip), %rsi # 0xe6608
movl $0x3, %edi
xorl %eax, %eax
callq 0xb9db7
leaq 0xd7b44(%rip), %rsi # 0x13ba30
movl $0x1, %edi
callq *0xd57d9(%rip) # 0x1396d0
movl 0xd7b33(%rip), %edx # 0x13ba30
leaq 0x7acbb(%rip), %rsi # 0xdebbf
movl $0x3, %edi
xorl %eax, %eax
addq $0x28, %rsp
jmp 0xb9db7
|
rlglClose:
sub rsp, 28h
movups xmm0, cs:xmmword_13B130
movups [rsp+28h+var_18], xmm0
movups xmm0, cs:xmmword_13B120
movups [rsp+28h+var_28], xmm0
call rlUnloadRenderBatch
xor edi, edi
call cs:glad_glUseProgram
mov edi, cs:dword_13BA4C
mov esi, cs:dword_13BA44
call cs:glad_glDetachShader
mov edi, cs:dword_13BA4C
mov esi, cs:dword_13BA48
call cs:glad_glDetachShader
mov edi, cs:dword_13BA44
call cs:glad_glDeleteShader
mov edi, cs:dword_13BA48
call cs:glad_glDeleteShader
mov edi, cs:dword_13BA4C
call cs:glad_glDeleteProgram
mov rdi, cs:qword_13BA50
call _free
mov edx, cs:dword_13BA4C
lea rsi, aShaderIdIDefau_0; "SHADER: [ID %i] Default shader unloaded"...
mov edi, 3
xor eax, eax
call TraceLog
lea rsi, dword_13BA30
mov edi, 1
call cs:glad_glDeleteTextures
mov edx, cs:dword_13BA30
lea rsi, aTextureIdIDefa_0; "TEXTURE: [ID %i] Default texture unload"...
mov edi, 3
xor eax, eax
add rsp, 28h
jmp TraceLog
|
long long rlglClose(int a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // ecx
int v10; // r8d
int v11; // r9d
rlUnloadRenderBatch(a1, a2, a3, a4, a5, a6, xmmword_13B120, xmmword_13B130);
glad_glUseProgram(0LL);
glad_glDetachShader((unsigned int)dword_13BA4C, (unsigned int)dword_13BA44);
glad_glDetachShader((unsigned int)dword_13BA4C, (unsigned int)dword_13BA48);
glad_glDeleteShader((unsigned int)dword_13BA44);
glad_glDeleteShader((unsigned int)dword_13BA48);
glad_glDeleteProgram((unsigned int)dword_13BA4C);
free(qword_13BA50);
TraceLog(3, (unsigned int)"SHADER: [ID %i] Default shader unloaded successfully", dword_13BA4C, v6, v7, v8);
glad_glDeleteTextures(1LL, &dword_13BA30);
return TraceLog(3, (unsigned int)"TEXTURE: [ID %i] Default texture unloaded successfully", dword_13BA30, v9, v10, v11);
}
|
rlglClose:
SUB RSP,0x28
MOVUPS XMM0,xmmword ptr [0x0023b130]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [0x0023b120]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00163f14
XOR EDI,EDI
CALL qword ptr [0x0023ac98]
MOV EDI,dword ptr [0x0023ba4c]
MOV ESI,dword ptr [0x0023ba44]
CALL qword ptr [0x00239728]
MOV EDI,dword ptr [0x0023ba4c]
MOV ESI,dword ptr [0x0023ba48]
CALL qword ptr [0x00239728]
MOV EDI,dword ptr [0x0023ba44]
CALL qword ptr [0x002396c0]
MOV EDI,dword ptr [0x0023ba48]
CALL qword ptr [0x002396c0]
MOV EDI,dword ptr [0x0023ba4c]
CALL qword ptr [0x00239680]
MOV RDI,qword ptr [0x0023ba50]
CALL 0x0010a650
MOV EDX,dword ptr [0x0023ba4c]
LEA RSI,[0x1e6608]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x001b9db7
LEA RSI,[0x23ba30]
MOV EDI,0x1
CALL qword ptr [0x002396d0]
MOV EDX,dword ptr [0x0023ba30]
LEA RSI,[0x1debbf]
MOV EDI,0x3
XOR EAX,EAX
ADD RSP,0x28
JMP 0x001b9db7
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void rlglClose(void)
{
rlUnloadRenderBatch();
(*glad_glUseProgram)(0);
(*glad_glDetachShader)(DAT_0023ba4c,DAT_0023ba44);
(*glad_glDetachShader)(DAT_0023ba4c,DAT_0023ba48);
(*glad_glDeleteShader)(DAT_0023ba44);
(*glad_glDeleteShader)(DAT_0023ba48);
(*glad_glDeleteProgram)(DAT_0023ba4c);
free(DAT_0023ba50);
TraceLog(3,"SHADER: [ID %i] Default shader unloaded successfully",DAT_0023ba4c);
(*glad_glDeleteTextures)(1,&DAT_0023ba30);
TraceLog(3,"TEXTURE: [ID %i] Default texture unloaded successfully",DAT_0023ba30);
return;
}
|
|
63,131 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O1
|
cpp
|
minja::Parser::parseIfExpression():
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x41a4e
cmpq $0x0, (%r15)
je 0x41dfa
leaq 0xa5321(%rip), %rax # 0xe7028
movb (%rax), %al
testb %al, %al
je 0x41e2c
leaq 0xa52f0(%rip), %rdx # 0xe7008
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x35972
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x41d49
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a740
testq %r15, %r15
je 0x41dba
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x35750
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x41d81
callq 0x35448
testq %r15, %r15
jne 0x41dc0
movl $0x10, %edi
callq 0x1a390
movq %rax, %r15
leaq 0x72713(%rip), %rsi # 0xb44ad
movq %rax, %rdi
callq 0x1a290
movq 0xa4247(%rip), %rsi # 0xe5ff0
movq 0xa41c0(%rip), %rdx # 0xe5f70
movq %r15, %rdi
callq 0x1acd0
jmp 0x41e2c
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movaps (%rsp), %xmm0
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x41ded
callq 0x35448
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1a390
movq %rax, %r14
leaq 0x7267a(%rip), %rsi # 0xb4488
movq %rax, %rdi
callq 0x1a290
movq 0xa41d3(%rip), %rsi # 0xe5ff0
movq 0xa414c(%rip), %rdx # 0xe5f70
movq %r14, %rdi
callq 0x1acd0
leaq 0xa51f5(%rip), %rdi # 0xe7028
callq 0x1ad90
testl %eax, %eax
je 0x41d11
leaq 0xa51c1(%rip), %rdi # 0xe7008
leaq 0x72658(%rip), %rsi # 0xb44a6
movl $0x10, %edx
callq 0x354b8
leaq -0xc93f(%rip), %rdi # 0x35520
leaq 0xa51a2(%rip), %rsi # 0xe7008
leaq 0xa491b(%rip), %rdx # 0xe6788
callq 0x1a620
leaq 0xa51af(%rip), %rdi # 0xe7028
callq 0x1a490
jmp 0x41d11
movq %rax, %rbx
leaq 0xa519b(%rip), %rdi # 0xe7028
callq 0x1a480
jmp 0x41ecd
movq %rax, %rbx
jmp 0x41ec0
movq %rax, %rbx
movq %r15, %rdi
callq 0x1a530
jmp 0x41ec0
movq %rax, %rbx
jmp 0x41ecd
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a530
jmp 0x41ecd
jmp 0x41eba
movq %rax, %rbx
xorl %r14d, %r14d
testq %r14, %r14
je 0x41ecd
movq %r14, %rdi
callq 0x35448
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x41edc
callq 0x35448
movq %rbx, %rdi
callq 0x1ad30
|
_ZN5minja6Parser17parseIfExpressionEv:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov rdi, r15; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
cmp qword ptr [r15], 0
jz loc_41DFA
lea rax, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
mov al, [rax]
test al, al
jz loc_41E2C
loc_41D11:
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+48h+var_38]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_41D49
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41D49:
test r15, r15
jz short loc_41DBA
lea rdi, [rsp+48h+var_38]; this
mov rsi, r14; bool
mov edx, 1
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov r15, qword ptr [rsp+48h+var_38]
mov r14, qword ptr [rsp+48h+var_38+8]
xorps xmm0, xmm0
movaps [rsp+48h+var_38], xmm0
mov rdi, qword ptr [rsp+48h+var_38+8]
test rdi, rdi
jz short loc_41D81
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41D81:
test r15, r15
jnz short loc_41DC0
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_41E2C
loc_41DBA:
xor r15d, r15d
xor r14d, r14d
loc_41DC0:
xor eax, eax
mov [rbx+8], rax
movaps xmm0, [rsp+48h+var_48]
mov qword ptr [rsp+48h+var_48+8], rax
movups xmmword ptr [rbx], xmm0
mov qword ptr [rsp+48h+var_48], rax
mov [rbx+10h], r15
mov [rbx+18h], r14
mov rdi, qword ptr [rsp+48h+var_48+8]
test rdi, rdi
jz short loc_41DED
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41DED:
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_41DFA:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_41E2C:
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_41D11
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_41D11
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_41ECD
mov rbx, rax
jmp short loc_41EC0
mov rbx, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_41EC0
mov rbx, rax
jmp short loc_41ECD
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_41ECD
jmp short $+2
loc_41EBA:
mov rbx, rax
xor r14d, r14d
loc_41EC0:
test r14, r14
jz short loc_41ECD
mov rdi, r14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41ECD:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_41EDC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41EDC:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, long long *a2)
{
long long v2; // r15
__int128 v3; // kr00_16
std::runtime_error *v4; // r15
__int128 v5; // xmm0
std::runtime_error *exception; // r14
__int128 v8; // [rsp+0h] [rbp-48h] BYREF
__int128 v9; // [rsp+10h] [rbp-38h] BYREF
long long v10; // [rsp+20h] [rbp-28h] BYREF
minja::Parser::parseLogicalOr((volatile signed __int32 **)&v8, a2);
if ( !(_QWORD)v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)&v9,
(long long)a2,
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
1u);
v2 = *((_QWORD *)&v9 + 1);
if ( (long long *)v9 != &v10 )
operator delete((void *)v9, v10 + 1);
if ( v2 )
{
minja::Parser::parseExpression((minja::Parser *)&v9, a2, 1);
v3 = v9;
v9 = 0LL;
if ( !(_QWORD)v3 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected 'else' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v3 = 0uLL;
}
*((_QWORD *)this + 1) = 0LL;
v5 = v8;
*((_QWORD *)&v8 + 1) = 0LL;
*(_OWORD *)this = v5;
*(_QWORD *)&v8 = 0LL;
*((_OWORD *)this + 1) = v3;
if ( *((_QWORD *)&v8 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v8 + 1));
return this;
}
|
parseIfExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x00141a4e
CMP qword ptr [R15],0x0
JZ 0x00141dfa
LEA RAX,[0x1e7028]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00141e2c
LAB_00141d11:
LEA RDX,[0x1e7008]
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV ECX,0x1
CALL 0x00135972
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x00141d49
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011a740
LAB_00141d49:
TEST R15,R15
JZ 0x00141dba
LAB_00141d4e:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV EDX,0x1
CALL 0x00135750
LAB_00141d60:
MOV R15,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x18]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00141d81
CALL 0x00135448
LAB_00141d81:
TEST R15,R15
JNZ 0x00141dc0
MOV EDI,0x10
CALL 0x0011a390
MOV R15,RAX
LAB_00141d93:
LEA RSI,[0x1b44ad]
MOV RDI,RAX
CALL 0x0011a290
LAB_00141da2:
MOV RSI,qword ptr [0x001e5ff0]
MOV RDX,qword ptr [0x001e5f70]
MOV RDI,R15
CALL 0x0011acd0
LAB_00141dba:
XOR R15D,R15D
XOR R14D,R14D
LAB_00141dc0:
XOR EAX,EAX
MOV qword ptr [RBX + 0x8],RAX
MOVAPS XMM0,xmmword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RSP],RAX
MOV qword ptr [RBX + 0x10],R15
MOV qword ptr [RBX + 0x18],R14
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00141ded
CALL 0x00135448
LAB_00141ded:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_00141dfa:
MOV EDI,0x10
CALL 0x0011a390
MOV R14,RAX
LAB_00141e07:
LEA RSI,[0x1b4488]
MOV RDI,RAX
CALL 0x0011a290
LAB_00141e16:
MOV RSI,qword ptr [0x001e5ff0]
MOV RDX,qword ptr [0x001e5f70]
MOV RDI,R14
CALL 0x0011acd0
LAB_00141e2c:
LEA RDI,[0x1e7028]
CALL 0x0011ad90
TEST EAX,EAX
JZ 0x00141d11
LAB_00141e40:
LEA RDI,[0x1e7008]
LEA RSI,[0x1b44a6]
MOV EDX,0x10
CALL 0x001354b8
LAB_00141e58:
LEA RDI,[0x135520]
LEA RSI,[0x1e7008]
LEA RDX,[0x1e6788]
CALL 0x0011a620
LEA RDI,[0x1e7028]
CALL 0x0011a490
JMP 0x00141d11
|
/* WARNING: Removing unreachable block (ram,0x00141d7c) */
/* WARNING: Removing unreachable block (ram,0x00141de8) */
/* minja::Parser::parseIfExpression() */
void minja::Parser::parseIfExpression(void)
{
int iVar1;
runtime_error *prVar2;
long *in_RDI;
long lVar3;
long *plVar4;
long local_48;
long lStack_40;
long *local_38;
long lStack_30;
long local_28 [2];
parseLogicalOr();
if (local_48 == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00141e07 to 00141e15 has its CatchHandler @ 00141eab */
std::runtime_error::runtime_error(prVar2,"Expected condition expression");
/* try { // try from 00141e16 to 00141e2b has its CatchHandler @ 00141ea6 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001e5ff0,PTR__runtime_error_001e5f70);
}
if ((parseIfExpression()::else_tok_abi_cxx11_ == '\0') &&
(iVar1 = __cxa_guard_acquire(&parseIfExpression()::else_tok_abi_cxx11_), iVar1 != 0)) {
/* try { // try from 00141e40 to 00141e57 has its CatchHandler @ 00141e83 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIfExpression()::else_tok_abi_cxx11_,"else\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIfExpression()::else_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIfExpression()::else_tok_abi_cxx11_);
}
/* try { // try from 00141d11 to 00141d29 has its CatchHandler @ 00141eba */
consumeToken(&local_38);
lVar3 = lStack_30;
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
if (lVar3 == 0) {
plVar4 = (long *)0x0;
lVar3 = 0;
}
else {
/* try { // try from 00141d4e to 00141d5f has its CatchHandler @ 00141eb8 */
parseExpression(SUB81(&local_38,0));
lVar3 = lStack_30;
plVar4 = local_38;
lStack_30 = 0;
local_38 = (long *)0x0;
if (plVar4 == (long *)0x0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00141d93 to 00141da1 has its CatchHandler @ 00141e99 */
std::runtime_error::runtime_error(prVar2,"Expected \'else\' expression");
/* try { // try from 00141da2 to 00141db7 has its CatchHandler @ 00141e94 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001e5ff0,PTR__runtime_error_001e5f70);
}
}
in_RDI[1] = 0;
*in_RDI = local_48;
in_RDI[1] = lStack_40;
in_RDI[2] = (long)plVar4;
in_RDI[3] = lVar3;
return;
}
|
|
63,132 |
enough_free_entries_on_page
|
eloqsql/storage/maria/ma_blockrec.c
|
my_bool enough_free_entries_on_page(MARIA_SHARE *share,
uchar *page_buff)
{
enum en_page_type page_type;
page_type= (enum en_page_type) (page_buff[PAGE_TYPE_OFFSET] &
~(uchar) PAGE_CAN_BE_COMPACTED);
if (page_type == HEAD_PAGE)
{
uint row_count= (uint) page_buff[DIR_COUNT_OFFSET];
return !(row_count == MAX_ROWS_PER_PAGE &&
page_buff[DIR_FREE_OFFSET] == END_OF_DIR_FREE_LIST);
}
return enough_free_entries(page_buff, share->block_size,
1 + share->base.blobs);
}
|
O0
|
c
|
enough_free_entries_on_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0xffffff7f, %eax # imm = 0xFFFFFF7F
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x73ca1
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0xff, -0x20(%rbp)
movb %al, -0x21(%rbp)
jne 0x73c92
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %eax
cmpl $0xff, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0x73cc4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x7bc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x3f0(%rax), %edx
addl $0x1, %edx
callq 0x73cd0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
enough_free_entries_on_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+7]
and eax, 0FFFFFF7Fh
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 1
jnz short loc_73CA1
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+8]
mov [rbp+var_20], eax
xor eax, eax
cmp [rbp+var_20], 0FFh
mov [rbp+var_21], al
jnz short loc_73C92
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+9]
cmp eax, 0FFh
setz al
mov [rbp+var_21], al
loc_73C92:
mov al, [rbp+var_21]
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp short loc_73CC4
loc_73CA1:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov esi, [rax+7BCh]
mov rax, [rbp+var_10]
mov edx, [rax+3F0h]
add edx, 1
call enough_free_entries
mov [rbp+var_1], al
loc_73CC4:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char enough_free_entries_on_page(long long a1, _BYTE *a2)
{
bool v3; // [rsp+Fh] [rbp-21h]
if ( (a2[7] & 0x7F) != 1 )
return enough_free_entries(a2, *(unsigned int *)(a1 + 1980), (unsigned int)(*(_DWORD *)(a1 + 1008) + 1));
v3 = 0;
if ( (unsigned __int8)a2[8] == 255 )
v3 = (unsigned __int8)a2[9] == 255;
return !v3;
}
|
enough_free_entries_on_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x7]
AND EAX,0xffffff7f
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x1
JNZ 0x00173ca1
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
XOR EAX,EAX
CMP dword ptr [RBP + -0x20],0xff
MOV byte ptr [RBP + -0x21],AL
JNZ 0x00173c92
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x9]
CMP EAX,0xff
SETZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00173c92:
MOV AL,byte ptr [RBP + -0x21]
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x00173cc4
LAB_00173ca1:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x7bc]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x3f0]
ADD EDX,0x1
CALL 0x00173cd0
MOV byte ptr [RBP + -0x1],AL
LAB_00173cc4:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
byte enough_free_entries_on_page(long param_1,long param_2)
{
bool local_29;
byte local_9;
if ((*(byte *)(param_2 + 7) & 0x7f) == 1) {
local_29 = false;
if (*(char *)(param_2 + 8) == -1) {
local_29 = *(char *)(param_2 + 9) == -1;
}
local_9 = (local_29 ^ 0xffU) & 1;
}
else {
local_9 = enough_free_entries(param_2,*(int4 *)(param_1 + 0x7bc),
*(int *)(param_1 + 0x3f0) + 1);
}
return local_9;
}
|
|
63,133 |
ggml_threadpool_params_from_cpu_params(cpu_params const&)
|
monkey531[P]llama/common/common.cpp
|
struct ggml_threadpool_params ggml_threadpool_params_from_cpu_params(const cpu_params & params) {
struct ggml_threadpool_params tpp;
ggml_threadpool_params_init(&tpp, params.n_threads); // setup the defaults
if (params.mask_valid) {
std::memcpy(&tpp.cpumask, ¶ms.cpumask, GGML_MAX_N_THREADS);
}
tpp.prio = params.priority;
tpp.poll = params.poll;
tpp.strict_cpu = params.strict_cpu;
return tpp;
}
|
O3
|
cpp
|
ggml_threadpool_params_from_cpu_params(cpu_params const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x185f0
cmpb $0x1, 0x204(%r14)
jne 0x22c0b
leaq 0x4(%r14), %rsi
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
callq 0x18580
movl 0x208(%r14), %eax
movl %eax, 0x204(%rbx)
movl 0x210(%r14), %eax
movl %eax, 0x208(%rbx)
movb 0x20c(%r14), %al
movb %al, 0x20c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_Z38ggml_threadpool_params_from_cpu_paramsRK10cpu_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov esi, [rsi]
call _ggml_threadpool_params_init
cmp byte ptr [r14+204h], 1
jnz short loc_22C0B
lea rsi, [r14+4]
mov edx, 200h
mov rdi, rbx
call _memcpy
loc_22C0B:
mov eax, [r14+208h]
mov [rbx+204h], eax
mov eax, [r14+210h]
mov [rbx+208h], eax
mov al, [r14+20Ch]
mov [rbx+20Ch], al
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
long long ggml_threadpool_params_from_cpu_params(long long a1, unsigned int *a2)
{
ggml_threadpool_params_init(a1, *a2);
if ( *((_BYTE *)a2 + 516) == 1 )
memcpy(a1, a2 + 1, 512LL);
*(_DWORD *)(a1 + 516) = a2[130];
*(_DWORD *)(a1 + 520) = a2[132];
*(_BYTE *)(a1 + 524) = *((_BYTE *)a2 + 524);
return a1;
}
|
ggml_threadpool_params_from_cpu_params:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RSI]
CALL 0x001185f0
CMP byte ptr [R14 + 0x204],0x1
JNZ 0x00122c0b
LEA RSI,[R14 + 0x4]
MOV EDX,0x200
MOV RDI,RBX
CALL 0x00118580
LAB_00122c0b:
MOV EAX,dword ptr [R14 + 0x208]
MOV dword ptr [RBX + 0x204],EAX
MOV EAX,dword ptr [R14 + 0x210]
MOV dword ptr [RBX + 0x208],EAX
MOV AL,byte ptr [R14 + 0x20c]
MOV byte ptr [RBX + 0x20c],AL
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ggml_threadpool_params_from_cpu_params(cpu_params const&) */
cpu_params * ggml_threadpool_params_from_cpu_params(cpu_params *param_1)
{
int4 *in_RSI;
ggml_threadpool_params_init(param_1,*in_RSI);
if (*(char *)(in_RSI + 0x81) == '\x01') {
memcpy(param_1,in_RSI + 1,0x200);
}
*(int4 *)(param_1 + 0x204) = in_RSI[0x82];
*(int4 *)(param_1 + 0x208) = in_RSI[0x84];
param_1[0x20c] = *(cpu_params *)(in_RSI + 0x83);
return param_1;
}
|
|
63,134 |
my_b_cache_write_r
|
eloqsql/mysys/mf_iocache.c
|
static int _my_b_cache_write_r(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
my_off_t old_pos_in_file= info->pos_in_file;
int res= _my_b_cache_write(info, Buffer, Count);
if (res)
return res;
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
DBUG_ASSERT(info->share);
copy_to_read_buffer(info, Buffer, old_pos_in_file);
return 0;
}
|
O3
|
c
|
my_b_cache_write_r:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
movq %rdi, -0x30(%rbp)
callq 0x521ed
testl %eax, %eax
jne 0x5119a
movq -0x30(%rbp), %rax
movq (%rax), %r12
xorl %eax, %eax
subq %r15, %r12
je 0x5119a
movq %r15, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x98(%rax), %r15
movq -0x30(%rbp), %r14
movq 0xe8(%r14), %r13
cmpq %r13, %r12
cmovbq %r12, %r13
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x523be
movq 0xc8(%r15), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x282a0
movl $0x0, 0xe0(%r15)
movq 0xc8(%r15), %rax
addq %r13, %rax
movq %rax, 0xd0(%r15)
movq -0x38(%rbp), %rax
movq %rax, 0xb8(%r15)
movq 0x98(%r14), %rdi
callq 0x525bf
addq %r13, %rbx
subq %r13, %r12
jne 0x51131
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_my_b_cache_write_r:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r15, [rdi]
mov [rbp+var_30], rdi
call _my_b_cache_write
test eax, eax
jnz loc_5119A
mov rax, [rbp+var_30]
mov r12, [rax]
xor eax, eax
sub r12, r15
jz short loc_5119A
mov [rbp+var_38], r15
mov rax, [rbp+var_30]
mov r15, [rax+98h]
mov r14, [rbp+var_30]
loc_51131:
mov r13, [r14+0E8h]
cmp r12, r13
cmovb r13, r12
mov rdi, r14
mov rsi, [rbp+var_38]
call lock_io_cache
mov rdi, [r15+0C8h]
mov rsi, rbx
mov rdx, r13
call _memcpy
mov dword ptr [r15+0E0h], 0
mov rax, [r15+0C8h]
add rax, r13
mov [r15+0D0h], rax
mov rax, [rbp+var_38]
mov [r15+0B8h], rax
mov rdi, [r14+98h]
call unlock_io_cache
add rbx, r13
sub r12, r13
jnz short loc_51131
xor eax, eax
loc_5119A:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_b_cache_write_r(long long *a1, long long a2)
{
long long v3; // r15
long long result; // rax
unsigned long long v5; // r12
long long v6; // r15
unsigned long long v7; // r13
long long v8; // [rsp+8h] [rbp-38h]
v3 = *a1;
result = my_b_cache_write();
if ( !(_DWORD)result )
{
result = 0LL;
v5 = *a1 - v3;
if ( *a1 != v3 )
{
v8 = v3;
v6 = a1[19];
do
{
v7 = a1[29];
if ( v5 < v7 )
v7 = v5;
lock_io_cache(a1, v8);
memcpy(*(_QWORD *)(v6 + 200), a2, v7);
*(_DWORD *)(v6 + 224) = 0;
*(_QWORD *)(v6 + 208) = v7 + *(_QWORD *)(v6 + 200);
*(_QWORD *)(v6 + 184) = v8;
unlock_io_cache(a1[19]);
a2 += v7;
v5 -= v7;
}
while ( v5 );
return 0LL;
}
}
return result;
}
|
_my_b_cache_write_r:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R15,qword ptr [RDI]
MOV qword ptr [RBP + -0x30],RDI
CALL 0x001521ed
TEST EAX,EAX
JNZ 0x0015119a
MOV RAX,qword ptr [RBP + -0x30]
MOV R12,qword ptr [RAX]
XOR EAX,EAX
SUB R12,R15
JZ 0x0015119a
MOV qword ptr [RBP + -0x38],R15
MOV RAX,qword ptr [RBP + -0x30]
MOV R15,qword ptr [RAX + 0x98]
MOV R14,qword ptr [RBP + -0x30]
LAB_00151131:
MOV R13,qword ptr [R14 + 0xe8]
CMP R12,R13
CMOVC R13,R12
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001523be
MOV RDI,qword ptr [R15 + 0xc8]
MOV RSI,RBX
MOV RDX,R13
CALL 0x001282a0
MOV dword ptr [R15 + 0xe0],0x0
MOV RAX,qword ptr [R15 + 0xc8]
ADD RAX,R13
MOV qword ptr [R15 + 0xd0],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [R15 + 0xb8],RAX
MOV RDI,qword ptr [R14 + 0x98]
CALL 0x001525bf
ADD RBX,R13
SUB R12,R13
JNZ 0x00151131
XOR EAX,EAX
LAB_0015119a:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _my_b_cache_write_r(long *param_1,void *param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
ulong uVar4;
ulong __n;
lVar1 = *param_1;
uVar3 = _my_b_cache_write();
if ((int)uVar3 == 0) {
uVar3 = 0;
uVar4 = *param_1 - lVar1;
if (uVar4 != 0) {
lVar2 = param_1[0x13];
do {
__n = param_1[0x1d];
if (uVar4 < (ulong)param_1[0x1d]) {
__n = uVar4;
}
lock_io_cache(param_1,lVar1);
memcpy(*(void **)(lVar2 + 200),param_2,__n);
*(int4 *)(lVar2 + 0xe0) = 0;
*(ulong *)(lVar2 + 0xd0) = *(long *)(lVar2 + 200) + __n;
*(long *)(lVar2 + 0xb8) = lVar1;
unlock_io_cache(param_1[0x13]);
param_2 = (void *)((long)param_2 + __n);
uVar4 = uVar4 - __n;
} while (uVar4 != 0);
uVar3 = 0;
}
}
return uVar3;
}
|
|
63,135 |
ftxui::ContainerBase::ContainerBase(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>, int*)
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/container.cpp
|
ContainerBase(Components children, int* selector)
: selector_(selector ? selector : &selected_) {
for (Component& child : children) {
Add(std::move(child));
}
}
|
O2
|
cpp
|
ftxui::ContainerBase::ContainerBase(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>, int*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x2e90e(%rip), %rax # 0x50dc8
movq %rax, (%rdi)
leaq 0x28(%rdi), %rax
andl $0x0, 0x28(%rdi)
testq %rdx, %rdx
cmovneq %rdx, %rax
movq %rax, 0x30(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
leaq 0x8(%rsp), %r14
movq %rsp, %r15
cmpq %r13, %r12
je 0x22511
movups (%r12), %xmm0
andq $0x0, 0x8(%r12)
movaps %xmm0, (%rsp)
andq $0x0, (%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21ae6
movq %r14, %rdi
callq 0x13452
addq $0x10, %r12
jmp 0x224df
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x13452
movq %rbx, %rdi
callq 0x21a40
movq %r15, %rdi
callq 0xc7f0
|
_ZN5ftxui13ContainerBaseC2ESt6vectorISt10shared_ptrINS_13ComponentBaseEESaIS4_EEPi:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+18h], xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, off_50DC8
mov [rdi], rax
lea rax, [rdi+28h]
and dword ptr [rdi+28h], 0
test rdx, rdx
cmovnz rax, rdx
mov [rdi+30h], rax
mov r12, [rsi]
mov r13, [rsi+8]
lea r14, [rsp+38h+var_30]
mov r15, rsp
loc_224DF:
cmp r12, r13
jz short loc_22511
movups xmm0, xmmword ptr [r12]
and qword ptr [r12+8], 0
movaps xmmword ptr [rsp], xmm0
and qword ptr [r12], 0
mov rdi, rbx
mov rsi, r15
call _ZN5ftxui13ComponentBase3AddESt10shared_ptrIS0_E; ftxui::ComponentBase::Add(std::shared_ptr<ftxui::ComponentBase>)
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
add r12, 10h
jmp short loc_224DF
loc_22511:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r15, rax
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx; this
call _ZN5ftxui13ComponentBaseD2Ev; ftxui::ComponentBase::~ComponentBase()
mov rdi, r15
call __Unwind_Resume
|
long long ftxui::ContainerBase::ContainerBase(long long a1, __int128 **a2, long long a3)
{
long long result; // rax
__int128 *v4; // r12
__int128 *v5; // r13
__int128 v6; // xmm0
_OWORD v7[3]; // [rsp+0h] [rbp-38h] BYREF
*(_OWORD *)(a1 + 24) = 0LL;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = off_50DC8;
result = a1 + 40;
*(_DWORD *)(a1 + 40) = 0;
if ( a3 )
result = a3;
*(_QWORD *)(a1 + 48) = result;
v4 = *a2;
v5 = a2[1];
while ( v4 != v5 )
{
v6 = *v4;
*((_QWORD *)v4 + 1) = 0LL;
v7[0] = v6;
*(_QWORD *)v4 = 0LL;
ftxui::ComponentBase::Add(a1, (ftxui::ComponentBase **)v7);
result = std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)v7 + 1);
++v4;
}
return result;
}
|
ContainerBase:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x150dc8]
MOV qword ptr [RDI],RAX
LEA RAX,[RDI + 0x28]
AND dword ptr [RDI + 0x28],0x0
TEST RDX,RDX
CMOVNZ RAX,RDX
MOV qword ptr [RDI + 0x30],RAX
MOV R12,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
LEA R14,[RSP + 0x8]
MOV R15,RSP
LAB_001224df:
CMP R12,R13
JZ 0x00122511
MOVUPS XMM0,xmmword ptr [R12]
AND qword ptr [R12 + 0x8],0x0
MOVAPS xmmword ptr [RSP],XMM0
AND qword ptr [R12],0x0
LAB_001224f8:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00121ae6
LAB_00122503:
MOV RDI,R14
CALL 0x00113452
ADD R12,0x10
JMP 0x001224df
LAB_00122511:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* ftxui::ContainerBase::ContainerBase(std::vector<std::shared_ptr<ftxui::ComponentBase>,
std::allocator<std::shared_ptr<ftxui::ComponentBase> > >, int*) */
void __thiscall
ftxui::ContainerBase::ContainerBase(ContainerBase *this,int8 *param_2,ContainerBase *param_3)
{
int8 *puVar1;
ContainerBase *pCVar2;
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__ComponentBase_00150dc8;
*(int4 *)(this + 0x28) = 0;
pCVar2 = this + 0x28;
if (param_3 != (ContainerBase *)0x0) {
pCVar2 = param_3;
}
*(ContainerBase **)(this + 0x30) = pCVar2;
puVar1 = (int8 *)param_2[1];
for (param_2 = (int8 *)*param_2; param_2 != puVar1; param_2 = param_2 + 2) {
local_38 = *(int4 *)param_2;
uStack_34 = *(int4 *)((long)param_2 + 4);
uStack_30 = *(int4 *)(param_2 + 1);
uStack_2c = *(int4 *)((long)param_2 + 0xc);
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 001224f8 to 00122502 has its CatchHandler @ 0012251f */
ComponentBase::Add((ComponentBase *)this,&local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30);
}
return;
}
|
|
63,136 |
inline_mysql_file_pwrite
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_pwrite(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pwrite(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_pwrite(file, buffer, count, offset, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_pwrite:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x1e3594(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %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 0xe411f
leaq 0x1e354a(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xfa980
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xe40ca
cmpq $0x0, -0x38(%rbp)
jne 0xe40af
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xe40ba
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xe40ba
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xe40f7
cmpq $-0x1, -0x38(%rbp)
je 0xe40de
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xe40e9
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xe40e9
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x1e34a2(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe4143
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xfa980
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
|
inline_mysql_file_pwrite_3:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
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, 7
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 loc_E411F
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_E40CA
cmp [rbp+var_38], 0
jnz short loc_E40AF
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_E40BA
loc_E40AF:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_E40BA:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_E40F7
loc_E40CA:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_E40DE
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_E40E9
loc_E40DE:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_E40E9:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_E40F7:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_E4143
loc_E411F:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pwrite
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_E4143:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long inline_mysql_file_pwrite_3(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 7LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pwrite(v16, v15, v14, v13, a7);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pwrite(v16, v15, v14, v13, a7);
}
}
|
inline_mysql_file_pwrite:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
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 qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
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 0x001e411f
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
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 RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001fa980
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001e40ca
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001e40af
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e40ba
LAB_001e40af:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e40ba
LAB_001e40ba:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001e40f7
LAB_001e40ca:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001e40de
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e40e9
LAB_001e40de:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e40e9
LAB_001e40e9:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001e40f7:
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e4143
LAB_001e411f:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001fa980
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e4143:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pwrite
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = 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,7);
if (local_48 == 0) {
local_10 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pwrite(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
|
|
63,137 |
my_long10_to_str_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_long10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *e;
long int new_val;
uint sign=0;
unsigned long int uval = (unsigned long int) val;
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval= (unsigned long int)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
len= MY_MIN(len, (size_t) (e-p));
memcpy(dst, p, len);
return len+sign;
}
|
O0
|
c
|
my_long10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x94(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x50(%rbp), %rax
addq $0x41, %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x6c(%rbp)
jge 0x44661
cmpq $0x0, -0x78(%rbp)
jge 0x4465f
xorl %eax, %eax
subq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2d, (%rax)
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x68(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x44661
movq -0xa0(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x90(%rbp)
movq -0xa0(%rbp), %rax
imulq $0xa, -0x90(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x44702
movq -0x78(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
imulq $0xa, -0x90(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x446b0
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x44726
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x4473b
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x24230
movq -0x68(%rbp), %rax
movl -0x94(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4478d
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x24320
nopw %cs:(%rax,%rax)
|
my_long10_to_str_8bit:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_94], 0
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
lea rax, [rbp+var_50]
add rax, 41h ; 'A'
mov [rbp+var_80], rax
mov [rbp+var_88], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_6C], 0
jge short loc_44661
cmp [rbp+var_78], 0
jge short loc_4465F
xor eax, eax
sub rax, [rbp+var_A0]
mov [rbp+var_A0], rax
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Dh ; '-'
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_68], rax
mov [rbp+var_94], 1
loc_4465F:
jmp short $+2
loc_44661:
mov rax, [rbp+var_A0]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_90], rax
mov rax, [rbp+var_A0]
imul rcx, [rbp+var_90], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_90]
mov [rbp+var_78], rax
loc_446B0:
cmp [rbp+var_78], 0
jz short loc_44702
mov rax, [rbp+var_78]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_90], rax
mov rax, [rbp+var_78]
imul rcx, [rbp+var_90], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_90]
mov [rbp+var_78], rax
jmp short loc_446B0
loc_44702:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_88]
mov rdx, [rbp+var_80]
sub rcx, rdx
cmp rax, rcx
jnb short loc_44726
mov rax, [rbp+var_68]
mov [rbp+var_A8], rax
jmp short loc_4473B
loc_44726:
mov rax, [rbp+var_88]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_A8], rax
loc_4473B:
mov rax, [rbp+var_A8]
mov [rbp+var_68], rax
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_68]
call _memcpy
mov rax, [rbp+var_68]
mov ecx, [rbp+var_94]
add rax, rcx
mov [rbp+var_B0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4478D
mov rax, [rbp+var_B0]
add rsp, 0B0h
pop rbp
retn
loc_4478D:
call ___stack_chk_fail
|
_BYTE * my_long10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, long long a5)
{
char *v5; // rax
_BYTE *v7; // [rsp+8h] [rbp-A8h]
unsigned long long v8; // [rsp+10h] [rbp-A0h]
unsigned int v9; // [rsp+1Ch] [rbp-94h]
char *v10; // [rsp+30h] [rbp-80h]
signed long long i; // [rsp+38h] [rbp-78h]
_BYTE *v12; // [rsp+48h] [rbp-68h]
_BYTE *v13; // [rsp+50h] [rbp-60h]
char v14; // [rsp+A0h] [rbp-10h] BYREF
_BYTE v15[7]; // [rsp+A1h] [rbp-Fh] BYREF
unsigned long long v16; // [rsp+A8h] [rbp-8h]
v16 = __readfsqword(0x28u);
v13 = a2;
v12 = a3;
v9 = 0;
v8 = a5;
v15[0] = 0;
if ( a4 < 0 && a5 < 0 )
{
v8 = -a5;
v13 = a2 + 1;
*a2 = 45;
v12 = a3 - 1;
v9 = 1;
}
v10 = &v14;
v14 = v8 % 0xA + 48;
for ( i = v8 / 0xA; i; i /= 10LL )
{
v5 = v10--;
*(v5 - 1) = i % 10 + 48;
}
if ( (unsigned long long)v12 >= v15 - v10 )
v7 = (_BYTE *)(v15 - v10);
else
v7 = v12;
memcpy(v13, v10, v7);
return &v7[v9];
}
|
my_long10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x94],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
LEA RAX,[RBP + -0x50]
ADD RAX,0x41
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00144661
CMP qword ptr [RBP + -0x78],0x0
JGE 0x0014465f
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2d
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x68],RAX
MOV dword ptr [RBP + -0x94],0x1
LAB_0014465f:
JMP 0x00144661
LAB_00144661:
MOV RAX,qword ptr [RBP + -0xa0]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0xa0]
IMUL RCX,qword ptr [RBP + -0x90],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x78],RAX
LAB_001446b0:
CMP qword ptr [RBP + -0x78],0x0
JZ 0x00144702
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x78]
IMUL RCX,qword ptr [RBP + -0x90],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x001446b0
LAB_00144702:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x80]
SUB RCX,RDX
CMP RAX,RCX
JNC 0x00144726
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x0014473b
LAB_00144726:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xa8],RAX
LAB_0014473b:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x00124230
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x94]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014478d
MOV RAX,qword ptr [RBP + -0xb0]
ADD RSP,0xb0
POP RBP
RET
LAB_0014478d:
CALL 0x00124320
|
char * my_long10_to_str_8bit
(int8 param_1,int1 *param_2,char *param_3,int param_4,ulong param_5)
{
long in_FS_OFFSET;
char *local_b0;
ulong local_a8;
uint local_9c;
char *local_88;
ulong local_80;
char *local_70;
int1 *local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_9c = 0;
local_19[2] = 0;
local_a8 = param_5;
local_70 = param_3;
local_68 = param_2;
if (param_4 < 0) {
if ((long)param_5 < 0) {
local_a8 = -param_5;
local_68 = param_2 + 1;
*param_2 = 0x2d;
local_70 = param_3 + -1;
}
local_9c = (uint)((long)param_5 < 0);
}
local_19[1] = (char)local_a8 + (char)(local_a8 / 10) * -10 + '0';
local_88 = local_19 + 1;
local_80 = local_a8 / 10;
while (local_80 != 0) {
local_88[-1] = (char)local_80 + (char)((long)local_80 / 10) * -10 + '0';
local_88 = local_88 + -1;
local_80 = (long)local_80 / 10;
}
if (local_70 < local_19 + (2 - (long)local_88)) {
local_b0 = local_70;
}
else {
local_b0 = local_19 + (2 - (long)local_88);
}
memcpy(local_68,local_88,(size_t)local_b0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_b0 + local_9c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,138 |
ma_control_file_end
|
eloqsql/storage/maria/ma_control_file.c
|
int ma_control_file_end(void)
{
int close_error;
DBUG_ENTER("ma_control_file_end");
if (control_file_fd < 0) /* already closed */
DBUG_RETURN(0);
#ifndef _WIN32
(void) my_lock(control_file_fd, F_UNLCK, 0L, F_TO_EOF,
MYF(MY_SEEK_NOT_DONE | MY_FORCE_LOCK));
#endif
close_error= mysql_file_close(control_file_fd, MYF(MY_WME));
/*
As mysql_file_close() frees structures even if close() fails, we do the
same, i.e. we mark the file as closed in all cases.
*/
control_file_fd= -1;
/*
As this module owns these variables, closing the module forbids access to
them (just a safety):
*/
last_checkpoint_lsn= LSN_IMPOSSIBLE;
last_logno= FILENO_IMPOSSIBLE;
max_trid_in_control_file= recovery_failures= 0;
DBUG_RETURN(close_error);
}
|
O0
|
c
|
ma_control_file_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x26e931(%rip) # 0x2be460
jge 0x4fb3c
jmp 0x4fb33
movl $0x0, -0x4(%rbp)
jmp 0x4fbaf
movl 0x26e91e(%rip), %edi # 0x2be460
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0xa0, %r8d
movq %rcx, %rdx
callq 0xf48b0
movl 0x26e901(%rip), %edx # 0x2be460
leaq 0x103060(%rip), %rdi # 0x152bc6
movl $0x24d, %esi # imm = 0x24D
movl $0x10, %ecx
callq 0x4fff0
movl %eax, -0x8(%rbp)
movl $0xffffffff, 0x26e8de(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x42987b(%rip) # 0x479408
movl $0x0, 0x429879(%rip) # 0x479410
movb $0x0, 0x429882(%rip) # 0x479420
movq $0x0, 0x42986f(%rip) # 0x479418
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ma_control_file_end:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:control_file_fd, 0
jge short loc_4FB3C
jmp short $+2
loc_4FB33:
mov [rbp+var_4], 0
jmp short loc_4FBAF
loc_4FB3C:
mov edi, cs:control_file_fd
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 0A0h
mov rdx, rcx
call my_lock
mov edx, cs:control_file_fd
lea rdi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 24Dh
mov ecx, 10h
call inline_mysql_file_close_1
mov [rbp+var_8], eax
mov cs:control_file_fd, 0FFFFFFFFh
mov cs:last_checkpoint_lsn, 0
mov cs:last_logno, 0
mov cs:recovery_failures, 0
mov cs:max_trid_in_control_file, 0
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_4FBAF:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
|
long long ma_control_file_end()
{
unsigned int v1; // [rsp+8h] [rbp-8h]
if ( control_file_fd >= 0 )
{
my_lock((unsigned int)control_file_fd, 2LL, 0LL, 0LL, 160LL);
v1 = inline_mysql_file_close_1(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
589LL,
(unsigned int)control_file_fd,
16LL);
control_file_fd = -1;
last_checkpoint_lsn = 0LL;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0LL;
return v1;
}
else
{
return 0;
}
}
|
ma_control_file_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP dword ptr [0x003be460],0x0
JGE 0x0014fb3c
JMP 0x0014fb33
LAB_0014fb33:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fbaf
LAB_0014fb3c:
MOV EDI,dword ptr [0x003be460]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0xa0
MOV RDX,RCX
CALL 0x001f48b0
MOV EDX,dword ptr [0x003be460]
LEA RDI,[0x252bc6]
MOV ESI,0x24d
MOV ECX,0x10
CALL 0x0014fff0
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [0x003be460],0xffffffff
MOV qword ptr [0x00579408],0x0
MOV dword ptr [0x00579410],0x0
MOV byte ptr [0x00579420],0x0
MOV qword ptr [0x00579418],0x0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014fbaf:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 ma_control_file_end(void)
{
int4 local_c;
if (control_file_fd < 0) {
local_c = 0;
}
else {
my_lock(control_file_fd,2,0,0,0xa0);
local_c = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
0x24d,control_file_fd,0x10);
control_file_fd = -1;
last_checkpoint_lsn = 0;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0;
}
return local_c;
}
|
|
63,139 |
translog_page_validator
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_page_validator(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
uint this_page_page_overhead;
uint flags;
uchar *page_pos;
TRANSLOG_FILE *data= (TRANSLOG_FILE *) args->data;
#ifndef DBUG_OFF
pgcache_page_no_t offset= page_no * TRANSLOG_PAGE_SIZE;
#endif
DBUG_ENTER("translog_page_validator");
data->was_recovered= 0;
if (res)
{
DBUG_RETURN(1);
}
if ((pgcache_page_no_t) uint3korr(page) != page_no ||
(uint32) uint3korr(page + 3) != data->number)
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"page address written in the page is incorrect: "
"File %lu instead of %lu or page %lu instead of %lu",
(uint)data->number, (uint)offset,
(ulong) uint3korr(page + 3), (ulong) data->number,
(ulong) uint3korr(page),
(ulong) page_no));
DBUG_RETURN(1);
}
flags= (uint)(page[TRANSLOG_PAGE_FLAGS]);
this_page_page_overhead= page_overhead[flags];
if (flags & ~(TRANSLOG_PAGE_CRC | TRANSLOG_SECTOR_PROTECTION |
TRANSLOG_RECORD_CRC))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"Garbage in the page flags field detected : %x",
(uint) data->number, (uint) offset,
(uint) flags));
DBUG_RETURN(1);
}
page_pos= page + (3 + 3 + 1);
if (flags & TRANSLOG_PAGE_CRC)
{
uint32 crc= translog_crc(page + this_page_page_overhead,
TRANSLOG_PAGE_SIZE -
this_page_page_overhead);
if (crc != uint4korr(page_pos))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"CRC mismatch: calculated: %lx on the page %lx",
(uint) data->number, (uint) offset,
(ulong) crc, (ulong) uint4korr(page_pos)));
DBUG_RETURN(1);
}
page_pos+= CRC_SIZE; /* Skip crc */
}
if (flags & TRANSLOG_SECTOR_PROTECTION &&
translog_check_sector_protection(page, data))
{
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
translog_page_validator:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %r15
movb $0x0, 0x50(%r15)
movb $0x1, %bl
testl %edi, %edi
jne 0x4fdf6
movzwl (%r14), %ecx
movzbl 0x2(%r14), %edx
shll $0x10, %edx
orq %rcx, %rdx
cmpq %rax, %rdx
jne 0x4fdf6
movzwl 0x3(%r14), %eax
movzbl 0x5(%r14), %ecx
shll $0x10, %ecx
orl %eax, %ecx
cmpl (%r15), %ecx
jne 0x4fdf6
movzbl 0x6(%r14), %r12d
cmpl $0x7, %r12d
ja 0x4fdf6
testb $0x1, %r12b
je 0x4fddf
leaq 0xbb1b9c(%rip), %rax # 0xc01960
movl (%rax,%r12,4), %esi
movl $0x2000, %edx # imm = 0x2000
subl %esi, %edx
addq %r14, %rsi
xorl %edi, %edi
callq 0xa8f0c
cmpl 0x7(%r14), %eax
jne 0x4fdf6
testb $0x2, %r12b
je 0x4fdf4
movq %r14, %rdi
movq %r15, %rsi
callq 0x4fe01
testb %al, %al
jne 0x4fdf6
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
translog_page_validator:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, [rsi]
mov rax, [rsi+8]
mov r15, [rsi+10h]
mov byte ptr [r15+50h], 0
mov bl, 1
test edi, edi
jnz short loc_4FDF6
movzx ecx, word ptr [r14]
movzx edx, byte ptr [r14+2]
shl edx, 10h
or rdx, rcx
cmp rdx, rax
jnz short loc_4FDF6
movzx eax, word ptr [r14+3]
movzx ecx, byte ptr [r14+5]
shl ecx, 10h
or ecx, eax
cmp ecx, [r15]
jnz short loc_4FDF6
movzx r12d, byte ptr [r14+6]
cmp r12d, 7
ja short loc_4FDF6
test r12b, 1
jz short loc_4FDDF
lea rax, page_overhead
mov esi, [rax+r12*4]
mov edx, 2000h
sub edx, esi
add rsi, r14
xor edi, edi
call my_checksum
cmp eax, [r14+7]
jnz short loc_4FDF6
loc_4FDDF:
test r12b, 2
jz short loc_4FDF4
mov rdi, r14
mov rsi, r15
call translog_check_sector_protection
test al, al
jnz short loc_4FDF6
loc_4FDF4:
xor ebx, ebx
loc_4FDF6:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long translog_page_validator(int a1, unsigned __int16 **a2)
{
unsigned int v2; // ebx
unsigned __int16 *v3; // r14
unsigned __int16 *v4; // rax
unsigned __int16 *v5; // r15
long long v6; // r12
v3 = *a2;
v4 = a2[1];
v5 = a2[2];
*((_BYTE *)v5 + 80) = 0;
LOBYTE(v2) = 1;
if ( !a1
&& (unsigned __int16 *)(*v3 | (unsigned long long)(*((unsigned __int8 *)v3 + 2) << 16)) == v4
&& (*(unsigned __int16 *)((char *)v3 + 3) | (*((unsigned __int8 *)v3 + 5) << 16)) == *(_DWORD *)v5 )
{
v6 = *((unsigned __int8 *)v3 + 6);
if ( (unsigned int)v6 <= 7
&& ((v6 & 1) == 0
|| (unsigned int)my_checksum(
0LL,
(char *)v3 + *((unsigned int *)&page_overhead + v6),
(unsigned int)(0x2000 - *((_DWORD *)&page_overhead + v6))) == *(_DWORD *)((char *)v3 + 7))
&& ((v6 & 2) == 0 || !(unsigned __int8)translog_check_sector_protection(v3, v5)) )
{
return 0;
}
}
return v2;
}
|
translog_page_validator:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI + 0x10]
MOV byte ptr [R15 + 0x50],0x0
MOV BL,0x1
TEST EDI,EDI
JNZ 0x0014fdf6
MOVZX ECX,word ptr [R14]
MOVZX EDX,byte ptr [R14 + 0x2]
SHL EDX,0x10
OR RDX,RCX
CMP RDX,RAX
JNZ 0x0014fdf6
MOVZX EAX,word ptr [R14 + 0x3]
MOVZX ECX,byte ptr [R14 + 0x5]
SHL ECX,0x10
OR ECX,EAX
CMP ECX,dword ptr [R15]
JNZ 0x0014fdf6
MOVZX R12D,byte ptr [R14 + 0x6]
CMP R12D,0x7
JA 0x0014fdf6
TEST R12B,0x1
JZ 0x0014fddf
LEA RAX,[0xd01960]
MOV ESI,dword ptr [RAX + R12*0x4]
MOV EDX,0x2000
SUB EDX,ESI
ADD RSI,R14
XOR EDI,EDI
CALL 0x001a8f0c
CMP EAX,dword ptr [R14 + 0x7]
JNZ 0x0014fdf6
LAB_0014fddf:
TEST R12B,0x2
JZ 0x0014fdf4
MOV RDI,R14
MOV RSI,R15
CALL 0x0014fe01
TEST AL,AL
JNZ 0x0014fdf6
LAB_0014fdf4:
XOR EBX,EBX
LAB_0014fdf6:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong translog_page_validator(int param_1,long *param_2)
{
byte bVar1;
uint3 *puVar2;
ulong uVar3;
uint *puVar4;
char cVar5;
int iVar6;
int8 unaff_RBX;
ulong uVar7;
puVar2 = (uint3 *)*param_2;
uVar3 = param_2[1];
puVar4 = (uint *)param_2[2];
*(int1 *)(puVar4 + 0x14) = 0;
uVar7 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (((param_1 == 0) && (*puVar2 == uVar3)) && ((uint)*(uint3 *)((long)puVar2 + 3) == *puVar4)) {
bVar1 = *(byte *)((long)puVar2 + 6);
if (bVar1 < 8) {
if ((bVar1 & 1) != 0) {
iVar6 = my_checksum(0,(ulong)*(uint *)(page_overhead + (ulong)bVar1 * 4) + (long)puVar2,
0x2000 - *(uint *)(page_overhead + (ulong)bVar1 * 4));
if (iVar6 != *(int *)((long)puVar2 + 7)) goto LAB_0014fdf6;
}
if ((bVar1 & 2) != 0) {
cVar5 = translog_check_sector_protection(puVar2,puVar4);
if (cVar5 != '\0') goto LAB_0014fdf6;
}
uVar7 = 0;
}
}
LAB_0014fdf6:
return uVar7 & 0xffffffff;
}
|
|
63,140 |
my_printf_error
|
eloqsql/mysys/my_error.c
|
void my_printf_error(uint error, const char *format, myf MyFlags, ...)
{
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printf_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_printf_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rdx, %rbx
movq %rsi, %r10
movl %edi, %r14d
leaq -0x2f0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x297c9
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movabsq $0x3000000018, %rax # imm = 0x3000000018
leaq -0x240(%rbp), %r8
movq %rax, (%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movq %rdx, 0x10(%r8)
leaq 0x3370a3(%rip), %rdi # 0x3608a0
leaq -0x220(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rsi
movq %r10, %rcx
callq 0x57af4
leaq 0x2c3b55(%rip), %rax # 0x2ed370
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rax)
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x29843
addq $0x2d8, %rsp # imm = 0x2D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x242e0
|
my_printf_error:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 2D8h
mov rbx, rdx
mov r10, rsi
mov r14d, edi
lea rdx, [rbp+var_2F0]
mov [rdx+18h], rcx
mov [rdx+20h], r8
mov [rdx+28h], r9
test al, al
jz short loc_297C9
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_297C9:
mov rax, fs:28h
mov [rbp+var_20], rax
mov rax, 3000000018h
lea r8, [rbp+var_240]
mov [r8], rax
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov [r8+10h], rdx
lea rdi, my_charset_utf8mb3_general_ci
lea r15, [rbp+var_220]
mov edx, 200h
mov rsi, r15
mov rcx, r10
call my_vsnprintf_ex
lea rax, error_handler_hook
mov edi, r14d
mov rsi, r15
mov rdx, rbx
call qword ptr [rax]
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_29843
add rsp, 2D8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_29843:
call ___stack_chk_fail
|
unsigned long long my_printf_error(
unsigned int a1,
long long a2,
__int16 a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v17; // [rsp+0h] [rbp-2F0h] BYREF
long long v18; // [rsp+18h] [rbp-2D8h]
long long v19; // [rsp+20h] [rbp-2D0h]
long long v20; // [rsp+28h] [rbp-2C8h]
__m128 v21; // [rsp+30h] [rbp-2C0h]
__m128 v22; // [rsp+40h] [rbp-2B0h]
__m128 v23; // [rsp+50h] [rbp-2A0h]
__m128 v24; // [rsp+60h] [rbp-290h]
__m128 v25; // [rsp+70h] [rbp-280h]
__m128 v26; // [rsp+80h] [rbp-270h]
__m128 v27; // [rsp+90h] [rbp-260h]
__m128 v28; // [rsp+A0h] [rbp-250h]
_QWORD v29[4]; // [rsp+B0h] [rbp-240h] BYREF
_BYTE v30[512]; // [rsp+D0h] [rbp-220h] BYREF
unsigned long long v31; // [rsp+2D0h] [rbp-20h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v18 = a4;
v19 = a5;
v20 = a6;
v31 = __readfsqword(0x28u);
v29[0] = 0x3000000018LL;
v29[1] = &a15;
v29[2] = &v17;
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v30, 512LL, a2, v29);
error_handler_hook(a1, (long long)v30, a3);
return __readfsqword(0x28u);
}
|
my_printf_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x2d8
MOV RBX,RDX
MOV R10,RSI
MOV R14D,EDI
LEA RDX,[RBP + -0x2f0]
MOV qword ptr [RDX + 0x18],RCX
MOV qword ptr [RDX + 0x20],R8
MOV qword ptr [RDX + 0x28],R9
TEST AL,AL
JZ 0x001297c9
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_001297c9:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,0x3000000018
LEA R8,[RBP + -0x240]
MOV qword ptr [R8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV qword ptr [R8 + 0x10],RDX
LEA RDI,[0x4608a0]
LEA R15,[RBP + -0x220]
MOV EDX,0x200
MOV RSI,R15
MOV RCX,R10
CALL 0x00157af4
LEA RAX,[0x3ed370]
MOV EDI,R14D
MOV RSI,R15
MOV RDX,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00129843
ADD RSP,0x2d8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00129843:
CALL 0x001242e0
|
void my_printf_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [24];
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int8 local_248;
int1 *local_240;
int1 *local_238;
int1 local_228 [512];
long local_28;
local_238 = local_2f8;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_28 = *(long *)(in_FS_OFFSET + 0x28);
local_248 = 0x3000000018;
local_240 = &stack0x00000008;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_228,0x200,param_10);
(*(code *)error_handler_hook)(param_9,local_228,param_11);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,141 |
options_add_initcommand
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
static void options_add_initcommand(struct st_mysql_options *options,
const char *init_cmd)
{
char *insert= strdup(init_cmd);
if (!options->init_command)
{
options->init_command= (DYNAMIC_ARRAY*)malloc(sizeof(DYNAMIC_ARRAY));
ma_init_dynamic_array(options->init_command, sizeof(char*), 5, 5);
}
if (ma_insert_dynamic(options->init_command, (gptr)&insert))
free(insert);
}
|
O0
|
c
|
options_add_initcommand:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a030
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xa8fc6
movl $0x18, %edi
callq 0x3a920
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movl $0x8, %esi
movl $0x5, %ecx
movl %ecx, %edx
callq 0xcafe0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcb0c0
cmpb $0x0, %al
je 0xa8fe4
movq -0x18(%rbp), %rdi
callq 0x3a1a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
options_add_initcommand:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
call _strdup
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+48h], 0
jnz short loc_A8FC6
mov edi, 18h
call _malloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+48h], rcx
mov rax, [rbp+var_8]
mov rdi, [rax+48h]
mov esi, 8
mov ecx, 5
mov edx, ecx
call ma_init_dynamic_array
loc_A8FC6:
mov rax, [rbp+var_8]
mov rdi, [rax+48h]
lea rsi, [rbp+var_18]
call ma_insert_dynamic
cmp al, 0
jz short loc_A8FE4
mov rdi, [rbp+var_18]
call _free
loc_A8FE4:
add rsp, 20h
pop rbp
retn
|
long long options_add_initcommand(long long a1, long long a2)
{
long long result; // rax
_QWORD v3[2]; // [rsp+8h] [rbp-18h] BYREF
long long v4; // [rsp+18h] [rbp-8h]
v4 = a1;
v3[1] = a2;
v3[0] = strdup(a2);
if ( !*(_QWORD *)(a1 + 72) )
{
*(_QWORD *)(v4 + 72) = malloc(24LL);
ma_init_dynamic_array(*(_QWORD *)(v4 + 72), 8LL, 5LL);
}
result = ma_insert_dynamic(*(_QWORD *)(v4 + 72), v3);
if ( (_BYTE)result )
return free(v3[0]);
return result;
}
|
options_add_initcommand:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013a030
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x48],0x0
JNZ 0x001a8fc6
MOV EDI,0x18
CALL 0x0013a920
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x48]
MOV ESI,0x8
MOV ECX,0x5
MOV EDX,ECX
CALL 0x001cafe0
LAB_001a8fc6:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x48]
LEA RSI,[RBP + -0x18]
CALL 0x001cb0c0
CMP AL,0x0
JZ 0x001a8fe4
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0013a1a0
LAB_001a8fe4:
ADD RSP,0x20
POP RBP
RET
|
void options_add_initcommand(long param_1,char *param_2)
{
char cVar1;
void *pvVar2;
char *local_20;
char *local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
local_20 = strdup(param_2);
if (*(long *)(local_10 + 0x48) == 0) {
pvVar2 = malloc(0x18);
*(void **)(local_10 + 0x48) = pvVar2;
ma_init_dynamic_array(*(int8 *)(local_10 + 0x48),8,5);
}
cVar1 = ma_insert_dynamic(*(int8 *)(local_10 + 0x48),&local_20);
if (cVar1 != '\0') {
free(local_20);
}
return;
}
|
|
63,142 |
my_caseup_str_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static size_t
my_caseup_str_utf8mb4(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->caseup_multiply == 1);
while (*src &&
(srcres= my_mb_wc_utf8mb4_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_toupper_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
*dst= '\0';
return (size_t) (dst - dst0);
}
|
O3
|
c
|
my_caseup_str_utf8mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %r14
je 0x4fcbb
movq 0x78(%rdi), %r15
movq %rbx, %r12
movq %rbx, %r14
leaq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x52fff
testl %eax, %eax
je 0x4fcbb
movl %eax, %r13d
movq -0x30(%rbp), %rdi
cmpq (%r15), %rdi
ja 0x4fc9c
movq 0x8(%r15), %rax
movq %rdi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4fc9c
movzbl %dil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %edi
movq %rdi, -0x30(%rbp)
movq %r14, %rsi
callq 0x5311b
testl %eax, %eax
je 0x4fcbb
movl %r13d, %ecx
movl %eax, %eax
addq %rax, %r14
cmpb $0x0, (%r12,%rcx)
leaq (%r12,%rcx), %r12
jne 0x4fc5d
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_caseup_str_utf8mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp byte ptr [rsi], 0
mov r14, rsi
jz short loc_4FCBB
mov r15, [rdi+78h]
mov r12, rbx
mov r14, rbx
loc_4FC5D:
lea rdi, [rbp+var_30]
mov rsi, r12
call my_mb_wc_utf8mb4_no_range
test eax, eax
jz short loc_4FCBB
mov r13d, eax
mov rdi, [rbp+var_30]
cmp rdi, [r15]
ja short loc_4FC9C
mov rax, [r15+8]
mov rcx, rdi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_4FC9C
movzx ecx, dil
lea rcx, [rcx+rcx*2]
mov edi, [rax+rcx*4]
mov [rbp+var_30], rdi
loc_4FC9C:
mov rsi, r14
call my_wc_mb_utf8mb4_no_range
test eax, eax
jz short loc_4FCBB
mov ecx, r13d
mov eax, eax
add r14, rax
cmp byte ptr [r12+rcx], 0
lea r12, [r12+rcx]
jnz short loc_4FC5D
loc_4FCBB:
mov byte ptr [r14], 0
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_caseup_str_utf8mb4(long long a1, _BYTE *a2)
{
long long v2; // rax
_BYTE *v3; // r14
_QWORD *v4; // r15
_BYTE *v5; // r12
unsigned int v6; // eax
unsigned int v7; // r13d
long long v8; // rdi
long long v9; // rax
unsigned int v10; // eax
bool v11; // zf
_QWORD v13[6]; // [rsp+0h] [rbp-30h] BYREF
v13[0] = v2;
v3 = a2;
if ( *a2 )
{
v4 = *(_QWORD **)(a1 + 120);
v5 = a2;
v3 = a2;
do
{
v6 = my_mb_wc_utf8mb4_no_range(v13, v5);
if ( !v6 )
break;
v7 = v6;
v8 = v13[0];
if ( v13[0] <= *v4 )
{
v9 = *(_QWORD *)(v4[1] + 8LL * (v13[0] >> 8));
if ( v9 )
{
v8 = *(unsigned int *)(v9 + 12LL * LOBYTE(v13[0]));
v13[0] = v8;
}
}
v10 = my_wc_mb_utf8mb4_no_range(v8, v3);
if ( !v10 )
break;
v3 += v10;
v11 = v5[v7] == 0;
v5 += v7;
}
while ( !v11 );
}
*v3 = 0;
return v3 - a2;
}
|
my_caseup_str_utf8mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV R14,RSI
JZ 0x0014fcbb
MOV R15,qword ptr [RDI + 0x78]
MOV R12,RBX
MOV R14,RBX
LAB_0014fc5d:
LEA RDI,[RBP + -0x30]
MOV RSI,R12
CALL 0x00152fff
TEST EAX,EAX
JZ 0x0014fcbb
MOV R13D,EAX
MOV RDI,qword ptr [RBP + -0x30]
CMP RDI,qword ptr [R15]
JA 0x0014fc9c
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,RDI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x0014fc9c
MOVZX ECX,DIL
LEA RCX,[RCX + RCX*0x2]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x30],RDI
LAB_0014fc9c:
MOV RSI,R14
CALL 0x0015311b
TEST EAX,EAX
JZ 0x0014fcbb
MOV ECX,R13D
MOV EAX,EAX
ADD R14,RAX
CMP byte ptr [R12 + RCX*0x1],0x0
LEA R12,[R12 + RCX*0x1]
JNZ 0x0014fc5d
LAB_0014fcbb:
MOV byte ptr [R14],0x0
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_str_utf8mb4(long param_1,char *param_2)
{
char *pcVar1;
ulong *puVar2;
long lVar3;
uint uVar4;
uint uVar5;
ulong in_RAX;
char *pcVar6;
char *pcVar7;
ulong local_38;
pcVar7 = param_2;
if (*param_2 != '\0') {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar6 = param_2;
local_38 = in_RAX;
do {
uVar4 = my_mb_wc_utf8mb4_no_range(&local_38,pcVar6);
if (uVar4 == 0) break;
if ((local_38 <= *puVar2) && (lVar3 = *(long *)(puVar2[1] + (local_38 >> 8) * 8), lVar3 != 0))
{
local_38 = (ulong)*(uint *)(lVar3 + (local_38 & 0xff) * 0xc);
}
uVar5 = my_wc_mb_utf8mb4_no_range(local_38,pcVar7);
if (uVar5 == 0) break;
pcVar7 = pcVar7 + uVar5;
pcVar1 = pcVar6 + uVar4;
pcVar6 = pcVar6 + uVar4;
} while (*pcVar1 != '\0');
}
*pcVar7 = '\0';
return (long)pcVar7 - (long)param_2;
}
|
|
63,143 |
void fmt::v10::detail::format_hexfloat<long double, 0>(long double, int, fmt::v10::detail::float_specs, fmt::v10::detail::buffer<char>&)
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
float_specs specs, buffer<char>& buf) {
// float is passed as double to reduce the number of instantiations and to
// simplify implementation.
static_assert(!std::is_same<Float, float>::value, "");
using info = dragonbox::float_info<Float>;
// Assume Float is in the format [sign][exponent][significand].
using carrier_uint = typename info::carrier_uint;
constexpr auto num_float_significand_bits =
detail::num_significand_bits<Float>();
basic_fp<carrier_uint> f(value);
f.e += num_float_significand_bits;
if (!has_implicit_bit<Float>()) --f.e;
constexpr auto num_fraction_bits =
num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
constexpr auto num_xdigits = (num_fraction_bits + 3) / 4;
constexpr auto leading_shift = ((num_xdigits - 1) * 4);
const auto leading_mask = carrier_uint(0xF) << leading_shift;
const auto leading_xdigit =
static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);
int print_xdigits = num_xdigits - 1;
if (precision >= 0 && print_xdigits > precision) {
const int shift = ((print_xdigits - precision - 1) * 4);
const auto mask = carrier_uint(0xF) << shift;
const auto v = static_cast<uint32_t>((f.f & mask) >> shift);
if (v >= 8) {
const auto inc = carrier_uint(1) << (shift + 4);
f.f += inc;
f.f &= ~(inc - 1);
}
// Check long double overflow
if (!has_implicit_bit<Float>()) {
const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
if ((f.f & implicit_bit) == implicit_bit) {
f.f >>= 4;
f.e += 4;
}
}
print_xdigits = precision;
}
char xdigits[num_bits<carrier_uint>() / 4];
detail::fill_n(xdigits, sizeof(xdigits), '0');
format_uint<4>(xdigits, f.f, num_xdigits, specs.upper);
// Remove zero tail
while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;
buf.push_back('0');
buf.push_back(specs.upper ? 'X' : 'x');
buf.push_back(xdigits[0]);
if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision)
buf.push_back('.');
buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0');
buf.push_back(specs.upper ? 'P' : 'p');
uint32_t abs_e;
if (f.e < 0) {
buf.push_back('-');
abs_e = static_cast<uint32_t>(-f.e);
} else {
buf.push_back('+');
abs_e = static_cast<uint32_t>(f.e);
}
format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e));
}
|
O3
|
c
|
void fmt::v10::detail::format_hexfloat<long double, 0>(long double, int, fmt::v10::detail::float_specs, fmt::v10::detail::buffer<char>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %r12d
shrq $0x20, %r15
movq %xmm0, %rax
movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
andq %rax, %rdx
movq %rax, %rsi
andq %rcx, %rsi
movq %rdx, %rdi
shrq $0x34, %rdi
addl $0xfffffc01, %edi # imm = 0xFFFFFC01
testq %rdx, %rdx
leaq 0x1(%rsi,%rcx), %rax
cmoveq %rsi, %rax
movl $0xfffffc02, %r8d # imm = 0xFFFFFC02
movq %rdi, 0x8(%rsp)
cmovnel %edi, %r8d
movl $0xd, %r13d
cmpl $0xc, %r12d
ja 0x4143f
leal (,%r12,4), %edx
movb $0x30, %cl
subb %dl, %cl
movq %rax, %rsi
shrq %cl, %rsi
testb $0x8, %sil
je 0x4143c
movb $0x34, %cl
subb %dl, %cl
movl $0x1, %edx
shlq %cl, %rdx
addq %rdx, %rax
negq %rdx
andq %rdx, %rax
movl %r12d, %r13d
movaps 0x11fcda(%rip), %xmm0 # 0x161120
leaq 0x1d(%rsp), %rcx
movaps %xmm0, -0xd(%rcx)
btl $0x10, %r15d
leaq 0x1202fa(%rip), %rsi # 0x161755
leaq 0x1202e2(%rip), %rdx # 0x161744
cmovaeq %rsi, %rdx
movq %rax, %rsi
movl %eax, %edi
andl $0xf, %edi
movb (%rdx,%rdi), %dil
movb %dil, (%rcx)
shrq $0x4, %rsi
decq %rcx
cmpq $0xf, %rax
movq %rsi, %rax
ja 0x41469
movl %r8d, 0x4(%rsp)
testl %r13d, %r13d
jle 0x414af
movl %r13d, %eax
cmpb $0x30, 0x10(%rsp,%rax)
setne %bpl
jne 0x414b1
leal -0x1(%r13), %eax
cmpl $0x1, %r13d
movl %eax, %r13d
jg 0x4148f
xorl %r13d, %r13d
jmp 0x414b1
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x414cf
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq %r15, %r14
btl $0x10, %r15d
setae %r15b
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x30, (%rcx,%rax)
shlb $0x5, %r15b
orb $0x58, %r15b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x4150d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r15b, (%rcx,%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x41537
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movb 0x10(%rsp), %cl
movq 0x8(%rbx), %rdx
movq %rsi, 0x10(%rbx)
movb %cl, (%rdx,%rax)
movl %r14d, %eax
shrl $0x13, %eax
andl $0x1, %eax
testl %r12d, %r12d
setg %cl
orb %al, %cl
orb %bpl, %cl
cmpb $0x1, %cl
jne 0x41589
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x4157d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x2e, (%rcx,%rax)
leaq 0x11(%rsp), %rsi
movl %r13d, %eax
leaq (%rsp,%rax), %rdx
addq $0x11, %rdx
movq %rbx, %rdi
callq 0x348f8
subl %r13d, %r12d
jle 0x415d5
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x415c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x30, (%rcx,%rax)
decl %r12d
jne 0x415a6
btl $0x10, %r14d
setae %bpl
shlb $0x5, %bpl
orb $0x50, %bpl
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x41604
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %bpl, (%rcx,%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x1(%rax), %rsi
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
js 0x4164c
cmpq %rsi, %rcx
jae 0x41639
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rsp), %r8
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x2b, (%rcx,%rax)
jmp 0x41672
cmpq %rsi, %rcx
jae 0x41661
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x2d, (%rcx,%rax)
negl %ebp
movl %ebp, %r8d
movl %r8d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x1203de(%rip), %rcx # 0x161a60
movl %r8d, %edx
addq (%rcx,%rax,8), %rdx
shrq $0x20, %rdx
leaq 0x28(%rsp), %r15
movw $0x0, 0x8(%r15)
movq $0x0, (%r15)
movq %r15, %rdi
movl %r8d, %esi
callq 0x34878
movq %r15, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x348e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN3fmt3v106detail15format_hexfloatIdTnNSt9enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEvS4_iNS1_11float_specsERNS1_6bufferIcEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdx
mov r15, rsi
mov r12d, edi
shr r15, 20h
movq rax, xmm0
mov rcx, 0FFFFFFFFFFFFFh
mov rdx, 7FF0000000000000h
and rdx, rax
mov rsi, rax
and rsi, rcx
mov rdi, rdx
shr rdi, 34h
add edi, 0FFFFFC01h
test rdx, rdx
lea rax, [rsi+rcx+1]
cmovz rax, rsi
mov r8d, 0FFFFFC02h
mov [rsp+68h+var_60], rdi
cmovnz r8d, edi
mov r13d, 0Dh
cmp r12d, 0Ch
ja short loc_4143F
lea edx, ds:0[r12*4]
mov cl, 30h ; '0'
sub cl, dl
mov rsi, rax
shr rsi, cl
test sil, 8
jz short loc_4143C
mov cl, 34h ; '4'
sub cl, dl
mov edx, 1
shl rdx, cl
add rax, rdx
neg rdx
and rax, rdx
loc_4143C:
mov r13d, r12d
loc_4143F:
movaps xmm0, cs:xmmword_161120
lea rcx, [rsp+68h+var_4B]
movaps xmmword ptr [rcx-0Dh], xmm0
bt r15d, 10h
lea rsi, a0123456789abcd_0; "0123456789abcdef"
lea rdx, a0123456789abcd; "0123456789ABCDEF"
cmovnb rdx, rsi
mov rsi, rax
loc_41469:
mov edi, eax
and edi, 0Fh
mov dil, [rdx+rdi]
mov [rcx], dil
shr rsi, 4
dec rcx
cmp rax, 0Fh
mov rax, rsi
ja short loc_41469
mov [rsp+68h+var_64], r8d
test r13d, r13d
jle short loc_414AF
loc_4148F:
mov eax, r13d
cmp [rsp+rax+68h+var_58], 30h ; '0'
setnz bpl
jnz short loc_414B1
lea eax, [r13-1]
cmp r13d, 1
mov r13d, eax
jg short loc_4148F
xor r13d, r13d
jmp short loc_414B1
loc_414AF:
xor ebp, ebp
loc_414B1:
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_414CF
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_414CF:
mov r14, r15
bt r15d, 10h
setnb r15b
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 30h ; '0'
shl r15b, 5
or r15b, 58h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_4150D
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_4150D:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], r15b
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_41537
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_41537:
mov cl, [rsp+68h+var_58]
mov rdx, [rbx+8]
mov [rbx+10h], rsi
mov [rdx+rax], cl
mov eax, r14d
shr eax, 13h
and eax, 1
test r12d, r12d
setnle cl
or cl, al
or cl, bpl
cmp cl, 1
jnz short loc_41589
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_4157D
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_4157D:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 2Eh ; '.'
loc_41589:
lea rsi, [rsp+68h+var_57]
mov eax, r13d
lea rdx, [rsp+rax+68h+var_68]
add rdx, 11h
mov rdi, rbx
call _ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v10::detail::buffer<char>::append<char>(char const*,char const*)
sub r12d, r13d
jle short loc_415D5
loc_415A6:
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_415C4
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_415C4:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 30h ; '0'
dec r12d
jnz short loc_415A6
loc_415D5:
bt r14d, 10h
setnb bpl
shl bpl, 5
or bpl, 50h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_41604
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_41604:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], bpl
mov rax, [rbx+10h]
mov rcx, [rbx+18h]
lea rsi, [rax+1]
mov ebp, [rsp+68h+var_64]
test ebp, ebp
js short loc_4164C
cmp rcx, rsi
jnb short loc_41639
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_41639:
mov r8, [rsp+68h+var_60]
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 2Bh ; '+'
jmp short loc_41672
loc_4164C:
cmp rcx, rsi
jnb short loc_41661
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_41661:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 2Dh ; '-'
neg ebp
mov r8d, ebp
loc_41672:
mov eax, r8d
or eax, 1
bsr eax, eax
lea rcx, _ZZN3fmt3v106detail15do_count_digitsEjE5table; fmt::v10::detail::do_count_digits(uint)::table
mov edx, r8d
add rdx, [rcx+rax*8]
shr rdx, 20h
lea r15, [rsp+68h+var_40]
mov word ptr [r15+8], 0
mov qword ptr [r15], 0
mov rdi, r15
mov esi, r8d
call _ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,uint>(char *,uint,int)
mov rdi, r15
mov rsi, rdx
mov rdx, rbx
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ZN3fmt3v106detail15format_hexfloatIdTnNSt9enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEvS4_iNS1_11float_specsERNS1_6bufferIcEE(
signed int a1,
unsigned long long a2,
long long a3,
double a4)
{
unsigned long long v5; // r15
unsigned long long v6; // rax
int v7; // r8d
int v8; // r13d
_BYTE *v9; // rcx
const char *v10; // rdx
unsigned long long v11; // rsi
bool v12; // cc
bool v13; // bp
long long v14; // rax
long long v15; // rsi
int v16; // r14d
long long v17; // rcx
char v18; // r15
long long v19; // rax
long long v20; // rsi
long long v21; // rcx
long long v22; // rax
long long v23; // rsi
char v24; // cl
long long v25; // rdx
long long v26; // rax
long long v27; // rsi
long long v28; // rcx
int v29; // r12d
long long v30; // rax
long long v31; // rsi
long long v32; // rcx
long long v33; // rax
long long v34; // rsi
long long v35; // rcx
long long v36; // rax
unsigned long long v37; // rcx
unsigned long long v38; // rsi
unsigned int v39; // r8d
long long v40; // rcx
long long v41; // rcx
long long v42; // rax
unsigned long long v43; // rdx
long long v44; // rdx
int v46; // [rsp+4h] [rbp-64h]
__int128 v47; // [rsp+10h] [rbp-58h] BYREF
long long v48; // [rsp+28h] [rbp-40h] BYREF
__int16 v49; // [rsp+30h] [rbp-38h]
v5 = HIDWORD(a2);
v6 = (*(_QWORD *)&a4 & 0xFFFFFFFFFFFFFLL) + 0x10000000000000LL;
if ( (*(_QWORD *)&a4 & 0x7FF0000000000000LL) == 0 )
v6 = *(_QWORD *)&a4 & 0xFFFFFFFFFFFFFLL;
v7 = -1022;
if ( (*(_QWORD *)&a4 & 0x7FF0000000000000LL) != 0 )
v7 = ((*(_QWORD *)&a4 & 0x7FF0000000000000uLL) >> 52) - 1023;
v8 = 13;
if ( (unsigned int)a1 <= 0xC )
{
if ( ((v6 >> (48 - 4 * (unsigned __int8)a1)) & 8) != 0 )
v6 = -(1LL << (52 - 4 * (unsigned __int8)a1)) & ((1LL << (52 - 4 * (unsigned __int8)a1)) + v6);
v8 = a1;
}
v9 = (char *)&v47 + 13;
v47 = xmmword_161120;
v10 = "0123456789ABCDEF";
if ( (a2 & 0x1000000000000LL) == 0 )
v10 = "0123456789abcdef";
v11 = v6;
do
{
*v9 = v10[v6 & 0xF];
v11 >>= 4;
--v9;
v12 = v6 <= 0xF;
v6 = v11;
}
while ( !v12 );
v46 = v7;
if ( v8 <= 0 )
{
v13 = 0;
}
else
{
while ( 1 )
{
v13 = *((_BYTE *)&v47 + (unsigned int)v8) != 48;
if ( *((_BYTE *)&v47 + (unsigned int)v8) != 48 )
break;
v12 = v8-- <= 1;
if ( v12 )
{
v8 = 0;
break;
}
}
}
v14 = *(_QWORD *)(a3 + 16);
v15 = v14 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v14 + 1) )
{
(**(void ( ***)(long long, long long, const char *, _BYTE *))a3)(a3, v15, v10, v9);
v14 = *(_QWORD *)(a3 + 16);
v15 = v14 + 1;
}
v16 = v5;
v17 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v15;
*(_BYTE *)(v17 + v14) = 48;
v18 = (32 * ((v5 & 0x10000) == 0)) | 0x58;
v19 = *(_QWORD *)(a3 + 16);
v20 = v19 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v19 + 1) )
{
(**(void ( ***)(long long))a3)(a3);
v19 = *(_QWORD *)(a3 + 16);
v20 = v19 + 1;
}
v21 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v20;
*(_BYTE *)(v21 + v19) = v18;
v22 = *(_QWORD *)(a3 + 16);
v23 = v22 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v22 + 1) )
{
(**(void ( ***)(long long))a3)(a3);
v22 = *(_QWORD *)(a3 + 16);
v23 = v22 + 1;
}
v24 = v47;
v25 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v23;
*(_BYTE *)(v25 + v22) = v24;
if ( v13 || (v16 & 0x80000) != 0 || a1 > 0 )
{
v26 = *(_QWORD *)(a3 + 16);
v27 = v26 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v26 + 1) )
{
(**(void ( ***)(long long))a3)(a3);
v26 = *(_QWORD *)(a3 + 16);
v27 = v26 + 1;
}
v28 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v27;
*(_BYTE *)(v28 + v26) = 46;
}
fmt::v10::detail::buffer<char>::append<char>(a3, (long long)&v47 + 1, (long long)&v47 + (unsigned int)v8 + 1);
v29 = a1 - v8;
if ( a1 > v8 )
{
do
{
v30 = *(_QWORD *)(a3 + 16);
v31 = v30 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v30 + 1) )
{
(**(void ( ***)(long long))a3)(a3);
v30 = *(_QWORD *)(a3 + 16);
v31 = v30 + 1;
}
v32 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v31;
*(_BYTE *)(v32 + v30) = 48;
--v29;
}
while ( v29 );
}
v33 = *(_QWORD *)(a3 + 16);
v34 = v33 + 1;
if ( *(_QWORD *)(a3 + 24) < (unsigned long long)(v33 + 1) )
{
(**(void ( ***)(long long))a3)(a3);
v33 = *(_QWORD *)(a3 + 16);
v34 = v33 + 1;
}
v35 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v34;
*(_BYTE *)(v35 + v33) = (32 * ((v16 & 0x10000) == 0)) | 0x50;
v36 = *(_QWORD *)(a3 + 16);
v37 = *(_QWORD *)(a3 + 24);
v38 = v36 + 1;
if ( v46 < 0 )
{
if ( v37 < v38 )
{
(**(void ( ***)(long long))a3)(a3);
v36 = *(_QWORD *)(a3 + 16);
v38 = v36 + 1;
}
v41 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v38;
*(_BYTE *)(v41 + v36) = 45;
v39 = -v46;
}
else
{
if ( v37 < v38 )
{
(**(void ( ***)(long long))a3)(a3);
v36 = *(_QWORD *)(a3 + 16);
v38 = v36 + 1;
}
v39 = ((*(_QWORD *)&a4 & 0x7FF0000000000000uLL) >> 52) - 1023;
v40 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a3 + 16) = v38;
*(_BYTE *)(v40 + v36) = 43;
}
_BitScanReverse((unsigned int *)&v42, v39 | 1);
v43 = (fmt::v10::detail::do_count_digits(unsigned int)::table[v42] + (unsigned long long)v39) >> 32;
v49 = 0;
v48 = 0LL;
fmt::v10::detail::format_decimal<char,unsigned int>((long long)&v48, v39, v43);
return fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>((long long)&v48, v44, a3);
}
|
_ZN3fmt3v106detail15format_hexfloatIdTnNSt9enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEvS4_iNS1_11float_specsERNS1_6bufferIcEE:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDX
MOV R15,RSI
MOV R12D,EDI
SHR R15,0x20
MOVQ RAX,XMM0
MOV RCX,0xfffffffffffff
MOV RDX,0x7ff0000000000000
AND RDX,RAX
MOV RSI,RAX
AND RSI,RCX
MOV RDI,RDX
SHR RDI,0x34
ADD EDI,0xfffffc01
TEST RDX,RDX
LEA RAX,[RSI + RCX*0x1 + 0x1]
CMOVZ RAX,RSI
MOV R8D,0xfffffc02
MOV qword ptr [RSP + 0x8],RDI
CMOVNZ R8D,EDI
MOV R13D,0xd
CMP R12D,0xc
JA 0x0014143f
LEA EDX,[R12*0x4]
MOV CL,0x30
SUB CL,DL
MOV RSI,RAX
SHR RSI,CL
TEST SIL,0x8
JZ 0x0014143c
MOV CL,0x34
SUB CL,DL
MOV EDX,0x1
SHL RDX,CL
ADD RAX,RDX
NEG RDX
AND RAX,RDX
LAB_0014143c:
MOV R13D,R12D
LAB_0014143f:
MOVAPS XMM0,xmmword ptr [0x00261120]
LEA RCX,[RSP + 0x1d]
MOVAPS xmmword ptr [RCX + -0xd],XMM0
BT R15D,0x10
LEA RSI,[0x261755]
LEA RDX,[0x261744]
CMOVNC RDX,RSI
MOV RSI,RAX
LAB_00141469:
MOV EDI,EAX
AND EDI,0xf
MOV DIL,byte ptr [RDX + RDI*0x1]
MOV byte ptr [RCX],DIL
SHR RSI,0x4
DEC RCX
CMP RAX,0xf
MOV RAX,RSI
JA 0x00141469
MOV dword ptr [RSP + 0x4],R8D
TEST R13D,R13D
JLE 0x001414af
LAB_0014148f:
MOV EAX,R13D
CMP byte ptr [RSP + RAX*0x1 + 0x10],0x30
SETNZ BPL
JNZ 0x001414b1
LEA EAX,[R13 + -0x1]
CMP R13D,0x1
MOV R13D,EAX
JG 0x0014148f
XOR R13D,R13D
JMP 0x001414b1
LAB_001414af:
XOR EBP,EBP
LAB_001414b1:
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001414cf
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001414cf:
MOV R14,R15
BT R15D,0x10
SETNC R15B
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x30
SHL R15B,0x5
OR R15B,0x58
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x0014150d
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_0014150d:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],R15B
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x00141537
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00141537:
MOV CL,byte ptr [RSP + 0x10]
MOV RDX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RDX + RAX*0x1],CL
MOV EAX,R14D
SHR EAX,0x13
AND EAX,0x1
TEST R12D,R12D
SETG CL
OR CL,AL
OR CL,BPL
CMP CL,0x1
JNZ 0x00141589
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x0014157d
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_0014157d:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x2e
LAB_00141589:
LEA RSI,[RSP + 0x11]
MOV EAX,R13D
LEA RDX,[RSP + RAX*0x1]
ADD RDX,0x11
MOV RDI,RBX
CALL 0x001348f8
SUB R12D,R13D
JLE 0x001415d5
LAB_001415a6:
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001415c4
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001415c4:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x30
DEC R12D
JNZ 0x001415a6
LAB_001415d5:
BT R14D,0x10
SETNC BPL
SHL BPL,0x5
OR BPL,0x50
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x00141604
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00141604:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],BPL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RBX + 0x18]
LEA RSI,[RAX + 0x1]
MOV EBP,dword ptr [RSP + 0x4]
TEST EBP,EBP
JS 0x0014164c
CMP RCX,RSI
JNC 0x00141639
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00141639:
MOV R8,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x2b
JMP 0x00141672
LAB_0014164c:
CMP RCX,RSI
JNC 0x00141661
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00141661:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x2d
NEG EBP
MOV R8D,EBP
LAB_00141672:
MOV EAX,R8D
OR EAX,0x1
BSR EAX,EAX
LEA RCX,[0x261a60]
MOV EDX,R8D
ADD RDX,qword ptr [RCX + RAX*0x8]
SHR RDX,0x20
LEA R15,[RSP + 0x28]
MOV word ptr [R15 + 0x8],0x0
MOV qword ptr [R15],0x0
MOV RDI,R15
MOV ESI,R8D
CALL 0x00134878
MOV RDI,R15
MOV RSI,RDX
MOV RDX,RBX
CALL 0x001348e0
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void _ZN3fmt3v106detail15format_hexfloatIdTnNSt9enable_ifIXntsr16is_double_doubleIT_EE5valueEiE4typeELi0EEEvS4_iNS1_11float_specsERNS1_6bufferIcEE
(ulong param_1,uint param_2,int8 param_3,buffer<char> *param_4)
{
ulong uVar1;
char *pcVar2;
long lVar3;
char *pcVar4;
int8 extraout_RDX;
uint uVar5;
uint uVar6;
int iVar7;
ulong uVar8;
uint uVar9;
bool bVar10;
char local_58 [8];
char acStack_50 [4];
char cStack_4c;
char acStack_4b [11];
char acStack_40 [16];
uVar5 = (((uint)(param_1 >> 0x20) & 0x7ff00000) >> 0x14) - 0x3ff;
bVar10 = (param_1 & 0x7ff0000000000000) == 0;
uVar1 = (param_1 & 0xfffffffffffff) + 0x10000000000000;
if (bVar10) {
uVar1 = param_1 & 0xfffffffffffff;
}
uVar6 = 0xfffffc02;
if (!bVar10) {
uVar6 = uVar5;
}
uVar8 = 0xd;
if (param_2 < 0xd) {
if ((uVar1 >> ((char)param_2 * -4 + 0x30U & 0x3f) & 8) != 0) {
lVar3 = 1L << ((char)param_2 * -4 + 0x34U & 0x3f);
uVar1 = uVar1 + lVar3 & -lVar3;
}
uVar8 = (ulong)param_2;
}
pcVar2 = acStack_4b;
local_58._0_4_ = s_0000000000000000_00261120._0_4_;
local_58._4_4_ = s_0000000000000000_00261120._4_4_;
acStack_50 = (char [4])s_0000000000000000_00261120._8_4_;
_cStack_4c = s_0000000000000000_00261120._12_4_;
uVar9 = (uint)((ulong)param_3 >> 0x20);
pcVar4 = "0123456789ABCDEF";
if ((uVar9 >> 0x10 & 1) == 0) {
pcVar4 = "0123456789abcdef";
}
do {
*pcVar2 = pcVar4[(uint)uVar1 & 0xf];
pcVar2 = pcVar2 + -1;
bVar10 = 0xf < uVar1;
uVar1 = uVar1 >> 4;
} while (bVar10);
if ((int)uVar8 < 1) {
bVar10 = false;
}
else {
do {
iVar7 = (int)uVar8;
bVar10 = local_58[uVar8] != '0';
if (bVar10) goto LAB_001414b1;
uVar8 = (ulong)(iVar7 - 1);
} while (1 < iVar7);
uVar8 = 0;
}
LAB_001414b1:
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(int1 *)(*(long *)(param_4 + 8) + lVar3) = 0x30;
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(byte *)(*(long *)(param_4 + 8) + lVar3) = ((uVar9 >> 0x10 & 1) == 0) << 5 | 0x58;
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(char *)(*(long *)(param_4 + 8) + lVar3) = local_58[0];
if ((byte)(0 < (int)param_2 | (byte)(uVar9 >> 0x13) & 1 | bVar10) == 1) {
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(int1 *)(*(long *)(param_4 + 8) + lVar3) = 0x2e;
}
fmt::v10::detail::buffer<char>::append<char>(param_4,local_58 + 1,local_58 + uVar8 + 1);
iVar7 = param_2 - (int)uVar8;
if (iVar7 != 0 && (int)uVar8 <= (int)param_2) {
do {
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(int1 *)(*(long *)(param_4 + 8) + lVar3) = 0x30;
iVar7 = iVar7 + -1;
} while (iVar7 != 0);
}
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(byte *)(*(long *)(param_4 + 8) + lVar3) = ((uVar9 >> 0x10 & 1) == 0) << 5 | 0x50;
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
if ((int)uVar6 < 0) {
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(int1 *)(*(long *)(param_4 + 8) + lVar3) = 0x2d;
uVar5 = -uVar6;
}
else {
if (*(ulong *)(param_4 + 0x18) < uVar1) {
(*(code *)**(int8 **)param_4)(param_4);
lVar3 = *(long *)(param_4 + 0x10);
uVar1 = lVar3 + 1;
}
*(ulong *)(param_4 + 0x10) = uVar1;
*(int1 *)(*(long *)(param_4 + 8) + lVar3) = 0x2b;
}
uVar6 = 0x1f;
if ((uVar5 | 1) != 0) {
for (; (uVar5 | 1) >> uVar6 == 0; uVar6 = uVar6 - 1) {
}
}
acStack_40[8] = '\0';
acStack_40[9] = '\0';
acStack_40[0] = '\0';
acStack_40[1] = '\0';
acStack_40[2] = '\0';
acStack_40[3] = '\0';
acStack_40[4] = '\0';
acStack_40[5] = '\0';
acStack_40[6] = '\0';
acStack_40[7] = '\0';
fmt::v10::detail::format_decimal<char,unsigned_int>
(acStack_40,uVar5,
(int)((ulong)uVar5 +
*(long *)(fmt::v10::detail::do_count_digits(unsigned_int)::table +
(ulong)uVar6 * 8) >> 0x20));
fmt::v10::detail::copy_str_noinline<char,char*,fmt::v10::appender>
(acStack_40,extraout_RDX,param_4);
return;
}
|
|
63,144 |
lf_hash_destroy
|
eloqsql/mysys/lf_hash.cc
|
void lf_hash_destroy(LF_HASH *hash)
{
LF_SLIST *el, **head= (LF_SLIST **)lf_dynarray_value(&hash->array, 0);
if (head)
{
el= *head;
while (el)
{
intptr next= el->link;
if (el->hashnr & 1)
lf_alloc_direct_free(&hash->alloc, el); /* normal node */
else
my_free(el); /* dummy node */
el= (LF_SLIST *)next;
}
}
lf_alloc_destroy(&hash->alloc);
lf_dynarray_destroy(&hash->array);
}
|
O3
|
cpp
|
lf_hash_destroy:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x47154
testq %rax, %rax
je 0x473ee
movq (%rax), %r14
testq %r14, %r14
je 0x473ee
movq (%r14), %r15
testb $0x1, 0x18(%r14)
je 0x473de
movq 0x88(%rbx), %rax
testq %rax, %rax
je 0x473de
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
callq 0x454fa
movq %r15, %r14
testq %r15, %r15
jne 0x473c3
leaq 0x28(%rbx), %rdi
callq 0x46f05
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x470d3
|
lf_hash_destroy:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
xor esi, esi
call lf_dynarray_value
test rax, rax
jz short loc_473EE
mov r14, [rax]
test r14, r14
jz short loc_473EE
loc_473C3:
mov r15, [r14]
test byte ptr [r14+18h], 1
jz short loc_473DE
mov rax, [rbx+88h]
test rax, rax
jz short loc_473DE
mov rdi, r14
call rax
loc_473DE:
mov rdi, r14
call my_free
mov r14, r15
test r15, r15
jnz short loc_473C3
loc_473EE:
lea rdi, [rbx+28h]
call lf_alloc_destroy
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp lf_dynarray_destroy
|
long long lf_hash_destroy(long long a1)
{
long long *v1; // rax
long long v2; // r14
long long v3; // r15
void ( *v4)(long long); // rax
v1 = (long long *)lf_dynarray_value(a1, 0);
if ( v1 )
{
v2 = *v1;
if ( *v1 )
{
do
{
v3 = *(_QWORD *)v2;
if ( (*(_BYTE *)(v2 + 24) & 1) != 0 )
{
v4 = *(void ( **)(long long))(a1 + 136);
if ( v4 )
v4(v2);
}
my_free(v2);
v2 = v3;
}
while ( v3 );
}
}
lf_alloc_destroy(a1 + 40);
return lf_dynarray_destroy(a1);
}
|
lf_hash_destroy:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR ESI,ESI
CALL 0x00147154
TEST RAX,RAX
JZ 0x001473ee
MOV R14,qword ptr [RAX]
TEST R14,R14
JZ 0x001473ee
LAB_001473c3:
MOV R15,qword ptr [R14]
TEST byte ptr [R14 + 0x18],0x1
JZ 0x001473de
MOV RAX,qword ptr [RBX + 0x88]
TEST RAX,RAX
JZ 0x001473de
MOV RDI,R14
CALL RAX
LAB_001473de:
MOV RDI,R14
CALL 0x001454fa
MOV R14,R15
TEST R15,R15
JNZ 0x001473c3
LAB_001473ee:
LEA RDI,[RBX + 0x28]
CALL 0x00146f05
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001470d3
|
void lf_hash_destroy(long param_1)
{
int8 *puVar1;
int8 *puVar2;
puVar2 = (int8 *)lf_dynarray_value(param_1,0);
if (puVar2 != (int8 *)0x0) {
puVar2 = (int8 *)*puVar2;
while (puVar2 != (int8 *)0x0) {
puVar1 = (int8 *)*puVar2;
if (((*(byte *)(puVar2 + 3) & 1) != 0) && (*(code **)(param_1 + 0x88) != (code *)0x0)) {
(**(code **)(param_1 + 0x88))(puVar2);
}
my_free(puVar2);
puVar2 = puVar1;
}
}
lf_alloc_destroy(param_1 + 0x28);
lf_dynarray_destroy(param_1);
return;
}
|
|
63,145 |
FloatOptional_inequality_Test::~FloatOptional_inequality_Test()
|
yoga-mod/tests/FloatOptionalTest.cpp
|
TEST(FloatOptional, inequality) {
ASSERT_FALSE(empty != empty);
ASSERT_FALSE(empty != YGUndefined);
ASSERT_TRUE(empty != zero);
ASSERT_TRUE(empty != negative);
ASSERT_TRUE(empty != 12.3f);
ASSERT_FALSE(zero != zero);
ASSERT_FALSE(zero != 0.0f);
ASSERT_TRUE(zero != positive);
ASSERT_TRUE(zero != -5555.5f);
ASSERT_FALSE(one != one);
ASSERT_FALSE(one != 1.0f);
ASSERT_TRUE(one != positive);
ASSERT_FALSE(positive != positive);
ASSERT_FALSE(positive != positive.unwrap());
ASSERT_TRUE(positive != one);
ASSERT_FALSE(negative != negative);
ASSERT_FALSE(negative != negative.unwrap());
ASSERT_TRUE(negative != zero);
}
|
O0
|
cpp
|
FloatOptional_inequality_Test::~FloatOptional_inequality_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x7047d0
movq -0x10(%rbp), %rax
leaq 0x7b1f0c(%rip), %rcx # 0x85b780
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN29FloatOptional_inequality_TestC2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN7testing4TestC2Ev; testing::Test::Test(void)
mov rax, [rbp+var_10]
lea rcx, _ZTV29FloatOptional_inequality_Test; `vtable for'FloatOptional_inequality_Test
add rcx, 10h
mov [rax], rcx
add rsp, 10h
pop rbp
retn
|
void FloatOptional_inequality_Test::FloatOptional_inequality_Test(FloatOptional_inequality_Test *this)
{
testing::Test::Test(this);
*(_QWORD *)this = (char *)&`vtable for'FloatOptional_inequality_Test + 16;
}
|
FloatOptional_inequality_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x008047d0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x95b780]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x10
POP RBP
RET
|
/* FloatOptional_inequality_Test::FloatOptional_inequality_Test() */
void __thiscall
FloatOptional_inequality_Test::FloatOptional_inequality_Test(FloatOptional_inequality_Test *this)
{
testing::Test::Test((Test *)this);
*(int ***)this = &PTR__FloatOptional_inequality_Test_0095b790;
return;
}
|
|
63,146 |
ma_tls_set_certs
|
eloqsql/libmariadb/libmariadb/secure/openssl.c
|
static int ma_tls_set_certs(MYSQL *mysql, SSL_CTX *ctx)
{
char *certfile= mysql->options.ssl_cert,
*keyfile= mysql->options.ssl_key;
char *pw= (mysql->options.extension) ?
mysql->options.extension->tls_pw : NULL;
/* add cipher */
if ((mysql->options.ssl_cipher &&
mysql->options.ssl_cipher[0] != 0))
{
if(
#ifdef TLS1_3_VERSION
SSL_CTX_set_ciphersuites(ctx, mysql->options.ssl_cipher) == 0 &&
#endif
SSL_CTX_set_cipher_list(ctx, mysql->options.ssl_cipher) == 0)
goto error;
}
/* ca_file and ca_path */
if (!SSL_CTX_load_verify_locations(ctx,
mysql->options.ssl_ca,
mysql->options.ssl_capath))
{
if (mysql->options.ssl_ca || mysql->options.ssl_capath)
goto error;
if (SSL_CTX_set_default_verify_paths(ctx) == 0)
goto error;
}
if (mysql->options.extension &&
(mysql->options.extension->ssl_crl || mysql->options.extension->ssl_crlpath))
{
X509_STORE *certstore;
if ((certstore= SSL_CTX_get_cert_store(ctx)))
{
if (X509_STORE_load_locations(certstore, mysql->options.extension->ssl_crl,
mysql->options.extension->ssl_crlpath) == 0)
goto error;
if (X509_STORE_set_flags(certstore, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL) == 0)
goto error;
}
}
if (keyfile && !certfile)
certfile= keyfile;
if (certfile && !keyfile)
keyfile= certfile;
/* set cert */
if (certfile && certfile[0] != 0)
{
if (SSL_CTX_use_certificate_chain_file(ctx, certfile) != 1)
{
goto error;
}
}
if (keyfile && keyfile[0])
{
FILE *fp;
if ((fp= fopen(keyfile, "rb")))
{
EVP_PKEY *key= EVP_PKEY_new();
PEM_read_PrivateKey(fp, &key, NULL, pw);
fclose(fp);
if (SSL_CTX_use_PrivateKey(ctx, key) != 1)
{
unsigned long err= ERR_peek_error();
EVP_PKEY_free(key);
if (!(ERR_GET_LIB(err) == ERR_LIB_X509 &&
ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE))
goto error;
}
EVP_PKEY_free(key);
} else {
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
CER(CR_FILE_NOT_FOUND), keyfile);
return 1;
}
}
/* verify key */
if (certfile && SSL_CTX_check_private_key(ctx) != 1)
goto error;
SSL_CTX_set_verify(ctx, (mysql->options.ssl_ca || mysql->options.ssl_capath) ?
SSL_VERIFY_PEER : SSL_VERIFY_NONE, NULL);
return 0;
error:
ma_tls_set_error(mysql);
return 1;
}
|
O0
|
c
|
ma_tls_set_certs:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x51444
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x5144c
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x5144c
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x420(%rax)
je 0x514ae
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x514ae
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rsi
callq 0x14510
cmpl $0x0, %eax
jne 0x514ac
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rsi
callq 0x14410
cmpl $0x0, %eax
jne 0x514ac
jmp 0x51742
jmp 0x514ae
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x410(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rdx
callq 0x14560
cmpl $0x0, %eax
jne 0x51508
movq -0x10(%rbp), %rax
cmpq $0x0, 0x410(%rax)
jne 0x514ee
movq -0x10(%rbp), %rax
cmpq $0x0, 0x418(%rax)
je 0x514f3
jmp 0x51742
movq -0x18(%rbp), %rdi
callq 0x144b0
cmpl $0x0, %eax
jne 0x51506
jmp 0x51742
jmp 0x51508
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x5159e
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5153e
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x5159e
movq -0x18(%rbp), %rdi
callq 0x147f0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5159c
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x18(%rax), %rdx
callq 0x14820
cmpl $0x0, %eax
jne 0x51582
jmp 0x51742
movq -0x38(%rbp), %rdi
movl $0xc, %esi
callq 0x14300
cmpl $0x0, %eax
jne 0x5159a
jmp 0x51742
jmp 0x5159c
jmp 0x5159e
cmpq $0x0, -0x28(%rbp)
je 0x515b4
cmpq $0x0, -0x20(%rbp)
jne 0x515b4
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x515ca
cmpq $0x0, -0x28(%rbp)
jne 0x515ca
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x515f6
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x515f6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14360
cmpl $0x1, %eax
je 0x515f4
jmp 0x51742
jmp 0x515f6
cmpq $0x0, -0x28(%rbp)
je 0x516d8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x516d8
movq -0x28(%rbp), %rdi
leaq 0x19b77(%rip), %rsi # 0x6b193
callq 0x144e0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x516a4
callq 0x14760
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
leaq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x142f0
movq -0x40(%rbp), %rdi
callq 0x14430
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x14390
cmpl $0x1, %eax
je 0x51699
callq 0x140c0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x142c0
movq -0x50(%rbp), %rdi
callq 0x52270
cmpl $0xb, %eax
jne 0x51692
movq -0x50(%rbp), %rdi
callq 0x522b0
cmpl $0x65, %eax
je 0x51697
jmp 0x51742
jmp 0x51699
movq -0x48(%rbp), %rdi
callq 0x142c0
jmp 0x516d6
movq -0x10(%rbp), %rdi
leaq 0x2f7f1(%rip), %rax # 0x80ea0
movq (%rax), %rdx
leaq 0x2f9f7(%rip), %rax # 0x810b0
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %r8
movl $0x7ea, %esi # imm = 0x7EA
movb $0x0, %al
callq 0x307d0
movl $0x1, -0x4(%rbp)
jmp 0x51752
jmp 0x516d8
cmpq $0x0, -0x20(%rbp)
je 0x516ef
movq -0x18(%rbp), %rdi
callq 0x14720
cmpl $0x1, %eax
je 0x516ef
jmp 0x51742
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x410(%rcx)
movb %al, -0x59(%rbp)
jne 0x5171c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x418(%rax)
setne %al
movb %al, -0x59(%rbp)
movq -0x68(%rbp), %rdi
movb -0x59(%rbp), %cl
xorl %esi, %esi
movl $0x1, %eax
testb $0x1, %cl
cmovnel %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x14120
movl $0x0, -0x4(%rbp)
jmp 0x51752
movq -0x10(%rbp), %rdi
callq 0x519a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ma_tls_set_certs:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+408h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+400h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_51444
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rax, [rax+0A0h]
mov [rbp+var_58], rax
jmp short loc_5144C
loc_51444:
xor eax, eax
mov [rbp+var_58], rax
jmp short $+2
loc_5144C:
mov rax, [rbp+var_58]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+420h], 0
jz short loc_514AE
mov rax, [rbp+var_10]
mov rax, [rax+420h]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_514AE
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+420h]
call _SSL_CTX_set_ciphersuites
cmp eax, 0
jnz short loc_514AC
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+420h]
call _SSL_CTX_set_cipher_list
cmp eax, 0
jnz short loc_514AC
jmp loc_51742
loc_514AC:
jmp short $+2
loc_514AE:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+410h]
mov rax, [rbp+var_10]
mov rdx, [rax+418h]
call _SSL_CTX_load_verify_locations
cmp eax, 0
jnz short loc_51508
mov rax, [rbp+var_10]
cmp qword ptr [rax+410h], 0
jnz short loc_514EE
mov rax, [rbp+var_10]
cmp qword ptr [rax+418h], 0
jz short loc_514F3
loc_514EE:
jmp loc_51742
loc_514F3:
mov rdi, [rbp+var_18]
call _SSL_CTX_set_default_verify_paths
cmp eax, 0
jnz short loc_51506
jmp loc_51742
loc_51506:
jmp short $+2
loc_51508:
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz loc_5159E
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+10h], 0
jnz short loc_5153E
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+18h], 0
jz short loc_5159E
loc_5153E:
mov rdi, [rbp+var_18]
call _SSL_CTX_get_cert_store
mov [rbp+var_38], rax
cmp rax, 0
jz short loc_5159C
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rdx, [rax+18h]
call _X509_STORE_load_locations
cmp eax, 0
jnz short loc_51582
jmp loc_51742
loc_51582:
mov rdi, [rbp+var_38]
mov esi, 0Ch
call _X509_STORE_set_flags
cmp eax, 0
jnz short loc_5159A
jmp loc_51742
loc_5159A:
jmp short $+2
loc_5159C:
jmp short $+2
loc_5159E:
cmp [rbp+var_28], 0
jz short loc_515B4
cmp [rbp+var_20], 0
jnz short loc_515B4
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
loc_515B4:
cmp [rbp+var_20], 0
jz short loc_515CA
cmp [rbp+var_28], 0
jnz short loc_515CA
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_515CA:
cmp [rbp+var_20], 0
jz short loc_515F6
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_515F6
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _SSL_CTX_use_certificate_chain_file
cmp eax, 1
jz short loc_515F4
jmp loc_51742
loc_515F4:
jmp short $+2
loc_515F6:
cmp [rbp+var_28], 0
jz loc_516D8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, 0
jz loc_516D8
mov rdi, [rbp+var_28]
lea rsi, aRb; "rb"
call _fopen64
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_516A4
call _EVP_PKEY_new
mov [rbp+var_48], rax
mov rdi, [rbp+var_40]
mov rcx, [rbp+var_30]
lea rsi, [rbp+var_48]
xor eax, eax
mov edx, eax
call _PEM_read_PrivateKey
mov rdi, [rbp+var_40]
call _fclose
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_48]
call _SSL_CTX_use_PrivateKey
cmp eax, 1
jz short loc_51699
call _ERR_peek_error
mov [rbp+var_50], rax
mov rdi, [rbp+var_48]
call _EVP_PKEY_free
mov rdi, [rbp+var_50]
call ERR_GET_LIB
cmp eax, 0Bh
jnz short loc_51692
mov rdi, [rbp+var_50]
call ERR_GET_REASON
cmp eax, 65h ; 'e'
jz short loc_51697
loc_51692:
jmp loc_51742
loc_51697:
jmp short $+2
loc_51699:
mov rdi, [rbp+var_48]
call _EVP_PKEY_free
jmp short loc_516D6
loc_516A4:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, mariadb_client_errors
mov rcx, [rax+20h]
mov r8, [rbp+var_28]
mov esi, 7EAh
mov al, 0
call my_set_error
mov [rbp+var_4], 1
jmp short loc_51752
loc_516D6:
jmp short $+2
loc_516D8:
cmp [rbp+var_20], 0
jz short loc_516EF
mov rdi, [rbp+var_18]
call _SSL_CTX_check_private_key
cmp eax, 1
jz short loc_516EF
jmp short loc_51742
loc_516EF:
mov rax, [rbp+var_18]
mov [rbp+var_68], rax
mov rcx, [rbp+var_10]
mov al, 1
cmp qword ptr [rcx+410h], 0
mov [rbp+var_59], al
jnz short loc_5171C
mov rax, [rbp+var_10]
cmp qword ptr [rax+418h], 0
setnz al
mov [rbp+var_59], al
loc_5171C:
mov rdi, [rbp+var_68]
mov cl, [rbp+var_59]
xor esi, esi
mov eax, 1
test cl, 1
cmovnz esi, eax
xor eax, eax
mov edx, eax
call _SSL_CTX_set_verify
mov [rbp+var_4], 0
jmp short loc_51752
loc_51742:
mov rdi, [rbp+var_10]
call ma_tls_set_error
mov [rbp+var_4], 1
loc_51752:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long ma_tls_set_certs(_QWORD *a1, long long a2)
{
bool v3; // [rsp+17h] [rbp-59h]
long long v4; // [rsp+18h] [rbp-58h]
long long v5; // [rsp+20h] [rbp-50h]
long long v6; // [rsp+28h] [rbp-48h] BYREF
long long v7; // [rsp+30h] [rbp-40h]
long long cert_store; // [rsp+38h] [rbp-38h]
long long v9; // [rsp+40h] [rbp-30h]
_BYTE *v10; // [rsp+48h] [rbp-28h]
_BYTE *v11; // [rsp+50h] [rbp-20h]
long long v12; // [rsp+58h] [rbp-18h]
_QWORD *v13; // [rsp+60h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = (_BYTE *)a1[129];
v10 = (_BYTE *)a1[128];
if ( a1[144] )
v4 = *(_QWORD *)(v13[144] + 160LL);
else
v4 = 0LL;
v9 = v4;
if ( v13[132]
&& *(_BYTE *)v13[132]
&& !(unsigned int)SSL_CTX_set_ciphersuites(v12, v13[132])
&& !(unsigned int)SSL_CTX_set_cipher_list(v12, v13[132]) )
{
goto LABEL_42;
}
if ( !(unsigned int)SSL_CTX_load_verify_locations(v12, v13[130], v13[131])
&& (v13[130] || v13[131] || !(unsigned int)SSL_CTX_set_default_verify_paths(v12)) )
{
goto LABEL_42;
}
if ( v13[144] && (*(_QWORD *)(v13[144] + 16LL) || *(_QWORD *)(v13[144] + 24LL)) )
{
cert_store = SSL_CTX_get_cert_store(v12);
if ( cert_store )
{
if ( !(unsigned int)X509_STORE_load_locations(
cert_store,
*(_QWORD *)(v13[144] + 16LL),
*(_QWORD *)(v13[144] + 24LL))
|| !(unsigned int)X509_STORE_set_flags(cert_store, 12LL) )
{
goto LABEL_42;
}
}
}
if ( v10 && !v11 )
v11 = v10;
if ( v11 && !v10 )
v10 = v11;
if ( v11 && *v11 && (unsigned int)SSL_CTX_use_certificate_chain_file(v12, v11) != 1 )
goto LABEL_42;
if ( v10 && *v10 )
{
v7 = fopen64(v10, "rb");
if ( !v7 )
{
my_set_error((long long)v13, 0x7EAu, (long long)SQLSTATE_UNKNOWN, (long long)mariadb_client_errors[4], v10);
return 1;
}
v6 = EVP_PKEY_new();
PEM_read_PrivateKey(v7, &v6, 0LL, v9);
fclose(v7);
if ( (unsigned int)SSL_CTX_use_PrivateKey(v12, v6) != 1 )
{
v5 = ERR_peek_error();
EVP_PKEY_free(v6);
if ( (unsigned int)ERR_GET_LIB(v5) != 11 || (unsigned int)ERR_GET_REASON(v5) != 101 )
goto LABEL_42;
}
EVP_PKEY_free(v6);
}
if ( v11 && (unsigned int)SSL_CTX_check_private_key(v12) != 1 )
{
LABEL_42:
ma_tls_set_error(v13);
return 1;
}
v3 = 1;
if ( !v13[130] )
v3 = v13[131] != 0LL;
SSL_CTX_set_verify(v12, v3, 0LL);
return 0;
}
|
ma_tls_set_certs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x408]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x400]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x00151444
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0xa0]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0015144c
LAB_00151444:
XOR EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0015144c
LAB_0015144c:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x420],0x0
JZ 0x001514ae
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x420]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001514ae
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x420]
CALL 0x00114510
CMP EAX,0x0
JNZ 0x001514ac
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x420]
CALL 0x00114410
CMP EAX,0x0
JNZ 0x001514ac
JMP 0x00151742
LAB_001514ac:
JMP 0x001514ae
LAB_001514ae:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x410]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x418]
CALL 0x00114560
CMP EAX,0x0
JNZ 0x00151508
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x410],0x0
JNZ 0x001514ee
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x418],0x0
JZ 0x001514f3
LAB_001514ee:
JMP 0x00151742
LAB_001514f3:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001144b0
CMP EAX,0x0
JNZ 0x00151506
JMP 0x00151742
LAB_00151506:
JMP 0x00151508
LAB_00151508:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0015159e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x0015153e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0015159e
LAB_0015153e:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001147f0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x0015159c
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00114820
CMP EAX,0x0
JNZ 0x00151582
JMP 0x00151742
LAB_00151582:
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,0xc
CALL 0x00114300
CMP EAX,0x0
JNZ 0x0015159a
JMP 0x00151742
LAB_0015159a:
JMP 0x0015159c
LAB_0015159c:
JMP 0x0015159e
LAB_0015159e:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001515b4
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001515b4
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
LAB_001515b4:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001515ca
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001515ca
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001515ca:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001515f6
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001515f6
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00114360
CMP EAX,0x1
JZ 0x001515f4
JMP 0x00151742
LAB_001515f4:
JMP 0x001515f6
LAB_001515f6:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001516d8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001516d8
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x16b193]
CALL 0x001144e0
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x001516a4
CALL 0x00114760
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x48]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001142f0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00114430
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00114390
CMP EAX,0x1
JZ 0x00151699
CALL 0x001140c0
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001142c0
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00152270
CMP EAX,0xb
JNZ 0x00151692
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001522b0
CMP EAX,0x65
JZ 0x00151697
LAB_00151692:
JMP 0x00151742
LAB_00151697:
JMP 0x00151699
LAB_00151699:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001142c0
JMP 0x001516d6
LAB_001516a4:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x1810b0]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV ESI,0x7ea
MOV AL,0x0
CALL 0x001307d0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00151752
LAB_001516d6:
JMP 0x001516d8
LAB_001516d8:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001516ef
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00114720
CMP EAX,0x1
JZ 0x001516ef
JMP 0x00151742
LAB_001516ef:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV AL,0x1
CMP qword ptr [RCX + 0x410],0x0
MOV byte ptr [RBP + -0x59],AL
JNZ 0x0015171c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x418],0x0
SETNZ AL
MOV byte ptr [RBP + -0x59],AL
LAB_0015171c:
MOV RDI,qword ptr [RBP + -0x68]
MOV CL,byte ptr [RBP + -0x59]
XOR ESI,ESI
MOV EAX,0x1
TEST CL,0x1
CMOVNZ ESI,EAX
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00114120
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00151752
LAB_00151742:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001519a0
MOV dword ptr [RBP + -0x4],0x1
LAB_00151752:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 ma_tls_set_certs(long param_1,SSL_CTX *param_2)
{
int iVar1;
ulong uVar2;
bool bVar3;
void *local_60;
EVP_PKEY *local_50;
FILE *local_48;
X509_STORE *local_40;
void *local_38;
char *local_30;
char *local_28;
SSL_CTX *local_20;
long local_18;
local_28 = *(char **)(param_1 + 0x408);
local_30 = *(char **)(param_1 + 0x400);
if (*(long *)(param_1 + 0x480) == 0) {
local_60 = (void *)0x0;
}
else {
local_60 = *(void **)(*(long *)(param_1 + 0x480) + 0xa0);
}
local_38 = local_60;
local_20 = param_2;
local_18 = param_1;
if ((((((*(long *)(param_1 + 0x420) == 0) || (**(char **)(param_1 + 0x420) == '\0')) ||
(iVar1 = SSL_CTX_set_ciphersuites(param_2,*(int8 *)(param_1 + 0x420)), iVar1 != 0)) ||
(iVar1 = SSL_CTX_set_cipher_list(local_20,*(char **)(local_18 + 0x420)), iVar1 != 0)) &&
((iVar1 = SSL_CTX_load_verify_locations
(local_20,*(char **)(local_18 + 0x410),*(char **)(local_18 + 0x418)),
iVar1 != 0 ||
(((*(long *)(local_18 + 0x410) == 0 && (*(long *)(local_18 + 0x418) == 0)) &&
(iVar1 = SSL_CTX_set_default_verify_paths(local_20), iVar1 != 0)))))) &&
((((*(long *)(local_18 + 0x480) == 0 ||
((*(long *)(*(long *)(local_18 + 0x480) + 0x10) == 0 &&
(*(long *)(*(long *)(local_18 + 0x480) + 0x18) == 0)))) ||
(local_40 = SSL_CTX_get_cert_store(local_20), local_40 == (X509_STORE *)0x0)) ||
((iVar1 = X509_STORE_load_locations
(local_40,*(char **)(*(long *)(local_18 + 0x480) + 0x10),
*(char **)(*(long *)(local_18 + 0x480) + 0x18)), iVar1 != 0 &&
(iVar1 = X509_STORE_set_flags(local_40,0xc), iVar1 != 0)))))) {
if ((local_30 != (char *)0x0) && (local_28 == (char *)0x0)) {
local_28 = local_30;
}
if ((local_28 != (char *)0x0) && (local_30 == (char *)0x0)) {
local_30 = local_28;
}
if (((local_28 == (char *)0x0) || (*local_28 == '\0')) ||
(iVar1 = SSL_CTX_use_certificate_chain_file(local_20,local_28), iVar1 == 1)) {
if ((local_30 != (char *)0x0) && (*local_30 != '\0')) {
local_48 = fopen64(local_30,"rb");
if (local_48 == (FILE *)0x0) {
my_set_error(local_18,0x7ea,SQLSTATE_UNKNOWN,mariadb_client_errors._32_8_,local_30);
return 1;
}
local_50 = EVP_PKEY_new();
PEM_read_PrivateKey(local_48,&local_50,(int1 *)0x0,local_38);
fclose(local_48);
iVar1 = SSL_CTX_use_PrivateKey(local_20,local_50);
if (iVar1 != 1) {
uVar2 = ERR_peek_error();
EVP_PKEY_free(local_50);
iVar1 = ERR_GET_LIB(uVar2);
if ((iVar1 != 0xb) || (iVar1 = ERR_GET_REASON(uVar2), iVar1 != 0x65)) goto LAB_00151742;
}
EVP_PKEY_free(local_50);
}
if ((local_28 == (char *)0x0) || (iVar1 = SSL_CTX_check_private_key(local_20), iVar1 == 1)) {
bVar3 = true;
if (*(long *)(local_18 + 0x410) == 0) {
bVar3 = *(long *)(local_18 + 0x418) != 0;
}
SSL_CTX_set_verify(local_20,(uint)bVar3,(callback *)0x0);
return 0;
}
}
}
LAB_00151742:
ma_tls_set_error(local_18);
return 1;
}
|
|
63,147 |
ftxui::TerminalInputParser::Send(ftxui::TerminalInputParser::Output)
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/component/terminal_input_parser.cpp
|
void TerminalInputParser::Send(TerminalInputParser::Output output) {
switch (output.type) {
case UNCOMPLETED:
return;
case DROP:
pending_.clear();
return;
case CHARACTER:
out_->Send(Event::Character(std::move(pending_)));
pending_.clear();
return;
case SPECIAL: {
auto it = g_uniformize.find(pending_);
if (it != g_uniformize.end()) {
pending_ = it->second;
}
out_->Send(Event::Special(std::move(pending_)));
pending_.clear();
}
return;
case MOUSE:
out_->Send(Event::Mouse(std::move(pending_), output.mouse)); // NOLINT
pending_.clear();
return;
case CURSOR_REPORTING:
out_->Send(Event::CursorReporting(std::move(pending_), // NOLINT
output.cursor.x, // NOLINT
output.cursor.y)); // NOLINT
pending_.clear();
return;
}
// NOT_REACHED().
}
|
O2
|
cpp
|
ftxui::TerminalInputParser::Send(ftxui::TerminalInputParser::Output):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movl 0x240(%rsp), %eax
decl %eax
cmpl $0x4, %eax
ja 0x2aaeb
movq %rdi, %rbx
leaq 0x240(%rsp), %r12
leaq 0xa7a4(%rip), %rcx # 0x35084
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %r14
leaq 0x10(%rbx), %rsi
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
callq 0xc5a0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x23b4c
leaq 0x1d0(%rsp), %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x29314
movq %r14, %rdi
movq %r15, %rsi
callq 0x28f9e
leaq 0x1d0(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
leaq 0xd8(%rsp), %rdi
jmp 0x2aada
movq (%rbx), %r14
leaq 0x10(%rbx), %rsi
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0xc5a0
movl 0x4(%r12), %edx
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x23ca2
leaq 0xf8(%rsp), %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x29314
movq %r14, %rdi
movq %r15, %rsi
callq 0x28f9e
leaq 0xf8(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
leaq 0x78(%rsp), %rdi
jmp 0x2aada
leaq 0x10(%rbx), %r15
leaq 0x28970(%rip), %rdi # 0x53338
movq %r15, %rsi
callq 0x1131a
leaq 0x28969(%rip), %rcx # 0x53340
cmpq %rcx, %rax
je 0x2a9eb
addq $0x40, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0xc240
movq (%rbx), %r14
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc5a0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x23c78
leaq 0x188(%rsp), %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x29314
movq %r14, %rdi
movq %r15, %rsi
callq 0x28f9e
leaq 0x188(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
leaq 0xb8(%rsp), %rdi
jmp 0x2aada
movq (%rbx), %r14
leaq 0x10(%rbx), %rsi
leaq 0x98(%rsp), %r15
movq %r15, %rdi
callq 0xc5a0
movl 0x14(%r12), %eax
movl %eax, 0x70(%rsp)
movups 0x4(%r12), %xmm0
movaps %xmm0, 0x60(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x23c38
leaq 0x140(%rsp), %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x29314
movq %r14, %rdi
movq %r15, %rsi
callq 0x28f9e
leaq 0x140(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
leaq 0x98(%rsp), %rdi
callq 0xc8c8
andq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
jmp 0x2ab7a
movq %rax, %rbx
leaq 0x1d0(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
jmp 0x2ab6d
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
jmp 0x2ab87
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x1368c
leaq 0x40(%rsp), %rdi
callq 0xc8c8
jmp 0x2ab94
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
jmp 0x2ab99
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x2ab99
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
jmp 0x2ab99
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xc8c8
movq %rbx, %rdi
callq 0xc7f0
|
_ZN5ftxui19TerminalInputParser4SendENS0_6OutputE:
push r15
push r14
push r12
push rbx
sub rsp, 218h
mov eax, [rsp+238h+arg_0]
dec eax; switch 5 cases
cmp eax, 4
ja def_2A8E7; jumptable 000000000002A8E7 default case
mov rbx, rdi
lea r12, [rsp+238h+arg_0]
lea rcx, jpt_2A8E7
movsxd rax, ds:(jpt_2A8E7 - 35084h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2A8E9:
mov r14, [rbx]; jumptable 000000000002A8E7 case 2
lea rsi, [rbx+10h]
lea r15, [rsp+238h+var_160]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
lea rdi, [rsp+238h+var_218]
mov rsi, r15
call _ZN5ftxui5Event9CharacterENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ftxui::Event::Character(std::string)
lea r15, [rsp+238h+var_68]
lea rsi, [rsp+238h+var_218]
mov rdi, r15
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEEC2IS1_vvS1_vEEOT_; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>(ftxui::Event &&)
mov rdi, r14
mov rsi, r15
call _ZN5ftxui10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEE4SendES7_; ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>)
lea rdi, [rsp+238h+var_68]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+238h+var_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_160]
jmp loc_2AADA
loc_2A951:
mov r14, [rbx]; jumptable 000000000002A8E7 case 5
lea rsi, [rbx+10h]
lea r15, [rsp+238h+var_1C0]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
mov edx, [r12+4]
mov ecx, [r12+8]
lea rdi, [rsp+238h+var_218]
mov rsi, r15
call _ZN5ftxui5Event15CursorReportingENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEii; ftxui::Event::CursorReporting(std::string,int,int)
lea r15, [rsp+238h+var_140]
lea rsi, [rsp+238h+var_218]
mov rdi, r15
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEEC2IS1_vvS1_vEEOT_; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>(ftxui::Event &&)
mov rdi, r14
mov rsi, r15
call _ZN5ftxui10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEE4SendES7_; ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>)
lea rdi, [rsp+238h+var_140]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+238h+var_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_1C0]
jmp loc_2AADA
loc_2A9BD:
lea r15, [rbx+10h]; jumptable 000000000002A8E7 case 3
lea rdi, _ZN5ftxuiL12g_uniformizeB5cxx11E; ftxui::g_uniformize
mov rsi, r15
call _ZNKSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
lea rcx, unk_53340
cmp rax, rcx
jz short loc_2A9EB
add rax, 40h ; '@'
mov rdi, r15
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_2A9EB:
mov r14, [rbx]
lea r12, [rsp+238h+var_180]
mov rdi, r12
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
lea rdi, [rsp+238h+var_218]
mov rsi, r12
call _ZN5ftxui5Event7SpecialENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ftxui::Event::Special(std::string)
lea r15, [rsp+238h+var_B0]
lea rsi, [rsp+238h+var_218]
mov rdi, r15
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEEC2IS1_vvS1_vEEOT_; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>(ftxui::Event &&)
mov rdi, r14
mov rsi, r15
call _ZN5ftxui10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEE4SendES7_; ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>)
lea rdi, [rsp+238h+var_B0]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+238h+var_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_180]
jmp loc_2AADA
loc_2AA52:
mov r14, [rbx]; jumptable 000000000002A8E7 case 4
lea rsi, [rbx+10h]
lea r15, [rsp+238h+var_1A0]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
mov eax, [r12+14h]
mov [rsp+238h+var_1C8], eax
movups xmm0, xmmword ptr [r12+4]
movaps [rsp+238h+var_1D8], xmm0
mov eax, [rsp+238h+var_1C8]
mov [rsp+238h+var_228], eax
movaps xmm0, [rsp+238h+var_1D8]
movups [rsp+238h+var_238], xmm0
lea rdi, [rsp+238h+var_218]
mov rsi, r15
call _ZN5ftxui5Event5MouseENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_5MouseE; ftxui::Event::Mouse(std::string,ftxui::Mouse)
lea r15, [rsp+238h+var_F8]
lea rsi, [rsp+238h+var_218]
mov rdi, r15
call _ZNSt7variantIJN5ftxui5EventESt8functionIFvvEENS0_13AnimationTaskEEEC2IS1_vvS1_vEEOT_; std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>(ftxui::Event &&)
mov rdi, r14
mov rsi, r15
call _ZN5ftxui10SenderImplISt7variantIJNS_5EventESt8functionIFvvEENS_13AnimationTaskEEEE4SendES7_; ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>)
lea rdi, [rsp+238h+var_F8]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+238h+var_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_1A0]; void *
loc_2AADA:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_2AADF:
and qword ptr [rbx+18h], 0; jumptable 000000000002A8E7 case 1
mov rax, [rbx+10h]
mov byte ptr [rax], 0
def_2A8E7:
add rsp, 218h; jumptable 000000000002A8E7 default case
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_138]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2AB7A
mov rbx, rax
lea rdi, [rsp+arg_1C8]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2AB6D
mov rbx, rax
lea rdi, [rsp+arg_180]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2AB87
mov rbx, rax
lea rdi, [rsp+arg_F0]
call _ZNSt8__detail9__variant16_Variant_storageILb0EJN5ftxui5EventESt8functionIFvvEENS2_13AnimationTaskEEED2Ev; std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage()
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2AB94
mov rbx, rax
loc_2AB6D:
lea rdi, [rsp+arg_D0]
jmp short loc_2AB99
mov rbx, rax
loc_2AB7A:
lea rdi, [rsp+arg_90]
jmp short loc_2AB99
mov rbx, rax
loc_2AB87:
lea rdi, [rsp+arg_B0]
jmp short loc_2AB99
mov rbx, rax
loc_2AB94:
lea rdi, [rsp+arg_70]; void *
loc_2AB99:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
unsigned long long ftxui::TerminalInputParser::Send(long long a1, arg7_2A8AE a2)
{
unsigned long long result; // rax
long long *v9; // r14
_BYTE *v10; // rdi
long long *v11; // r14
char *v12; // rax
long long *v13; // r14
long long *v14; // r14
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
_BYTE v19[32]; // [rsp+20h] [rbp-218h] BYREF
_BYTE v20[32]; // [rsp+40h] [rbp-1F8h] BYREF
__int128 v21; // [rsp+60h] [rbp-1D8h]
int v22; // [rsp+70h] [rbp-1C8h]
_BYTE v23[32]; // [rsp+78h] [rbp-1C0h] BYREF
_BYTE v24[32]; // [rsp+98h] [rbp-1A0h] BYREF
_BYTE v25[32]; // [rsp+B8h] [rbp-180h] BYREF
_BYTE v26[32]; // [rsp+D8h] [rbp-160h] BYREF
result = (unsigned int)(*(_DWORD *)a2.arr - 1);
switch ( *(_DWORD *)a2.arr )
{
case 1:
goto LABEL_9;
case 2:
v9 = *(long long **)a1;
std::string::basic_string(v26, a1 + 16);
ftxui::Event::Character((ftxui::Event *)v19, (long long)v26);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>();
ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(v9);
std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage();
std::string::~string(v20);
v10 = v26;
goto LABEL_8;
case 3:
v12 = (char *)std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
(long long)&ftxui::g_uniformize[abi:cxx11],
a1 + 16);
if ( v12 != (char *)&unk_53340 )
std::string::_M_assign(a1 + 16, v12 + 64);
v13 = *(long long **)a1;
std::string::basic_string(v25, a1 + 16);
ftxui::Event::Special((ftxui::Event *)v19, (long long)v25);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>();
ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(v13);
std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage();
std::string::~string(v20);
v10 = v25;
goto LABEL_8;
case 4:
v14 = *(long long **)a1;
std::string::basic_string(v24, a1 + 16);
v22 = *(_DWORD *)&a2.arr[20];
v21 = *(_OWORD *)&a2.arr[4];
ftxui::Event::Mouse((long long)v19, (long long)v24, v15, v16, v17, v18, *(__int128 *)&a2.arr[4], *(int *)&a2.arr[20]);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>();
ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(v14);
std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage();
std::string::~string(v20);
v10 = v24;
goto LABEL_8;
case 5:
v11 = *(long long **)a1;
std::string::basic_string(v23, a1 + 16);
ftxui::Event::CursorReporting((ftxui::Event *)v19, (long long)v23, *(int *)&a2.arr[4], *(int *)&a2.arr[8]);
std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::variant<ftxui::Event,void,void,ftxui::Event,void>();
ftxui::SenderImpl<std::variant<ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>>::Send(v11);
std::__detail::__variant::_Variant_storage<false,ftxui::Event,std::function<void ()(void)>,ftxui::AnimationTask>::~_Variant_storage();
std::string::~string(v20);
v10 = v23;
LABEL_8:
std::string::~string(v10);
LABEL_9:
*(_QWORD *)(a1 + 24) = 0LL;
result = *(_QWORD *)(a1 + 16);
*(_BYTE *)result = 0;
break;
default:
return result;
}
return result;
}
|
Send:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV EAX,dword ptr [RSP + 0x240]
DEC EAX
CMP EAX,0x4
JA 0x0012aaeb
MOV RBX,RDI
LEA R12,[RSP + 0x240]
LEA RCX,[0x135084]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_2:
MOV R14,qword ptr [RBX]
LEA RSI,[RBX + 0x10]
LEA R15,[RSP + 0xd8]
MOV RDI,R15
CALL 0x0010c5a0
LAB_0012a900:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x00123b4c
LEA R15,[RSP + 0x1d0]
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x00129314
LAB_0012a922:
MOV RDI,R14
MOV RSI,R15
CALL 0x00128f9e
LEA RDI,[RSP + 0x1d0]
CALL 0x0011368c
LEA RDI,[RSP + 0x40]
CALL 0x0010c8c8
LEA RDI,[RSP + 0xd8]
JMP 0x0012aada
caseD_5:
MOV R14,qword ptr [RBX]
LEA RSI,[RBX + 0x10]
LEA R15,[RSP + 0x78]
MOV RDI,R15
CALL 0x0010c5a0
MOV EDX,dword ptr [R12 + 0x4]
MOV ECX,dword ptr [R12 + 0x8]
LAB_0012a96f:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x00123ca2
LEA R15,[RSP + 0xf8]
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x00129314
LAB_0012a991:
MOV RDI,R14
MOV RSI,R15
CALL 0x00128f9e
LAB_0012a99c:
LEA RDI,[RSP + 0xf8]
CALL 0x0011368c
LEA RDI,[RSP + 0x40]
CALL 0x0010c8c8
LEA RDI,[RSP + 0x78]
JMP 0x0012aada
caseD_3:
LEA R15,[RBX + 0x10]
LEA RDI,[0x153338]
MOV RSI,R15
CALL 0x0011131a
LEA RCX,[0x153340]
CMP RAX,RCX
JZ 0x0012a9eb
ADD RAX,0x40
MOV RDI,R15
MOV RSI,RAX
CALL 0x0010c240
LAB_0012a9eb:
MOV R14,qword ptr [RBX]
LEA R12,[RSP + 0xb8]
MOV RDI,R12
MOV RSI,R15
CALL 0x0010c5a0
LAB_0012aa01:
LEA RDI,[RSP + 0x20]
MOV RSI,R12
CALL 0x00123c78
LEA R15,[RSP + 0x188]
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x00129314
LAB_0012aa23:
MOV RDI,R14
MOV RSI,R15
CALL 0x00128f9e
LEA RDI,[RSP + 0x188]
CALL 0x0011368c
LEA RDI,[RSP + 0x40]
CALL 0x0010c8c8
LEA RDI,[RSP + 0xb8]
JMP 0x0012aada
caseD_4:
MOV R14,qword ptr [RBX]
LEA RSI,[RBX + 0x10]
LEA R15,[RSP + 0x98]
MOV RDI,R15
CALL 0x0010c5a0
MOV EAX,dword ptr [R12 + 0x14]
MOV dword ptr [RSP + 0x70],EAX
MOVUPS XMM0,xmmword ptr [R12 + 0x4]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
LAB_0012aa7d:
MOV EAX,dword ptr [RSP + 0x70]
MOV dword ptr [RSP + 0x10],EAX
MOVAPS XMM0,xmmword ptr [RSP + 0x60]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x00123c38
LEA R15,[RSP + 0x140]
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x00129314
LAB_0012aab0:
MOV RDI,R14
MOV RSI,R15
CALL 0x00128f9e
LAB_0012aabb:
LEA RDI,[RSP + 0x140]
CALL 0x0011368c
LEA RDI,[RSP + 0x40]
CALL 0x0010c8c8
LEA RDI,[RSP + 0x98]
LAB_0012aada:
CALL 0x0010c8c8
caseD_1:
AND qword ptr [RBX + 0x18],0x0
MOV RAX,qword ptr [RBX + 0x10]
MOV byte ptr [RAX],0x0
default:
ADD RSP,0x218
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::TerminalInputParser::Send(ftxui::TerminalInputParser::Output) */
void ftxui::TerminalInputParser::Send(int8 *param_1)
{
int8 uVar1;
long lVar2;
string *psVar3;
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int4 in_stack_00000010;
Event local_218 [32];
string local_1f8 [32];
int8 local_1d8;
string local_1c0 [32];
string local_1a0 [32];
string local_180 [32];
string local_160 [32];
Event local_140 [72];
Event local_f8 [72];
Event local_b0 [72];
Event local_68 [72];
switch(uStack0000000000000008) {
case 1:
goto switchD_0012a8e7_caseD_1;
case 2:
uVar1 = *param_1;
std::__cxx11::string::string(local_160,(string *)(param_1 + 2));
/* try { // try from 0012a900 to 0012a90c has its CatchHandler @ 0012ab6a */
Event::Character(local_218,local_160);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
variant<ftxui::Event,void,void,ftxui::Event,void>(local_68);
/* try { // try from 0012a922 to 0012a92c has its CatchHandler @ 0012ab16 */
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>::Send
(uVar1,local_68);
std::__detail::__variant::
_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
~_Variant_storage((_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>
*)local_68);
std::__cxx11::string::~string(local_1f8);
psVar3 = local_160;
break;
case 3:
psVar3 = (string *)(param_1 + 2);
lVar2 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)g_uniformize_abi_cxx11_,psVar3);
if (lVar2 != 0x153340) {
std::__cxx11::string::_M_assign(psVar3);
}
uVar1 = *param_1;
std::__cxx11::string::string(local_180,psVar3);
/* try { // try from 0012aa01 to 0012aa0d has its CatchHandler @ 0012ab84 */
Event::Special(local_218,local_180);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
variant<ftxui::Event,void,void,ftxui::Event,void>(local_b0);
/* try { // try from 0012aa23 to 0012aa2d has its CatchHandler @ 0012ab32 */
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>::Send
(uVar1,local_b0);
std::__detail::__variant::
_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
~_Variant_storage((_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>
*)local_b0);
std::__cxx11::string::~string(local_1f8);
psVar3 = local_180;
break;
case 4:
uVar1 = *param_1;
std::__cxx11::string::string(local_1a0,(string *)(param_1 + 2));
local_1d8 = CONCAT44(in_stack_00000010,uStack000000000000000c);
/* try { // try from 0012aa7d to 0012aa9a has its CatchHandler @ 0012ab77 */
Event::Mouse(local_218,local_1a0);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
variant<ftxui::Event,void,void,ftxui::Event,void>(local_f8);
/* try { // try from 0012aab0 to 0012aaba has its CatchHandler @ 0012aafa */
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>::Send
(uVar1,local_f8);
std::__detail::__variant::
_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
~_Variant_storage((_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>
*)local_f8);
std::__cxx11::string::~string(local_1f8);
psVar3 = local_1a0;
break;
case 5:
uVar1 = *param_1;
std::__cxx11::string::string(local_1c0,(string *)(param_1 + 2));
/* try { // try from 0012a96f to 0012a97b has its CatchHandler @ 0012ab91 */
Event::CursorReporting(local_218,local_1c0,uStack000000000000000c,in_stack_00000010);
std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
variant<ftxui::Event,void,void,ftxui::Event,void>(local_140);
/* try { // try from 0012a991 to 0012a99b has its CatchHandler @ 0012ab4e */
SenderImpl<std::variant<ftxui::Event,std::function<void()>,ftxui::AnimationTask>>::Send
(uVar1,local_140);
std::__detail::__variant::
_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>::
~_Variant_storage((_Variant_storage<false,ftxui::Event,std::function<void()>,ftxui::AnimationTask>
*)local_140);
std::__cxx11::string::~string(local_1f8);
psVar3 = local_1c0;
break;
default:
return;
}
std::__cxx11::string::~string(psVar3);
switchD_0012a8e7_caseD_1:
param_1[3] = 0;
*(int1 *)param_1[2] = 0;
return;
}
|
|
63,148 |
mysql_stmt_fetch
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
}
|
O3
|
c
|
mysql_stmt_fetch:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %ecx
cmpl $0x2, %ecx
jbe 0x4f4f6
cmpl $0x0, 0x60(%rbx)
je 0x4f4f6
cmpl $0x3, %ecx
jne 0x4f4b8
movq %rbx, %rdi
callq *0x358(%rbx)
movl 0x50(%rbx), %ecx
movl $0x64, %eax
cmpl $0x6, %ecx
je 0x4f54d
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x68(%rax)
testl %eax, %eax
je 0x4f556
movl $0x6, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x488(%rcx)
jmp 0x4f54d
movl $0x7de, 0x108(%rbx) # imm = 0x7DE
leaq 0x30d(%rbx), %rdi
leaq 0x2fe072(%rip), %rax # 0x34d580
movq (%rax), %rsi
movl $0x5, %edx
callq 0x37130
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2fe05d(%rip), %rax # 0x34d590
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x37130
movb %r14b, 0x30b(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x70(%rax)
movl $0x5, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x90(%rcx)
movq 0x38(%rbx), %rcx
movl $0x30303030, 0x297(%rcx) # imm = 0x30303030
movw $0x30, 0x29b(%rcx)
movq 0x38(%rbx), %rcx
movb $0x0, 0x97(%rcx)
movq 0x38(%rbx), %rcx
movq 0x2a0(%rcx), %rcx
testq %rcx, %rcx
je 0x4f5b9
movl $0x0, 0x4(%rcx)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
jmp 0x4f54d
|
mysql_stmt_fetch:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov ecx, [rdi+50h]
cmp ecx, 2
jbe short loc_4F4F6
cmp dword ptr [rbx+60h], 0
jz short loc_4F4F6
cmp ecx, 3
jnz short loc_4F4B8
mov rdi, rbx
call qword ptr [rbx+358h]
mov ecx, [rbx+50h]
loc_4F4B8:
mov eax, 64h ; 'd'
cmp ecx, 6
jz loc_4F54D
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
lea rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+68h]
test eax, eax
jz short loc_4F556
mov dword ptr [rbx+50h], 6
mov rcx, [rbx+38h]
mov dword ptr [rcx+488h], 0
jmp short loc_4F54D
loc_4F4F6:
mov dword ptr [rbx+108h], 7DEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov eax, 1
loc_4F54D:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_4F556:
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
mov rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+70h]
mov dword ptr [rbx+50h], 5
mov rcx, [rbx+38h]
mov dword ptr [rcx+90h], 0
mov rcx, [rbx+38h]
mov dword ptr [rcx+297h], 30303030h
mov word ptr [rcx+29Bh], 30h ; '0'
mov rcx, [rbx+38h]
mov byte ptr [rcx+97h], 0
mov rcx, [rbx+38h]
mov rcx, [rcx+2A0h]
test rcx, rcx
jz short loc_4F5B9
mov dword ptr [rcx+4], 0
loc_4F5B9:
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
jmp loc_4F54D
|
long long mysql_stmt_fetch(long long a1)
{
unsigned int v1; // ecx
long long result; // rax
long long v3; // rcx
_QWORD v4[3]; // [rsp+8h] [rbp-18h] BYREF
v1 = *(_DWORD *)(a1 + 80);
if ( v1 > 2 && *(_DWORD *)(a1 + 96) )
{
if ( v1 == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
v1 = *(_DWORD *)(a1 + 80);
}
result = 100LL;
if ( v1 != 6 )
{
result = (*(long long ( **)(long long, _QWORD *))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 104LL))(
a1,
v4);
if ( (_DWORD)result )
{
*(_DWORD *)(a1 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
}
else
{
result = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 112LL))(
a1,
v4[0]);
*(_DWORD *)(a1 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v3 )
*(_DWORD *)(v3 + 4) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
}
}
}
else
{
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1LL;
}
return result;
}
|
mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV ECX,dword ptr [RDI + 0x50]
CMP ECX,0x2
JBE 0x0014f4f6
CMP dword ptr [RBX + 0x60],0x0
JZ 0x0014f4f6
CMP ECX,0x3
JNZ 0x0014f4b8
MOV RDI,RBX
CALL qword ptr [RBX + 0x358]
MOV ECX,dword ptr [RBX + 0x50]
LAB_0014f4b8:
MOV EAX,0x64
CMP ECX,0x6
JZ 0x0014f54d
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
LEA RSI,[RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x68]
TEST EAX,EAX
JZ 0x0014f556
MOV dword ptr [RBX + 0x50],0x6
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x488],0x0
JMP 0x0014f54d
LAB_0014f4f6:
MOV dword ptr [RBX + 0x108],0x7de
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x44d580]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00137130
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x44d590]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00137130
MOV byte ptr [RBX + 0x30b],R14B
MOV EAX,0x1
LAB_0014f54d:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_0014f556:
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x70]
MOV dword ptr [RBX + 0x50],0x5
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x90],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x297],0x30303030
MOV word ptr [RCX + 0x29b],0x30
MOV RCX,qword ptr [RBX + 0x38]
MOV byte ptr [RCX + 0x97],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RCX + 0x2a0]
TEST RCX,RCX
JZ 0x0014f5b9
MOV dword ptr [RCX + 0x4],0x0
LAB_0014f5b9:
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
JMP 0x0014f54d
|
int8 mysql_stmt_fetch(long param_1)
{
long lVar1;
int8 uVar2;
uint uVar3;
int8 local_20;
uVar3 = *(uint *)(param_1 + 0x50);
if ((uVar3 < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0044d600,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar2 = 1;
}
else {
if (uVar3 == 3) {
(**(code **)(param_1 + 0x358))(param_1);
uVar3 = *(uint *)(param_1 + 0x50);
}
uVar2 = 100;
if (uVar3 != 6) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x68))(param_1,&local_20);
if ((int)uVar2 == 0) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x70))(param_1,local_20)
;
*(int4 *)(param_1 + 0x50) = 5;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
}
else {
*(int4 *)(param_1 + 0x50) = 6;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
}
}
}
return uVar2;
}
|
|
63,149 |
init_one_value
|
eloqsql/mysys/my_getopt.c
|
static void init_one_value(const struct my_option *option, void *variable,
longlong value)
{
DBUG_ENTER("init_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_BOOL:
*((my_bool*) variable)= (my_bool) value;
break;
case GET_INT:
*((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
break;
case GET_ENUM:
*((ulong*) variable)= (ulong) value;
break;
case GET_UINT:
*((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
break;
case GET_LONG:
*((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
break;
case GET_ULONG:
*((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
break;
case GET_LL:
*((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
break;
case GET_ULL:
*((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
break;
case GET_SET:
case GET_FLAGSET:
*((ulonglong*) variable)= (ulonglong) value;
break;
case GET_BIT:
{
ulonglong bit= (option->block_size >= 0 ?
option->block_size :
-option->block_size);
if (option->block_size < 0)
value= !value;
if (value)
(*(ulonglong*)variable)|= bit;
else
(*(ulonglong*)variable)&= ~bit;
break;
}
case GET_DOUBLE:
*((double*) variable)= getopt_ulonglong2double(value);
break;
case GET_STR:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
*((char**) variable)= (char*) (intptr) value;
break;
case GET_STR_ALLOC:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
{
char **pstr= (char **) variable;
my_free(*pstr);
*pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
}
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_one_value:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
andl $0x3f, %eax
addq $-0x2, %rax
cmpq $0xe, %rax
ja 0x28f67
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x3bba4(%rip), %rcx # 0x64a60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, (%rbx)
jmp 0x28f67
movq %r14, %rdi
xorl %edx, %edx
callq 0x29453
jmp 0x28f64
movq %r14, %rdi
xorl %edx, %edx
callq 0x29574
jmp 0x28f64
movq 0x60(%rsi), %rcx
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
xorl %edx, %edx
testq %r14, %r14
sete %dl
testq %rcx, %rcx
cmovnsq %r14, %rdx
testq %rdx, %rdx
je 0x28f5e
orq (%rbx), %rax
jmp 0x28f64
movb %r14b, (%rbx)
jmp 0x28f67
movl %r14d, %edi
xorl %edx, %edx
callq 0x29574
jmp 0x28f4f
testq %r14, %r14
je 0x28f67
movq (%rbx), %rdi
callq 0x2afe6
leaq 0x342004(%rip), %rax # 0x36af38
movl (%rax), %edi
movl $0x10, %edx
movq %r14, %rsi
callq 0x2b07c
jmp 0x28f64
movslq %r14d, %rdi
xorl %edx, %edx
callq 0x29453
movl %eax, (%rbx)
jmp 0x28f67
testq %r14, %r14
jne 0x28ec5
jmp 0x28f67
notq %rax
andq (%rbx), %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
init_one_value:
push rbp
mov rbp, rsp
push r14
push rbx
mov rax, [rdi+30h]
and eax, 3Fh
add rax, 0FFFFFFFFFFFFFFFEh; switch 15 cases
cmp rax, 0Eh
ja def_28EC3; jumptable 0000000000028EC3 default case, case 11
mov r14, rdx
mov rbx, rsi
mov rsi, rdi
lea rcx, jpt_28EC3
movsxd rax, ds:(jpt_28EC3 - 64A60h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_28EC5:
mov [rbx], r14; jumptable 0000000000028EC3 cases 12-15
jmp def_28EC3; jumptable 0000000000028EC3 default case, case 11
loc_28ECD:
mov rdi, r14; jumptable 0000000000028EC3 cases 5,7
xor edx, edx
call getopt_ll_limit_value
jmp loc_28F64
loc_28EDC:
mov rdi, r14; jumptable 0000000000028EC3 cases 6,8
xor edx, edx
call getopt_ull_limit_value
jmp short loc_28F64
loc_28EE8:
mov rcx, [rsi+60h]; jumptable 0000000000028EC3 case 16
mov rax, rcx
neg rax
cmovs rax, rcx
xor edx, edx
test r14, r14
setz dl
test rcx, rcx
cmovns rdx, r14
test rdx, rdx
jz short loc_28F5E
or rax, [rbx]
jmp short loc_28F64
loc_28F0F:
mov [rbx], r14b; jumptable 0000000000028EC3 case 2
jmp short def_28EC3; jumptable 0000000000028EC3 default case, case 11
loc_28F14:
mov edi, r14d; jumptable 0000000000028EC3 case 4
xor edx, edx
call getopt_ull_limit_value
jmp short loc_28F4F
loc_28F20:
test r14, r14; jumptable 0000000000028EC3 case 10
jz short def_28EC3; jumptable 0000000000028EC3 default case, case 11
mov rdi, [rbx]
call my_free
lea rax, key_memory_defaults
mov edi, [rax]
mov edx, 10h
mov rsi, r14
call my_strdup
jmp short loc_28F64
loc_28F45:
movsxd rdi, r14d; jumptable 0000000000028EC3 case 3
xor edx, edx
call getopt_ll_limit_value
loc_28F4F:
mov [rbx], eax
jmp short def_28EC3; jumptable 0000000000028EC3 default case, case 11
loc_28F53:
test r14, r14; jumptable 0000000000028EC3 case 9
jnz loc_28EC5; jumptable 0000000000028EC3 cases 12-15
jmp short def_28EC3; jumptable 0000000000028EC3 default case, case 11
loc_28F5E:
not rax
and rax, [rbx]
loc_28F64:
mov [rbx], rax
def_28EC3:
pop rbx; jumptable 0000000000028EC3 default case, case 11
pop r14
pop rbp
retn
|
long long init_one_value(long long a1, long long *a2, _BOOL8 a3)
{
long long result; // rax
long long v5; // rax
_BOOL8 v6; // rdx
result = (*(_QWORD *)(a1 + 48) & 0x3FLL) - 2;
switch ( *(_QWORD *)(a1 + 48) & 0x3FLL )
{
case 2LL:
*(_BYTE *)a2 = a3;
return result;
case 3LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_16;
case 4LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
LABEL_16:
*(_DWORD *)a2 = result;
return result;
case 5LL:
case 7LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 6LL:
case 8LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 9LL:
if ( !a3 )
return result;
goto LABEL_2;
case 0xALL:
if ( !a3 )
return result;
my_free(*a2);
result = my_strdup(key_memory_defaults, a3, 16LL);
goto LABEL_20;
case 0xCLL:
case 0xDLL:
case 0xELL:
case 0xFLL:
LABEL_2:
*a2 = a3;
return result;
case 0x10LL:
v5 = -*(_QWORD *)(a1 + 96);
if ( *(long long *)(a1 + 96) > 0 )
v5 = *(_QWORD *)(a1 + 96);
v6 = !a3;
if ( *(long long *)(a1 + 96) >= 0 )
v6 = a3;
if ( v6 )
result = *a2 | v5;
else
result = *a2 & ~v5;
LABEL_20:
*a2 = result;
break;
default:
return result;
}
return result;
}
|
init_one_value:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x30]
AND EAX,0x3f
ADD RAX,-0x2
CMP RAX,0xe
JA 0x00128f67
MOV R14,RDX
MOV RBX,RSI
MOV RSI,RDI
LEA RCX,[0x164a60]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_c:
MOV qword ptr [RBX],R14
JMP 0x00128f67
caseD_5:
MOV RDI,R14
XOR EDX,EDX
CALL 0x00129453
JMP 0x00128f64
caseD_6:
MOV RDI,R14
XOR EDX,EDX
CALL 0x00129574
JMP 0x00128f64
caseD_10:
MOV RCX,qword ptr [RSI + 0x60]
MOV RAX,RCX
NEG RAX
CMOVS RAX,RCX
XOR EDX,EDX
TEST R14,R14
SETZ DL
TEST RCX,RCX
CMOVNS RDX,R14
TEST RDX,RDX
JZ 0x00128f5e
OR RAX,qword ptr [RBX]
JMP 0x00128f64
caseD_2:
MOV byte ptr [RBX],R14B
JMP 0x00128f67
caseD_4:
MOV EDI,R14D
XOR EDX,EDX
CALL 0x00129574
JMP 0x00128f4f
caseD_a:
TEST R14,R14
JZ 0x00128f67
MOV RDI,qword ptr [RBX]
CALL 0x0012afe6
LEA RAX,[0x46af38]
MOV EDI,dword ptr [RAX]
MOV EDX,0x10
MOV RSI,R14
CALL 0x0012b07c
JMP 0x00128f64
caseD_3:
MOVSXD RDI,R14D
XOR EDX,EDX
CALL 0x00129453
LAB_00128f4f:
MOV dword ptr [RBX],EAX
JMP 0x00128f67
caseD_9:
TEST R14,R14
JNZ 0x00128ec5
JMP 0x00128f67
LAB_00128f5e:
NOT RAX
AND RAX,qword ptr [RBX]
LAB_00128f64:
MOV qword ptr [RBX],RAX
caseD_b:
POP RBX
POP R14
POP RBP
RET
|
void init_one_value(long param_1,ulong *param_2,ulong param_3)
{
ulong uVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
switch((uint)*(int8 *)(param_1 + 0x30) & 0x3f) {
case 2:
*(char *)param_2 = (char)param_3;
return;
case 3:
uVar2 = getopt_ll_limit_value((long)(int)param_3,param_1,0);
goto LAB_00128f4f;
case 4:
uVar2 = getopt_ull_limit_value(param_3 & 0xffffffff,param_1,0);
LAB_00128f4f:
*(int4 *)param_2 = uVar2;
return;
case 5:
case 7:
uVar3 = getopt_ll_limit_value(param_3,param_1,0);
break;
case 6:
case 8:
uVar3 = getopt_ull_limit_value(param_3,param_1,0);
break;
case 9:
if (param_3 == 0) {
return;
}
case 0xc:
case 0xd:
case 0xe:
case 0xf:
*param_2 = param_3;
return;
case 10:
if (param_3 == 0) {
return;
}
my_free(*param_2);
uVar3 = my_strdup(key_memory_defaults,param_3,0x10);
break;
default:
goto switchD_00128ec3_caseD_b;
case 0x10:
uVar1 = *(ulong *)(param_1 + 0x60);
uVar3 = -uVar1;
if (0 < (long)uVar1) {
uVar3 = uVar1;
}
uVar4 = (ulong)(param_3 == 0);
if (-1 < (long)uVar1) {
uVar4 = param_3;
}
if (uVar4 == 0) {
uVar3 = ~uVar3 & *param_2;
}
else {
uVar3 = uVar3 | *param_2;
}
}
*param_2 = uVar3;
switchD_00128ec3_caseD_b:
return;
}
|
|
63,150 |
my_uca_implicit_weight_put
|
eloqsql/strings/ctype-uca.c
|
static inline void
my_uca_implicit_weight_put(uint16 *to, my_wc_t code, uint level)
{
switch (level) {
case 1: to[0]= 0x0020; to[1]= 0; break; /* Secondary level */
case 2: to[0]= 0x0002; to[1]= 0; break; /* Tertiary level */
case 3: to[0]= 0x0001; to[1]= 0; break; /* Quaternary level */
default:
DBUG_ASSERT(0);
case 0:
break;
}
/* Primary level */
to[0]= (uint16)(code >> 15) + my_uca_implicit_weight_base(code);
to[1]= (code & 0x7FFF) | 0x8000;
to[2]= 0;
}
|
O0
|
c
|
my_uca_implicit_weight_put:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x56903
movq -0x20(%rbp), %rax
leaq 0xf26a1(%rip), %rcx # 0x148f5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movw $0x20, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5690b
movq -0x8(%rbp), %rax
movw $0x2, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5690b
movq -0x8(%rbp), %rax
movw $0x1, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5690b
jmp 0x56905
jmp 0x56907
jmp 0x56909
jmp 0x5690b
movq -0x10(%rbp), %rax
shrq $0xf, %rax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56970
movw %ax, %cx
movl -0x24(%rbp), %eax
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
andq $0x7fff, %rax # imm = 0x7FFF
orq $0x8000, %rax # imm = 0x8000
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_implicit_weight_put:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
mov [rbp+var_20], rax
sub rax, 3; switch 4 cases
ja short def_568C2; jumptable 00000000000568C2 default case
mov rax, [rbp+var_20]
lea rcx, jpt_568C2
movsxd rax, ds:(jpt_568C2 - 148F5Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_568C4:
mov rax, [rbp+var_8]; jumptable 00000000000568C2 case 1
mov word ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5690B
loc_568D9:
mov rax, [rbp+var_8]; jumptable 00000000000568C2 case 2
mov word ptr [rax], 2
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5690B
loc_568EE:
mov rax, [rbp+var_8]; jumptable 00000000000568C2 case 3
mov word ptr [rax], 1
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5690B
def_568C2:
jmp short $+2; jumptable 00000000000568C2 default case
loc_56905:
jmp short $+2
loc_56907:
jmp short $+2; jumptable 00000000000568C2 case 0
loc_56909:
jmp short $+2; jumptable 00000000000568C2 case 0
loc_5690B:
mov rax, [rbp+var_10]
shr rax, 0Fh
movzx eax, ax
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
call my_uca_implicit_weight_base
mov cx, ax
mov eax, [rbp+var_24]
movzx ecx, cx
add eax, ecx
mov cx, ax
mov rax, [rbp+var_8]
mov [rax], cx
mov rax, [rbp+var_10]
and rax, 7FFFh
or rax, 8000h
mov cx, ax
mov rax, [rbp+var_8]
mov [rax+2], cx
mov rax, [rbp+var_8]
mov word ptr [rax+4], 0
add rsp, 30h
pop rbp
retn
|
_WORD * my_uca_implicit_weight_put(_WORD *a1, unsigned long long a2, int a3)
{
_WORD *result; // rax
switch ( a3 )
{
case 1:
*a1 = 32;
a1[1] = 0;
break;
case 2:
*a1 = 2;
a1[1] = 0;
break;
case 3:
*a1 = 1;
a1[1] = 0;
break;
default:
break;
}
*a1 = my_uca_implicit_weight_base(a2) + (a2 >> 15);
a1[1] = a2 & 0x7FFF | 0x8000;
result = a1;
a1[2] = 0;
return result;
}
|
my_uca_implicit_weight_put:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV EAX,dword ptr [RBP + -0x14]
MOV qword ptr [RBP + -0x20],RAX
SUB RAX,0x3
JA 0x00156903
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x248f5c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x20
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015690b
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015690b
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015690b
LAB_00156903:
JMP 0x00156905
LAB_00156905:
JMP 0x00156907
LAB_00156907:
JMP 0x00156909
caseD_0:
JMP 0x0015690b
LAB_0015690b:
MOV RAX,qword ptr [RBP + -0x10]
SHR RAX,0xf
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00156970
MOV CX,AX
MOV EAX,dword ptr [RBP + -0x24]
MOVZX ECX,CX
ADD EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x7fff
OR RAX,0x8000
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],CX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x4],0x0
ADD RSP,0x30
POP RBP
RET
|
void my_uca_implicit_weight_put(short *param_1,ulong param_2,int4 param_3)
{
short sVar1;
switch(param_3) {
default:
break;
case 1:
*param_1 = 0x20;
param_1[1] = 0;
break;
case 2:
*param_1 = 2;
param_1[1] = 0;
break;
case 3:
*param_1 = 1;
param_1[1] = 0;
}
sVar1 = my_uca_implicit_weight_base(param_2);
*param_1 = (short)(param_2 >> 0xf) + sVar1;
param_1[1] = (ushort)param_2 & 0x7fff | 0x8000;
param_1[2] = 0;
return;
}
|
|
63,151 |
ma_crypt_read
|
eloqsql/storage/maria/ma_crypt.c
|
uchar*
ma_crypt_read(MARIA_SHARE* share, uchar *buff)
{
uchar type= buff[0];
uchar iv_length= buff[1];
/* currently only supported type */
if (type != CRYPT_SCHEME_1 ||
iv_length != sizeof(((MARIA_CRYPT_DATA*)1)->scheme.iv) + 4)
{
my_printf_error(HA_ERR_UNSUPPORTED,
"Unsupported crypt scheme! type: %d iv_length: %d\n",
MYF(ME_FATAL|ME_ERROR_LOG),
type, iv_length);
return 0;
}
if (share->crypt_data == NULL)
{
/* opening a table */
MARIA_CRYPT_DATA *crypt_data=
(MARIA_CRYPT_DATA*)my_malloc(PSI_INSTRUMENT_ME, sizeof(MARIA_CRYPT_DATA), MYF(MY_ZEROFILL));
crypt_data->scheme.type= type;
mysql_mutex_init(key_CRYPT_DATA_lock, &crypt_data->lock,
MY_MUTEX_INIT_FAST);
crypt_data->scheme.locker= crypt_data_scheme_locker;
crypt_data->scheme.key_id= get_encryption_key_id(share);
crypt_data->space= uint4korr(buff + 2);
memcpy(crypt_data->scheme.iv, buff + 6, sizeof(crypt_data->scheme.iv));
share->crypt_data= crypt_data;
}
share->crypt_page_header_space= CRYPT_SCHEME_1_KEY_VERSION_SIZE;
return buff + 2 + iv_length;
}
|
O3
|
c
|
ma_crypt_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movzbl (%rsi), %ecx
movb 0x1(%rsi), %al
movl %ecx, %edx
xorb $0x1, %dl
movl %eax, %esi
xorb $0x14, %sil
orb %dl, %sil
je 0x51d5c
movzbl %al, %r8d
leaq 0x89f58(%rip), %rsi # 0xdbc9c
xorl %ebx, %ebx
movl $0x1040, %edx # imm = 0x1040
movl $0x8a, %edi
xorl %eax, %eax
callq 0x9f21d
jmp 0x51e27
movq %rdi, %r14
cmpq $0x0, 0xc20(%rdi)
jne 0x51e18
movl $0xb0, %esi
movl $0x20, %edx
xorl %edi, %edi
callq 0xa0cdd
movq %rax, %r15
movl $0x1, 0x54(%rax)
movl 0xbafd2e(%rip), %edi # 0xc01abc
leaq 0x68(%rax), %r12
leaq 0x336327(%rip), %rax # 0x3880c0
movq (%rax), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq %rax, 0xa8(%r15)
movq %r12, 0xa0(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r15)
leaq 0xbb8f1e(%rip), %rsi # 0xc0ace0
movq %r12, %rdi
callq 0x29340
leaq -0x244(%rip), %rax # 0x51b8d
movq %rax, 0x58(%r15)
testb $0x10, 0x720(%r14)
je 0x51df8
leaq 0x3342da(%rip), %rax # 0x3860c0
movl $0x2, %r12d
movl $0x2, %edi
callq *(%rax)
cmpl $-0x1, %eax
jne 0x51dfe
movl $0x1, %r12d
movl %r12d, 0x50(%r15)
movl 0x2(%rbx), %eax
movl %eax, 0x60(%r15)
movups 0x6(%rbx), %xmm0
movups %xmm0, (%r15)
movq %r15, 0xc20(%r14)
movl $0x4, 0xc18(%r14)
addq $0x16, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
ma_crypt_read:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
movzx ecx, byte ptr [rsi]
mov al, [rsi+1]
mov edx, ecx
xor dl, 1
mov esi, eax
xor sil, 14h
or sil, dl
jz short loc_51D5C
movzx r8d, al
lea rsi, aUnsupportedCry; "Unsupported crypt scheme! type: %d iv_l"...
xor ebx, ebx
mov edx, 1040h
mov edi, 8Ah
xor eax, eax
call my_printf_error
jmp loc_51E27
loc_51D5C:
mov r14, rdi
cmp qword ptr [rdi+0C20h], 0
jnz loc_51E18
mov esi, 0B0h
mov edx, 20h ; ' '
xor edi, edi
call my_malloc
mov r15, rax
mov dword ptr [rax+54h], 1
mov edi, cs:key_CRYPT_DATA_lock
lea r12, [rax+68h]
lea rax, PSI_server
mov rax, [rax]
mov rsi, r12
call qword ptr [rax+40h]
mov [r15+0A8h], rax
mov [r15+0A0h], r12
xorps xmm0, xmm0
movups xmmword ptr [r15+90h], xmm0
lea rsi, my_fast_mutexattr
mov rdi, r12
call _pthread_mutex_init
lea rax, crypt_data_scheme_locker
mov [r15+58h], rax
test byte ptr [r14+720h], 10h
jz short loc_51DF8
lea rax, encryption_handler
mov r12d, 2
mov edi, 2
call qword ptr [rax]
cmp eax, 0FFFFFFFFh
jnz short loc_51DFE
loc_51DF8:
mov r12d, 1
loc_51DFE:
mov [r15+50h], r12d
mov eax, [rbx+2]
mov [r15+60h], eax
movups xmm0, xmmword ptr [rbx+6]
movups xmmword ptr [r15], xmm0
mov [r14+0C20h], r15
loc_51E18:
mov dword ptr [r14+0C18h], 4
add rbx, 16h
loc_51E27:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
unsigned __int8 * ma_crypt_read(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5, int a6)
{
unsigned __int8 v6; // al
long long v7; // rbx
long long v8; // r15
int v9; // r12d
v6 = a2[1];
if ( *a2 ^ 1 | v6 ^ 0x14 )
{
v7 = 0LL;
my_printf_error(138, (unsigned int)"Unsupported crypt scheme! type: %d iv_length: %d\n", 4160, *a2, v6, a6);
}
else
{
if ( !*(_QWORD *)(a1 + 3104) )
{
v8 = my_malloc(0LL, 176LL, 32LL);
*(_DWORD *)(v8 + 84) = 1;
*(_QWORD *)(v8 + 168) = ((long long ( *)(_QWORD, long long))PSI_server[8])(
(unsigned int)key_CRYPT_DATA_lock,
v8 + 104);
*(_QWORD *)(v8 + 160) = v8 + 104;
*(_OWORD *)(v8 + 144) = 0LL;
pthread_mutex_init(v8 + 104, &my_fast_mutexattr);
*(_QWORD *)(v8 + 88) = crypt_data_scheme_locker;
if ( (*(_BYTE *)(a1 + 1824) & 0x10) == 0 || (v9 = 2, (unsigned int)encryption_handler() == -1) )
v9 = 1;
*(_DWORD *)(v8 + 80) = v9;
*(_DWORD *)(v8 + 96) = *(_DWORD *)(a2 + 2);
*(_OWORD *)v8 = *(_OWORD *)(a2 + 6);
*(_QWORD *)(a1 + 3104) = v8;
}
*(_DWORD *)(a1 + 3096) = 4;
return a2 + 22;
}
return (unsigned __int8 *)v7;
}
|
ma_crypt_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOVZX ECX,byte ptr [RSI]
MOV AL,byte ptr [RSI + 0x1]
MOV EDX,ECX
XOR DL,0x1
MOV ESI,EAX
XOR SIL,0x14
OR SIL,DL
JZ 0x00151d5c
MOVZX R8D,AL
LEA RSI,[0x1dbc9c]
XOR EBX,EBX
MOV EDX,0x1040
MOV EDI,0x8a
XOR EAX,EAX
CALL 0x0019f21d
JMP 0x00151e27
LAB_00151d5c:
MOV R14,RDI
CMP qword ptr [RDI + 0xc20],0x0
JNZ 0x00151e18
MOV ESI,0xb0
MOV EDX,0x20
XOR EDI,EDI
CALL 0x001a0cdd
MOV R15,RAX
MOV dword ptr [RAX + 0x54],0x1
MOV EDI,dword ptr [0x00d01abc]
LEA R12,[RAX + 0x68]
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
MOV RSI,R12
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R15 + 0xa8],RAX
MOV qword ptr [R15 + 0xa0],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x90],XMM0
LEA RSI,[0xd0ace0]
MOV RDI,R12
CALL 0x00129340
LEA RAX,[0x151b8d]
MOV qword ptr [R15 + 0x58],RAX
TEST byte ptr [R14 + 0x720],0x10
JZ 0x00151df8
LEA RAX,[0x4860c0]
MOV R12D,0x2
MOV EDI,0x2
CALL qword ptr [RAX]
CMP EAX,-0x1
JNZ 0x00151dfe
LAB_00151df8:
MOV R12D,0x1
LAB_00151dfe:
MOV dword ptr [R15 + 0x50],R12D
MOV EAX,dword ptr [RBX + 0x2]
MOV dword ptr [R15 + 0x60],EAX
MOVUPS XMM0,xmmword ptr [RBX + 0x6]
MOVUPS xmmword ptr [R15],XMM0
MOV qword ptr [R14 + 0xc20],R15
LAB_00151e18:
MOV dword ptr [R14 + 0xc18],0x4
ADD RBX,0x16
LAB_00151e27:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
char * ma_crypt_read(long param_1,char *param_2)
{
pthread_mutex_t *__mutex;
int iVar1;
int8 *puVar2;
int8 uVar3;
int4 uVar4;
if (param_2[1] != '\x14' || *param_2 != '\x01') {
my_printf_error(0x8a,"Unsupported crypt scheme! type: %d iv_length: %d\n",0x1040,*param_2,
param_2[1]);
return (char *)0x0;
}
if (*(long *)(param_1 + 0xc20) != 0) goto LAB_00151e18;
puVar2 = (int8 *)my_malloc(0,0xb0,0x20);
*(int4 *)((long)puVar2 + 0x54) = 1;
__mutex = (pthread_mutex_t *)(puVar2 + 0xd);
uVar3 = (**(code **)(PSI_server + 0x40))(key_CRYPT_DATA_lock,__mutex);
puVar2[0x15] = uVar3;
puVar2[0x14] = __mutex;
puVar2[0x12] = 0;
puVar2[0x13] = 0;
pthread_mutex_init(__mutex,(pthread_mutexattr_t *)&my_fast_mutexattr);
puVar2[0xb] = crypt_data_scheme_locker;
if ((*(byte *)(param_1 + 0x720) & 0x10) == 0) {
LAB_00151df8:
uVar4 = 1;
}
else {
uVar4 = 2;
iVar1 = (*(code *)encryption_handler)(2);
if (iVar1 == -1) goto LAB_00151df8;
}
*(int4 *)(puVar2 + 10) = uVar4;
*(int4 *)(puVar2 + 0xc) = *(int4 *)(param_2 + 2);
uVar3 = *(int8 *)(param_2 + 0xe);
*puVar2 = *(int8 *)(param_2 + 6);
puVar2[1] = uVar3;
*(int8 **)(param_1 + 0xc20) = puVar2;
LAB_00151e18:
*(int4 *)(param_1 + 0xc18) = 4;
return param_2 + 0x16;
}
|
|
63,152 |
coro::thread_pool::thread_pool(coro::thread_pool::options)
|
AlayaLite/build_O3/_deps/libcoro-src/src/thread_pool.cpp
|
thread_pool::thread_pool(options opts) : m_opts(std::move(opts))
{
m_threads.reserve(m_opts.thread_count);
for (uint32_t i = 0; i < m_opts.thread_count; ++i)
{
m_threads.emplace_back([this, i]() { executor(i); });
}
}
|
O3
|
cpp
|
coro::thread_pool::thread_pool(coro::thread_pool::options):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r13
leaq 0x7c64(%rip), %rax # 0xdbc8
addq $0x10, %rax
movq %rax, (%rdi)
movl (%rsi), %eax
movl %eax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x28(%rdi)
cmpq $0x0, 0x18(%rsi)
je 0x5fa8
leaq 0x10(%r13), %rax
leaq 0x18(%rsi), %rcx
movups 0x8(%rsi), %xmm1
movups %xmm1, (%rax)
movq 0x18(%rsi), %rax
movq %rax, 0x20(%r13)
movups %xmm0, (%rcx)
movups %xmm0, 0x30(%r13)
movq $0x0, 0x40(%r13)
movq 0x40(%rsi), %rax
movq %rax, 0x48(%r13)
cmpq $0x0, 0x38(%rsi)
je 0x5fe1
leaq 0x30(%r13), %rax
leaq 0x38(%rsi), %rcx
movups 0x28(%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x38(%rsi), %rax
movq %rax, 0x40(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
leaq 0x8(%r13), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%r13), %rax
movq %rax, (%rsp)
leaq 0x90(%r13), %rbx
movups %xmm0, 0x80(%r13)
movups %xmm0, 0x70(%r13)
movups %xmm0, 0x60(%r13)
movups %xmm0, 0x50(%r13)
movq %rbx, %rdi
callq 0x66f4
leaq 0xd0(%r13), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%r13)
movups %xmm0, 0x100(%r13)
movups %xmm0, 0xf0(%r13)
movups %xmm0, 0xe0(%r13)
movups %xmm0, 0xd0(%r13)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, 0x28(%rsp)
callq 0x6a14
movq %r14, 0x20(%rsp)
movq $0x0, 0x120(%r13)
movb $0x0, 0x128(%r13)
movl 0x8(%r13), %esi
movq (%rsp), %rdi
callq 0x6764
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0x61ce
movq 0x58(%r13), %rbp
xorl %r12d, %r12d
movq %r13, 0x30(%rsp)
movq %r13, 0x38(%rsp)
movl %r12d, 0x40(%rsp)
cmpq 0x60(%r13), %rbp
je 0x60c6
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x665e
movq 0x58(%r13), %rbx
addq $0x8, %rbx
movq %rbx, 0x58(%r13)
jmp 0x61ba
movl $0x1, %esi
movq (%rsp), %rdi
leaq 0x2f56(%rip), %rdx # 0x902c
callq 0x6bfe
movq %rax, %rbx
movq 0x50(%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%r13), %r15
testq %rbx, %rbx
movq %rbx, 0x18(%rsp)
je 0x6108
movq (%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6be2
movq %rax, %r13
jmp 0x610b
xorl %r13d, %r13d
movq %rbp, %rcx
movq 0x10(%rsp), %r14
subq %r14, %rcx
sarq $0x3, %rcx
leaq (,%rcx,8), %rbx
addq %r13, %rbx
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq 0x665e
movq %r13, %rbx
cmpq %rbp, %r14
movq %r13, %rdx
je 0x615f
movq %rdx, %rbx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq $0x0, (%rax)
addq $0x8, %rax
addq $0x8, %rbx
cmpq %rbp, %rax
jne 0x6145
addq $0x8, %rbx
cmpq %rbp, %r15
movq 0x30(%rsp), %r13
je 0x6189
movq (%rbp), %rax
movq %rax, (%rbx)
movq $0x0, (%rbp)
addq $0x8, %rbp
addq $0x8, %rbx
cmpq %r15, %rbp
jne 0x616d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x61a5
movq 0x60(%r13), %rsi
subq %rdi, %rsi
movq %rdx, %r14
callq 0x3250
movq %r14, %rdx
movq %rdx, 0x50(%r13)
movq %rbx, 0x58(%r13)
movq 0x18(%rsp), %rax
leaq (%rdx,%rax,8), %rax
movq %rax, 0x60(%r13)
incl %r12d
movq %rbx, %rbp
movq 0x8(%rsp), %rax
cmpl (%rax), %r12d
jb 0x6098
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6229
movq %rax, %r14
jmp 0x6236
movq %rax, %r14
jmp 0x6240
movq %rax, %rdi
callq 0x30d0
testq %r13, %r13
jne 0x6201
cmpq $0x0, (%rbx)
je 0x6212
callq 0x3070
movq %r13, %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
callq 0x3250
callq 0x3300
movq %rax, %r14
callq 0x3340
jmp 0x622c
movq %rax, %rdi
callq 0x4a0a
movq %rax, %r14
movq 0x20(%rsp), %rdi
callq 0x6b8a
movq 0x28(%rsp), %rdi
callq 0x6810
movq (%rsp), %rdi
callq 0x682c
movq 0x8(%rsp), %rdi
callq 0x6868
movq %r14, %rdi
callq 0x3390
nop
|
_ZN4coro11thread_poolC2ENS0_7optionsE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, rdi
lea rax, _ZTVN4coro11thread_poolE; `vtable for'coro::thread_pool
add rax, 10h
mov [rdi], rax
mov eax, [rsi]
mov [rdi+8], eax
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+20h], 0
mov rax, [rsi+20h]
mov [rdi+28h], rax
cmp qword ptr [rsi+18h], 0
jz short loc_5FA8
lea rax, [r13+10h]
lea rcx, [rsi+18h]
movups xmm1, xmmword ptr [rsi+8]
movups xmmword ptr [rax], xmm1
mov rax, [rsi+18h]
mov [r13+20h], rax
movups xmmword ptr [rcx], xmm0
loc_5FA8:
movups xmmword ptr [r13+30h], xmm0
mov qword ptr [r13+40h], 0
mov rax, [rsi+40h]
mov [r13+48h], rax
cmp qword ptr [rsi+38h], 0
jz short loc_5FE1
lea rax, [r13+30h]
lea rcx, [rsi+38h]
movups xmm0, xmmword ptr [rsi+28h]
movups xmmword ptr [rax], xmm0
mov rax, [rsi+38h]
mov [r13+40h], rax
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
loc_5FE1:
lea rax, [r13+8]
mov [rsp+78h+var_70], rax
lea rax, [r13+50h]
mov [rsp+78h+var_78], rax
lea rbx, [r13+90h]
movups xmmword ptr [r13+80h], xmm0
movups xmmword ptr [r13+70h], xmm0
movups xmmword ptr [r13+60h], xmm0
movups xmmword ptr [r13+50h], xmm0
mov rdi, rbx; this
call _ZNSt3_V222condition_variable_anyC2Ev; std::_V2::condition_variable_any::condition_variable_any(void)
lea r14, [r13+0D0h]
xorps xmm0, xmm0
movups xmmword ptr [r13+110h], xmm0
movups xmmword ptr [r13+100h], xmm0
movups xmmword ptr [r13+0F0h], xmm0
movups xmmword ptr [r13+0E0h], xmm0
movups xmmword ptr [r13+0D0h], xmm0
mov rdi, r14
xor esi, esi
mov [rsp+78h+var_50], rbx
call _ZNSt11_Deque_baseINSt7__n486116coroutine_handleIvEESaIS2_EE17_M_initialize_mapEm; std::_Deque_base<std::__n4861::coroutine_handle<void>>::_M_initialize_map(ulong)
mov [rsp+78h+var_58], r14
mov qword ptr [r13+120h], 0
mov byte ptr [r13+128h], 0
mov esi, [r13+8]
mov rdi, [rsp+78h+var_78]
call _ZNSt6vectorISt6threadSaIS0_EE7reserveEm; std::vector<std::thread>::reserve(ulong)
mov rax, [rsp+78h+var_70]
cmp dword ptr [rax], 0
jz loc_61CE
mov rbp, [r13+58h]
xor r12d, r12d
mov [rsp+78h+var_48], r13
loc_6098:
mov [rsp+78h+var_40], r13
mov [rsp+78h+var_38], r12d
cmp rbp, [r13+60h]
jz short loc_60C6
mov rdi, rbp
lea rsi, [rsp+78h+var_40]
call _ZNSt16allocator_traitsISaISt6threadEE9constructIS0_JZN4coro11thread_poolC1ENS5_7optionsEE3$_0EEEvRS1_PT_DpOT0_; std::allocator_traits<std::allocator<std::thread>>::construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0>(std::allocator<std::thread>&,std::thread *,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0 &&)
mov rbx, [r13+58h]
add rbx, 8
mov [r13+58h], rbx
jmp loc_61BA
loc_60C6:
mov esi, 1
mov rdi, [rsp+78h+var_78]
lea rdx, aVectorMRealloc; "vector::_M_realloc_insert"
call _ZNKSt6vectorISt6threadSaIS0_EE12_M_check_lenEmPKc; std::vector<std::thread>::_M_check_len(ulong,char const*)
mov rbx, rax
mov rax, [r13+50h]
mov [rsp+78h+var_68], rax
mov r15, [r13+58h]
test rbx, rbx
mov [rsp+78h+var_60], rbx
jz short loc_6108
mov rdi, [rsp+78h+var_78]
mov rsi, rbx
xor edx, edx
call _ZN9__gnu_cxx13new_allocatorISt6threadE8allocateEmPKv; __gnu_cxx::new_allocator<std::thread>::allocate(ulong,void const*)
mov r13, rax
jmp short loc_610B
loc_6108:
xor r13d, r13d
loc_610B:
mov rcx, rbp
mov r14, [rsp+78h+var_68]
sub rcx, r14
sar rcx, 3
lea rbx, ds:0[rcx*8]
add rbx, r13
mov rdi, rbx
lea rsi, [rsp+78h+var_40]
call _ZNSt16allocator_traitsISaISt6threadEE9constructIS0_JZN4coro11thread_poolC1ENS5_7optionsEE3$_0EEEvRS1_PT_DpOT0_; std::allocator_traits<std::allocator<std::thread>>::construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0>(std::allocator<std::thread>&,std::thread *,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0 &&)
mov rbx, r13
cmp r14, rbp
mov rdx, r13
jz short loc_615F
mov rbx, rdx
mov rax, [rsp+78h+var_68]
loc_6145:
mov rcx, [rax]
mov [rbx], rcx
mov qword ptr [rax], 0
add rax, 8
add rbx, 8
cmp rax, rbp
jnz short loc_6145
loc_615F:
add rbx, 8
cmp r15, rbp
mov r13, [rsp+78h+var_48]
jz short loc_6189
loc_616D:
mov rax, [rbp+0]
mov [rbx], rax
mov qword ptr [rbp+0], 0
add rbp, 8
add rbx, 8
cmp rbp, r15
jnz short loc_616D
loc_6189:
mov rdi, [rsp+78h+var_68]; void *
test rdi, rdi
jz short loc_61A5
mov rsi, [r13+60h]
sub rsi, rdi; unsigned __int64
mov r14, rdx
call __ZdlPvm; operator delete(void *,ulong)
mov rdx, r14
loc_61A5:
mov [r13+50h], rdx
mov [r13+58h], rbx
mov rax, [rsp+78h+var_60]
lea rax, [rdx+rax*8]
mov [r13+60h], rax
loc_61BA:
inc r12d
mov rbp, rbx
mov rax, [rsp+78h+var_70]
cmp r12d, [rax]
jb loc_6098
loc_61CE:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_6229
mov r14, rax
jmp short loc_6236
mov r14, rax
jmp short loc_6240
mov rdi, rax; void *
call ___cxa_begin_catch
test r13, r13
jnz short loc_6201
cmp qword ptr [rbx], 0
jz short loc_6212
call __ZSt9terminatev; std::terminate(void)
loc_6201:
mov rdi, r13; void *
mov rsi, [rsp+78h+var_60]
shl rsi, 3; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6212:
call ___cxa_rethrow
mov r14, rax
call ___cxa_end_catch
jmp short loc_622C
mov rdi, rax
call __clang_call_terminate
loc_6229:
mov r14, rax
loc_622C:
mov rdi, [rsp+78h+var_58]
call _ZNSt11_Deque_baseINSt7__n486116coroutine_handleIvEESaIS2_EED2Ev; std::_Deque_base<std::__n4861::coroutine_handle<void>>::~_Deque_base()
loc_6236:
mov rdi, [rsp+78h+var_50]; this
call _ZNSt3_V222condition_variable_anyD2Ev; std::_V2::condition_variable_any::~condition_variable_any()
loc_6240:
mov rdi, [rsp+78h+var_78]
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
mov rdi, [rsp+78h+var_70]; this
call _ZN4coro11thread_pool7optionsD2Ev; coro::thread_pool::options::~options()
mov rdi, r14
call __Unwind_Resume
|
long long coro::thread_pool::thread_pool(long long a1, long long a2)
{
_QWORD *i; // r13
__int128 v3; // xmm0
long long result; // rax
char *v5; // rbp
unsigned int v6; // r12d
char *v7; // rbx
long long v8; // rbx
char *v9; // r15
long long v10; // r13
_QWORD *v11; // rbx
long long v12; // rdx
char *v13; // rax
long long v14; // r14
long long v15; // [rsp+0h] [rbp-78h]
char *v16; // [rsp+10h] [rbp-68h]
long long v17; // [rsp+18h] [rbp-60h]
_QWORD *v18; // [rsp+38h] [rbp-40h] BYREF
unsigned int v19; // [rsp+40h] [rbp-38h]
i = (_QWORD *)a1;
*(_QWORD *)a1 = &`vtable for'coro::thread_pool + 2;
*(_DWORD *)(a1 + 8) = *(_DWORD *)a2;
v3 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = *(_QWORD *)(a2 + 32);
if ( *(_QWORD *)(a2 + 24) )
{
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a2 + 8);
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a2 + 24);
*(_OWORD *)(a2 + 24) = 0LL;
}
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a2 + 64);
if ( *(_QWORD *)(a2 + 56) )
{
*(_OWORD *)(a1 + 48) = *(_OWORD *)(a2 + 40);
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a2 + 56);
v3 = 0LL;
*(_OWORD *)(a2 + 56) = 0LL;
}
v15 = a1 + 80;
*(_OWORD *)(a1 + 128) = v3;
*(_OWORD *)(a1 + 112) = v3;
*(_OWORD *)(a1 + 96) = v3;
*(_OWORD *)(a1 + 80) = v3;
std::_V2::condition_variable_any::condition_variable_any((std::_V2::condition_variable_any *)(a1 + 144));
*(_OWORD *)(a1 + 272) = 0LL;
*(_OWORD *)(a1 + 256) = 0LL;
*(_OWORD *)(a1 + 240) = 0LL;
*(_OWORD *)(a1 + 224) = 0LL;
*(_OWORD *)(a1 + 208) = 0LL;
std::_Deque_base<std::__n4861::coroutine_handle<void>>::_M_initialize_map(a1 + 208, 0LL);
*(_QWORD *)(a1 + 288) = 0LL;
*(_BYTE *)(a1 + 296) = 0;
std::vector<std::thread>::reserve(a1 + 80, *(unsigned int *)(a1 + 8));
result = a1 + 8;
if ( *(_DWORD *)(a1 + 8) )
{
v5 = *(char **)(a1 + 88);
v6 = 0;
do
{
v18 = i;
v19 = v6;
if ( v5 == (char *)i[12] )
{
v8 = std::vector<std::thread>::_M_check_len(v15, 1LL, "vector::_M_realloc_insert");
v16 = (char *)i[10];
v9 = (char *)i[11];
v17 = v8;
if ( v8 )
v10 = __gnu_cxx::new_allocator<std::thread>::allocate(v15, v8, 0LL);
else
v10 = 0LL;
std::allocator_traits<std::allocator<std::thread>>::construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0>(
v10 + 8 * ((v5 - v16) >> 3),
&v18);
v11 = (_QWORD *)v10;
v12 = v10;
if ( v16 != v5 )
{
v11 = (_QWORD *)v10;
v13 = v16;
do
{
*v11 = *(_QWORD *)v13;
*(_QWORD *)v13 = 0LL;
v13 += 8;
++v11;
}
while ( v13 != v5 );
}
v7 = (char *)(v11 + 1);
for ( i = (_QWORD *)a1; v5 != v9; v7 += 8 )
{
*(_QWORD *)v7 = *(_QWORD *)v5;
*(_QWORD *)v5 = 0LL;
v5 += 8;
}
if ( v16 )
{
v14 = v12;
operator delete(v16, *(_QWORD *)(a1 + 96) - (_QWORD)v16);
v12 = v14;
}
*(_QWORD *)(a1 + 80) = v12;
*(_QWORD *)(a1 + 88) = v7;
*(_QWORD *)(a1 + 96) = v12 + 8 * v17;
}
else
{
std::allocator_traits<std::allocator<std::thread>>::construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::$_0>(
v5,
&v18);
v7 = (char *)(i[11] + 8LL);
i[11] = v7;
}
++v6;
v5 = v7;
result = a1 + 8;
}
while ( v6 < *(_DWORD *)(a1 + 8) );
}
return result;
}
|
thread_pool:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
LEA RAX,[0x10dbc8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV EAX,dword ptr [RSI]
MOV dword ptr [RDI + 0x8],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x20],0x0
MOV RAX,qword ptr [RSI + 0x20]
MOV qword ptr [RDI + 0x28],RAX
CMP qword ptr [RSI + 0x18],0x0
JZ 0x00105fa8
LEA RAX,[R13 + 0x10]
LEA RCX,[RSI + 0x18]
MOVUPS XMM1,xmmword ptr [RSI + 0x8]
MOVUPS xmmword ptr [RAX],XMM1
MOV RAX,qword ptr [RSI + 0x18]
MOV qword ptr [R13 + 0x20],RAX
MOVUPS xmmword ptr [RCX],XMM0
LAB_00105fa8:
MOVUPS xmmword ptr [R13 + 0x30],XMM0
MOV qword ptr [R13 + 0x40],0x0
MOV RAX,qword ptr [RSI + 0x40]
MOV qword ptr [R13 + 0x48],RAX
CMP qword ptr [RSI + 0x38],0x0
JZ 0x00105fe1
LEA RAX,[R13 + 0x30]
LEA RCX,[RSI + 0x38]
MOVUPS XMM0,xmmword ptr [RSI + 0x28]
MOVUPS xmmword ptr [RAX],XMM0
MOV RAX,qword ptr [RSI + 0x38]
MOV qword ptr [R13 + 0x40],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
LAB_00105fe1:
LEA RAX,[R13 + 0x8]
MOV qword ptr [RSP + 0x8],RAX
LEA RAX,[R13 + 0x50]
MOV qword ptr [RSP],RAX
LEA RBX,[R13 + 0x90]
MOVUPS xmmword ptr [R13 + 0x80],XMM0
MOVUPS xmmword ptr [R13 + 0x70],XMM0
MOVUPS xmmword ptr [R13 + 0x60],XMM0
MOVUPS xmmword ptr [R13 + 0x50],XMM0
LAB_00106010:
MOV RDI,RBX
CALL 0x001066f4
LEA R14,[R13 + 0xd0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x110],XMM0
MOVUPS xmmword ptr [R13 + 0x100],XMM0
MOVUPS xmmword ptr [R13 + 0xf0],XMM0
MOVUPS xmmword ptr [R13 + 0xe0],XMM0
MOVUPS xmmword ptr [R13 + 0xd0],XMM0
LAB_0010604a:
MOV RDI,R14
XOR ESI,ESI
MOV qword ptr [RSP + 0x28],RBX
CALL 0x00106a14
MOV qword ptr [RSP + 0x20],R14
MOV qword ptr [R13 + 0x120],0x0
MOV byte ptr [R13 + 0x128],0x0
MOV ESI,dword ptr [R13 + 0x8]
LAB_00106075:
MOV RDI,qword ptr [RSP]
CALL 0x00106764
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX],0x0
JZ 0x001061ce
MOV RBP,qword ptr [R13 + 0x58]
XOR R12D,R12D
MOV qword ptr [RSP + 0x30],R13
LAB_00106098:
MOV qword ptr [RSP + 0x38],R13
MOV dword ptr [RSP + 0x40],R12D
CMP RBP,qword ptr [R13 + 0x60]
JZ 0x001060c6
LAB_001060a8:
MOV RDI,RBP
LEA RSI,[RSP + 0x38]
CALL 0x0010665e
MOV RBX,qword ptr [R13 + 0x58]
ADD RBX,0x8
MOV qword ptr [R13 + 0x58],RBX
JMP 0x001061ba
LAB_001060c6:
MOV ESI,0x1
MOV RDI,qword ptr [RSP]
LEA RDX,[0x10902c]
CALL 0x00106bfe
MOV RBX,RAX
MOV RAX,qword ptr [R13 + 0x50]
MOV qword ptr [RSP + 0x10],RAX
MOV R15,qword ptr [R13 + 0x58]
TEST RBX,RBX
MOV qword ptr [RSP + 0x18],RBX
JZ 0x00106108
MOV RDI,qword ptr [RSP]
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00106be2
MOV R13,RAX
JMP 0x0010610b
LAB_00106108:
XOR R13D,R13D
LAB_0010610b:
MOV RCX,RBP
MOV R14,qword ptr [RSP + 0x10]
SUB RCX,R14
SAR RCX,0x3
LEA RBX,[RCX*0x8]
ADD RBX,R13
LAB_00106125:
MOV RDI,RBX
LEA RSI,[RSP + 0x38]
CALL 0x0010665e
LAB_00106132:
MOV RBX,R13
CMP R14,RBP
MOV RDX,R13
JZ 0x0010615f
MOV RBX,RDX
MOV RAX,qword ptr [RSP + 0x10]
LAB_00106145:
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV qword ptr [RAX],0x0
ADD RAX,0x8
ADD RBX,0x8
CMP RAX,RBP
JNZ 0x00106145
LAB_0010615f:
ADD RBX,0x8
CMP R15,RBP
MOV R13,qword ptr [RSP + 0x30]
JZ 0x00106189
LAB_0010616d:
MOV RAX,qword ptr [RBP]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBP],0x0
ADD RBP,0x8
ADD RBX,0x8
CMP RBP,R15
JNZ 0x0010616d
LAB_00106189:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001061a5
MOV RSI,qword ptr [R13 + 0x60]
SUB RSI,RDI
MOV R14,RDX
CALL 0x00103250
MOV RDX,R14
LAB_001061a5:
MOV qword ptr [R13 + 0x50],RDX
MOV qword ptr [R13 + 0x58],RBX
MOV RAX,qword ptr [RSP + 0x18]
LEA RAX,[RDX + RAX*0x8]
MOV qword ptr [R13 + 0x60],RAX
LAB_001061ba:
INC R12D
MOV RBP,RBX
MOV RAX,qword ptr [RSP + 0x8]
CMP R12D,dword ptr [RAX]
JC 0x00106098
LAB_001061ce:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* coro::thread_pool::thread_pool(coro::thread_pool::options) */
void __thiscall coro::thread_pool::thread_pool(thread_pool *this,int4 *param_2)
{
vector<std::thread,std::allocator<std::thread>> *this_00;
allocator *paVar1;
allocator *paVar2;
int8 uVar3;
allocator *paVar4;
void *pvVar5;
allocator *paVar6;
__0 *extraout_RDX;
__0 *extraout_RDX_00;
__0 *p_Var7;
allocator *paVar8;
__0 *p_Var9;
uint uVar10;
int1 auVar11 [16];
int1 auVar12 [16];
thread_pool *local_40;
uint local_38;
*(int ***)this = &PTR__thread_pool_0010dbd8;
*(int4 *)(this + 8) = *param_2;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = *(int8 *)(param_2 + 8);
if (*(long *)(param_2 + 6) != 0) {
uVar3 = *(int8 *)(param_2 + 4);
*(int8 *)(this + 0x10) = *(int8 *)(param_2 + 2);
*(int8 *)(this + 0x18) = uVar3;
*(int8 *)(this + 0x20) = *(int8 *)(param_2 + 6);
*(int8 *)(param_2 + 6) = 0;
*(int8 *)(param_2 + 8) = 0;
}
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_2 + 0x10);
if (*(long *)(param_2 + 0xe) != 0) {
uVar3 = *(int8 *)(param_2 + 0xc);
*(int8 *)(this + 0x30) = *(int8 *)(param_2 + 10);
*(int8 *)(this + 0x38) = uVar3;
*(int8 *)(this + 0x40) = *(int8 *)(param_2 + 0xe);
*(int8 *)(param_2 + 0xe) = 0;
*(int8 *)(param_2 + 0x10) = 0;
}
this_00 = (vector<std::thread,std::allocator<std::thread>> *)(this + 0x50);
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 00106010 to 00106017 has its CatchHandler @ 001061e4 */
std::_V2::condition_variable_any::condition_variable_any((condition_variable_any *)(this + 0x90));
*(int8 *)(this + 0x110) = 0;
*(int8 *)(this + 0x118) = 0;
*(int8 *)(this + 0x100) = 0;
*(int8 *)(this + 0x108) = 0;
*(int8 *)(this + 0xf0) = 0;
*(int8 *)(this + 0xf8) = 0;
*(int8 *)(this + 0xe0) = 0;
*(int8 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xd0) = 0;
*(int8 *)(this + 0xd8) = 0;
/* try { // try from 0010604a to 00106058 has its CatchHandler @ 001061df */
std::
_Deque_base<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
::_M_initialize_map((_Deque_base<std::__n4861::coroutine_handle<void>,std::allocator<std::__n4861::coroutine_handle<void>>>
*)(this + 0xd0),0);
*(int8 *)(this + 0x120) = 0;
this[0x128] = (thread_pool)0x0;
/* try { // try from 00106075 to 0010607d has its CatchHandler @ 001061dd */
std::vector<std::thread,std::allocator<std::thread>>::reserve(this_00,(ulong)*(uint *)(this + 8));
if (*(uint *)(this + 8) != 0) {
paVar8 = *(allocator **)(this + 0x58);
uVar10 = 0;
p_Var7 = extraout_RDX;
do {
local_40 = this;
local_38 = uVar10;
if (paVar8 == *(allocator **)(this + 0x60)) {
auVar11 = std::vector<std::thread,std::allocator<std::thread>>::_M_check_len
(this_00,1,"vector::_M_realloc_insert");
pvVar5 = auVar11._0_8_;
paVar1 = *(allocator **)(this + 0x50);
paVar2 = *(allocator **)(this + 0x58);
if (pvVar5 == (void *)0x0) {
auVar12._8_8_ = 0;
auVar12._0_8_ = auVar11._8_8_;
auVar12 = auVar12 << 0x40;
}
else {
auVar12 = __gnu_cxx::new_allocator<std::thread>::allocate((ulong)this_00,pvVar5);
}
p_Var7 = auVar12._0_8_;
/* try { // try from 00106125 to 00106131 has its CatchHandler @ 001061e9 */
std::allocator_traits<std::allocator<std::thread>>::
construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::__0>
((allocator *)(p_Var7 + ((long)paVar8 - (long)paVar1 >> 3) * 8),
(thread *)&local_40,auVar12._8_8_);
p_Var9 = p_Var7;
for (paVar6 = paVar1; paVar4 = paVar8, paVar6 != paVar8; paVar6 = paVar6 + 8) {
*(int8 *)p_Var9 = *(int8 *)paVar6;
*(int8 *)paVar6 = 0;
p_Var9 = p_Var9 + 8;
}
for (; paVar8 = (allocator *)(p_Var9 + 8), paVar2 != paVar4; paVar4 = paVar4 + 8) {
*(int8 *)paVar8 = *(int8 *)paVar4;
*(int8 *)paVar4 = 0;
p_Var9 = (__0 *)paVar8;
}
if (paVar1 != (allocator *)0x0) {
operator_delete(paVar1,*(long *)(this + 0x60) - (long)paVar1);
}
*(__0 **)(this + 0x50) = p_Var7;
*(allocator **)(this + 0x58) = paVar8;
*(__0 **)(this + 0x60) = p_Var7 + (long)pvVar5 * 8;
}
else {
/* try { // try from 001060a8 to 00106102 has its CatchHandler @ 00106229 */
std::allocator_traits<std::allocator<std::thread>>::
construct<std::thread,coro::thread_pool::thread_pool(coro::thread_pool::options)::__0>
(paVar8,(thread *)&local_40,p_Var7);
paVar8 = (allocator *)(*(long *)(this + 0x58) + 8);
*(allocator **)(this + 0x58) = paVar8;
p_Var7 = extraout_RDX_00;
}
uVar10 = uVar10 + 1;
} while (uVar10 < *(uint *)(this + 8));
}
return;
}
|
|
63,153 |
mi_find_last_pos
|
eloqsql/storage/myisam/mi_write.c
|
static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uint *return_key_length,
uchar **after_key)
{
uint keys, length, UNINIT_VAR(last_length), key_ref_length;
uchar *end,*lastpos,*prevpos;
uchar key_buff[HA_MAX_KEY_BUFF];
DBUG_ENTER("_mi_find_last_pos");
key_ref_length=2;
length=mi_getint(page)-key_ref_length;
page+=key_ref_length;
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
HA_BINARY_PACK_KEY)))
{
keys=length/keyinfo->keylength-2;
*return_key_length=length=keyinfo->keylength;
end=page+keys*length;
*after_key=end+length;
memcpy(key,end,length);
DBUG_RETURN(end);
}
end=page+length-key_ref_length;
DBUG_ASSERT(page < end);
*key='\0';
length=0;
lastpos=page;
do
{
prevpos=lastpos; lastpos=page;
last_length=length;
memcpy(key, key_buff, length); /* previous key */
if (!(length=(*keyinfo->get_key)(keyinfo,0,&page,key_buff)))
{
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
} while (page < end);
*return_key_length=last_length;
*after_key=lastpos;
DBUG_PRINT("exit",("returns: %p page: %p end: %p",
prevpos, page, end));
DBUG_RETURN(prevpos);
}
|
O0
|
c
|
mi_find_last_pos:
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp # imm = 0x520
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdx, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movq %r8, -0x4f0(%rbp)
movl -0x4fc(%rbp), %eax
movl %eax, -0x4fc(%rbp)
movl $0x2, -0x500(%rbp)
movq -0x4d8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x4d8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
subl -0x500(%rbp), %eax
movl %eax, -0x4f8(%rbp)
movl -0x500(%rbp), %ecx
movq -0x4d8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x4d8(%rbp)
movq -0x4d0(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x2e, %eax
cmpl $0x0, %eax
jne 0xc7725
movl -0x4f8(%rbp), %eax
movq -0x4d0(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
xorl %edx, %edx
divl %ecx
subl $0x2, %eax
movl %eax, -0x4f4(%rbp)
movq -0x4d0(%rbp), %rax
movzwl 0x12(%rax), %ecx
movl %ecx, -0x4f8(%rbp)
movq -0x4e8(%rbp), %rax
movl %ecx, (%rax)
movq -0x4d8(%rbp), %rax
movl -0x4f4(%rbp), %ecx
imull -0x4f8(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x508(%rbp)
movq -0x508(%rbp), %rcx
movl -0x4f8(%rbp), %eax
addq %rax, %rcx
movq -0x4f0(%rbp), %rax
movq %rcx, (%rax)
movq -0x4e0(%rbp), %rdi
movq -0x508(%rbp), %rsi
movl -0x4f8(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x508(%rbp), %rax
movq %rax, -0x4c8(%rbp)
jmp 0xc785d
movq -0x4d8(%rbp), %rax
movl -0x4f8(%rbp), %ecx
addq %rcx, %rax
movl -0x500(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x508(%rbp)
jmp 0xc774e
movq -0x4e0(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4f8(%rbp)
movq -0x4d8(%rbp), %rax
movq %rax, -0x510(%rbp)
movq -0x510(%rbp), %rax
movq %rax, -0x518(%rbp)
movq -0x4d8(%rbp), %rax
movq %rax, -0x510(%rbp)
movl -0x4f8(%rbp), %eax
movl %eax, -0x4fc(%rbp)
movq -0x4e0(%rbp), %rdi
leaq -0x4c0(%rbp), %rsi
movl -0x4f8(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x4d0(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x4d0(%rbp), %rdi
leaq -0x4c0(%rbp), %rcx
xorl %esi, %esi
leaq -0x4d8(%rbp), %rdx
callq *%rax
movl %eax, -0x4f8(%rbp)
cmpl $0x0, %eax
jne 0xc7815
movq -0x4d0(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xade70
callq 0xfc1b0
movl $0x7e, (%rax)
movq $0x0, -0x4c8(%rbp)
jmp 0xc785d
jmp 0xc7817
movq -0x4d8(%rbp), %rax
cmpq -0x508(%rbp), %rax
jb 0xc7770
movl -0x4fc(%rbp), %ecx
movq -0x4e8(%rbp), %rax
movl %ecx, (%rax)
movq -0x510(%rbp), %rcx
movq -0x4f0(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc784d
jmp 0xc784f
movq -0x518(%rbp), %rax
movq %rax, -0x4c8(%rbp)
movq -0x4c8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc788d
movq -0x520(%rbp), %rax
addq $0x520, %rsp # imm = 0x520
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
|
_mi_find_last_pos:
push rbp
mov rbp, rsp
sub rsp, 520h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_4D0], rdi
mov [rbp+var_4D8], rsi
mov [rbp+var_4E0], rdx
mov [rbp+var_4E8], rcx
mov [rbp+var_4F0], r8
mov eax, [rbp+var_4FC]
mov [rbp+var_4FC], eax
mov [rbp+var_500], 2
mov rax, [rbp+var_4D8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_4D8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
sub eax, [rbp+var_500]
mov [rbp+var_4F8], eax
mov ecx, [rbp+var_500]
mov rax, [rbp+var_4D8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_4D8], rax
mov rax, [rbp+var_4D0]
movzx eax, word ptr [rax+0Ah]
and eax, 2Eh
cmp eax, 0
jnz loc_C7725
mov eax, [rbp+var_4F8]
mov rcx, [rbp+var_4D0]
movzx ecx, word ptr [rcx+12h]
xor edx, edx
div ecx
sub eax, 2
mov [rbp+var_4F4], eax
mov rax, [rbp+var_4D0]
movzx ecx, word ptr [rax+12h]
mov [rbp+var_4F8], ecx
mov rax, [rbp+var_4E8]
mov [rax], ecx
mov rax, [rbp+var_4D8]
mov ecx, [rbp+var_4F4]
imul ecx, [rbp+var_4F8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_508], rax
mov rcx, [rbp+var_508]
mov eax, [rbp+var_4F8]
add rcx, rax
mov rax, [rbp+var_4F0]
mov [rax], rcx
mov rdi, [rbp+var_4E0]
mov rsi, [rbp+var_508]
mov eax, [rbp+var_4F8]
mov edx, eax
call _memcpy
mov rax, [rbp+var_508]
mov [rbp+var_4C8], rax
jmp loc_C785D
loc_C7725:
mov rax, [rbp+var_4D8]
mov ecx, [rbp+var_4F8]
add rax, rcx
mov ecx, [rbp+var_500]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_508], rax
jmp short $+2
loc_C774E:
mov rax, [rbp+var_4E0]
mov byte ptr [rax], 0
mov [rbp+var_4F8], 0
mov rax, [rbp+var_4D8]
mov [rbp+var_510], rax
loc_C7770:
mov rax, [rbp+var_510]
mov [rbp+var_518], rax
mov rax, [rbp+var_4D8]
mov [rbp+var_510], rax
mov eax, [rbp+var_4F8]
mov [rbp+var_4FC], eax
mov rdi, [rbp+var_4E0]
lea rsi, [rbp+var_4C0]
mov eax, [rbp+var_4F8]
mov edx, eax
call _memcpy
mov rax, [rbp+var_4D0]
mov rax, [rax+48h]
mov rdi, [rbp+var_4D0]
lea rcx, [rbp+var_4C0]
xor esi, esi
lea rdx, [rbp+var_4D8]
call rax
mov [rbp+var_4F8], eax
cmp eax, 0
jnz short loc_C7815
mov rax, [rbp+var_4D0]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov [rbp+var_4C8], 0
jmp short loc_C785D
loc_C7815:
jmp short $+2
loc_C7817:
mov rax, [rbp+var_4D8]
cmp rax, [rbp+var_508]
jb loc_C7770
mov ecx, [rbp+var_4FC]
mov rax, [rbp+var_4E8]
mov [rax], ecx
mov rcx, [rbp+var_510]
mov rax, [rbp+var_4F0]
mov [rax], rcx
jmp short $+2
loc_C784D:
jmp short $+2
loc_C784F:
mov rax, [rbp+var_518]
mov [rbp+var_4C8], rax
loc_C785D:
mov rax, [rbp+var_4C8]
mov [rbp+var_520], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C788D
mov rax, [rbp+var_520]
add rsp, 520h
pop rbp
retn
loc_C788D:
call ___stack_chk_fail
|
unsigned __int16 * mi_find_last_pos(
long long a1,
unsigned __int16 *a2,
_BYTE *a3,
unsigned int *a4,
unsigned __int16 **a5)
{
const char *v5; // rsi
unsigned __int16 *v7; // [rsp+8h] [rbp-518h]
unsigned __int16 *v8; // [rsp+10h] [rbp-510h]
char *v9; // [rsp+18h] [rbp-508h]
unsigned long long v10; // [rsp+18h] [rbp-508h]
unsigned int v11; // [rsp+24h] [rbp-4FCh]
unsigned int v12; // [rsp+28h] [rbp-4F8h]
unsigned int v13; // [rsp+28h] [rbp-4F8h]
unsigned int v14; // [rsp+28h] [rbp-4F8h]
unsigned int v15; // [rsp+2Ch] [rbp-4F4h]
unsigned __int16 *v19; // [rsp+48h] [rbp-4D8h] BYREF
long long v20; // [rsp+50h] [rbp-4D0h]
_BYTE v22[1208]; // [rsp+60h] [rbp-4C0h] BYREF
unsigned long long v23; // [rsp+518h] [rbp-8h]
v23 = __readfsqword(0x28u);
v20 = a1;
v19 = a2;
v12 = (_byteswap_ushort(*a2) & 0x7FFF) - 2;
v19 = a2 + 1;
if ( (*(_WORD *)(a1 + 10) & 0x2E) != 0 )
{
v10 = (unsigned long long)v19 + v12 - 2;
*a3 = 0;
v14 = 0;
v8 = v19;
do
{
v7 = v8;
v8 = v19;
v11 = v14;
memcpy(a3, v22, v14);
v14 = (*(long long ( **)(long long, _QWORD, unsigned __int16 **, _BYTE *))(v20 + 72))(v20, 0LL, &v19, v22);
if ( !v14 )
{
v5 = *(const char **)(*(_QWORD *)v20 + 616LL);
mi_report_error(126, (long long)v5);
*(_DWORD *)my_thread_var(126LL, v5) = 126;
return 0LL;
}
}
while ( (unsigned long long)v19 < v10 );
*a4 = v11;
*a5 = v8;
return v7;
}
else
{
v15 = v12 / *(unsigned __int16 *)(v20 + 18) - 2;
v13 = *(unsigned __int16 *)(v20 + 18);
*a4 = v13;
v9 = (char *)v19 + v13 * v15;
*a5 = (unsigned __int16 *)&v9[v13];
memcpy(a3, v9, v13);
return (unsigned __int16 *)v9;
}
}
|
_mi_find_last_pos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x520
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x4d0],RDI
MOV qword ptr [RBP + -0x4d8],RSI
MOV qword ptr [RBP + -0x4e0],RDX
MOV qword ptr [RBP + -0x4e8],RCX
MOV qword ptr [RBP + -0x4f0],R8
MOV EAX,dword ptr [RBP + -0x4fc]
MOV dword ptr [RBP + -0x4fc],EAX
MOV dword ptr [RBP + -0x500],0x2
MOV RAX,qword ptr [RBP + -0x4d8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x4d8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
SUB EAX,dword ptr [RBP + -0x500]
MOV dword ptr [RBP + -0x4f8],EAX
MOV ECX,dword ptr [RBP + -0x500]
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x4d8],RAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x2e
CMP EAX,0x0
JNZ 0x001c7725
MOV EAX,dword ptr [RBP + -0x4f8]
MOV RCX,qword ptr [RBP + -0x4d0]
MOVZX ECX,word ptr [RCX + 0x12]
XOR EDX,EDX
DIV ECX
SUB EAX,0x2
MOV dword ptr [RBP + -0x4f4],EAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOVZX ECX,word ptr [RAX + 0x12]
MOV dword ptr [RBP + -0x4f8],ECX
MOV RAX,qword ptr [RBP + -0x4e8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,dword ptr [RBP + -0x4f4]
IMUL ECX,dword ptr [RBP + -0x4f8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x508],RAX
MOV RCX,qword ptr [RBP + -0x508]
MOV EAX,dword ptr [RBP + -0x4f8]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x4f0]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x4e0]
MOV RSI,qword ptr [RBP + -0x508]
MOV EAX,dword ptr [RBP + -0x4f8]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x508]
MOV qword ptr [RBP + -0x4c8],RAX
JMP 0x001c785d
LAB_001c7725:
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,dword ptr [RBP + -0x4f8]
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x500]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x508],RAX
JMP 0x001c774e
LAB_001c774e:
MOV RAX,qword ptr [RBP + -0x4e0]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0x4f8],0x0
MOV RAX,qword ptr [RBP + -0x4d8]
MOV qword ptr [RBP + -0x510],RAX
LAB_001c7770:
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RBP + -0x518],RAX
MOV RAX,qword ptr [RBP + -0x4d8]
MOV qword ptr [RBP + -0x510],RAX
MOV EAX,dword ptr [RBP + -0x4f8]
MOV dword ptr [RBP + -0x4fc],EAX
MOV RDI,qword ptr [RBP + -0x4e0]
LEA RSI,[RBP + -0x4c0]
MOV EAX,dword ptr [RBP + -0x4f8]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x4d0]
LEA RCX,[RBP + -0x4c0]
XOR ESI,ESI
LEA RDX,[RBP + -0x4d8]
CALL RAX
MOV dword ptr [RBP + -0x4f8],EAX
CMP EAX,0x0
JNZ 0x001c7815
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001ade70
CALL 0x001fc1b0
MOV dword ptr [RAX],0x7e
MOV qword ptr [RBP + -0x4c8],0x0
JMP 0x001c785d
LAB_001c7815:
JMP 0x001c7817
LAB_001c7817:
MOV RAX,qword ptr [RBP + -0x4d8]
CMP RAX,qword ptr [RBP + -0x508]
JC 0x001c7770
MOV ECX,dword ptr [RBP + -0x4fc]
MOV RAX,qword ptr [RBP + -0x4e8]
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RBP + -0x4f0]
MOV qword ptr [RAX],RCX
JMP 0x001c784d
LAB_001c784d:
JMP 0x001c784f
LAB_001c784f:
MOV RAX,qword ptr [RBP + -0x518]
MOV qword ptr [RBP + -0x4c8],RAX
LAB_001c785d:
MOV RAX,qword ptr [RBP + -0x4c8]
MOV qword ptr [RBP + -0x520],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c788d
MOV RAX,qword ptr [RBP + -0x520]
ADD RSP,0x520
POP RBP
RET
LAB_001c788d:
CALL 0x0012a250
|
byte * _mi_find_last_pos(long *param_1,byte *param_2,int1 *param_3,uint *param_4,
int8 *param_5)
{
ushort uVar1;
byte *pbVar2;
byte *pbVar3;
uint uVar4;
byte *pbVar5;
int4 *puVar6;
uint uVar7;
long in_FS_OFFSET;
byte *local_518;
uint local_500;
byte *local_4e0;
long *local_4d8;
byte *local_4d0;
int1 local_4c8 [1208];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = ((uint)param_2[1] | (*param_2 & 0x7f) << 8) - 2;
local_518 = param_2 + 2;
local_4e0 = local_518;
local_4d8 = param_1;
if ((*(ushort *)((long)param_1 + 10) & 0x2e) == 0) {
uVar1 = *(ushort *)((long)param_1 + 0x12);
uVar7 = (uint)*(ushort *)((long)param_1 + 0x12);
*param_4 = uVar7;
local_518 = local_518 + (uVar4 / uVar1 - 2) * uVar7;
*param_5 = local_518 + uVar7;
memcpy(param_3,local_518,(ulong)uVar7);
local_4d0 = local_518;
}
else {
pbVar5 = local_518 + ((ulong)uVar4 - 2);
*param_3 = 0;
local_500 = 0;
uVar4 = local_500;
do {
local_500 = uVar4;
pbVar3 = local_4e0;
pbVar2 = local_518;
local_518 = local_4e0;
memcpy(param_3,local_4c8,(ulong)local_500);
uVar4 = (*(code *)local_4d8[9])(local_4d8,0,&local_4e0,local_4c8);
if (uVar4 == 0) {
mi_report_error(0x7e,*(int8 *)(*local_4d8 + 0x268));
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x7e;
local_4d0 = (byte *)0x0;
goto LAB_001c785d;
}
} while (local_4e0 < pbVar5);
*param_4 = local_500;
*param_5 = pbVar3;
local_4d0 = pbVar2;
}
LAB_001c785d:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_4d0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,154 |
mbedtls_hmac_drbg_random
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/hmac_drbg.c
|
int mbedtls_hmac_drbg_random(void *p_rng, unsigned char *output, size_t out_len)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_context *) p_rng;
#if defined(MBEDTLS_THREADING_C)
if ((ret = mbedtls_mutex_lock(&ctx->mutex)) != 0) {
return ret;
}
#endif
ret = mbedtls_hmac_drbg_random_with_add(ctx, output, out_len, NULL, 0);
#if defined(MBEDTLS_THREADING_C)
if (mbedtls_mutex_unlock(&ctx->mutex) != 0) {
return MBEDTLS_ERR_THREADING_MUTEX_ERROR;
}
#endif
return ret;
}
|
O3
|
c
|
mbedtls_hmac_drbg_random:
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x89c38
|
mbedtls_hmac_drbg_random:
xor ecx, ecx
xor r8d, r8d
jmp mbedtls_hmac_drbg_random_with_add
|
long long mbedtls_hmac_drbg_random(_QWORD *a1, long long a2, unsigned long long a3)
{
return mbedtls_hmac_drbg_random_with_add(a1, a2, a3, 0LL, 0LL);
}
|
mbedtls_hmac_drbg_random:
XOR ECX,ECX
XOR R8D,R8D
JMP 0x00189c38
|
void mbedtls_hmac_drbg_random(void)
{
mbedtls_hmac_drbg_random_with_add();
return;
}
|
|
63,155 |
spdlog::details::m_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&)
|
aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/pattern_formatter-inl.h
|
void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mon + 1, dest);
}
|
O3
|
c
|
spdlog::details::m_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x10(%rdx), %eax
incl %eax
cmpl $0x63, %eax
ja 0x42625
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl $0xb, %r14d
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r14b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x425e9
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r14b, (%rcx,%rax)
orb $0x30, %bpl
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x42617
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %bpl, (%rcx,%rax)
jmp 0x42665
movl %eax, %eax
movq %rsp, %r8
movq %rax, (%r8)
movq 0x10(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x1a053(%rip), %rax # 0x5c698
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x8d1c(%rip), %rsi # 0x4b36f
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x2b306
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN6spdlog7details11m_formatterINS0_18null_scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt2v819basic_memory_bufferIcLm250ESaIcEEE:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rcx
mov eax, [rdx+10h]
inc eax
cmp eax, 63h ; 'c'
ja short loc_42625
movzx ebp, al
imul r14d, ebp, 0CDh
shr r14d, 0Bh
lea eax, [r14+r14]
lea eax, [rax+rax*4]
sub bpl, al
or r14b, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_425E9
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_425E9:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], r14b
or bpl, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_42617
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_42617:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], bpl
jmp short loc_42665
loc_42625:
mov eax, eax
mov r8, rsp
mov [r8], rax
mov rax, [rbx+10h]
lea rdi, [rsp+58h+var_40]
mov [rdi+10h], rax
mov [rdi+18h], rax
lea rax, off_5C698
mov [rdi], rax
mov [rdi+20h], rbx
lea rsi, a02; "{:02}"
mov edx, 5
mov ecx, 1
xor r9d, r9d
call _ZN3fmt2v86detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS0_17basic_format_argsINS0_20basic_format_contextINSt11conditionalIXsr3std7is_sameINS0_13type_identityIS4_E4typeEcEE5valueENS0_8appenderESt20back_insert_iteratorINS3_ISE_EEEE4typeESE_EEEENS1_10locale_refE
loc_42665:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
|
char * spdlog::details::m_formatter<spdlog::details::null_scoped_padder>::format(
long long a1,
long long a2,
long long a3,
long long a4)
{
unsigned int v5; // eax
char v6; // bp
char v7; // r14
long long v8; // rax
long long v9; // rsi
long long v10; // rcx
char v11; // bp
char *result; // rax
char *v13; // rsi
long long v14; // rcx
_QWORD v15[3]; // [rsp+0h] [rbp-58h] BYREF
long long ( **v16)(); // [rsp+18h] [rbp-40h] BYREF
long long v17; // [rsp+28h] [rbp-30h]
long long v18; // [rsp+30h] [rbp-28h]
long long v19; // [rsp+38h] [rbp-20h]
v5 = *(_DWORD *)(a3 + 16) + 1;
if ( v5 > 0x63 )
{
v15[0] = v5;
v17 = *(_QWORD *)(a4 + 16);
v18 = v17;
v16 = &off_5C698;
v19 = a4;
return fmt::v8::detail::vformat_to<char>((long long)&v16, "{:02}", 5LL, 1LL, (long long)v15, 0LL);
}
else
{
v6 = (unsigned __int8)v5 % 0xAu;
v7 = ((unsigned __int8)v5 / 0xAu) | 0x30;
v8 = *(_QWORD *)(a4 + 16);
v9 = v8 + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(v8 + 1) )
{
(**(void ( ***)(long long))a4)(a4);
v8 = *(_QWORD *)(a4 + 16);
v9 = v8 + 1;
}
v10 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v9;
*(_BYTE *)(v10 + v8) = v7;
v11 = v6 | 0x30;
result = *(char **)(a4 + 16);
v13 = result + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(result + 1) )
{
(**(void ( ***)(long long))a4)(a4);
result = *(char **)(a4 + 16);
v13 = result + 1;
}
v14 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v13;
result[v14] = v11;
}
return result;
}
|
format:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RCX
MOV EAX,dword ptr [RDX + 0x10]
INC EAX
CMP EAX,0x63
JA 0x00142625
MOVZX EBP,AL
IMUL R14D,EBP,0xcd
SHR R14D,0xb
LEA EAX,[R14 + R14*0x1]
LEA EAX,[RAX + RAX*0x4]
SUB BPL,AL
OR R14B,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001425e9
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001425e9:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],R14B
OR BPL,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x00142617
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00142617:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],BPL
JMP 0x00142665
LAB_00142625:
MOV EAX,EAX
MOV R8,RSP
MOV qword ptr [R8],RAX
MOV RAX,qword ptr [RBX + 0x10]
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x15c698]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x20],RBX
LEA RSI,[0x14b36f]
MOV EDX,0x5
MOV ECX,0x1
XOR R9D,R9D
CALL 0x0012b306
LAB_00142665:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* spdlog::details::m_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v8::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::m_formatter<spdlog::details::null_scoped_padder>::format
(m_formatter<spdlog::details::null_scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
byte bVar1;
uint uVar2;
long lVar3;
ulong uVar4;
ulong local_58 [3];
int **local_40 [2];
int8 local_30;
int8 local_28;
basic_memory_buffer *local_20;
uVar2 = param_2->tm_mon + 1;
if (uVar2 < 100) {
bVar1 = (byte)((uVar2 & 0xff) / 10);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar4) {
(*(code *)**(int8 **)param_3)(param_3);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar4;
*(byte *)(*(long *)(param_3 + 8) + lVar3) = bVar1 | 0x30;
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar4) {
(*(code *)**(int8 **)param_3)(param_3);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar4;
*(byte *)(*(long *)(param_3 + 8) + lVar3) = (char)uVar2 + bVar1 * -10 | 0x30;
}
else {
local_58[0] = (ulong)uVar2;
local_30 = *(int8 *)(param_3 + 0x10);
local_40[0] = &PTR_grow_0015c698;
local_28 = local_30;
local_20 = param_3;
fmt::v8::detail::vformat_to<char>(local_40,"{:02}",5,1,local_58,0);
}
return;
}
|
|
63,156 |
LefDefParser::defiComponentMaskShiftLayer::bumpLayers(int)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiComponent.cpp
|
void defiComponentMaskShiftLayer::bumpLayers(int size) {
int i;
char** newLayers = (char**)malloc(sizeof(char*)* size);
for (i = 0; i < numLayers_; i++) {
newLayers[i] = layers_[i];
}
if (layers_) {
free((char*)(layers_));
}
layers_ = newLayers;
layersAllocated_ = size;
}
|
O3
|
cpp
|
LefDefParser::defiComponentMaskShiftLayer::bumpLayers(int):
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x6270
movq %rax, %r15
movslq 0x4(%r14), %rax
movq 0x8(%r14), %rdi
testq %rax, %rax
jle 0xf7ae
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xf79c
jmp 0xf7b3
testq %rdi, %rdi
je 0xf7b8
callq 0x6220
movq %r15, 0x8(%r14)
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN12LefDefParser27defiComponentMaskShiftLayer10bumpLayersEi:
push r15
push r14
push rbx
mov ebx, esi
mov r14, rdi
movsxd rdi, esi
shl rdi, 3
call _malloc
mov r15, rax
movsxd rax, dword ptr [r14+4]
mov rdi, [r14+8]
test rax, rax
jle short loc_F7AE
xor ecx, ecx
loc_F79C:
mov rdx, [rdi+rcx*8]
mov [r15+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_F79C
jmp short loc_F7B3
loc_F7AE:
test rdi, rdi
jz short loc_F7B8
loc_F7B3:
call _free
loc_F7B8:
mov [r14+8], r15
mov [r14], ebx
pop rbx
pop r14
pop r15
retn
|
long long LefDefParser::defiComponentMaskShiftLayer::bumpLayers(
LefDefParser::defiComponentMaskShiftLayer *this,
int a2)
{
long long v3; // r15
long long result; // rax
long long v5; // rdi
long long i; // rcx
v3 = malloc(8LL * a2);
result = *((int *)this + 1);
v5 = *((_QWORD *)this + 1);
if ( result > 0 )
{
for ( i = 0LL; i != result; ++i )
*(_QWORD *)(v3 + 8 * i) = *(_QWORD *)(v5 + 8 * i);
goto LABEL_6;
}
if ( v5 )
LABEL_6:
result = free(v5);
*((_QWORD *)this + 1) = v3;
*(_DWORD *)this = a2;
return result;
}
|
bumpLayers:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
MOVSXD RDI,ESI
SHL RDI,0x3
CALL 0x00106270
MOV R15,RAX
MOVSXD RAX,dword ptr [R14 + 0x4]
MOV RDI,qword ptr [R14 + 0x8]
TEST RAX,RAX
JLE 0x0010f7ae
XOR ECX,ECX
LAB_0010f79c:
MOV RDX,qword ptr [RDI + RCX*0x8]
MOV qword ptr [R15 + RCX*0x8],RDX
INC RCX
CMP RAX,RCX
JNZ 0x0010f79c
JMP 0x0010f7b3
LAB_0010f7ae:
TEST RDI,RDI
JZ 0x0010f7b8
LAB_0010f7b3:
CALL 0x00106220
LAB_0010f7b8:
MOV qword ptr [R14 + 0x8],R15
MOV dword ptr [R14],EBX
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::defiComponentMaskShiftLayer::bumpLayers(int) */
void __thiscall
LefDefParser::defiComponentMaskShiftLayer::bumpLayers(defiComponentMaskShiftLayer *this,int param_1)
{
int iVar1;
void *__ptr;
void *pvVar2;
long lVar3;
pvVar2 = malloc((long)param_1 << 3);
iVar1 = *(int *)(this + 4);
__ptr = *(void **)(this + 8);
if ((long)iVar1 < 1) {
if (__ptr == (void *)0x0) goto LAB_0010f7b8;
}
else {
lVar3 = 0;
do {
*(int8 *)((long)pvVar2 + lVar3 * 8) = *(int8 *)((long)__ptr + lVar3 * 8);
lVar3 = lVar3 + 1;
} while (iVar1 != lVar3);
}
free(__ptr);
LAB_0010f7b8:
*(void **)(this + 8) = pvVar2;
*(int *)this = param_1;
return;
}
|
|
63,157 |
ggml_view_tensor
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_view_tensor(
struct ggml_context * ctx,
struct ggml_tensor * src) {
struct ggml_tensor * result = ggml_new_tensor_impl(ctx, src->type, GGML_MAX_DIMS, src->ne, src, 0);
ggml_format_name(result, "%s (view)", src->name);
for (int i = 0; i < GGML_MAX_DIMS; i++) {
result->nb[i] = src->nb[i];
}
return result;
}
|
O0
|
c
|
ggml_view_tensor:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %r8
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %r9d
callq 0x4bff0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x100, %rdx # imm = 0x100
leaq 0x64c57(%rip), %rsi # 0xb17c6
movb $0x0, %al
callq 0x481b0
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x4cba8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4cb7d
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ggml_view_tensor:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov esi, [rax]
mov rcx, [rbp+var_10]
add rcx, 10h
mov r8, [rbp+var_10]
mov edx, 4
xor eax, eax
mov r9d, eax
call ggml_new_tensor_impl
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_10]
add rdx, 100h
lea rsi, aSView; "%s (view)"
mov al, 0
call _ggml_format_name
mov [rbp+var_1C], 0
loc_4CB7D:
cmp [rbp+var_1C], 4
jge short loc_4CBA8
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rdx, [rax+rcx*8+30h]
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_1C]
mov [rax+rcx*8+30h], rdx
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_4CB7D
loc_4CBA8:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
|
_QWORD * ggml_view_tensor(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rcx
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
char v16; // [rsp+0h] [rbp-20h]
int i; // [rsp+4h] [rbp-1Ch]
_QWORD *v18; // [rsp+8h] [rbp-18h]
v18 = ggml_new_tensor_impl(
a1,
*(_DWORD *)a2,
4,
(long long *)(a2 + 16),
(unsigned int *)a2,
0LL,
*(double *)a3.m128_u64);
ggml_format_name((long long)v18, (long long)"%s (view)", a2 + 256, v10, v11, v12, a3, a4, a5, a6, v13, v14, a9, a10, v16);
for ( i = 0; i < 4; ++i )
v18[i + 6] = *(_QWORD *)(a2 + 8LL * i + 48);
return v18;
}
|
ggml_view_tensor:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x10
MOV R8,qword ptr [RBP + -0x10]
MOV EDX,0x4
XOR EAX,EAX
MOV R9D,EAX
CALL 0x0014bff0
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x100
LEA RSI,[0x1b17c6]
MOV AL,0x0
CALL 0x001481b0
MOV dword ptr [RBP + -0x1c],0x0
LAB_0014cb7d:
CMP dword ptr [RBP + -0x1c],0x4
JGE 0x0014cba8
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RAX + RCX*0x8 + 0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8 + 0x30],RDX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014cb7d
LAB_0014cba8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
long ggml_view_tensor(int8 param_1,int4 *param_2)
{
long lVar1;
int local_24;
lVar1 = ggml_new_tensor_impl(param_1,*param_2,4,param_2 + 4,param_2,0);
ggml_format_name(lVar1,"%s (view)",param_2 + 0x40);
for (local_24 = 0; local_24 < 4; local_24 = local_24 + 1) {
*(int8 *)(lVar1 + 0x30 + (long)local_24 * 8) =
*(int8 *)(param_2 + (long)local_24 * 2 + 0xc);
}
return lVar1;
}
|
|
63,158 |
my_b_write
|
eloqsql/include/my_sys.h
|
static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
MEM_CHECK_DEFINED(Buffer, Count);
if (info->write_pos + Count <= info->write_end)
{
if (Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return 0;
}
return _my_b_write(info, Buffer, Count);
}
|
O0
|
c
|
my_b_write:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
ja 0xc35ef
cmpq $0x0, -0x20(%rbp)
je 0xc35e6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0a0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc3603
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe04d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_b_write_2:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+48h]
ja short loc_C35EF
cmp [rbp+var_20], 0
jz short loc_C35E6
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
loc_C35E6:
mov [rbp+var_4], 0
jmp short loc_C3603
loc_C35EF:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _my_b_write
mov [rbp+var_4], eax
loc_C3603:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_b_write_2(long long a1, long long a2, long long a3)
{
if ( (unsigned long long)(a3 + *(_QWORD *)(a1 + 64)) > *(_QWORD *)(a1 + 72) )
{
return (unsigned int)my_b_write(a1, a2, a3);
}
else
{
if ( a3 )
{
memcpy(*(_QWORD *)(a1 + 64), a2, a3);
*(_QWORD *)(a1 + 64) += a3;
}
return 0;
}
}
|
my_b_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x48]
JA 0x001c35ef
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001c35e6
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0a0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
LAB_001c35e6:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c3603
LAB_001c35ef:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001e04d0
MOV dword ptr [RBP + -0x4],EAX
LAB_001c3603:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_b_write(long param_1,void *param_2,size_t param_3)
{
int4 local_c;
if (*(ulong *)(param_1 + 0x48) < *(long *)(param_1 + 0x40) + param_3) {
local_c = _my_b_write(param_1,param_2,param_3);
}
else {
if (param_3 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(size_t *)(param_1 + 0x40) = param_3 + *(long *)(param_1 + 0x40);
}
local_c = 0;
}
return local_c;
}
|
|
63,159 |
ma_log_delete
|
eloqsql/storage/maria/ma_delete.c
|
my_bool _ma_log_delete(MARIA_PAGE *ma_page, const uchar *key_pos,
uint changed_length, uint move_length,
uint append_length __attribute__((unused)),
enum en_key_debug debug_marker __attribute__((unused)))
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 5+ 2 + 3 + 3 + 6 + 3 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 7];
uint translog_parts, current_size, extra_length;
uint offset= (uint) (key_pos - ma_page->buff);
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
my_off_t page= ma_page->pos / share->block_size;
DBUG_ENTER("_ma_log_delete");
DBUG_PRINT("enter", ("page: %lu offset: %u changed_length: %u move_length: %u append_length: %u page_size: %u",
(ulong) page, offset, changed_length, move_length,
append_length, ma_page->size));
DBUG_ASSERT(share->now_transactional && move_length);
DBUG_ASSERT(offset + changed_length <= ma_page->size);
DBUG_ASSERT(ma_page->org_size - move_length + append_length == ma_page->size);
DBUG_ASSERT(move_length <= ma_page->org_size - share->keypage_header);
/* Store address of new root page */
page_store(log_data + FILEID_STORE_SIZE, page);
log_pos= log_data+ FILEID_STORE_SIZE + PAGE_STORE_SIZE;
current_size= ma_page->org_size;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= debug_marker;
*log_pos++= KEY_OP_DEBUG_2;
int2store(log_pos, ma_page->org_size);
int2store(log_pos+2, ma_page->size);
log_pos+=4;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, offset);
log_pos+= 3;
translog_parts= TRANSLOG_INTERNAL_PARTS + 1;
extra_length= 0;
if (changed_length)
{
if (offset + changed_length >= share->max_index_block_size)
{
changed_length= share->max_index_block_size - offset;
move_length= 0; /* Nothing to move */
current_size= share->max_index_block_size;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, changed_length);
log_pos+= 3;
log_array[translog_parts].str= ma_page->buff + offset;
log_array[translog_parts].length= changed_length;
translog_parts++;
/* We only have to move things after offset+changed_length */
offset+= changed_length;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos - log_data);
if (move_length)
{
uint log_length;
if (offset + move_length < share->max_index_block_size)
{
/*
Move down things that is on page.
page_offset in apply_redo_inxed() will be at original offset
+ changed_length.
*/
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, - (int) move_length);
log_length= 3;
current_size-= move_length;
}
else
{
/* Delete to end of page */
uint tmp= current_size - offset;
current_size= offset;
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, tmp);
log_length= 3;
}
log_array[translog_parts].str= log_pos;
log_array[translog_parts].length= log_length;
translog_parts++;
log_pos+= log_length;
extra_length+= log_length;
}
if (current_size != ma_page->size &&
current_size != share->max_index_block_size)
{
/* Append data that didn't fit on the page before */
uint length= (MY_MIN(ma_page->size, share->max_index_block_size) -
current_size);
uchar *data= ma_page->buff + current_size;
DBUG_ASSERT(length <= append_length);
log_pos[0]= KEY_OP_ADD_SUFFIX;
int2store(log_pos+1, length);
log_array[translog_parts].str= log_pos;
log_array[translog_parts].length= 3;
log_array[translog_parts + 1].str= data;
log_array[translog_parts + 1].length= length;
log_pos+= 3;
translog_parts+= 2;
current_size+= length;
extra_length+= 3 + length;
}
_ma_log_key_changes(ma_page,
log_array + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= current_size;
if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS].length +
changed_length + extra_length, translog_parts,
log_array, log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_log_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %r11d
movl %edx, %r10d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rcx
movq 0x10(%rdi), %rbx
subq %rbx, %rsi
movq (%rcx), %r14
movq 0x18(%rdi), %rax
movl 0x7bc(%r14), %r9d
xorl %r8d, %r8d
xorl %edx, %edx
divq %r9
movl %eax, -0x5e(%rbp)
shrq $0x20, %rax
movb %al, -0x5a(%rbp)
movl 0x24(%rdi), %r12d
movb $0xa, -0x59(%rbp)
movl 0x744(%r14), %eax
addl $-0x3, %eax
movb (%rbx,%rax), %al
movb %al, -0x58(%rbp)
movb $0x1, -0x57(%rbp)
movw %si, -0x56(%rbp)
testl %r10d, %r10d
je 0x67bce
leal (%rsi,%r10), %r9d
movl 0x7c0(%r14), %edx
movl %edx, %r15d
subl %esi, %r15d
cmpl %edx, %r9d
movl %r15d, %r13d
cmovbl %r10d, %r13d
movl %esi, %eax
addq %rbx, %rax
movq %rax, -0xd0(%rbp)
leaq -0x51(%rbp), %rax
movb $0x3, -0x3(%rax)
movw %r13w, -0x2(%rax)
movq %r13, -0xc8(%rbp)
cmpl %edx, %r9d
jae 0x67c53
addl %esi, %r13d
movl $0x4, %r9d
movl %r13d, %esi
jmp 0x67bd8
leaq -0x54(%rbp), %rax
movl $0x3, %r9d
leaq -0x60(%rbp), %rdx
movq %rdx, -0xe0(%rbp)
movl %eax, %r15d
subl %edx, %r15d
movq %r15, -0xd8(%rbp)
testl %r11d, %r11d
je 0x67c74
leal (%rsi,%r11), %r8d
movl %r12d, %edx
subl %r11d, %edx
negl %r11d
subl %esi, %r12d
xorl %r15d, %r15d
cmpl 0x7c0(%r14), %r8d
setae %r15b
leal 0x2(%r15,%r15,4), %r8d
cmovbl %r11d, %r12d
cmovael %esi, %edx
movb %r8b, (%rax)
movw %r12w, 0x1(%rax)
movl %r9d, %esi
shll $0x4, %esi
movq %rax, -0x100(%rbp,%rsi)
movq $0x3, -0xf8(%rbp,%rsi)
incl %r9d
addq $0x3, %rax
movl $0x3, %r8d
movl %r10d, %r15d
jmp 0x67c7a
leaq -0x60(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movq $0xf, -0xd8(%rbp)
movl $0x4, %r9d
xorl %r8d, %r8d
jmp 0x67c7a
movl %r10d, %r15d
movl %r12d, %edx
movl 0x20(%rdi), %r10d
cmpl %r10d, %edx
je 0x67cdf
movl 0x7c0(%r14), %esi
cmpl %esi, %edx
je 0x67cdf
cmpl %esi, %r10d
cmovbl %r10d, %esi
movl %esi, %r10d
subl %edx, %r10d
movl %edx, %edx
addq %rdx, %rbx
movb $0x6, (%rax)
movw %r10w, 0x1(%rax)
movl %r9d, %edx
shll $0x4, %edx
movq %rax, -0x100(%rbp,%rdx)
movq $0x3, -0xf8(%rbp,%rdx)
movq %rbx, -0xf0(%rbp,%rdx)
movq %r10, -0xe8(%rbp,%rdx)
addl $0x2, %r9d
addl %r10d, %r8d
addl $0x3, %r8d
movl %esi, %edx
addl %r15d, %r8d
movl %edx, 0x24(%rdi)
movq 0x8(%rcx), %rdx
leaq -0x100(%rbp), %rax
addl 0x28(%rax), %r8d
subq $0x8, %rsp
leaq -0x60(%rbp), %r10
leaq -0x68(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r10
pushq %rax
callq 0x2a88c
addq $0x20, %rsp
testb %al, %al
setne %al
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x67d39
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29260
|
_ma_log_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r11d, ecx
mov r10d, edx
mov rax, fs:28h
mov [rbp+var_30], rax
mov rcx, [rdi]
mov rbx, [rdi+10h]
sub rsi, rbx
mov r14, [rcx]
mov rax, [rdi+18h]
mov r9d, [r14+7BCh]
xor r8d, r8d
xor edx, edx
div r9
mov [rbp+var_5E], eax
shr rax, 20h
mov [rbp+var_5A], al
mov r12d, [rdi+24h]
mov [rbp+var_59], 0Ah
mov eax, [r14+744h]
add eax, 0FFFFFFFDh
mov al, [rbx+rax]
mov [rbp+var_58], al
mov [rbp+var_57], 1
mov [rbp+var_56], si
test r10d, r10d
jz short loc_67BCE
lea r9d, [rsi+r10]
mov edx, [r14+7C0h]
mov r15d, edx
sub r15d, esi
cmp r9d, edx
mov r13d, r15d
cmovb r13d, r10d
mov eax, esi
add rax, rbx
mov [rbp+var_D0], rax
lea rax, [rbp+var_51]
mov byte ptr [rax-3], 3
mov [rax-2], r13w
mov [rbp+var_C8], r13
cmp r9d, edx
jnb loc_67C53
add r13d, esi
mov r9d, 4
mov esi, r13d
jmp short loc_67BD8
loc_67BCE:
lea rax, [rbp+var_54]
mov r9d, 3
loc_67BD8:
lea rdx, [rbp+var_60]
mov [rbp+var_E0], rdx
mov r15d, eax
sub r15d, edx
mov [rbp+var_D8], r15
test r11d, r11d
jz short loc_67C74
lea r8d, [rsi+r11]
mov edx, r12d
sub edx, r11d
neg r11d
sub r12d, esi
xor r15d, r15d
cmp r8d, [r14+7C0h]
setnb r15b
lea r8d, [r15+r15*4+2]
cmovb r12d, r11d
cmovnb edx, esi
mov [rax], r8b
mov [rax+1], r12w
mov esi, r9d
shl esi, 4
mov [rbp+rsi+var_100], rax
mov [rbp+rsi+var_F8], 3
inc r9d
add rax, 3
mov r8d, 3
mov r15d, r10d
jmp short loc_67C7A
loc_67C53:
lea rsi, [rbp+var_60]
mov [rbp+var_E0], rsi
mov [rbp+var_D8], 0Fh
mov r9d, 4
xor r8d, r8d
jmp short loc_67C7A
loc_67C74:
mov r15d, r10d
mov edx, r12d
loc_67C7A:
mov r10d, [rdi+20h]
cmp edx, r10d
jz short loc_67CDF
mov esi, [r14+7C0h]
cmp edx, esi
jz short loc_67CDF
cmp r10d, esi
cmovb esi, r10d
mov r10d, esi
sub r10d, edx
mov edx, edx
add rbx, rdx
mov byte ptr [rax], 6
mov [rax+1], r10w
mov edx, r9d
shl edx, 4
mov [rbp+rdx+var_100], rax
mov [rbp+rdx+var_F8], 3
mov [rbp+rdx+var_F0], rbx
mov [rbp+rdx+var_E8], r10
add r9d, 2
add r8d, r10d
add r8d, 3
mov edx, esi
loc_67CDF:
add r8d, r15d
mov [rdi+24h], edx
mov rdx, [rcx+8]
lea rax, [rbp+var_100]
add r8d, [rax+28h]
sub rsp, 8
lea r10, [rbp+var_60]
lea rdi, [rbp+var_68]
mov esi, 0Ch
push 0
push r10
push rax
call translog_write_record
add rsp, 20h
test al, al
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_67D39
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_67D39:
call ___stack_chk_fail
|
bool ma_log_delete(long long a1, int a2, unsigned int a3, int a4)
{
_QWORD *v6; // rcx
long long v7; // rbx
unsigned int v8; // esi
_DWORD *v9; // r14
int v10; // r8d
unsigned long long v11; // rax
unsigned int v12; // r12d
unsigned int v13; // r9d
unsigned int v14; // edx
unsigned int v15; // r15d
long long v16; // r13
char *v17; // rax
int v18; // r9d
unsigned int v19; // r8d
int v20; // r11d
__int16 v21; // r12
bool v22; // cf
char v23; // r8
unsigned int v24; // r10d
unsigned int v25; // esi
long long v26; // r10
_OWORD v28[2]; // [rsp+0h] [rbp-100h] BYREF
__int16 *v29; // [rsp+20h] [rbp-E0h]
long long v30; // [rsp+28h] [rbp-D8h]
long long v31; // [rsp+30h] [rbp-D0h]
long long v32; // [rsp+38h] [rbp-C8h]
char v33[8]; // [rsp+98h] [rbp-68h] BYREF
__int16 v34; // [rsp+A0h] [rbp-60h] BYREF
int v35; // [rsp+A2h] [rbp-5Eh]
char v36; // [rsp+A6h] [rbp-5Ah]
char v37; // [rsp+A7h] [rbp-59h]
char v38; // [rsp+A8h] [rbp-58h]
char v39; // [rsp+A9h] [rbp-57h]
__int16 v40; // [rsp+AAh] [rbp-56h]
char v41; // [rsp+ACh] [rbp-54h] BYREF
__int16 v42; // [rsp+ADh] [rbp-53h]
char v43; // [rsp+AFh] [rbp-51h] BYREF
unsigned long long v44; // [rsp+D0h] [rbp-30h]
v44 = __readfsqword(0x28u);
v6 = *(_QWORD **)a1;
v7 = *(_QWORD *)(a1 + 16);
v8 = a2 - v7;
v9 = **(_DWORD ***)a1;
v10 = 0;
v11 = *(_QWORD *)(a1 + 24) / (unsigned long long)(unsigned int)v9[495];
v35 = v11;
v36 = BYTE4(v11);
v12 = *(_DWORD *)(a1 + 36);
v37 = 10;
v38 = *(_BYTE *)(v7 + (unsigned int)(v9[465] - 3));
v39 = 1;
v40 = v8;
if ( a3 )
{
v13 = v8 + a3;
v14 = v9[496];
v15 = v14 - v8;
v16 = v14 - v8;
if ( v8 + a3 < v14 )
v16 = a3;
v31 = v7 + v8;
v17 = &v43;
v41 = 3;
v42 = v16;
v32 = v16;
if ( v13 >= v14 )
{
v29 = &v34;
v30 = 15LL;
v18 = 4;
v10 = 0;
goto LABEL_14;
}
v18 = 4;
v8 += v16;
}
else
{
v17 = &v41;
v18 = 3;
}
v29 = &v34;
v30 = (unsigned int)v17 - (unsigned int)&v34;
if ( a4 )
{
v19 = v8 + a4;
v14 = v12 - a4;
v20 = -a4;
v21 = v12 - v8;
v22 = v19 < v9[496];
v23 = 5 * (v19 >= v9[496]) + 2;
if ( v22 )
v21 = v20;
else
v14 = v8;
*v17 = v23;
*(_WORD *)(v17 + 1) = v21;
*(_QWORD *)((char *)v28 + (unsigned int)(16 * v18)) = v17;
*(_QWORD *)((char *)v28 + (unsigned int)(16 * v18++) + 8) = 3LL;
v17 += 3;
v10 = 3;
v15 = a3;
}
else
{
v15 = a3;
v14 = v12;
}
LABEL_14:
v24 = *(_DWORD *)(a1 + 32);
if ( v14 != v24 )
{
v25 = v9[496];
if ( v14 != v25 )
{
if ( v24 < v25 )
v25 = *(_DWORD *)(a1 + 32);
v26 = v25 - v14;
*v17 = 6;
*(_WORD *)(v17 + 1) = v25 - v14;
*(_QWORD *)((char *)v28 + (unsigned int)(16 * v18)) = v17;
*(_QWORD *)((char *)v28 + (unsigned int)(16 * v18) + 8) = 3LL;
*(_QWORD *)((char *)&v28[1] + (unsigned int)(16 * v18)) = v14 + v7;
*(_QWORD *)((char *)&v28[1] + (unsigned int)(16 * v18) + 8) = v26;
v18 += 2;
v10 += v26 + 3;
v14 = v25;
}
}
*(_DWORD *)(a1 + 36) = v14;
return (unsigned __int8)translog_write_record(
(unsigned long long)v33,
&byte_9[3],
v6[1],
v6,
(unsigned int)v30 + v15 + v10,
v18,
v28,
&v34,
0LL) != 0;
}
|
_ma_log_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R11D,ECX
MOV R10D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x10]
SUB RSI,RBX
MOV R14,qword ptr [RCX]
MOV RAX,qword ptr [RDI + 0x18]
MOV R9D,dword ptr [R14 + 0x7bc]
XOR R8D,R8D
XOR EDX,EDX
DIV R9
MOV dword ptr [RBP + -0x5e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x5a],AL
MOV R12D,dword ptr [RDI + 0x24]
MOV byte ptr [RBP + -0x59],0xa
MOV EAX,dword ptr [R14 + 0x744]
ADD EAX,-0x3
MOV AL,byte ptr [RBX + RAX*0x1]
MOV byte ptr [RBP + -0x58],AL
MOV byte ptr [RBP + -0x57],0x1
MOV word ptr [RBP + -0x56],SI
TEST R10D,R10D
JZ 0x00167bce
LEA R9D,[RSI + R10*0x1]
MOV EDX,dword ptr [R14 + 0x7c0]
MOV R15D,EDX
SUB R15D,ESI
CMP R9D,EDX
MOV R13D,R15D
CMOVC R13D,R10D
MOV EAX,ESI
ADD RAX,RBX
MOV qword ptr [RBP + -0xd0],RAX
LEA RAX,[RBP + -0x51]
MOV byte ptr [RAX + -0x3],0x3
MOV word ptr [RAX + -0x2],R13W
MOV qword ptr [RBP + -0xc8],R13
CMP R9D,EDX
JNC 0x00167c53
ADD R13D,ESI
MOV R9D,0x4
MOV ESI,R13D
JMP 0x00167bd8
LAB_00167bce:
LEA RAX,[RBP + -0x54]
MOV R9D,0x3
LAB_00167bd8:
LEA RDX,[RBP + -0x60]
MOV qword ptr [RBP + -0xe0],RDX
MOV R15D,EAX
SUB R15D,EDX
MOV qword ptr [RBP + -0xd8],R15
TEST R11D,R11D
JZ 0x00167c74
LEA R8D,[RSI + R11*0x1]
MOV EDX,R12D
SUB EDX,R11D
NEG R11D
SUB R12D,ESI
XOR R15D,R15D
CMP R8D,dword ptr [R14 + 0x7c0]
SETNC R15B
LEA R8D,[R15 + R15*0x4 + 0x2]
CMOVC R12D,R11D
CMOVNC EDX,ESI
MOV byte ptr [RAX],R8B
MOV word ptr [RAX + 0x1],R12W
MOV ESI,R9D
SHL ESI,0x4
MOV qword ptr [RBP + RSI*0x1 + -0x100],RAX
MOV qword ptr [RBP + RSI*0x1 + -0xf8],0x3
INC R9D
ADD RAX,0x3
MOV R8D,0x3
MOV R15D,R10D
JMP 0x00167c7a
LAB_00167c53:
LEA RSI,[RBP + -0x60]
MOV qword ptr [RBP + -0xe0],RSI
MOV qword ptr [RBP + -0xd8],0xf
MOV R9D,0x4
XOR R8D,R8D
JMP 0x00167c7a
LAB_00167c74:
MOV R15D,R10D
MOV EDX,R12D
LAB_00167c7a:
MOV R10D,dword ptr [RDI + 0x20]
CMP EDX,R10D
JZ 0x00167cdf
MOV ESI,dword ptr [R14 + 0x7c0]
CMP EDX,ESI
JZ 0x00167cdf
CMP R10D,ESI
CMOVC ESI,R10D
MOV R10D,ESI
SUB R10D,EDX
MOV EDX,EDX
ADD RBX,RDX
MOV byte ptr [RAX],0x6
MOV word ptr [RAX + 0x1],R10W
MOV EDX,R9D
SHL EDX,0x4
MOV qword ptr [RBP + RDX*0x1 + -0x100],RAX
MOV qword ptr [RBP + RDX*0x1 + -0xf8],0x3
MOV qword ptr [RBP + RDX*0x1 + -0xf0],RBX
MOV qword ptr [RBP + RDX*0x1 + -0xe8],R10
ADD R9D,0x2
ADD R8D,R10D
ADD R8D,0x3
MOV EDX,ESI
LAB_00167cdf:
ADD R8D,R15D
MOV dword ptr [RDI + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
LEA RAX,[RBP + -0x100]
ADD R8D,dword ptr [RAX + 0x28]
SUB RSP,0x8
LEA R10,[RBP + -0x60]
LEA RDI,[RBP + -0x68]
MOV ESI,0xc
PUSH 0x0
PUSH R10
PUSH RAX
CALL 0x0012a88c
ADD RSP,0x20
TEST AL,AL
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00167d39
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00167d39:
CALL 0x00129260
|
bool _ma_log_delete(long *param_1,long param_2,uint param_3,int param_4)
{
uint uVar1;
long *plVar2;
long lVar3;
long lVar4;
int1 auVar5 [16];
char cVar6;
char *pcVar7;
uint uVar8;
uint uVar9;
ulong uVar10;
int iVar11;
int iVar12;
short sVar13;
uint uVar14;
long in_FS_OFFSET;
bool bVar15;
long local_108 [4];
int1 *local_e8;
ulong local_e0;
long local_d8 [13];
int1 local_70 [8];
int1 local_68 [2];
int4 local_66;
int1 local_62;
int1 local_61;
int1 local_60;
int1 local_5f;
int2 local_5e;
char local_5c;
int2 local_5b;
char local_59 [33];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
plVar2 = (long *)*param_1;
lVar3 = param_1[2];
uVar10 = param_2 - lVar3;
uVar14 = (uint)uVar10;
lVar4 = *plVar2;
iVar11 = 0;
auVar5._8_8_ = 0;
auVar5._0_8_ = param_1[3];
auVar5 = auVar5 / ZEXT416(*(uint *)(lVar4 + 0x7bc));
local_66 = auVar5._0_4_;
local_62 = auVar5[4];
uVar9 = *(uint *)((long)param_1 + 0x24);
local_61 = 10;
local_60 = *(int1 *)(lVar3 + (ulong)(*(int *)(lVar4 + 0x744) - 3));
local_5f = 1;
local_5e = (int2)uVar10;
if (param_3 == 0) {
pcVar7 = &local_5c;
iVar12 = 3;
}
else {
uVar8 = *(uint *)(lVar4 + 0x7c0);
local_d8[1] = (long)(uVar8 - uVar14);
if (uVar14 + param_3 < uVar8) {
local_d8[1] = (long)param_3;
}
local_d8[0] = (uVar10 & 0xffffffff) + lVar3;
pcVar7 = local_59;
local_5c = '\x03';
local_5b = (int2)local_d8[1];
if (uVar8 <= uVar14 + param_3) {
local_e0 = 0xf;
iVar12 = 4;
iVar11 = 0;
uVar9 = uVar8;
param_3 = uVar8 - uVar14;
goto LAB_00167c7a;
}
uVar14 = (int)local_d8[1] + uVar14;
iVar12 = 4;
}
local_e0 = (ulong)(uint)((int)pcVar7 - (int)local_68);
if (param_4 != 0) {
uVar8 = uVar9 - param_4;
sVar13 = -(short)param_4;
bVar15 = *(uint *)(lVar4 + 0x7c0) <= uVar14 + param_4;
if (bVar15) {
uVar8 = uVar14;
sVar13 = (short)uVar9 - (short)uVar14;
}
*pcVar7 = bVar15 * '\x05' + '\x02';
*(short *)(pcVar7 + 1) = sVar13;
*(char **)((long)local_108 + (ulong)(uint)(iVar12 << 4)) = pcVar7;
*(int8 *)((long)local_108 + (ulong)(uint)(iVar12 << 4) + 8) = 3;
iVar12 = iVar12 + 1;
pcVar7 = pcVar7 + 3;
iVar11 = 3;
uVar9 = uVar8;
}
LAB_00167c7a:
local_e8 = local_68;
uVar14 = *(uint *)(param_1 + 4);
uVar8 = uVar9;
if ((uVar9 != uVar14) && (uVar1 = *(uint *)(lVar4 + 0x7c0), uVar9 != uVar1)) {
uVar8 = uVar1;
if (uVar14 < uVar1) {
uVar8 = uVar14;
}
uVar14 = uVar8 - uVar9;
*pcVar7 = '\x06';
*(short *)(pcVar7 + 1) = (short)uVar14;
uVar10 = (ulong)(uint)(iVar12 << 4);
*(char **)((long)local_108 + uVar10) = pcVar7;
*(int8 *)((long)local_108 + uVar10 + 8) = 3;
*(ulong *)((long)local_108 + uVar10 + 0x10) = lVar3 + (ulong)uVar9;
*(ulong *)((long)local_108 + uVar10 + 0x18) = (ulong)uVar14;
iVar12 = iVar12 + 2;
iVar11 = iVar11 + uVar14 + 3;
}
*(uint *)((long)param_1 + 0x24) = uVar8;
cVar6 = translog_write_record
(local_70,0xc,plVar2[1],plVar2,iVar11 + param_3 + (int)local_e0,iVar12,local_108
,local_68,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return cVar6 != '\0';
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
63,160 |
google::protobuf::compiler::java::ImmutableMessageLiteGenerator::GenerateInterface(google::protobuf::io::Printer*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message_lite.cc
|
void ImmutableMessageLiteGenerator::GenerateInterface(io::Printer* printer) {
MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
/* immutable = */ true, "OrBuilder");
if (descriptor_->extension_range_count() > 0) {
printer->Print(
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends \n"
" $extra_interfaces$\n"
" com.google.protobuf.GeneratedMessageLite.\n"
" ExtendableMessageOrBuilder<\n"
" $classname$, $classname$.Builder> {\n",
"deprecation",
descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
"classname", descriptor_->name(), "{", "", "}", "");
} else {
printer->Print(
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n"
" $extra_interfaces$\n"
" com.google.protobuf.MessageLiteOrBuilder {\n",
"deprecation",
descriptor_->options().deprecated() ? "@java.lang.Deprecated " : "",
"extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
"classname", descriptor_->name(), "{", "", "}", "");
}
printer->Annotate("{", "}", descriptor_);
printer->Indent();
for (int i = 0; i < descriptor_->field_count(); i++) {
printer->Print("\n");
field_generators_.get(descriptor_->field(i))
.GenerateInterfaceMembers(printer);
}
for (auto oneof : oneofs_) {
printer->Print(
"\n"
"public $classname$.$oneof_capitalized_name$Case "
"get$oneof_capitalized_name$Case();\n",
"oneof_capitalized_name",
context_->GetOneofGeneratorInfo(oneof)->capitalized_name, "classname",
context_->GetNameResolver()->GetImmutableClassName(descriptor_));
}
printer->Outdent();
printer->Print("}\n");
}
|
O3
|
cpp
|
google::protobuf::compiler::java::ImmutableMessageLiteGenerator::GenerateInterface(google::protobuf::io::Printer*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x40(%rdi), %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x107204(%rip), %rsi # 0x1bac34
leaq 0x107206(%rip), %rdx # 0x1bac3d
leaq 0x8(%rsp), %rdi
callq 0x250b2
leaq 0x8(%rsp), %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0xae857
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3a6d
callq 0x1f4a0
movq 0x8(%r14), %rsi
cmpl $0x0, 0x78(%rsi)
leaq 0x106948(%rip), %rax # 0x1ba3c4
leaq 0xe6b26(%rip), %r13 # 0x19a5a9
jle 0xb3b0b
movq 0x20(%rsi), %rcx
cmpb $0x0, 0x4a(%rcx)
cmoveq %r13, %rax
leaq 0x40(%rsp), %r15
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x43e14
movq 0x8(%r14), %rax
leaq 0x12cc18(%rip), %r10 # 0x1e06cd
leaq 0x13c61d(%rip), %r11 # 0x1f00d9
leaq 0xf29db(%rip), %rbp # 0x1a649e
leaq 0x10df5b(%rip), %rsi # 0x1c1a25
leaq 0x12284b(%rip), %rdx # 0x1d631c
leaq 0x10797c(%rip), %r8 # 0x1bb454
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r9
pushq %r13
pushq %r10
pushq %r13
pushq %r11
pushq 0x8(%rax)
pushq %rbp
callq 0xae9f0
addq $0x30, %rsp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3b8c
jmp 0xb3b87
movq 0x20(%rsi), %rcx
cmpb $0x0, 0x4a(%rcx)
cmoveq %r13, %rax
leaq 0x40(%rsp), %r15
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x43e14
movq 0x8(%r14), %rax
leaq 0x12cb96(%rip), %r10 # 0x1e06cd
leaq 0x13c59b(%rip), %r11 # 0x1f00d9
leaq 0xf2959(%rip), %rbp # 0x1a649e
leaq 0x10dfba(%rip), %rsi # 0x1c1b06
leaq 0x1227c9(%rip), %rdx # 0x1d631c
leaq 0x1078fa(%rip), %r8 # 0x1bb454
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r9
pushq %r13
pushq %r10
pushq %r13
pushq %r11
pushq 0x8(%rax)
pushq %rbp
callq 0xae9f0
addq $0x30, %rsp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3b8c
callq 0x1f4a0
movq 0x8(%r14), %rcx
leaq 0x13c542(%rip), %rsi # 0x1f00d9
leaq 0x12cb2f(%rip), %rdx # 0x1e06cd
movq %rbx, %rdi
callq 0xaeae2
movq %rbx, %rdi
callq 0x16d126
movq 0x8(%r14), %rax
cmpl $0x0, 0x4(%rax)
jle 0xb3c8d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
xorl %r12d, %r12d
movq %rbx, %rdi
leaq 0xff7ad(%rip), %rsi # 0x1b337d
callq 0x2e40a
movq 0x8(%r14), %rax
movq 0x28(%rax), %r15
movq 0x20(%r15,%rbp), %rax
cmpq 0x50(%r14), %rax
je 0xb3c25
movq %r13, %rdi
movl $0x3, %esi
leaq 0x10c132(%rip), %rdx # 0x1bfd29
movl $0x8b, %ecx
callq 0x1072ba
movq %r13, %rdi
leaq 0x10c18d(%rip), %rsi # 0x1bfd98
callq 0x106db8
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
movq %r13, %rdi
callq 0x1072d8
testb $0x8, 0x1(%r15,%rbp)
jne 0xb3c38
movq 0x20(%r15,%rbp), %rax
addq $0x28, %rax
jmp 0xb3c51
movq 0x28(%r15,%rbp), %rax
testq %rax, %rax
je 0xb3c48
addq $0x50, %rax
jmp 0xb3c51
movq 0x10(%r15,%rbp), %rax
addq $0x70, %rax
subq (%rax), %r15
addq %rbp, %r15
shrq $0x3, %r15
imull $0x38e38e39, %r15d, %eax # imm = 0x38E38E39
movq 0x58(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
incq %r12
movq 0x8(%r14), %rax
movslq 0x4(%rax), %rax
addq $0x48, %rbp
cmpq %rax, %r12
jl 0xb3bc6
movq 0x28(%r14), %r15
leaq 0x18(%r14), %r13
cmpq %r13, %r15
je 0xb3d14
leaq 0x8(%rsp), %r12
movq 0x20(%r15), %rsi
movq 0x40(%r14), %rdi
callq 0xcef84
leaq 0x20(%rax), %rbp
movq 0x40(%r14), %rdi
callq 0xcda64
movq 0x8(%r14), %rdx
movq %r12, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq 0x47ac2
movq %rbx, %rdi
leaq 0x107812(%rip), %rsi # 0x1bb4e9
leaq 0x107860(%rip), %rdx # 0x1bb53e
movq %rbp, %rcx
leaq 0xf27b6(%rip), %r8 # 0x1a649e
movq %r12, %r9
callq 0xaeb6a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3d04
callq 0x1f4a0
movq %r15, %rdi
callq 0x1f570
movq %rax, %r15
cmpq %r13, %rax
jne 0xb3c9f
movq %rbx, %rdi
callq 0x16d136
leaq 0x12e3f4(%rip), %rsi # 0x1e2117
movq %rbx, %rdi
callq 0x2e40a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3da3
jmp 0xb3d9e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3da3
jmp 0xb3d9e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3da3
jmp 0xb3d9e
movq %rax, %rbx
jmp 0xb3da3
jmp 0xb3d7d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1072d8
jmp 0xb3da3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb3da3
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
nop
|
_ZN6google8protobuf8compiler4java29ImmutableMessageLiteGenerator17GenerateInterfaceEPNS0_2io7PrinterE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov r15, [rdi+8]
mov r12, [rdi+40h]
lea rax, [rsp+78h+var_60]
mov [rax-10h], rax
lea rsi, aOrbuilder; "OrBuilder"
lea rdx, aOrbuilder+9; ""
lea rdi, [rsp+78h+var_70]
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 r8, [rsp+78h+var_70]
mov rdi, r12
mov rsi, rbx
mov rdx, r15
mov ecx, 1
call _ZN6google8protobuf8compiler4java29MaybePrintGeneratedAnnotationIKNS0_10DescriptorEEEvPNS2_7ContextEPNS0_2io7PrinterEPT_bRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::compiler::java::MaybePrintGeneratedAnnotation<google::protobuf::Descriptor const>(google::protobuf::compiler::java::Context *,google::protobuf::io::Printer *,google::protobuf::Descriptor const *,bool,std::string const&)
mov rdi, [rsp+78h+var_70]; void *
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz short loc_B3A6D
call __ZdlPv; operator delete(void *)
loc_B3A6D:
mov rsi, [r14+8]
cmp dword ptr [rsi+78h], 0
lea rax, aJavaLangDeprec; "@java.lang.Deprecated "
lea r13, asc_19A5A7+2; ""
jle loc_B3B0B
mov rcx, [rsi+20h]
cmp byte ptr [rcx+4Ah], 0
cmovz rax, r13
lea r15, [rsp+78h+var_38]
mov [r15], rax
lea r12, [rsp+78h+var_70]
mov rdi, r12
call _ZN6google8protobuf8compiler4java31ExtraMessageOrBuilderInterfacesB5cxx11EPKNS0_10DescriptorE; google::protobuf::compiler::java::ExtraMessageOrBuilderInterfaces(google::protobuf::Descriptor const*)
mov rax, [r14+8]
lea r10, aKotlinJvmJvmsy_32+0E3h; "}"
lea r11, a0oneof1+0Bh; "{"
lea rbp, aMetadataClassn+9; "classname"
lea rsi, aDeprecationPub_3; "$deprecation$public interface ${$$class"...
lea rdx, aKtDeprecation+3; "deprecation"
lea r8, aExtraInterface; "extra_interfaces"
mov rdi, rbx; this
mov rcx, r15
mov r9, r12
push r13; __int64
push r10; __int64
push r13; __int64
push r11; __int64
push qword ptr [rax+8]; __int64
push rbp; __int64
call _ZN6google8protobuf2io7Printer5PrintIJA12_cPKcA17_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA10_cSD_A2_cA1_cSF_SG_EEEvS6_DpRKT_; google::protobuf::io::Printer::Print<char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1]>(char const*,char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1] const&)
add rsp, 30h
mov rdi, [rsp+78h+var_70]
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz loc_B3B8C
jmp short loc_B3B87
loc_B3B0B:
mov rcx, [rsi+20h]
cmp byte ptr [rcx+4Ah], 0
cmovz rax, r13
lea r15, [rsp+78h+var_38]
mov [r15], rax
lea r12, [rsp+78h+var_70]
mov rdi, r12
call _ZN6google8protobuf8compiler4java31ExtraMessageOrBuilderInterfacesB5cxx11EPKNS0_10DescriptorE; google::protobuf::compiler::java::ExtraMessageOrBuilderInterfaces(google::protobuf::Descriptor const*)
mov rax, [r14+8]
lea r10, aKotlinJvmJvmsy_32+0E3h; "}"
lea r11, a0oneof1+0Bh; "{"
lea rbp, aMetadataClassn+9; "classname"
lea rsi, aDeprecationPub_4; "$deprecation$public interface ${$$class"...
lea rdx, aKtDeprecation+3; "deprecation"
lea r8, aExtraInterface; "extra_interfaces"
mov rdi, rbx; this
mov rcx, r15
mov r9, r12
push r13; __int64
push r10; __int64
push r13; __int64
push r11; __int64
push qword ptr [rax+8]; __int64
push rbp; __int64
call _ZN6google8protobuf2io7Printer5PrintIJA12_cPKcA17_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA10_cSD_A2_cA1_cSF_SG_EEEvS6_DpRKT_; google::protobuf::io::Printer::Print<char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1]>(char const*,char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1] const&)
add rsp, 30h
mov rdi, [rsp+78h+var_70]; void *
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz short loc_B3B8C
loc_B3B87:
call __ZdlPv; operator delete(void *)
loc_B3B8C:
mov rcx, [r14+8]
lea rsi, a0oneof1+0Bh; "{"
lea rdx, aKotlinJvmJvmsy_32+0E3h; "}"
mov rdi, rbx
call _ZN6google8protobuf2io7Printer8AnnotateINS0_10DescriptorEEEvPKcS6_PKT_; google::protobuf::io::Printer::Annotate<google::protobuf::Descriptor>(char const*,char const*,google::protobuf::Descriptor const*)
mov rdi, rbx; this
call _ZN6google8protobuf2io7Printer6IndentEv; google::protobuf::io::Printer::Indent(void)
mov rax, [r14+8]
cmp dword ptr [rax+4], 0
jle loc_B3C8D
xor ebp, ebp
lea r13, [rsp+78h+var_70]
xor r12d, r12d
loc_B3BC6:
mov rdi, rbx
lea rsi, aConstProtoNsMe_0+0E5h; "\n"
call _ZN6google8protobuf2io7Printer5PrintIJEEEvPKcDpRKT_
mov rax, [r14+8]
mov r15, [rax+28h]
mov rax, [r15+rbp+20h]
cmp rax, [r14+50h]
jz short loc_B3C25
mov rdi, r13
mov esi, 3
lea rdx, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/aimrt_"...
mov ecx, 8Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, r13
lea rsi, aCheckFailedFie_4; "CHECK failed: (field->containing_type()"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_38]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
mov rdi, r13; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_B3C25:
test byte ptr [r15+rbp+1], 8
jnz short loc_B3C38
mov rax, [r15+rbp+20h]
add rax, 28h ; '('
jmp short loc_B3C51
loc_B3C38:
mov rax, [r15+rbp+28h]
test rax, rax
jz short loc_B3C48
add rax, 50h ; 'P'
jmp short loc_B3C51
loc_B3C48:
mov rax, [r15+rbp+10h]
add rax, 70h ; 'p'
loc_B3C51:
sub r15, [rax]
add r15, rbp
shr r15, 3
imul eax, r15d, 38E38E39h
mov rcx, [r14+58h]
cdqe
mov rdi, [rcx+rax*8]
mov rax, [rdi]
mov rsi, rbx
call qword ptr [rax+18h]
inc r12
mov rax, [r14+8]
movsxd rax, dword ptr [rax+4]
add rbp, 48h ; 'H'
cmp r12, rax
jl loc_B3BC6
loc_B3C8D:
mov r15, [r14+28h]
lea r13, [r14+18h]
cmp r15, r13
jz short loc_B3D14
lea r12, [rsp+78h+var_70]
loc_B3C9F:
mov rsi, [r15+20h]
mov rdi, [r14+40h]
call _ZNK6google8protobuf8compiler4java7Context21GetOneofGeneratorInfoEPKNS0_15OneofDescriptorE; google::protobuf::compiler::java::Context::GetOneofGeneratorInfo(google::protobuf::OneofDescriptor const*)
lea rbp, [rax+20h]
mov rdi, [r14+40h]; this
call _ZNK6google8protobuf8compiler4java7Context15GetNameResolverEv; google::protobuf::compiler::java::Context::GetNameResolver(void)
mov rdx, [r14+8]
mov rdi, r12
mov rsi, rax
mov ecx, 1
call _ZN6google8protobuf8compiler4java17ClassNameResolver12GetClassNameB5cxx11EPKNS0_10DescriptorEb; google::protobuf::compiler::java::ClassNameResolver::GetClassName(google::protobuf::Descriptor const*,bool)
mov rdi, rbx
lea rsi, aPublicClassnam; "\npublic $classname$.$oneof_capitalized"...
lea rdx, aOneofCapitaliz; "oneof_capitalized_name"
mov rcx, rbp
lea r8, aMetadataClassn+9; "classname"
mov r9, r12
call _ZN6google8protobuf2io7Printer5PrintIJA23_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA10_cSA_EEEvPKcDpRKT_; google::protobuf::io::Printer::Print<char [23],std::string,char [10],std::string>(char const*,char [23],std::string,char [10],std::string const&)
mov rdi, [rsp+78h+var_70]; void *
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz short loc_B3D04
call __ZdlPv; operator delete(void *)
loc_B3D04:
mov rdi, r15
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov r15, rax
cmp rax, r13
jnz short loc_B3C9F
loc_B3D14:
mov rdi, rbx; this
call _ZN6google8protobuf2io7Printer7OutdentEv; google::protobuf::io::Printer::Outdent(void)
lea rsi, aIfOtherHasCapi_1+6Dh; "}\n"
mov rdi, rbx
call _ZN6google8protobuf2io7Printer5PrintIJEEEvPKcDpRKT_
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_B3DA3
jmp short loc_B3D9E
mov rbx, rax
mov rdi, [rsp+arg_0]
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_B3DA3
jmp short loc_B3D9E
mov rbx, rax
mov rdi, [rsp+arg_0]
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_B3DA3
jmp short loc_B3D9E
mov rbx, rax
jmp short loc_B3DA3
jmp short $+2
loc_B3D7D:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_B3DA3
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_B3DA3
loc_B3D9E:
call __ZdlPv; operator delete(void *)
loc_B3DA3:
mov rdi, rbx
call __Unwind_Resume
|
long long google::protobuf::compiler::java::ImmutableMessageLiteGenerator::GenerateInterface(
google::protobuf::compiler::java::ImmutableMessageLiteGenerator *this,
google::protobuf::io::Printer *a2)
{
long long v4; // r15
long long v5; // r12
int v6; // r9d
long long v7; // rsi
char *v8; // rax
void *v9; // rdi
long long v10; // rbp
long long v11; // r12
long long v12; // r15
long long v13; // rax
_QWORD *v14; // rax
long long v15; // rax
long long v16; // rdi
const google::protobuf::OneofDescriptor **i; // r15
long long v18; // rbp
long long NameResolver; // rax
void *v21[2]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v22[40]; // [rsp+18h] [rbp-60h] BYREF
_QWORD v23[7]; // [rsp+40h] [rbp-38h] BYREF
v4 = *((_QWORD *)this + 1);
v5 = *((_QWORD *)this + 8);
v21[0] = v22;
std::string::_M_construct<char const*>((long long)v21, "OrBuilder", (long long)"");
google::protobuf::compiler::java::MaybePrintGeneratedAnnotation<google::protobuf::Descriptor const>(
v5,
(long long)a2,
v4,
1,
(int)v21,
v6);
if ( v21[0] != v22 )
operator delete(v21[0]);
v7 = *((_QWORD *)this + 1);
v8 = "@java.lang.Deprecated ";
if ( *(int *)(v7 + 120) <= 0 )
{
if ( !*(_BYTE *)(*(_QWORD *)(v7 + 32) + 74LL) )
v8 = "";
v23[0] = v8;
google::protobuf::compiler::java::ExtraMessageOrBuilderInterfaces[abi:cxx11]((long long)v21, v7);
google::protobuf::io::Printer::Print<char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1]>(
a2,
(long long)"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n"
" $extra_interfaces$\n"
" com.google.protobuf.MessageLiteOrBuilder {\n",
(long long)"deprecation",
v23,
(long long)"extra_interfaces",
(long long)v21,
(long long)"classname",
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL),
(long long)"{",
(long long)"",
(long long)"}",
(long long)"");
v9 = v21[0];
if ( v21[0] != v22 )
goto LABEL_11;
}
else
{
if ( !*(_BYTE *)(*(_QWORD *)(v7 + 32) + 74LL) )
v8 = "";
v23[0] = v8;
google::protobuf::compiler::java::ExtraMessageOrBuilderInterfaces[abi:cxx11]((long long)v21, v7);
google::protobuf::io::Printer::Print<char [12],char const*,char [17],std::string,char [10],std::string,char [2],char [1],char [2],char [1]>(
a2,
(long long)"$deprecation$public interface ${$$classname$OrBuilder$}$ extends \n"
" $extra_interfaces$\n"
" com.google.protobuf.GeneratedMessageLite.\n"
" ExtendableMessageOrBuilder<\n"
" $classname$, $classname$.Builder> {\n",
(long long)"deprecation",
v23,
(long long)"extra_interfaces",
(long long)v21,
(long long)"classname",
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL),
(long long)"{",
(long long)"",
(long long)"}",
(long long)"");
v9 = v21[0];
if ( v21[0] != v22 )
LABEL_11:
operator delete(v9);
}
google::protobuf::io::Printer::Annotate<google::protobuf::Descriptor>(
(long long)a2,
(int)"{",
(int)"}",
*((_QWORD *)this + 1));
google::protobuf::io::Printer::Indent(a2);
if ( *(int *)(*((_QWORD *)this + 1) + 4LL) > 0 )
{
v10 = 0LL;
v11 = 0LL;
do
{
google::protobuf::io::Printer::Print<>(a2, "\n");
v12 = *(_QWORD *)(*((_QWORD *)this + 1) + 40LL);
if ( *(_QWORD *)(v12 + v10 + 32) != *((_QWORD *)this + 10) )
{
google::protobuf::internal::LogMessage::LogMessage(
v21,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/field.h",
139LL);
v13 = google::protobuf::internal::LogMessage::operator<<(
v21,
"CHECK failed: (field->containing_type()) == (descriptor_): ");
google::protobuf::internal::LogFinisher::operator=(v23, v13);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v21);
}
if ( (*(_BYTE *)(v12 + v10 + 1) & 8) != 0 )
{
v15 = *(_QWORD *)(v12 + v10 + 40);
if ( v15 )
v14 = (_QWORD *)(v15 + 80);
else
v14 = (_QWORD *)(*(_QWORD *)(v12 + v10 + 16) + 112LL);
}
else
{
v14 = (_QWORD *)(*(_QWORD *)(v12 + v10 + 32) + 40LL);
}
v16 = *(_QWORD *)(*((_QWORD *)this + 11) + 8LL * (int)(954437177 * ((unsigned long long)(v10 + v12 - *v14) >> 3)));
(*(void ( **)(long long, google::protobuf::io::Printer *))(*(_QWORD *)v16 + 24LL))(v16, a2);
++v11;
v10 += 72LL;
}
while ( v11 < *(int *)(*((_QWORD *)this + 1) + 4LL) );
}
for ( i = (const google::protobuf::OneofDescriptor **)*((_QWORD *)this + 5);
i != (const google::protobuf::OneofDescriptor **)((char *)this + 24);
i = (const google::protobuf::OneofDescriptor **)std::_Rb_tree_increment(i) )
{
v18 = google::protobuf::compiler::java::Context::GetOneofGeneratorInfo(
*((google::protobuf::compiler::java::Context **)this + 8),
i[4])
+ 32;
NameResolver = google::protobuf::compiler::java::Context::GetNameResolver(*((google::protobuf::compiler::java::Context **)this
+ 8));
google::protobuf::compiler::java::ClassNameResolver::GetClassName[abi:cxx11](
v21,
NameResolver,
*((_QWORD *)this + 1),
1LL);
google::protobuf::io::Printer::Print<char [23],std::string,char [10],std::string>(
a2,
(long long)"\npublic $classname$.$oneof_capitalized_name$Case get$oneof_capitalized_name$Case();\n",
(long long)"oneof_capitalized_name",
v18);
if ( v21[0] != v22 )
operator delete(v21[0]);
}
google::protobuf::io::Printer::Outdent(a2);
return google::protobuf::io::Printer::Print<>(a2, "}\n");
}
|
GenerateInterface:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x8]
MOV R12,qword ptr [RDI + 0x40]
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LAB_001b3a29:
LEA RSI,[0x2bac34]
LEA RDX,[0x2bac3d]
LEA RDI,[RSP + 0x8]
CALL 0x001250b2
LAB_001b3a41:
LEA R8,[RSP + 0x8]
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
MOV ECX,0x1
CALL 0x001ae857
LAB_001b3a59:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001b3a6d
CALL 0x0011f4a0
LAB_001b3a6d:
MOV RSI,qword ptr [R14 + 0x8]
CMP dword ptr [RSI + 0x78],0x0
LEA RAX,[0x2ba3c4]
LEA R13,[0x29a5a9]
JLE 0x001b3b0b
MOV RCX,qword ptr [RSI + 0x20]
CMP byte ptr [RCX + 0x4a],0x0
CMOVZ RAX,R13
LEA R15,[RSP + 0x40]
MOV qword ptr [R15],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00143e14
MOV RAX,qword ptr [R14 + 0x8]
LAB_001b3aae:
LEA R10,[0x2e06cd]
LEA R11,[0x2f00d9]
LEA RBP,[0x2a649e]
LEA RSI,[0x2c1a25]
LEA RDX,[0x2d631c]
LEA R8,[0x2bb454]
MOV RDI,RBX
MOV RCX,R15
MOV R9,R12
PUSH R13
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RAX + 0x8]
PUSH RBP
CALL 0x001ae9f0
ADD RSP,0x30
LAB_001b3af6:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001b3b8c
JMP 0x001b3b87
LAB_001b3b0b:
MOV RCX,qword ptr [RSI + 0x20]
CMP byte ptr [RCX + 0x4a],0x0
CMOVZ RAX,R13
LEA R15,[RSP + 0x40]
MOV qword ptr [R15],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00143e14
MOV RAX,qword ptr [R14 + 0x8]
LAB_001b3b30:
LEA R10,[0x2e06cd]
LEA R11,[0x2f00d9]
LEA RBP,[0x2a649e]
LEA RSI,[0x2c1b06]
LEA RDX,[0x2d631c]
LEA R8,[0x2bb454]
MOV RDI,RBX
MOV RCX,R15
MOV R9,R12
PUSH R13
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RAX + 0x8]
PUSH RBP
CALL 0x001ae9f0
ADD RSP,0x30
LAB_001b3b78:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001b3b8c
LAB_001b3b87:
CALL 0x0011f4a0
LAB_001b3b8c:
MOV RCX,qword ptr [R14 + 0x8]
LEA RSI,[0x2f00d9]
LEA RDX,[0x2e06cd]
MOV RDI,RBX
CALL 0x001aeae2
MOV RDI,RBX
CALL 0x0026d126
MOV RAX,qword ptr [R14 + 0x8]
CMP dword ptr [RAX + 0x4],0x0
JLE 0x001b3c8d
XOR EBP,EBP
LEA R13,[RSP + 0x8]
XOR R12D,R12D
LAB_001b3bc6:
MOV RDI,RBX
LEA RSI,[0x2b337d]
CALL 0x0012e40a
MOV RAX,qword ptr [R14 + 0x8]
MOV R15,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [R15 + RBP*0x1 + 0x20]
CMP RAX,qword ptr [R14 + 0x50]
JZ 0x001b3c25
MOV RDI,R13
MOV ESI,0x3
LEA RDX,[0x2bfd29]
MOV ECX,0x8b
CALL 0x002072ba
LAB_001b3c01:
MOV RDI,R13
LEA RSI,[0x2bfd98]
CALL 0x00206db8
LAB_001b3c10:
LEA RDI,[RSP + 0x40]
MOV RSI,RAX
CALL 0x00206e92
LAB_001b3c1d:
MOV RDI,R13
CALL 0x002072d8
LAB_001b3c25:
TEST byte ptr [R15 + RBP*0x1 + 0x1],0x8
JNZ 0x001b3c38
MOV RAX,qword ptr [R15 + RBP*0x1 + 0x20]
ADD RAX,0x28
JMP 0x001b3c51
LAB_001b3c38:
MOV RAX,qword ptr [R15 + RBP*0x1 + 0x28]
TEST RAX,RAX
JZ 0x001b3c48
ADD RAX,0x50
JMP 0x001b3c51
LAB_001b3c48:
MOV RAX,qword ptr [R15 + RBP*0x1 + 0x10]
ADD RAX,0x70
LAB_001b3c51:
SUB R15,qword ptr [RAX]
ADD R15,RBP
SHR R15,0x3
IMUL EAX,R15D,0x38e38e39
MOV RCX,qword ptr [R14 + 0x58]
CDQE
MOV RDI,qword ptr [RCX + RAX*0x8]
MOV RAX,qword ptr [RDI]
MOV RSI,RBX
CALL qword ptr [RAX + 0x18]
INC R12
MOV RAX,qword ptr [R14 + 0x8]
MOVSXD RAX,dword ptr [RAX + 0x4]
ADD RBP,0x48
CMP R12,RAX
JL 0x001b3bc6
LAB_001b3c8d:
MOV R15,qword ptr [R14 + 0x28]
LEA R13,[R14 + 0x18]
CMP R15,R13
JZ 0x001b3d14
LEA R12,[RSP + 0x8]
LAB_001b3c9f:
MOV RSI,qword ptr [R15 + 0x20]
MOV RDI,qword ptr [R14 + 0x40]
CALL 0x001cef84
LEA RBP,[RAX + 0x20]
MOV RDI,qword ptr [R14 + 0x40]
CALL 0x001cda64
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,R12
MOV RSI,RAX
MOV ECX,0x1
CALL 0x00147ac2
LAB_001b3ccd:
MOV RDI,RBX
LEA RSI,[0x2bb4e9]
LEA RDX,[0x2bb53e]
MOV RCX,RBP
LEA R8,[0x2a649e]
MOV R9,R12
CALL 0x001aeb6a
LAB_001b3cf0:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001b3d04
CALL 0x0011f4a0
LAB_001b3d04:
MOV RDI,R15
CALL 0x0011f570
MOV R15,RAX
CMP RAX,R13
JNZ 0x001b3c9f
LAB_001b3d14:
MOV RDI,RBX
CALL 0x0026d136
LEA RSI,[0x2e2117]
MOV RDI,RBX
CALL 0x0012e40a
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::compiler::java::ImmutableMessageLiteGenerator::GenerateInterface(google::protobuf::io::Printer*)
*/
void __thiscall
google::protobuf::compiler::java::ImmutableMessageLiteGenerator::GenerateInterface
(ImmutableMessageLiteGenerator *this,Printer *param_1)
{
Descriptor *pDVar1;
Context *pCVar2;
long lVar3;
long lVar4;
bool bVar5;
LogMessage *pLVar6;
long *plVar7;
ImmutableMessageLiteGenerator *pIVar8;
long lVar9;
long lVar10;
int1 *local_70 [2];
int1 local_60 [40];
char *local_38;
pDVar1 = *(Descriptor **)(this + 8);
pCVar2 = *(Context **)(this + 0x40);
local_70[0] = local_60;
/* try { // try from 001b3a29 to 001b3a40 has its CatchHandler @ 001b3d76 */
std::__cxx11::string::_M_construct<char_const*>(local_70,"OrBuilder","");
/* try { // try from 001b3a41 to 001b3a58 has its CatchHandler @ 001b3d62 */
MaybePrintGeneratedAnnotation<google::protobuf::Descriptor_const>
(pCVar2,param_1,pDVar1,true,(string *)local_70);
if (local_70[0] != local_60) {
operator_delete(local_70[0]);
}
lVar9 = *(long *)(this + 8);
local_38 = "@java.lang.Deprecated ";
if (*(int *)(lVar9 + 0x78) < 1) {
if (*(char *)(*(long *)(lVar9 + 0x20) + 0x4a) == '\0') {
local_38 = "";
}
ExtraMessageOrBuilderInterfaces_abi_cxx11_((Descriptor *)local_70);
/* try { // try from 001b3b30 to 001b3b77 has its CatchHandler @ 001b3d3a */
io::Printer::
Print<char[12],char_const*,char[17],std::__cxx11::string,char[10],std::__cxx11::string,char[2],char[1],char[2],char[1]>
(param_1,
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends\n $extra_interfaces$\n com.google.protobuf.MessageLiteOrBuilder {\n"
,"deprecation",&local_38,"extra_interfaces",(string *)local_70,"classname",
*(string **)(*(long *)(this + 8) + 8),"{","","}","");
if (local_70[0] == local_60) goto LAB_001b3b8c;
}
else {
if (*(char *)(*(long *)(lVar9 + 0x20) + 0x4a) == '\0') {
local_38 = "";
}
ExtraMessageOrBuilderInterfaces_abi_cxx11_((Descriptor *)local_70);
/* try { // try from 001b3aae to 001b3af5 has its CatchHandler @ 001b3d4e */
io::Printer::
Print<char[12],char_const*,char[17],std::__cxx11::string,char[10],std::__cxx11::string,char[2],char[1],char[2],char[1]>
(param_1,
"$deprecation$public interface ${$$classname$OrBuilder$}$ extends \n $extra_interfaces$\n com.google.protobuf.GeneratedMessageLite.\n ExtendableMessageOrBuilder<\n $classname$, $classname$.Builder> {\n"
,"deprecation",&local_38,"extra_interfaces",(string *)local_70,"classname",
*(string **)(*(long *)(this + 8) + 8),"{","","}","");
if (local_70[0] == local_60) goto LAB_001b3b8c;
}
operator_delete(local_70[0]);
LAB_001b3b8c:
io::Printer::Annotate<google::protobuf::Descriptor>(param_1,"{","}",*(Descriptor **)(this + 8));
io::Printer::Indent(param_1);
if (0 < *(int *)(*(long *)(this + 8) + 4)) {
lVar9 = 0;
lVar10 = 0;
do {
io::Printer::Print<>(param_1,"\n");
lVar3 = *(long *)(*(long *)(this + 8) + 0x28);
if (*(long *)(lVar3 + 0x20 + lVar9) != *(long *)(this + 0x50)) {
internal::LogMessage::LogMessage
((LogMessage *)local_70,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/field.h"
,0x8b);
/* try { // try from 001b3c01 to 001b3c0f has its CatchHandler @ 001b3d7b */
pLVar6 = (LogMessage *)
internal::LogMessage::operator<<
((LogMessage *)local_70,
"CHECK failed: (field->containing_type()) == (descriptor_): ");
/* try { // try from 001b3c10 to 001b3c1c has its CatchHandler @ 001b3d7d */
internal::LogFinisher::operator=((LogFinisher *)&local_38,pLVar6);
internal::LogMessage::~LogMessage((LogMessage *)local_70);
}
if ((*(byte *)(lVar3 + 1 + lVar9) & 8) == 0) {
plVar7 = (long *)(*(long *)(lVar3 + 0x20 + lVar9) + 0x28);
}
else {
lVar4 = *(long *)(lVar3 + 0x28 + lVar9);
if (lVar4 == 0) {
plVar7 = (long *)(*(long *)(lVar3 + 0x10 + lVar9) + 0x70);
}
else {
plVar7 = (long *)(lVar4 + 0x50);
}
}
plVar7 = *(long **)(*(long *)(this + 0x58) +
(long)((int)((ulong)((lVar3 - *plVar7) + lVar9) >> 3) * 0x38e38e39) * 8);
(**(code **)(*plVar7 + 0x18))(plVar7,param_1);
lVar10 = lVar10 + 1;
lVar9 = lVar9 + 0x48;
} while (lVar10 < *(int *)(*(long *)(this + 8) + 4));
}
pIVar8 = *(ImmutableMessageLiteGenerator **)(this + 0x28);
if (pIVar8 != this + 0x18) {
do {
lVar9 = Context::GetOneofGeneratorInfo
(*(Context **)(this + 0x40),
*(OneofDescriptor **)((_Rb_tree_node_base *)pIVar8 + 0x20));
bVar5 = (bool)Context::GetNameResolver(*(Context **)(this + 0x40));
ClassNameResolver::GetClassName_abi_cxx11_((Descriptor *)local_70,bVar5);
/* try { // try from 001b3ccd to 001b3cef has its CatchHandler @ 001b3d8c */
io::Printer::Print<char[23],std::__cxx11::string,char[10],std::__cxx11::string>
((char *)param_1,
"\npublic $classname$.$oneof_capitalized_name$Case get$oneof_capitalized_name$Case();\n"
,(string *)"oneof_capitalized_name",(char *)(lVar9 + 0x20),(string *)0x2a649e);
if (local_70[0] != local_60) {
operator_delete(local_70[0]);
}
pIVar8 = (ImmutableMessageLiteGenerator *)
std::_Rb_tree_increment((_Rb_tree_node_base *)pIVar8);
} while (pIVar8 != this + 0x18);
}
io::Printer::Outdent(param_1);
io::Printer::Print<>(param_1,"}\n");
return;
}
|
|
63,161 |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> get_knot_json<float, Eigen::Matrix<float, 3, 1, 0, 3, 1>>(PolyLine<float> const&)
|
zkingston[P]unknot/src/util.hh
|
auto get_knot_json(const PolyLine<RealT> &knot) -> nlohmann::json
{
nlohmann::json j;
for (const auto &point : knot.points)
{
nlohmann::json jp;
for (auto i = 0U; i < dimension; ++i)
{
jp.emplace_back(point[i]);
}
j.emplace_back(jp);
}
return j;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> get_knot_json<float, Eigen::Matrix<float, 3, 1, 0, 3, 1>>(PolyLine<float> const&):
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5edb0
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x61e60
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x61e90
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x61ec0
testb $0x1, %al
jne 0x5ef09
jmp 0x5efbb
leaq 0x50(%rsp), %rdi
callq 0x61f00
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5edb0
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpq $0x3, %rax
jae 0x5ef91
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x620b0
movq %rax, (%rsp)
jmp 0x5ef4e
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x61f10
jmp 0x5ef5e
jmp 0x5ef60
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5ef2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5f190
movq 0x8(%rsp), %rdi
callq 0x5f190
jmp 0x5efdb
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5eff0
jmp 0x5efa2
leaq 0x30(%rsp), %rdi
callq 0x5f190
leaq 0x50(%rsp), %rdi
callq 0x620e0
jmp 0x5eef1
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x5efd1
movq 0x8(%rsp), %rdi
callq 0x5f190
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13540
nopw %cs:(%rax,%rax)
nop
|
_Z13get_knot_jsonIfN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEEEN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEERK8PolyLineIT_E:
sub rsp, 78h
mov qword ptr [rsp+78h+var_70], rdi; int
mov rax, rdi
mov qword ptr [rsp+78h+var_68], rax; int
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_11], 0
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEESaIS2_EE5beginEv; std::vector<Eigen::Matrix<float,3,1,0,3,1>>::begin(void)
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEESaIS2_EE3endEv; std::vector<Eigen::Matrix<float,3,1,0,3,1>>::end(void)
mov [rsp+78h+var_30], rax
loc_5EEF1:
lea rdi, [rsp+78h+var_28]
lea rsi, [rsp+78h+var_30]
call _ZN9__gnu_cxxneIPKN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEESt6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator!=<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>(__gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>> const&,__gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>> const&)
test al, 1
jnz short loc_5EF09
jmp loc_5EFBB
loc_5EF09:
lea rdi, [rsp+78h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEESt6vectorIS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>::operator*(void)
mov qword ptr [rsp+78h+var_38], rax; char
lea rdi, [rsp+78h+var_48]
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov [rsp+78h+var_4C], 0
loc_5EF2E:
mov eax, [rsp+78h+var_4C]
cmp rax, 3
jnb short loc_5EF91
mov rdi, qword ptr [rsp+78h+var_38]
mov eax, [rsp+78h+var_4C]
mov esi, eax
call _ZNK5Eigen15DenseCoeffsBaseINS_6MatrixIfLi3ELi1ELi0ELi3ELi1EEELi0EEixEl; Eigen::DenseCoeffsBase<Eigen::Matrix<float,3,1,0,3,1>,0>::operator[](long)
mov [rsp+78h+var_78], rax; void *
jmp short $+2
loc_5EF4E:
mov rsi, [rsp+78h+var_78]; int
lea rdi, [rsp+78h+var_48]; char
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRKfEEERSD_DpOT_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::emplace_back<float const&>(float const&)
jmp short $+2
loc_5EF5E:
jmp short $+2
loc_5EF60:
mov eax, [rsp+78h+var_4C]
add eax, 1
mov [rsp+78h+var_4C], eax
jmp short loc_5EF2E
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, [rsp+arg_0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_5EFDB
loc_5EF91:
mov rdi, qword ptr [rsp+78h+var_70]; char
lea rsi, [rsp+78h+var_48]; int
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
jmp short $+2
loc_5EFA2:
lea rdi, [rsp+78h+var_48]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
lea rdi, [rsp+78h+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPKN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEESt6vectorIS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>::operator++(void)
jmp loc_5EEF1
loc_5EFBB:
mov [rsp+78h+var_11], 1
test [rsp+78h+var_11], 1
jnz short loc_5EFD1
mov rdi, qword ptr [rsp+78h+var_70]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_5EFD1:
mov rax, qword ptr [rsp+78h+var_68]
add rsp, 78h
retn
loc_5EFDB:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
long long get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>(long long a1, long long a2)
{
void *v3; // [rsp+0h] [rbp-78h]
void *v4; // [rsp+0h] [rbp-78h]
int v5; // [rsp+8h] [rbp-70h]
int v6[2]; // [rsp+10h] [rbp-68h]
int v7; // [rsp+18h] [rbp-60h]
int v8; // [rsp+20h] [rbp-58h]
__int16 v9; // [rsp+28h] [rbp-50h]
unsigned int i; // [rsp+2Ch] [rbp-4Ch]
int v11; // [rsp+2Ch] [rbp-4Ch]
long long v12; // [rsp+30h] [rbp-48h] BYREF
int v13; // [rsp+38h] [rbp-40h]
char v14[8]; // [rsp+40h] [rbp-38h]
long long v15; // [rsp+48h] [rbp-30h] BYREF
_QWORD v16[2]; // [rsp+50h] [rbp-28h] BYREF
char v17; // [rsp+67h] [rbp-11h]
long long v18; // [rsp+68h] [rbp-10h]
long long v19; // [rsp+70h] [rbp-8h]
v5 = a1;
*(_QWORD *)v6 = a1;
v19 = a1;
v18 = a2;
v17 = 0;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1);
v16[1] = a2;
v16[0] = std::vector<Eigen::Matrix<float,3,1,0,3,1>>::begin(a2);
v15 = std::vector<Eigen::Matrix<float,3,1,0,3,1>>::end(a2);
while ( (__gnu_cxx::operator!=<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>(
v16,
&v15) & 1) != 0 )
{
*(_QWORD *)v14 = __gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>::operator*(v16);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)&v12);
for ( i = 0; i < 3uLL; i = v11 + 1 )
{
v4 = (void *)Eigen::DenseCoeffsBase<Eigen::Matrix<float,3,1,0,3,1>,0>::operator[](*(_QWORD *)v14, i);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<float const&>(
(char)&v12,
(int)v4,
v4,
v5,
v6[0],
v7,
v8,
v9,
v12,
v13,
v14[0]);
}
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
v5,
(int)&v12,
v3,
v5,
v6[0],
v7,
v8,
v9,
v12,
v13,
v14[0]);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(&v12);
__gnu_cxx::__normal_iterator<Eigen::Matrix<float,3,1,0,3,1> const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>>>::operator++(v16);
}
return *(_QWORD *)v6;
}
|
get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>:
SUB RSP,0x78
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV byte ptr [RSP + 0x67],0x0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015edb0
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00161e60
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00161e90
MOV qword ptr [RSP + 0x48],RAX
LAB_0015eef1:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x48]
CALL 0x00161ec0
TEST AL,0x1
JNZ 0x0015ef09
JMP 0x0015efbb
LAB_0015ef09:
LEA RDI,[RSP + 0x50]
CALL 0x00161f00
MOV qword ptr [RSP + 0x40],RAX
LEA RDI,[RSP + 0x30]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0015edb0
MOV dword ptr [RSP + 0x2c],0x0
LAB_0015ef2e:
MOV EAX,dword ptr [RSP + 0x2c]
CMP RAX,0x3
JNC 0x0015ef91
MOV RDI,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RSP + 0x2c]
MOV ESI,EAX
LAB_0015ef43:
CALL 0x001620b0
MOV qword ptr [RSP],RAX
JMP 0x0015ef4e
LAB_0015ef4e:
MOV RSI,qword ptr [RSP]
LEA RDI,[RSP + 0x30]
CALL 0x00161f10
JMP 0x0015ef5e
LAB_0015ef5e:
JMP 0x0015ef60
LAB_0015ef60:
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x0015ef2e
LAB_0015ef91:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x30]
CALL 0x0015eff0
LAB_0015efa0:
JMP 0x0015efa2
LAB_0015efa2:
LEA RDI,[RSP + 0x30]
CALL 0x0015f190
LEA RDI,[RSP + 0x50]
CALL 0x001620e0
JMP 0x0015eef1
LAB_0015efbb:
MOV byte ptr [RSP + 0x67],0x1
TEST byte ptr [RSP + 0x67],0x1
JNZ 0x0015efd1
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0015f190
LAB_0015efd1:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x0015efc7) */
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void> get_knot_json<float,
Eigen::Matrix<float, 3, 1, 0, 3, 1> >(PolyLine<float> const&) */
PolyLine * get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>(PolyLine *param_1)
{
bool bVar1;
float *pfVar2;
vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>> *in_RSI;
uint local_4c;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_48 [16];
DenseCoeffsBase<Eigen::Matrix<float,3,1,0,3,1>,0> *local_38;
int8 local_30;
int8 local_28;
vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>> *local_20;
int1 local_11;
vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>> *local_10;
PolyLine *local_8;
local_11 = 0;
local_10 = in_RSI;
local_8 = param_1;
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)param_1);
local_20 = local_10;
local_28 = std::
vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>::
begin(local_10);
local_30 = std::
vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>::
end(local_20);
while (bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_28,(__normal_iterator *)&local_30), bVar1) {
local_38 = (DenseCoeffsBase<Eigen::Matrix<float,3,1,0,3,1>,0> *)
__gnu_cxx::
__normal_iterator<Eigen::Matrix<float,3,1,0,3,1>const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>>
::operator*((__normal_iterator<Eigen::Matrix<float,3,1,0,3,1>const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>>
*)&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)local_48);
for (local_4c = 0; local_4c < 3; local_4c = local_4c + 1) {
/* try { // try from 0015ef43 to 0015ef9f has its CatchHandler @ 0015ef6d */
pfVar2 = (float *)Eigen::DenseCoeffsBase<Eigen::Matrix<float,3,1,0,3,1>,0>::operator[]
(local_38,(ulong)local_4c);
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::emplace_back<float_const&>(local_48,pfVar2);
}
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,local_48);
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_48);
__gnu_cxx::
__normal_iterator<Eigen::Matrix<float,3,1,0,3,1>const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>>
::operator++((__normal_iterator<Eigen::Matrix<float,3,1,0,3,1>const*,std::vector<Eigen::Matrix<float,3,1,0,3,1>,std::allocator<Eigen::Matrix<float,3,1,0,3,1>>>>
*)&local_28);
}
return param_1;
}
|
|
63,162 |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> get_knot_json<float, Eigen::Matrix<float, 3, 1, 0, 3, 1>>(PolyLine<float> const&)
|
zkingston[P]unknot/src/util.hh
|
auto get_knot_json(const PolyLine<RealT> &knot) -> nlohmann::json
{
nlohmann::json j;
for (const auto &point : knot.points)
{
nlohmann::json jp;
for (auto i = 0U; i < dimension; ++i)
{
jp.emplace_back(point[i]);
}
j.emplace_back(jp);
}
return j;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> get_knot_json<float, Eigen::Matrix<float, 3, 1, 0, 3, 1>>(PolyLine<float> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x2b0e4
movq %rsp, %r14
movb $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
leaq (%r15,%r13), %rsi
movq %r14, %rdi
callq 0x2b742
addq $0x4, %r13
cmpq $0xc, %r13
jne 0x2b0b2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b112
movq %r14, %rdi
callq 0x2c524
addq $0xc, %r15
cmpq %r12, %r15
jne 0x2b0a2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2b0f7
movq %rax, %r14
movq %rsp, %rdi
callq 0x2c524
movq %rbx, %rdi
callq 0x2c524
movq %r14, %rdi
callq 0x101c0
|
_Z13get_knot_jsonIfN5Eigen6MatrixIfLi3ELi1ELi0ELi3ELi1EEEEN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEERK8PolyLineIT_E:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rdi
mov byte ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov r15, [rsi]
mov r12, [rsi+8]
cmp r15, r12
jz short loc_2B0E4
mov r14, rsp
loc_2B0A2:
mov [rsp+38h+var_38], 0
mov [rsp+38h+var_30], 0
xor r13d, r13d
loc_2B0B2:
lea rsi, [r15+r13]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRKfEEERSD_DpOT_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::emplace_back<float const&>(float const&)
add r13, 4
cmp r13, 0Ch
jnz short loc_2B0B2
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r15, 0Ch
cmp r15, r12
jnz short loc_2B0A2
loc_2B0E4:
mov rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short $+2
loc_2B0F7:
mov r14, rax
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r14
call __Unwind_Resume
|
long long get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>(long long a1, long long *a2)
{
long long v2; // r15
long long v3; // r12
long long i; // r13
_BYTE v6[8]; // [rsp+0h] [rbp-38h] BYREF
long long v7; // [rsp+8h] [rbp-30h]
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
v2 = *a2;
v3 = a2[1];
if ( *a2 != v3 )
{
do
{
v6[0] = 0;
v7 = 0LL;
for ( i = 0LL; i != 12; i += 4LL )
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<float const&>(
v6,
v2 + i);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
a1,
v6);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v6);
v2 += 12LL;
}
while ( v2 != v3 );
}
return a1;
}
|
get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV byte ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV R15,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R15,R12
JZ 0x0012b0e4
MOV R14,RSP
LAB_0012b0a2:
MOV byte ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
XOR R13D,R13D
LAB_0012b0b2:
LEA RSI,[R15 + R13*0x1]
LAB_0012b0b6:
MOV RDI,R14
CALL 0x0012b742
ADD R13,0x4
CMP R13,0xc
JNZ 0x0012b0b2
LAB_0012b0c8:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012b112
LAB_0012b0d3:
MOV RDI,R14
CALL 0x0012c524
ADD R15,0xc
CMP R15,R12
JNZ 0x0012b0a2
LAB_0012b0e4:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void> get_knot_json<float,
Eigen::Matrix<float, 3, 1, 0, 3, 1> >(PolyLine<float> const&) */
PolyLine * get_knot_json<float,Eigen::Matrix<float,3,1,0,3,1>>(PolyLine *param_1)
{
long lVar1;
long *in_RSI;
long lVar2;
long lVar3;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_38 [8];
int8 local_30;
*param_1 = (PolyLine)0x0;
*(int8 *)(param_1 + 8) = 0;
lVar1 = in_RSI[1];
for (lVar3 = *in_RSI; lVar3 != lVar1; lVar3 = lVar3 + 0xc) {
local_38[0] = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
local_30 = 0;
lVar2 = 0;
do {
/* try { // try from 0012b0b6 to 0012b0bd has its CatchHandler @ 0012b0f7 */
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::emplace_back<float_const&>(local_38,(float *)(lVar3 + lVar2));
lVar2 = lVar2 + 4;
} while (lVar2 != 0xc);
/* try { // try from 0012b0c8 to 0012b0d2 has its CatchHandler @ 0012b0f5 */
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1,(basic_json *)local_38);
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_38);
}
return param_1;
}
|
|
63,163 |
SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
void resolve_refs(json & schema, const std::string & url) {
/*
* Resolves all $ref fields in the given schema, fetching any remote schemas,
* replacing each $ref with absolute reference URL and populates _refs with the
* respective referenced (sub)schema dictionaries.
*/
std::function<void(json &)> visit_refs = [&](json & n) {
if (n.is_array()) {
for (auto & x : n) {
visit_refs(x);
}
} else if (n.is_object()) {
if (n.contains("$ref")) {
std::string ref = n["$ref"];
if (_refs.find(ref) == _refs.end()) {
json target;
if (ref.find("https://") == 0) {
std::string base_url = ref.substr(0, ref.find('#'));
auto it = _refs.find(base_url);
if (it != _refs.end()) {
target = it->second;
} else {
// Fetch the referenced schema and resolve its refs
auto referenced = _fetch_json(ref);
resolve_refs(referenced, base_url);
_refs[base_url] = referenced;
}
if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) {
return;
}
} else if (ref.find("#/") == 0) {
target = schema;
n["$ref"] = url + ref;
ref = url + ref;
} else {
_errors.push_back("Unsupported ref: " + ref);
return;
}
std::string pointer = ref.substr(ref.find('#') + 1);
std::vector<std::string> tokens = string_split(pointer, "/");
for (size_t i = 1; i < tokens.size(); ++i) {
std::string sel = tokens[i];
if (target.is_null() || !target.contains(sel)) {
_errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump());
return;
}
target = target[sel];
}
_refs[ref] = target;
}
} else {
for (auto & kv : n.items()) {
visit_refs(kv.value());
}
}
}
};
visit_refs(schema);
}
|
O3
|
cpp
|
SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%r12)
movl $0x20, %edi
callq 0x1b890
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, (%r12)
leaq 0x70(%rip), %rcx # 0xcae34
movq %rcx, 0x18(%r12)
leaq 0x6c(%rip), %rcx # 0xcae3c
movq %rcx, 0x10(%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0xcae64
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xcadf9
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xcae2b
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xcae23
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x1bf70
movq %rax, %rdi
callq 0x21ae5
nop
|
_ZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+48h+var_40]
mov qword ptr [r12+8], 0
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], r15
mov [rax+10h], r14
mov [rax+18h], rbx
mov [r12], rax
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E9_M_invokeERKSt9_Any_dataSF_; std::_Function_handler<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> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::string const&)::{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)#1}>::_M_invoke(std::_Any_data 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> &)
mov [r12+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEZN15SchemaConverter12resolve_refsESF_RKSA_EUlSF_E_E10_M_managerERSt9_Any_dataRKSM_St18_Manager_operation; std::_Function_handler<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> &),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::string const&)::{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [r12+10h], rcx
mov rdi, rax
mov rsi, r14
call _ZZN15SchemaConverter12resolve_refsERN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_ENKUlSF_E_clESF_; SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::string const&)::{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)#1}::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 rax, [rsp+48h+var_30]
test rax, rax
jz short loc_CADF9
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_CADF9:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_CAE2B
mov rbx, rax
mov rax, [rsp+48h+var_30]
test rax, rax
jz short loc_CAE23
lea rdi, [rsp+48h+var_40]
mov rsi, rdi
mov edx, 3
call rax
loc_CAE23:
mov rdi, rbx
call __Unwind_Resume
loc_CAE2B:
mov rdi, rax
call __clang_call_terminate
|
long long SchemaConverter::resolve_refs(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rax
long long result; // rax
_QWORD v6[2]; // [rsp+8h] [rbp-40h] BYREF
long long ( *v7)(); // [rsp+18h] [rbp-30h]
long long ( *v8)(); // [rsp+20h] [rbp-28h]
v6[1] = 0LL;
v4 = (_QWORD *)operator new(0x20uLL);
*v4 = v6;
v4[1] = a1;
v4[2] = a2;
v4[3] = a3;
v6[0] = v4;
v8 = std::_Function_handler<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> &),SchemaConverter::resolve_refs(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::string const&)::{lambda(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> &)#1}>::_M_invoke;
v7 = std::_Function_handler<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> &),SchemaConverter::resolve_refs(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::string const&)::{lambda(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> &)#1}>::_M_manager;
SchemaConverter::resolve_refs(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::string const&)::{lambda(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> &)#1}::operator()(
v4,
a2);
result = (long long)v7;
if ( v7 )
return ((long long ( *)(_QWORD *, _QWORD *, long long))v7)(v6, v6, 3LL);
return result;
}
|
resolve_refs:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12 + 0x8],0x0
MOV EDI,0x20
CALL 0x0011b890
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [R12],RAX
LEA RCX,[0x1cae34]
MOV qword ptr [R12 + 0x18],RCX
LEA RCX,[0x1cae3c]
MOV qword ptr [R12 + 0x10],RCX
LAB_001cadd5:
MOV RDI,RAX
MOV RSI,R14
CALL 0x001cae64
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x001cadf9
LAB_001cadea:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001cadf9:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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::__cxx11::string const&) */
void __thiscall
SchemaConverter::resolve_refs(SchemaConverter *this,basic_json *param_1,string *param_2)
{
_lambda_nlohmann__json_abi_v3_11_3__basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>___1_
*local_40;
int8 local_38;
code *local_30;
code *local_28;
local_38 = 0;
local_40 = (_lambda_nlohmann__json_abi_v3_11_3__basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>___1_
*)operator_new(0x20);
*(_lambda_nlohmann__json_abi_v3_11_3__basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>___1_
***)local_40 = &local_40;
*(SchemaConverter **)(local_40 + 8) = this;
*(basic_json **)(local_40 + 0x10) = param_1;
*(string **)(local_40 + 0x18) = param_2;
local_28 = std::
_Function_handler<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>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::__cxx11::string_const&)::{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)#1}>
::_M_invoke;
local_30 = std::
_Function_handler<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>&),SchemaConverter::resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::__cxx11::string_const&)::{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)#1}>
::_M_manager;
/* try { // try from 001cadd5 to 001caddf has its CatchHandler @ 001cae07 */
resolve_refs(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::__cxx11::string_const&)
::
{lambda(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)#1}
::operator()(local_40,param_1);
if (local_30 != (code *)0x0) {
/* try { // try from 001cadea to 001cadf8 has its CatchHandler @ 001cae05 */
(*local_30)(&local_40,&local_40,3);
}
return;
}
|
|
63,164 |
google::protobuf::RepeatedField<unsigned int>::erase(google::protobuf::internal::RepeatedIterator<unsigned int const>, google::protobuf::internal::RepeatedIterator<unsigned int const>)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h
|
inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
const_iterator first, const_iterator last) {
size_type first_offset = first - cbegin();
if (first != last) {
Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
}
return begin() + first_offset;
}
|
O3
|
c
|
google::protobuf::RepeatedField<unsigned int>::erase(google::protobuf::internal::RepeatedIterator<unsigned int const>, google::protobuf::internal::RepeatedIterator<unsigned int const>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq 0x8(%rdi), %rsi
movq %rax, %rbx
subq %rsi, %rbx
cmpq %rdx, %rax
je 0x80b14
movq %rdx, %r15
movq %rdi, %r14
movslq (%rdi), %rax
leaq (%rsi,%rax,4), %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x846d8
shlq $0x1e, %rbx
sarq $0x1e, %rbx
movq (%r12), %rsi
addq %rbx, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x846d8
movq (%r12), %rax
subq %r15, %r13
sarq $0x2, %r13
testq %r13, %r13
jle 0x80afe
incq %r13
movl (%r15), %ecx
movl %ecx, (%rax)
addq $0x4, %r15
addq $0x4, %rax
decq %r13
cmpq $0x1, %r13
ja 0x80ae8
cmpl $0x0, (%r14)
movq 0x8(%r14), %rsi
jle 0x80b1c
subq %rsi, %rax
shrq $0x2, %rax
movl %eax, (%r14)
jmp 0x80b1c
shlq $0x1e, %rbx
sarq $0x1e, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x846d8
addq (%r14), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x846d8
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN6google8protobuf13RepeatedFieldIjE5eraseENS0_8internal16RepeatedIteratorIKjEES6_:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rax, rsi
mov rsi, [rdi+8]
mov rbx, rax
sub rbx, rsi
cmp rax, rdx
jz short loc_80B14
mov r15, rdx
mov r14, rdi
movsxd rax, dword ptr [rdi]
lea r13, [rsi+rax*4]
lea r12, [rsp+38h+var_30]
mov rdi, r12
call _ZN6google8protobuf8internal16RepeatedIteratorIjEC2EPj; google::protobuf::internal::RepeatedIterator<uint>::RepeatedIterator(uint *)
shl rbx, 1Eh
sar rbx, 1Eh
mov rsi, [r12]
add rsi, rbx
lea r12, [rsp+38h+var_30]
mov rdi, r12
call _ZN6google8protobuf8internal16RepeatedIteratorIjEC2EPj; google::protobuf::internal::RepeatedIterator<uint>::RepeatedIterator(uint *)
mov rax, [r12]
sub r13, r15
sar r13, 2
test r13, r13
jle short loc_80AFE
inc r13
loc_80AE8:
mov ecx, [r15]
mov [rax], ecx
add r15, 4
add rax, 4
dec r13
cmp r13, 1
ja short loc_80AE8
loc_80AFE:
cmp dword ptr [r14], 0
mov rsi, [r14+8]
jle short loc_80B1C
sub rax, rsi
shr rax, 2
mov [r14], eax
jmp short loc_80B1C
loc_80B14:
shl rbx, 1Eh
sar rbx, 1Eh
loc_80B1C:
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZN6google8protobuf8internal16RepeatedIteratorIjEC2EPj; google::protobuf::internal::RepeatedIterator<uint>::RepeatedIterator(uint *)
add rbx, [r14]
lea r14, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rbx
call _ZN6google8protobuf8internal16RepeatedIteratorIjEC2EPj; google::protobuf::internal::RepeatedIterator<uint>::RepeatedIterator(uint *)
mov rax, [r14]
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long google::protobuf::RepeatedField<unsigned int>::erase(int *a1, _DWORD *a2, _DWORD *a3)
{
long long v4; // rsi
long long v5; // rbx
_DWORD *v6; // r15
long long v7; // r13
long long v8; // rbx
_DWORD *v9; // rax
long long v10; // r13
long long v11; // r13
bool v12; // cf
_QWORD v14[6]; // [rsp+8h] [rbp-30h] BYREF
v4 = *((_QWORD *)a1 + 1);
v5 = (long long)a2 - v4;
if ( a2 == a3 )
{
v8 = v5 << 30 >> 30;
}
else
{
v6 = a3;
v7 = v4 + 4LL * *a1;
google::protobuf::internal::RepeatedIterator<unsigned int>::RepeatedIterator(v14, v4);
v8 = v5 << 30 >> 30;
google::protobuf::internal::RepeatedIterator<unsigned int>::RepeatedIterator(v14, v8 + v14[0]);
v9 = (_DWORD *)v14[0];
v10 = (v7 - (long long)v6) >> 2;
if ( v10 > 0 )
{
v11 = v10 + 1;
do
{
*v9++ = *v6++;
v12 = v11-- == 1;
}
while ( !v12 && v11 != 1 );
}
v4 = *((_QWORD *)a1 + 1);
if ( *a1 > 0 )
*a1 = ((unsigned long long)v9 - v4) >> 2;
}
google::protobuf::internal::RepeatedIterator<unsigned int>::RepeatedIterator(v14, v4);
google::protobuf::internal::RepeatedIterator<unsigned int>::RepeatedIterator(v14, v14[0] + v8);
return v14[0];
}
|
erase:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RAX,RSI
MOV RSI,qword ptr [RDI + 0x8]
MOV RBX,RAX
SUB RBX,RSI
CMP RAX,RDX
JZ 0x00180b14
MOV R15,RDX
MOV R14,RDI
MOVSXD RAX,dword ptr [RDI]
LEA R13,[RSI + RAX*0x4]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x001846d8
SHL RBX,0x1e
SAR RBX,0x1e
MOV RSI,qword ptr [R12]
ADD RSI,RBX
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x001846d8
MOV RAX,qword ptr [R12]
SUB R13,R15
SAR R13,0x2
TEST R13,R13
JLE 0x00180afe
INC R13
LAB_00180ae8:
MOV ECX,dword ptr [R15]
MOV dword ptr [RAX],ECX
ADD R15,0x4
ADD RAX,0x4
DEC R13
CMP R13,0x1
JA 0x00180ae8
LAB_00180afe:
CMP dword ptr [R14],0x0
MOV RSI,qword ptr [R14 + 0x8]
JLE 0x00180b1c
SUB RAX,RSI
SHR RAX,0x2
MOV dword ptr [R14],EAX
JMP 0x00180b1c
LAB_00180b14:
SHL RBX,0x1e
SAR RBX,0x1e
LAB_00180b1c:
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001846d8
ADD RBX,qword ptr [R14]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001846d8
MOV RAX,qword ptr [R14]
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* google::protobuf::RepeatedField<unsigned
int>::erase(google::protobuf::internal::RepeatedIterator<unsigned int const>,
google::protobuf::internal::RepeatedIterator<unsigned int const>) */
int4 * __thiscall
google::protobuf::RepeatedField<unsigned_int>::erase
(RepeatedField<unsigned_int> *this,int4 *param_2,int4 *param_3)
{
int iVar1;
int4 *puVar2;
long lVar3;
uint *puVar4;
long lVar5;
ulong uVar6;
int4 *local_30;
puVar4 = *(uint **)(this + 8);
if (param_2 == param_3) {
lVar3 = ((long)param_2 - (long)puVar4) * 0x40000000 >> 0x1e;
}
else {
iVar1 = *(int *)this;
internal::RepeatedIterator<unsigned_int>::RepeatedIterator
((RepeatedIterator<unsigned_int> *)&local_30,puVar4);
lVar3 = ((long)param_2 - (long)puVar4) * 0x40000000 >> 0x1e;
internal::RepeatedIterator<unsigned_int>::RepeatedIterator
((RepeatedIterator<unsigned_int> *)&local_30,(uint *)((long)local_30 + lVar3));
lVar5 = (long)puVar4 + ((long)iVar1 * 4 - (long)param_3) >> 2;
puVar2 = local_30;
if (0 < lVar5) {
uVar6 = lVar5 + 1;
do {
*puVar2 = *param_3;
param_3 = param_3 + 1;
puVar2 = puVar2 + 1;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
puVar4 = *(uint **)(this + 8);
if (0 < *(int *)this) {
*(int *)this = (int)((ulong)((long)puVar2 - (long)puVar4) >> 2);
}
}
internal::RepeatedIterator<unsigned_int>::RepeatedIterator
((RepeatedIterator<unsigned_int> *)&local_30,puVar4);
internal::RepeatedIterator<unsigned_int>::RepeatedIterator
((RepeatedIterator<unsigned_int> *)&local_30,(uint *)(lVar3 + (long)local_30));
return local_30;
}
|
|
63,165 |
intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>)
|
corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp
|
inline uint128 udivrem_by2(uint64_t u[], int len, uint128 d) noexcept
{
INTX_REQUIRE(len >= 3);
const auto reciprocal = reciprocal_3by2(d);
auto rem = uint128{u[len - 2], u[len - 1]}; // Set the 2 top words as remainder.
u[len - 1] = u[len - 2] = 0; // Reset these words being a part of the result quotient.
auto it = &u[len - 3];
do
{
std::tie(*it, rem) = udivrem_3by2(rem[1], rem[0], *it, d, reciprocal);
} while (it-- != &u[0]);
return rem;
}
|
O3
|
cpp
|
intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %esi
jle 0x401c2
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x4051c
movq %rax, 0x10(%rsp)
movl %ebp, %eax
leaq (%r12,%rax,8), %r10
addq $-0x18, %r10
movq 0x8(%r10), %rdi
movq 0x10(%r10), %r8
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r10)
leaq 0x8(%rsp), %r11
movq %rsp, %r15
movq %r12, %rcx
movq %r8, %rax
mulq 0x10(%rsp)
movq %rax, %r9
movq %rdx, %rsi
xorl %r13d, %r13d
addq %rdi, %r9
movq (%r10), %rbp
adcq %r8, %rsi
movq %rsi, %rax
imulq %rbx, %rax
subq %rax, %rdi
movq %rsi, %rax
mulq %r14
movq %r13, 0x8(%rsp)
movq %r13, (%rsp)
movb $0x1, %r8b
movq %r11, %r12
movzbl %r13b, %r13d
btl $0x0, %r13d
sbbq %rax, %rbp
setb %r13b
movq %rbp, (%r12)
movq %rdx, %rax
movq %rdi, %rbp
movq %r15, %r12
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x4008b
movq 0x8(%rsp), %r8
movq (%rsp), %rax
xorl %edx, %edx
movq %rdx, 0x8(%rsp)
movq %rdx, (%rsp)
movb $0x1, %dil
movq %r14, %r12
movq %r11, %r13
movzbl %dl, %edx
btl $0x0, %edx
sbbq %r12, %r8
setb %dl
movq %r8, (%r13)
movq %rbx, %r12
movq %rax, %r8
movq %r15, %r13
testb $0x1, %dil
movl $0x0, %edi
jne 0x400d1
movq 0x8(%rsp), %rdi
movq (%rsp), %r8
cmpq %r9, %r8
jae 0x40109
incq %rsi
jmp 0x40149
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movb $0x1, %dl
movq %r14, %r9
movq %r11, %r12
movzbl %al, %eax
btl $0x0, %eax
adcq %rdi, %r9
setb %al
movq %r9, (%r12)
movq %rbx, %r9
movq %r8, %rdi
movq %r15, %r12
testb $0x1, %dl
movl $0x0, %edx
jne 0x4011c
movq 0x8(%rsp), %rdi
movq (%rsp), %r8
cmpq %r14, %rdi
movq %r8, %rax
sbbq %rbx, %rax
jb 0x40197
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movb $0x1, %dl
movq %r14, %r9
movq %r11, %r12
movzbl %al, %eax
btl $0x0, %eax
sbbq %r9, %rdi
setb %al
movq %rdi, (%r12)
movq %rbx, %r9
movq %r8, %rdi
movq %r15, %r12
testb $0x1, %dl
movl $0x0, %edx
jne 0x40167
incq %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %r8
movq %rcx, %r12
movq %rsi, (%r10)
leaq -0x8(%r10), %rax
cmpq %rcx, %r10
movq %rax, %r10
jne 0x4004f
movq %rdi, %rax
movq %r8, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43f06(%rip), %rdi # 0x840cf
leaq 0x43d8e(%rip), %rsi # 0x83f5e
leaq 0x43eb9(%rip), %rcx # 0x84090
movl $0x65c, %edx # imm = 0x65C
callq 0x22110
|
_ZN4intx8internal11udivrem_by2EPmiNS_4uintILj128EEE:
push rbp
push r15
push r14
loc_40000:
push r13
push r12
push rbx
sub rsp, 18h
cmp esi, 2
jle loc_401C2
mov rbx, rcx
mov r14, rdx
mov ebp, esi
mov r12, rdi
mov rdi, rdx
mov rsi, rcx
call _ZN4intx15reciprocal_3by2ENS_4uintILj128EEE; intx::reciprocal_3by2(intx::uint<128u>)
mov [rsp+48h+var_38], rax
mov eax, ebp
lea r10, [r12+rax*8]
add r10, 0FFFFFFFFFFFFFFE8h
mov rdi, [r10+8]
mov r8, [r10+10h]
xorps xmm0, xmm0
movups xmmword ptr [r10+8], xmm0
lea r11, [rsp+48h+var_40]
mov r15, rsp
loc_4004F:
mov rcx, r12
mov rax, r8
mul [rsp+48h+var_38]
mov r9, rax
mov rsi, rdx
xor r13d, r13d
add r9, rdi
mov rbp, [r10]
adc rsi, r8
mov rax, rsi
imul rax, rbx
sub rdi, rax
mov rax, rsi
mul r14
mov [rsp+48h+var_40], r13
mov [rsp+48h+var_48], r13
mov r8b, 1
mov r12, r11
loc_4008B:
movzx r13d, r13b
bt r13d, 0
sbb rbp, rax
setb r13b
mov [r12], rbp
mov rax, rdx
mov rbp, rdi
mov r12, r15
test r8b, 1
mov r8d, 0
jnz short loc_4008B
mov r8, [rsp+48h+var_40]
mov rax, [rsp+48h+var_48]
xor edx, edx
mov [rsp+48h+var_40], rdx
mov [rsp+48h+var_48], rdx
mov dil, 1
mov r12, r14
mov r13, r11
loc_400D1:
movzx edx, dl
bt edx, 0
sbb r8, r12
setb dl
mov [r13+0], r8
mov r12, rbx
mov r8, rax
mov r13, r15
test dil, 1
mov edi, 0
jnz short loc_400D1
mov rdi, [rsp+48h+var_40]
mov r8, [rsp+48h+var_48]
cmp r8, r9
jnb short loc_40109
inc rsi
jmp short loc_40149
loc_40109:
xor eax, eax
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_48], rax
mov dl, 1
mov r9, r14
mov r12, r11
loc_4011C:
movzx eax, al
bt eax, 0
adc r9, rdi
setb al
mov [r12], r9
mov r9, rbx
mov rdi, r8
mov r12, r15
test dl, 1
mov edx, 0
jnz short loc_4011C
mov rdi, [rsp+48h+var_40]
mov r8, [rsp+48h+var_48]
loc_40149:
cmp rdi, r14
mov rax, r8
sbb rax, rbx
jb short loc_40197
xor eax, eax
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_48], rax
mov dl, 1
mov r9, r14
mov r12, r11
loc_40167:
movzx eax, al
bt eax, 0
sbb rdi, r9
setb al
mov [r12], rdi
mov r9, rbx
mov rdi, r8
mov r12, r15
test dl, 1
mov edx, 0
jnz short loc_40167
inc rsi
mov rdi, [rsp+48h+var_40]
mov r8, [rsp+48h+var_48]
loc_40197:
mov r12, rcx
mov [r10], rsi
lea rax, [r10-8]
cmp r10, rcx
mov r10, rax
jnz loc_4004F
mov rax, rdi
mov rdx, r8
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_401C2:
lea rdi, aDlen3+1; "len >= 3"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aUint128IntxInt; "uint128 intx::internal::udivrem_by2(uin"...
mov edx, 65Ch
call ___assert_fail
|
long long intx::internal::udivrem_by2(__int128 a1, unsigned long long a2, unsigned long long a3)
{
_QWORD *v5; // r12
_QWORD *v6; // r10
unsigned long long v7; // r8
_QWORD *v8; // rcx
bool v9; // r13
unsigned long long v10; // kr10_8
unsigned long long v11; // rbp
unsigned __int128 v12; // rax
char v13; // r8
unsigned long long *v14; // r12
bool v15; // cf
unsigned long long v16; // rbp
bool v17; // zf
unsigned long long v18; // r8
unsigned long long v19; // rax
bool v20; // dl
char v21; // di
unsigned long long v22; // r12
unsigned long long *v23; // r13
unsigned long long v24; // r8
char v25; // al
char v26; // dl
unsigned long long v27; // r9
unsigned long long *v28; // r12
unsigned long long v29; // r9
bool v30; // al
char v31; // dl
unsigned long long v32; // r9
unsigned long long *v33; // r12
unsigned long long v34; // rdi
unsigned long long v36; // [rsp+0h] [rbp-48h] BYREF
unsigned long long v37; // [rsp+8h] [rbp-40h] BYREF
long long v38; // [rsp+10h] [rbp-38h]
if ( SDWORD2(a1) <= 2 )
__assert_fail(
"len >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp",
1628LL,
"uint128 intx::internal::udivrem_by2(uint64_t *, int, uint128)");
v5 = (_QWORD *)a1;
v38 = intx::reciprocal_3by2(a2, a3);
v6 = (_QWORD *)(a1 + 8LL * DWORD2(a1) - 24);
*(_QWORD *)&a1 = v6[1];
v7 = v6[2];
*(_OWORD *)(v6 + 1) = 0LL;
do
{
v8 = v5;
*((_QWORD *)&a1 + 1) = ((unsigned long long)v38 * (unsigned __int128)v7) >> 64;
v9 = 0;
v11 = *v6;
v10 = a1 + v38 * v7;
*((_QWORD *)&a1 + 1) = (a1 + __PAIR128__(v7, v38 * v7)) >> 64;
*(_QWORD *)&a1 = a1 - a3 * *((_QWORD *)&a1 + 1);
v12 = a2 * (unsigned __int128)*((unsigned long long *)&a1 + 1);
v37 = 0LL;
v36 = 0LL;
v13 = 1;
v14 = &v37;
do
{
v15 = v11 < v9 + (unsigned long long)v12;
v16 = v11 - (v9 + (_QWORD)v12);
v9 = v15;
*v14 = v16;
*(_QWORD *)&v12 = *((_QWORD *)&v12 + 1);
v11 = a1;
v14 = &v36;
v17 = (v13 & 1) == 0;
v13 = 0;
}
while ( !v17 );
v18 = v37;
v19 = v36;
v20 = 0;
v37 = 0LL;
v36 = 0LL;
v21 = 1;
v22 = a2;
v23 = &v37;
do
{
v15 = v18 < v20 + v22;
v24 = v18 - (v20 + v22);
v20 = v15;
*v23 = v24;
v22 = a3;
v18 = v19;
v23 = &v36;
v17 = (v21 & 1) == 0;
v21 = 0;
}
while ( !v17 );
*(_QWORD *)&a1 = v37;
v7 = v36;
if ( v36 >= v10 )
{
v25 = 0;
v37 = 0LL;
v36 = 0LL;
v26 = 1;
v27 = a2;
v28 = &v37;
do
{
v15 = __CFADD__((v25 & 1) != 0, v27);
v29 = ((v25 & 1) != 0) + v27;
v25 = v15 | __CFADD__((_QWORD)a1, v29);
*v28 = a1 + v29;
v27 = a3;
*(_QWORD *)&a1 = v7;
v28 = &v36;
v17 = (v26 & 1) == 0;
v26 = 0;
}
while ( !v17 );
*(_QWORD *)&a1 = v37;
v7 = v36;
}
else
{
++*((_QWORD *)&a1 + 1);
}
if ( __PAIR128__(v7, a1) >= __PAIR128__(a3, a2) )
{
v30 = 0;
v37 = 0LL;
v36 = 0LL;
v31 = 1;
v32 = a2;
v33 = &v37;
do
{
v15 = (unsigned long long)a1 < v30 + v32;
v34 = a1 - (v30 + v32);
v30 = v15;
*v33 = v34;
v32 = a3;
*(_QWORD *)&a1 = v7;
v33 = &v36;
v17 = (v31 & 1) == 0;
v31 = 0;
}
while ( !v17 );
++*((_QWORD *)&a1 + 1);
*(_QWORD *)&a1 = v37;
v7 = v36;
}
v5 = v8;
*v6 = *((_QWORD *)&a1 + 1);
v17 = v6-- == v8;
}
while ( !v17 );
return a1;
}
|
udivrem_by2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP ESI,0x2
JLE 0x001401c2
MOV RBX,RCX
MOV R14,RDX
MOV EBP,ESI
MOV R12,RDI
MOV RDI,RDX
MOV RSI,RCX
CALL 0x0014051c
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,EBP
LEA R10,[R12 + RAX*0x8]
ADD R10,-0x18
MOV RDI,qword ptr [R10 + 0x8]
MOV R8,qword ptr [R10 + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R10 + 0x8],XMM0
LEA R11,[RSP + 0x8]
MOV R15,RSP
LAB_0014004f:
MOV RCX,R12
MOV RAX,R8
MUL qword ptr [RSP + 0x10]
MOV R9,RAX
MOV RSI,RDX
XOR R13D,R13D
ADD R9,RDI
MOV RBP,qword ptr [R10]
ADC RSI,R8
MOV RAX,RSI
IMUL RAX,RBX
SUB RDI,RAX
MOV RAX,RSI
MUL R14
MOV qword ptr [RSP + 0x8],R13
MOV qword ptr [RSP],R13
MOV R8B,0x1
MOV R12,R11
LAB_0014008b:
MOVZX R13D,R13B
BT R13D,0x0
SBB RBP,RAX
SETC R13B
MOV qword ptr [R12],RBP
MOV RAX,RDX
MOV RBP,RDI
MOV R12,R15
TEST R8B,0x1
MOV R8D,0x0
JNZ 0x0014008b
MOV R8,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
XOR EDX,EDX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RDX
MOV DIL,0x1
MOV R12,R14
MOV R13,R11
LAB_001400d1:
MOVZX EDX,DL
BT EDX,0x0
SBB R8,R12
SETC DL
MOV qword ptr [R13],R8
MOV R12,RBX
MOV R8,RAX
MOV R13,R15
TEST DIL,0x1
MOV EDI,0x0
JNZ 0x001400d1
MOV RDI,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP]
CMP R8,R9
JNC 0x00140109
INC RSI
JMP 0x00140149
LAB_00140109:
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],RAX
MOV DL,0x1
MOV R9,R14
MOV R12,R11
LAB_0014011c:
MOVZX EAX,AL
BT EAX,0x0
ADC R9,RDI
SETC AL
MOV qword ptr [R12],R9
MOV R9,RBX
MOV RDI,R8
MOV R12,R15
TEST DL,0x1
MOV EDX,0x0
JNZ 0x0014011c
MOV RDI,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP]
LAB_00140149:
CMP RDI,R14
MOV RAX,R8
SBB RAX,RBX
JC 0x00140197
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],RAX
MOV DL,0x1
MOV R9,R14
MOV R12,R11
LAB_00140167:
MOVZX EAX,AL
BT EAX,0x0
SBB RDI,R9
SETC AL
MOV qword ptr [R12],RDI
MOV R9,RBX
MOV RDI,R8
MOV R12,R15
TEST DL,0x1
MOV EDX,0x0
JNZ 0x00140167
INC RSI
MOV RDI,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP]
LAB_00140197:
MOV R12,RCX
MOV qword ptr [R10],RSI
LEA RAX,[R10 + -0x8]
CMP R10,RCX
MOV R10,RAX
JNZ 0x0014004f
MOV RAX,RDI
MOV RDX,R8
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001401c2:
LEA RDI,[0x1840cf]
LEA RSI,[0x183f5e]
LEA RCX,[0x184090]
MOV EDX,0x65c
CALL 0x00122110
|
/* intx::internal::udivrem_by2(unsigned long*, int, intx::uint<128u>) */
int1 [16] __thiscall
intx::internal::udivrem_by2(internal *this,uint param_2,intx *param_3,intx *param_4)
{
ulong uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
intx *piVar7;
ulong uVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
intx *piVar13;
intx *piVar14;
bool bVar15;
intx *piVar16;
intx *piVar17;
internal *piVar18;
intx **ppiVar19;
bool bVar20;
bool bVar21;
int1 auVar22 [16];
intx *local_48;
intx *local_40 [2];
if ((int)param_2 < 3) {
/* WARNING: Subroutine does not return */
__assert_fail("len >= 3",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O3/_deps/intx-src/include/intx/intx.hpp"
,0x65c,"uint128 intx::internal::udivrem_by2(uint64_t *, int, uint128)");
}
uVar8 = reciprocal_3by2(param_3,param_4);
local_40[0] = *(intx **)(this + (ulong)param_2 * 8 + -0x10);
local_48 = *(intx **)(this + (ulong)param_2 * 8 + -8);
*(int8 *)(this + (ulong)param_2 * 8 + -0x10) = 0;
*(int8 *)(this + (ulong)param_2 * 8 + -8) = 0;
piVar18 = this + (ulong)param_2 * 8 + -0x18;
do {
auVar6._8_8_ = local_48;
auVar6._0_8_ = local_40[0];
auVar2._8_8_ = 0;
auVar2._0_8_ = local_48;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar8;
bVar20 = false;
auVar6 = auVar2 * auVar4 + auVar6;
uVar11 = auVar6._8_8_;
uVar12 = (long)local_40[0] - uVar11 * (long)param_4;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = param_3;
local_40[0] = (intx *)0x0;
local_48 = (intx *)0x0;
uVar9 = SUB168(auVar3 * auVar5,0);
uVar10 = *(ulong *)piVar18;
ppiVar19 = local_40;
bVar21 = true;
do {
bVar15 = bVar21;
uVar1 = (ulong)bVar20;
bVar20 = uVar10 < uVar9 || uVar10 - uVar9 < uVar1;
*ppiVar19 = (intx *)((uVar10 - uVar9) - uVar1);
piVar14 = local_40[0];
piVar17 = local_48;
uVar9 = SUB168(auVar3 * auVar5,8);
uVar10 = uVar12;
ppiVar19 = &local_48;
bVar21 = false;
} while (bVar15);
bVar20 = false;
local_40[0] = (intx *)0x0;
local_48 = (intx *)0x0;
piVar16 = param_3;
ppiVar19 = local_40;
bVar21 = true;
do {
bVar15 = bVar21;
uVar9 = (ulong)bVar20;
bVar20 = piVar14 < piVar16 || (ulong)((long)piVar14 - (long)piVar16) < uVar9;
*ppiVar19 = (intx *)(((long)piVar14 - (long)piVar16) - uVar9);
piVar13 = local_40[0];
piVar7 = local_48;
piVar14 = piVar17;
piVar16 = param_4;
ppiVar19 = &local_48;
bVar21 = false;
} while (bVar15);
if (local_48 < auVar6._0_8_) {
uVar11 = uVar11 + 1;
piVar14 = local_40[0];
piVar16 = local_48;
}
else {
bVar20 = false;
local_40[0] = (intx *)0x0;
local_48 = (intx *)0x0;
piVar17 = param_3;
ppiVar19 = local_40;
bVar21 = true;
do {
bVar15 = bVar21;
uVar9 = (ulong)bVar20;
bVar20 = CARRY8((ulong)piVar17,(ulong)piVar13) ||
CARRY8((ulong)(piVar17 + (long)piVar13),uVar9);
*ppiVar19 = piVar17 + (long)piVar13 + uVar9;
piVar14 = local_40[0];
piVar13 = piVar7;
piVar16 = local_48;
piVar17 = param_4;
ppiVar19 = &local_48;
bVar21 = false;
} while (bVar15);
}
local_40[0] = piVar14;
local_48 = piVar16;
if (param_4 <= piVar16 && (ulong)(piVar14 < param_3) <= (ulong)((long)piVar16 - (long)param_4))
{
bVar20 = false;
local_40[0] = (intx *)0x0;
local_48 = (intx *)0x0;
piVar17 = param_3;
ppiVar19 = local_40;
bVar21 = true;
do {
bVar15 = bVar21;
uVar9 = (ulong)bVar20;
bVar20 = piVar14 < piVar17 || (ulong)((long)piVar14 - (long)piVar17) < uVar9;
*ppiVar19 = (intx *)(((long)piVar14 - (long)piVar17) - uVar9);
piVar14 = piVar16;
piVar17 = param_4;
ppiVar19 = &local_48;
bVar21 = false;
} while (bVar15);
uVar11 = uVar11 + 1;
}
*(ulong *)piVar18 = uVar11;
bVar21 = piVar18 != this;
piVar18 = piVar18 + -8;
} while (bVar21);
auVar22._8_8_ = local_48;
auVar22._0_8_ = local_40[0];
return auVar22;
}
|
|
63,166 |
mysql_stmt_send_long_data
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number,
const char *data, unsigned long length)
{
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
if (stmt->state < MYSQL_STMT_PREPARED || !stmt->params)
{
SET_CLIENT_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (param_number >= stmt->param_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_INVALID_PARAMETER_NO, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (length || !stmt->params[param_number].long_data_used)
{
int ret;
size_t packet_len= STMT_ID_LENGTH + 2 + length;
uchar *cmd_buff= (uchar *)calloc(1, packet_len);
int4store(cmd_buff, stmt->stmt_id);
int2store(cmd_buff + STMT_ID_LENGTH, param_number);
memcpy(cmd_buff + STMT_ID_LENGTH + 2, data, length);
stmt->params[param_number].long_data_used= 1;
ret= stmt->mysql->methods->db_command(stmt->mysql, COM_STMT_SEND_LONG_DATA,
(char *)cmd_buff, packet_len, 1, stmt);
if (ret)
UPDATE_STMT_ERROR(stmt);
free(cmd_buff);
return(ret);
}
return(0);
}
|
O3
|
c
|
mysql_stmt_send_long_data:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movl %esi, %ecx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movl $0x0, 0x90(%rax)
movq 0x38(%rdi), %rax
movw $0x30, 0x29b(%rax)
movl $0x30303030, 0x297(%rax) # imm = 0x30303030
movq 0x38(%rdi), %rax
movb $0x0, 0x97(%rax)
movq 0x38(%rdi), %rax
movq 0x2a0(%rax), %rax
testq %rax, %rax
je 0x2715c
movl $0x0, 0x4(%rax)
movl $0x0, 0x108(%rbx)
leaq 0x30d(%rbx), %r15
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
leaq 0x10c(%rbx), %r14
movb $0x0, 0x10c(%rbx)
cmpl $0x0, 0x50(%rbx)
je 0x272a0
movq 0x70(%rbx), %r13
testq %r13, %r13
je 0x272a0
cmpl %ecx, 0x64(%rbx)
jbe 0x272db
movl %ecx, %r8d
testq %r12, %r12
je 0x2733d
movq %r14, -0x30(%rbp)
leaq 0x6(%r12), %rsi
movq %rsi, -0x48(%rbp)
movl $0x1, %edi
movq %r8, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movl %ecx, %r14d
callq 0x132e0
movq 0x40(%rbx), %rdx
movb %dl, (%rax)
movb %dh, 0x1(%rax)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, 0x2(%rax)
shrl $0x18, %edx
movb %dl, 0x3(%rax)
movl %r14d, %ecx
movb %cl, 0x4(%rax)
movb %ch, 0x5(%rax)
leaq 0x6(%rax), %rdi
movq %rax, %r14
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x13390
imulq $0x70, -0x40(%rbp), %rax
movb $0x1, 0x66(%r13,%rax)
movq 0x38(%rbx), %rdi
movq 0x4d0(%rdi), %rax
movl $0x18, %esi
movq %r14, %r13
movq %r14, %rdx
movq -0x48(%rbp), %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
movl %eax, %r12d
testl %eax, %eax
je 0x27293
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
movq %r15, %rdi
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x312(%rbx)
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
movq -0x30(%rbp), %rdi
callq 0x13220
movb %r15b, 0x30b(%rbx)
movq %r13, %rdi
callq 0x13570
jmp 0x2732b
movl $0x7ee, 0x108(%rbx) # imm = 0x7EE
leaq 0x29c2f(%rip), %rax # 0x50ee0
movq (%rax), %rsi
movl $0x5, %edx
movq %r15, %rdi
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x312(%rbx)
leaq 0x29c1e(%rip), %rax # 0x50ef0
movq 0xf0(%rax), %rsi
jmp 0x27314
movl $0x7f2, 0x108(%rbx) # imm = 0x7F2
leaq 0x29bf4(%rip), %rax # 0x50ee0
movq (%rax), %rsi
movl $0x5, %edx
movq %r15, %rdi
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x312(%rbx)
leaq 0x29be3(%rip), %rax # 0x50ef0
movq 0x110(%rax), %rsi
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
callq 0x13220
movb %r15b, 0x30b(%rbx)
movb $0x1, %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
imulq $0x70, %r8, %rax
cmpb $0x0, 0x66(%r13,%rax)
je 0x271ba
xorl %r12d, %r12d
jmp 0x2732b
|
mysql_stmt_send_long_data:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, rcx
mov ecx, esi
mov rbx, rdi
mov rax, [rdi+38h]
mov dword ptr [rax+90h], 0
mov rax, [rdi+38h]
mov word ptr [rax+29Bh], 30h ; '0'
mov dword ptr [rax+297h], 30303030h
mov rax, [rdi+38h]
mov byte ptr [rax+97h], 0
mov rax, [rdi+38h]
mov rax, [rax+2A0h]
test rax, rax
jz short loc_2715C
mov dword ptr [rax+4], 0
loc_2715C:
mov dword ptr [rbx+108h], 0
lea r15, [rbx+30Dh]
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
lea r14, [rbx+10Ch]
mov byte ptr [rbx+10Ch], 0
cmp dword ptr [rbx+50h], 0
jz loc_272A0
mov r13, [rbx+70h]
test r13, r13
jz loc_272A0
cmp [rbx+64h], ecx
jbe loc_272DB
mov r8d, ecx
test r12, r12
jz loc_2733D
loc_271BA:
mov [rbp+var_30], r14
lea rsi, [r12+6]
mov [rbp+var_48], rsi
mov edi, 1
mov [rbp+var_40], r8
mov [rbp+var_38], rdx
mov r14d, ecx
call _calloc
mov rdx, [rbx+40h]
mov [rax], dl
mov [rax+1], dh
mov ecx, edx
shr ecx, 10h
mov [rax+2], cl
shr edx, 18h
mov [rax+3], dl
mov ecx, r14d
mov [rax+4], cl
mov [rax+5], ch
lea rdi, [rax+6]
mov r14, rax
mov rsi, [rbp+var_38]
mov rdx, r12
call _memcpy
imul rax, [rbp+var_40], 70h ; 'p'
mov byte ptr [r13+rax+66h], 1
mov rdi, [rbx+38h]
mov rax, [rdi+4D0h]
mov esi, 18h
mov r13, r14
mov rdx, r14
mov rcx, [rbp+var_48]
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
mov r12d, eax
test eax, eax
jz short loc_27293
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
add rsi, 297h
mov edx, 5
mov rdi, r15
call _strncpy
xor r15d, r15d
mov [rbx+312h], r15b
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
mov rdi, [rbp+var_30]
call _strncpy
mov [rbx+30Bh], r15b
loc_27293:
mov rdi, r13
call _free
jmp loc_2732B
loc_272A0:
mov dword ptr [rbx+108h], 7EEh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
mov rdi, r15
call _strncpy
xor r15d, r15d
mov [rbx+312h], r15b
lea rax, client_errors
mov rsi, [rax+0F0h]
jmp short loc_27314
loc_272DB:
mov dword ptr [rbx+108h], 7F2h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
mov rdi, r15
call _strncpy
xor r15d, r15d
mov [rbx+312h], r15b
lea rax, client_errors
mov rsi, [rax+110h]
loc_27314:
mov edx, 200h
mov rdi, r14
call _strncpy
mov [rbx+30Bh], r15b
mov r12b, 1
loc_2732B:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2733D:
imul rax, r8, 70h ; 'p'
cmp byte ptr [r13+rax+66h], 0
jz loc_271BA
xor r12d, r12d
jmp short loc_2732B
|
long long mysql_stmt_send_long_data(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // r12
long long v5; // rax
long long v6; // r13
long long v7; // rax
long long v8; // rdx
long long v9; // r14
long long v10; // rsi
char *v11; // rsi
v4 = a4;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v5 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v5 )
*(_DWORD *)(v5 + 4) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
if ( !*(_DWORD *)(a1 + 80) || (v6 = *(_QWORD *)(a1 + 112)) == 0 )
{
*(_DWORD *)(a1 + 264) = 2030;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v11 = client_errors[30];
LABEL_12:
strncpy(a1 + 268, v11, 512LL);
*(_BYTE *)(a1 + 779) = 0;
LOBYTE(v4) = 1;
return (unsigned int)v4;
}
if ( *(_DWORD *)(a1 + 100) <= a2 )
{
*(_DWORD *)(a1 + 264) = 2034;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v11 = client_errors[34];
goto LABEL_12;
}
if ( a4 || !*(_BYTE *)(v6 + 112LL * a2 + 102) )
{
v7 = calloc(1LL, a4 + 6);
v8 = *(_QWORD *)(a1 + 64);
*(_WORD *)v7 = v8;
*(_BYTE *)(v7 + 2) = BYTE2(v8);
*(_BYTE *)(v7 + 3) = BYTE3(v8);
*(_WORD *)(v7 + 4) = a2;
v9 = v7;
memcpy(v7 + 6, a3, v4);
*(_BYTE *)(v6 + 112LL * a2 + 102) = 1;
LODWORD(v4) = (*(long long ( **)(_QWORD, long long, long long, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
*(_QWORD *)(a1 + 56),
24LL,
v9,
v4 + 6,
1LL,
a1);
if ( (_DWORD)v4 )
{
v10 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v10 + 144);
strncpy(a1 + 781, v10 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
}
free(v9);
}
else
{
LODWORD(v4) = 0;
}
return (unsigned int)v4;
}
|
mysql_stmt_send_long_data:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,RCX
MOV ECX,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x38]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RDI + 0x38]
MOV word ptr [RAX + 0x29b],0x30
MOV dword ptr [RAX + 0x297],0x30303030
MOV RAX,qword ptr [RDI + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
TEST RAX,RAX
JZ 0x0012715c
MOV dword ptr [RAX + 0x4],0x0
LAB_0012715c:
MOV dword ptr [RBX + 0x108],0x0
LEA R15,[RBX + 0x30d]
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
LEA R14,[RBX + 0x10c]
MOV byte ptr [RBX + 0x10c],0x0
CMP dword ptr [RBX + 0x50],0x0
JZ 0x001272a0
MOV R13,qword ptr [RBX + 0x70]
TEST R13,R13
JZ 0x001272a0
CMP dword ptr [RBX + 0x64],ECX
JBE 0x001272db
MOV R8D,ECX
TEST R12,R12
JZ 0x0012733d
LAB_001271ba:
MOV qword ptr [RBP + -0x30],R14
LEA RSI,[R12 + 0x6]
MOV qword ptr [RBP + -0x48],RSI
MOV EDI,0x1
MOV qword ptr [RBP + -0x40],R8
MOV qword ptr [RBP + -0x38],RDX
MOV R14D,ECX
CALL 0x001132e0
MOV RDX,qword ptr [RBX + 0x40]
MOV byte ptr [RAX],DL
MOV byte ptr [RAX + 0x1],DH
MOV ECX,EDX
SHR ECX,0x10
MOV byte ptr [RAX + 0x2],CL
SHR EDX,0x18
MOV byte ptr [RAX + 0x3],DL
MOV ECX,R14D
MOV byte ptr [RAX + 0x4],CL
MOV byte ptr [RAX + 0x5],CH
LEA RDI,[RAX + 0x6]
MOV R14,RAX
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R12
CALL 0x00113390
IMUL RAX,qword ptr [RBP + -0x40],0x70
MOV byte ptr [R13 + RAX*0x1 + 0x66],0x1
MOV RDI,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ESI,0x18
MOV R13,R14
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x48]
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
MOV R12D,EAX
TEST EAX,EAX
JZ 0x00127293
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
ADD RSI,0x297
MOV EDX,0x5
MOV RDI,R15
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [RBX + 0x312],R15B
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R15B
LAB_00127293:
MOV RDI,R13
CALL 0x00113570
JMP 0x0012732b
LAB_001272a0:
MOV dword ptr [RBX + 0x108],0x7ee
LEA RAX,[0x150ee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
MOV RDI,R15
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [RBX + 0x312],R15B
LEA RAX,[0x150ef0]
MOV RSI,qword ptr [RAX + 0xf0]
JMP 0x00127314
LAB_001272db:
MOV dword ptr [RBX + 0x108],0x7f2
LEA RAX,[0x150ee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
MOV RDI,R15
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [RBX + 0x312],R15B
LEA RAX,[0x150ef0]
MOV RSI,qword ptr [RAX + 0x110]
LAB_00127314:
MOV EDX,0x200
MOV RDI,R14
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R15B
MOV R12B,0x1
LAB_0012732b:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012733d:
IMUL RAX,R8,0x70
CMP byte ptr [R13 + RAX*0x1 + 0x66],0x0
JZ 0x001271ba
XOR R12D,R12D
JMP 0x0012732b
|
ulong mysql_stmt_send_long_data(long param_1,uint param_2,void *param_3,size_t param_4)
{
long lVar1;
int8 uVar2;
uint uVar3;
int1 *__ptr;
char *pcVar4;
ulong uVar5;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
pcVar4 = (char *)(param_1 + 0x30d);
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
if ((*(int *)(param_1 + 0x50) == 0) || (lVar1 = *(long *)(param_1 + 0x70), lVar1 == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7ee;
strncpy(pcVar4,SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
pcVar4 = PTR_s_Statement_is_not_prepared_00150fe0;
}
else {
if (param_2 < *(uint *)(param_1 + 100)) {
if ((param_4 == 0) && (*(char *)(lVar1 + 0x66 + (ulong)param_2 * 0x70) != '\0')) {
uVar5 = 0;
}
else {
__ptr = (int1 *)calloc(1,param_4 + 6);
uVar2 = *(int8 *)(param_1 + 0x40);
*__ptr = (char)uVar2;
__ptr[1] = (char)((ulong)uVar2 >> 8);
__ptr[2] = (char)((ulong)uVar2 >> 0x10);
__ptr[3] = (char)((ulong)uVar2 >> 0x18);
__ptr[4] = (char)param_2;
__ptr[5] = (char)(param_2 >> 8);
memcpy(__ptr + 6,param_3,param_4);
*(int1 *)(lVar1 + 0x66 + (ulong)param_2 * 0x70) = 1;
uVar3 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(*(long *)(param_1 + 0x38),0x18,__ptr,param_4 + 6,1,param_1);
uVar5 = (ulong)uVar3;
if (uVar3 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy(pcVar4,(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
}
free(__ptr);
}
goto LAB_0012732b;
}
*(int4 *)(param_1 + 0x108) = 0x7f2;
strncpy(pcVar4,SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
pcVar4 = PTR_s_Invalid_parameter_number_00151000;
}
strncpy((char *)(param_1 + 0x10c),pcVar4,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar5 = CONCAT71((int7)(param_4 >> 8),1);
LAB_0012732b:
return uVar5 & 0xffffffff;
}
|
|
63,167 |
mysql_stmt_prepare_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_prepare_start(int *ret, MYSQL_STMT *stmt, const char *query,
unsigned long length)
{
MK_ASYNC_START_BODY(
mysql_stmt_prepare,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
parms.query= query;
parms.length= length;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_prepare(stmt, query, length);
return 0;
})
}
|
O3
|
c
|
mysql_stmt_prepare_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x32a1e
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x30(%rbp), %rax
movq %r14, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xae(%rip), %rsi # 0x32aac
movq %rax, %rdx
callq 0x345f8
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x32a2e
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x32aa1
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x27d1c
jmp 0x32a9d
js 0x32a36
movl 0x8(%r15), %eax
jmp 0x32a9d
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1f7bc(%rip), %rax # 0x52210
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1f7a1(%rip), %rax # 0x52220
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stmt_prepare_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
test rax, rax
jz short loc_32A1E
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rax, [rbp+var_30]
mov [rax], r14
mov [rax+8], rdx
mov [rax+10h], rcx
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_stmt_prepare_start_internal
mov rdx, rax
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_32A2E
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp loc_32AA1
loc_32A1E:
mov rdi, r14
mov rsi, rdx
mov rdx, rcx
call mysql_stmt_prepare
jmp short loc_32A9D
loc_32A2E:
js short loc_32A36
mov eax, [r15+8]
jmp short loc_32A9D
loc_32A36:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov eax, 1
loc_32A9D:
mov [rbx], eax
xor eax, eax
loc_32AA1:
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_stmt_prepare_start(int *a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
unsigned int *v5; // r15
int v6; // eax
int v8; // eax
_QWORD v9[6]; // [rsp+0h] [rbp-30h] BYREF
v4 = *(_QWORD *)(a2 + 56);
if ( v4 )
{
v5 = *(unsigned int **)(*(_QWORD *)(v4 + 1152) + 40LL);
v9[0] = a2;
v9[1] = a3;
v9[2] = a4;
*((_BYTE *)v5 + 20) = 1;
v6 = my_context_spawn(v5 + 14, mysql_stmt_prepare_start_internal, v9);
*((_WORD *)v5 + 10) = 0;
if ( v6 > 0 )
{
*((_BYTE *)v5 + 21) = 1;
return *v5;
}
if ( v6 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v8 = 1;
}
else
{
v8 = v5[2];
}
}
else
{
v8 = mysql_stmt_prepare(a2, a3, a4);
}
*a1 = v8;
return 0LL;
}
|
mysql_stmt_prepare_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
TEST RAX,RAX
JZ 0x00132a1e
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RAX,[RBP + -0x30]
MOV qword ptr [RAX],R14
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RAX + 0x10],RCX
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x132aac]
MOV RDX,RAX
CALL 0x001345f8
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x00132a2e
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x00132aa1
LAB_00132a1e:
MOV RDI,R14
MOV RSI,RDX
MOV RDX,RCX
CALL 0x00127d1c
JMP 0x00132a9d
LAB_00132a2e:
JS 0x00132a36
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x00132a9d
LAB_00132a36:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152210]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x152220]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV EAX,0x1
LAB_00132a9d:
MOV dword ptr [RBX],EAX
XOR EAX,EAX
LAB_00132aa1:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4
mysql_stmt_prepare_start(int4 *param_1,long param_2,int8 param_3,int8 param_4)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
long local_38;
int8 local_30;
int8 local_28;
if (*(long *)(param_2 + 0x38) == 0) {
uVar3 = mysql_stmt_prepare(param_2,param_3,param_4);
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
local_38 = param_2;
local_30 = param_3;
local_28 = param_4;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_stmt_prepare_start_internal,&local_38);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00152260,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
}
*param_1 = uVar3;
return 0;
}
|
|
63,168 |
get_record_position
|
eloqsql/storage/maria/ma_blockrec.c
|
static uchar *get_record_position(MARIA_SHARE *share, uchar *buff,
uint record_number, uchar **end_of_data)
{
uint block_size= share->block_size;
uint number_of_records= (uint) buff[DIR_COUNT_OFFSET];
uchar *dir;
uchar *data;
uint offset, length;
#ifdef SANITY_CHECKS
if (record_number >= number_of_records ||
record_number > ((block_size - PAGE_HEADER_SIZE(share) - PAGE_SUFFIX_SIZE)
/ DIR_ENTRY_SIZE))
{
DBUG_PRINT("error",
("Wrong row number: record_number: %u number_of_records: %u",
record_number, number_of_records));
return 0;
}
#endif
dir= dir_entry_pos(buff, block_size, record_number);
offset= uint2korr(dir);
length= uint2korr(dir + 2);
#ifdef SANITY_CHECKS
if (offset < PAGE_HEADER_SIZE(share) ||
offset + length > (block_size -
number_of_records * DIR_ENTRY_SIZE -
PAGE_SUFFIX_SIZE))
{
DBUG_PRINT("error",
("Wrong row position: record_number: %u offset: %u "
"length: %u number_of_records: %u",
record_number, offset, length, number_of_records));
return 0;
}
#endif
data= buff + offset;
*end_of_data= data + length;
return data;
}
|
O0
|
c
|
get_record_position:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x31d06
movl -0x1c(%rbp), %eax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
movl 0xc18(%rdx), %edx
addl $0xc, %edx
subl %edx, %ecx
subl $0x4, %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jbe 0x31d17
jmp 0x31d08
jmp 0x31d0a
movq $0x0, -0x8(%rbp)
jmp 0x31da0
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x2e640
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0xc, %ecx
cmpl %ecx, %eax
jb 0x31d6b
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %edx
shll $0x2, %edx
subl %edx, %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jbe 0x31d79
jmp 0x31d6d
jmp 0x31d6f
movq $0x0, -0x8(%rbp)
jmp 0x31da0
movq -0x18(%rbp), %rax
movl -0x44(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
get_record_position:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov eax, [rax+7BCh]
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+8]
mov [rbp+var_30], eax
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_30]
jnb short loc_31D06
mov eax, [rbp+var_1C]
mov ecx, [rbp+var_2C]
mov rdx, [rbp+var_10]
mov edx, [rdx+0C18h]
add edx, 0Ch
sub ecx, edx
sub ecx, 4
shr ecx, 2
cmp eax, ecx
jbe short loc_31D17
loc_31D06:
jmp short $+2
loc_31D08:
jmp short $+2
loc_31D0A:
mov [rbp+var_8], 0
jmp loc_31DA0
loc_31D17:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_2C]
mov edx, [rbp+var_1C]
call dir_entry_pos
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax]
mov [rbp+var_44], eax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+2]
mov [rbp+var_48], eax
mov eax, [rbp+var_44]
mov rcx, [rbp+var_10]
mov ecx, [rcx+0C18h]
add ecx, 0Ch
cmp eax, ecx
jb short loc_31D6B
mov eax, [rbp+var_44]
add eax, [rbp+var_48]
mov ecx, [rbp+var_2C]
mov edx, [rbp+var_30]
shl edx, 2
sub ecx, edx
sub ecx, 4
cmp eax, ecx
jbe short loc_31D79
loc_31D6B:
jmp short $+2
loc_31D6D:
jmp short $+2
loc_31D6F:
mov [rbp+var_8], 0
jmp short loc_31DA0
loc_31D79:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_44]
add rax, rcx
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
mov eax, [rbp+var_48]
add rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_31DA0:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
long long get_record_position(long long a1, long long a2, unsigned int a3, _QWORD *a4)
{
unsigned int v5; // [rsp+Ch] [rbp-44h]
unsigned __int16 *v6; // [rsp+18h] [rbp-38h]
unsigned int v7; // [rsp+20h] [rbp-30h]
unsigned int v8; // [rsp+24h] [rbp-2Ch]
v8 = *(_DWORD *)(a1 + 1980);
v7 = *(unsigned __int8 *)(a2 + 8);
if ( a3 >= v7 || a3 > (v8 - (*(_DWORD *)(a1 + 3096) + 12) - 4) >> 2 )
return 0LL;
v6 = (unsigned __int16 *)dir_entry_pos(a2, v8, a3);
v5 = *v6;
if ( v5 < *(_DWORD *)(a1 + 3096) + 12 || v6[1] + v5 > v8 - 4 * v7 - 4 )
return 0LL;
*a4 = v6[1] + *v6 + a2;
return v5 + a2;
}
|
get_record_position:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x30]
JNC 0x00131d06
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX + 0xc18]
ADD EDX,0xc
SUB ECX,EDX
SUB ECX,0x4
SHR ECX,0x2
CMP EAX,ECX
JBE 0x00131d17
LAB_00131d06:
JMP 0x00131d08
LAB_00131d08:
JMP 0x00131d0a
LAB_00131d0a:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00131da0
LAB_00131d17:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x0012e640
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x2]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0xc
CMP EAX,ECX
JC 0x00131d6b
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x30]
SHL EDX,0x2
SUB ECX,EDX
SUB ECX,0x4
CMP EAX,ECX
JBE 0x00131d79
LAB_00131d6b:
JMP 0x00131d6d
LAB_00131d6d:
JMP 0x00131d6f
LAB_00131d6f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00131da0
LAB_00131d79:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x44]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x48]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00131da0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long get_record_position(long param_1,long param_2,uint param_3,long *param_4)
{
byte bVar1;
int iVar2;
uint uVar3;
ushort *puVar4;
long local_10;
iVar2 = *(int *)(param_1 + 0x7bc);
bVar1 = *(byte *)(param_2 + 8);
if ((param_3 < bVar1) && (param_3 <= (iVar2 - (*(int *)(param_1 + 0xc18) + 0xc)) - 4U >> 2)) {
puVar4 = (ushort *)dir_entry_pos(param_2,iVar2,param_3);
uVar3 = (uint)*puVar4;
if ((uVar3 < *(int *)(param_1 + 0xc18) + 0xcU) ||
((iVar2 + (uint)bVar1 * -4) - 4 < uVar3 + puVar4[1])) {
local_10 = 0;
}
else {
local_10 = param_2 + (ulong)uVar3;
*param_4 = local_10 + (ulong)(uint)puVar4[1];
}
}
else {
local_10 = 0;
}
return local_10;
}
|
|
63,169 |
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>):
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x14(%rdi), %esi
callq 0xd4c90
leaq 0x30(%rsp), %rdi
callq 0x466d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x466e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xd4f16
movq 0x18(%rsp), %rdi
callq 0xd4930
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, 0xf(%rsp)
jg 0xd4ecd
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, 0x20(%rsp)
cmpl 0x4(%rcx), %eax
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd4edb
jmp 0xd4eea
movq 0x18(%rsp), %rdi
movl 0x14(%rdi), %esi
callq 0xd4c90
jmp 0xd4f01
movq 0x18(%rsp), %rax
leaq 0xb00e6(%rip), %rcx # 0x184fdc
movq %rcx, 0x70(%rax)
movb $0x0, 0x47(%rsp)
jmp 0xd4f1b
jmp 0xd4f03
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0xd4e64
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE18next_byte_in_rangeESt16initializer_listIiE:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rdi, [rsp+48h+var_20]
mov [rsp+48h+var_30], rdi
mov esi, [rdi+14h]
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3addEi; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::add(int)
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE5beginEv; std::initializer_list<int>::begin(void)
mov [rsp+48h+var_28], rax
loc_D4E64:
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_38], rax
lea rdi, [rsp+48h+var_18]
call _ZNKSt16initializer_listIiE3endEv; std::initializer_list<int>::end(void)
mov rcx, rax
mov rax, [rsp+48h+var_38]
cmp rax, rcx
jz loc_D4F16
mov rdi, [rsp+48h+var_30]
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3getEv; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(void)
mov rdx, [rsp+48h+var_30]
mov rax, [rsp+48h+var_28]
mov ecx, [rax]
xor eax, eax
cmp ecx, [rdx+14h]
mov [rsp+48h+var_39], al
jg short loc_D4ECD
mov rax, [rsp+48h+var_30]
mov eax, [rax+14h]
mov rcx, [rsp+48h+var_28]
mov rdx, rcx
add rdx, 4
mov [rsp+48h+var_28], rdx
cmp eax, [rcx+4]
setle al
mov [rsp+48h+var_39], al
loc_D4ECD:
mov al, [rsp+48h+var_39]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_D4EDB
jmp short loc_D4EEA
loc_D4EDB:
mov rdi, [rsp+48h+var_30]
mov esi, [rdi+14h]
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3addEi; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::add(int)
jmp short loc_D4F01
loc_D4EEA:
mov rax, [rsp+48h+var_30]
lea rcx, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [rax+70h], rcx
mov [rsp+48h+var_1], 0
jmp short loc_D4F1B
loc_D4F01:
jmp short $+2
loc_D4F03:
mov rax, [rsp+48h+var_28]
add rax, 4
mov [rsp+48h+var_28], rax
jmp loc_D4E64
loc_D4F16:
mov [rsp+48h+var_1], 1
loc_D4F1B:
mov al, [rsp+48h+var_1]
and al, 1
add rsp, 48h
retn
|
char nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(
long long a1,
long long a2,
long long a3)
{
_DWORD *v3; // rcx
bool v5; // [rsp+Fh] [rbp-39h]
_DWORD *i; // [rsp+20h] [rbp-28h]
_QWORD v7[2]; // [rsp+30h] [rbp-18h] BYREF
v7[0] = a2;
v7[1] = a3;
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::add(
a1,
*(_DWORD *)(a1 + 20));
for ( i = (_DWORD *)std::initializer_list<int>::begin((long long)v7);
i != (_DWORD *)std::initializer_list<int>::end((long long)v7);
++i )
{
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(a1);
v5 = 0;
if ( *i <= *(_DWORD *)(a1 + 20) )
{
v3 = i++;
v5 = *(_DWORD *)(a1 + 20) <= v3[1];
}
if ( !v5 )
{
*(_QWORD *)(a1 + 112) = "invalid string: ill-formed UTF-8 byte";
return 0;
}
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::add(
a1,
*(_DWORD *)(a1 + 20));
}
return 1;
}
|
next_byte_in_range:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x18],RDI
MOV ESI,dword ptr [RDI + 0x14]
CALL 0x001d4c90
LEA RDI,[RSP + 0x30]
CALL 0x001466d0
MOV qword ptr [RSP + 0x20],RAX
LAB_001d4e64:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x30]
CALL 0x001466e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JZ 0x001d4f16
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001d4930
MOV RDX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RDX + 0x14]
MOV byte ptr [RSP + 0xf],AL
JG 0x001d4ecd
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV RCX,qword ptr [RSP + 0x20]
MOV RDX,RCX
ADD RDX,0x4
MOV qword ptr [RSP + 0x20],RDX
CMP EAX,dword ptr [RCX + 0x4]
SETLE AL
MOV byte ptr [RSP + 0xf],AL
LAB_001d4ecd:
MOV AL,byte ptr [RSP + 0xf]
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001d4edb
JMP 0x001d4eea
LAB_001d4edb:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RDI + 0x14]
CALL 0x001d4c90
JMP 0x001d4f01
LAB_001d4eea:
MOV RAX,qword ptr [RSP + 0x18]
LEA RCX,[0x284fdc]
MOV qword ptr [RAX + 0x70],RCX
MOV byte ptr [RSP + 0x47],0x0
JMP 0x001d4f1b
LAB_001d4f01:
JMP 0x001d4f03
LAB_001d4f03:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x4
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001d4e64
LAB_001d4f16:
MOV byte ptr [RSP + 0x47],0x1
LAB_001d4f1b:
MOV AL,byte ptr [RSP + 0x47]
AND AL,0x1
ADD RSP,0x48
RET
|
/* nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>
>::next_byte_in_range(std::initializer_list<int>) */
int1
nlohmann::json_abi_v3_11_2::detail::
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
::next_byte_in_range
(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*param_1,int8 param_2,int8 param_3)
{
bool bVar1;
int *piVar2;
int *local_28;
int8 local_18;
int8 local_10;
local_18 = param_2;
local_10 = param_3;
add((int)param_1);
local_28 = (int *)std::initializer_list<int>::begin((initializer_list<int> *)&local_18);
while( true ) {
piVar2 = (int *)std::initializer_list<int>::end((initializer_list<int> *)&local_18);
if (local_28 == piVar2) {
return 1;
}
get(param_1);
bVar1 = false;
if (*local_28 <= *(int *)(param_1 + 0x14)) {
bVar1 = *(int *)(param_1 + 0x14) <= local_28[1];
local_28 = local_28 + 1;
}
if (!bVar1) break;
add((int)param_1);
local_28 = local_28 + 1;
}
*(char **)(param_1 + 0x70) = "invalid string: ill-formed UTF-8 byte";
return 0;
}
|
|
63,170 |
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0xa4f0
testq %r12, %r12
sete %bpl
je 0x71d0a
leaq (%r14,%r12,4), %r12
movq %rbx, %rdi
callq 0xbab2
movl 0x14(%rbx), %eax
cmpl %eax, (%r14)
jg 0x71cfb
cmpl 0x4(%r14), %eax
leaq 0x4(%r14), %r14
setle %cl
testb %cl, %cl
je 0x71cff
movsbl %al, %esi
movq %r15, %rdi
callq 0xa4f0
addq $0x4, %r14
cmpq %r12, %r14
sete %bpl
jne 0x71cc2
jmp 0x71d0a
xorl %ecx, %ecx
jmp 0x71cdd
leaq 0x51206(%rip), %rax # 0xc2f0c
movq %rax, 0x70(%rbx)
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE18next_byte_in_rangeESt16initializer_listIiE:
push rbp
push r15
push r14
push r12
push rbx
mov r12, rdx
mov r14, rsi
mov rbx, rdi
movsx esi, byte ptr [rdi+14h]
lea r15, [rdi+50h]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
test r12, r12
setz bpl
jz short loc_71D0A
lea r12, [r14+r12*4]
loc_71CC2:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3getEv; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(void)
mov eax, [rbx+14h]
cmp [r14], eax
jg short loc_71CFB
cmp eax, [r14+4]
lea r14, [r14+4]
setle cl
loc_71CDD:
test cl, cl
jz short loc_71CFF
movsx esi, al
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r14, 4
cmp r14, r12
setz bpl
jnz short loc_71CC2
jmp short loc_71D0A
loc_71CFB:
xor ecx, ecx
jmp short loc_71CDD
loc_71CFF:
lea rax, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [rbx+70h], rax
loc_71D0A:
and bpl, 1
mov eax, ebp
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(
__m128i *a1,
__int32 *a2,
long long a3)
{
unsigned int v3; // ebp
__int32 *v5; // r14
__int32 *v6; // r12
__int32 v7; // eax
bool v8; // zf
bool v9; // sf
bool v10; // of
char v11; // cl
v5 = a2;
std::string::push_back(&a1[5], (unsigned int)a1[1].m128i_i8[4]);
LOBYTE(v3) = a3 == 0;
if ( a3 )
{
v6 = &a2[a3];
while ( 1 )
{
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(a1);
v7 = a1[1].m128i_i32[1];
if ( *v5 > v7 )
{
v11 = 0;
}
else
{
v10 = __OFSUB__(v7, v5[1]);
v8 = v7 == v5[1];
v9 = v7 - v5[1] < 0;
++v5;
v11 = v9 ^ v10 | v8;
}
if ( !v11 )
break;
std::string::push_back(&a1[5], (unsigned int)(char)v7);
LOBYTE(v3) = ++v5 == v6;
if ( v5 == v6 )
goto LABEL_10;
}
a1[7].m128i_i64[0] = (long long)"invalid string: ill-formed UTF-8 byte";
}
LABEL_10:
LOBYTE(v3) = v3 & 1;
return v3;
}
| |||
63,171 |
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
{
add(current);
}
else
{
error_message = "invalid string: ill-formed UTF-8 byte";
return false;
}
}
return true;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(std::initializer_list<int>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movsbl 0x14(%rdi), %esi
leaq 0x50(%rdi), %r12
movq %r12, %rdi
callq 0xa4e0
movb $0x1, %bl
testq %r13, %r13
je 0x71032
leaq (%r15,%r13,4), %r13
movq %r14, %rdi
callq 0xba72
movl 0x14(%r14), %eax
cmpl %eax, (%r15)
jg 0x7103e
cmpl 0x4(%r15), %eax
jg 0x7103e
movsbl %al, %esi
movq %r12, %rdi
callq 0xa4e0
addq $0x8, %r15
cmpq %r13, %r15
jne 0x71007
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x50ed7(%rip), %rax # 0xc1f1c
movq %rax, 0x70(%r14)
xorl %ebx, %ebx
jmp 0x71032
nop
|
_ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE18next_byte_in_rangeESt16initializer_listIiE:
push r15
push r14
push r13
push r12
push rbx
mov r13, rdx
mov r15, rsi
mov r14, rdi
movsx esi, byte ptr [rdi+14h]
lea r12, [rdi+50h]
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov bl, 1
test r13, r13
jz short loc_71032
lea r13, [r15+r13*4]
loc_71007:
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE3getEv; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(void)
mov eax, [r14+14h]
cmp [r15], eax
jg short loc_7103E
cmp eax, [r15+4]
jg short loc_7103E
movsx esi, al
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r15, 8
cmp r15, r13
jnz short loc_71007
loc_71032:
mov eax, ebx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_7103E:
lea rax, aInvalidStringI; "invalid string: ill-formed UTF-8 byte"
mov [r14+70h], rax
xor ebx, ebx
jmp short loc_71032
|
long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::next_byte_in_range(
__m128i *a1,
__int32 *a2,
long long a3)
{
unsigned int v3; // ebx
__int32 *v5; // r15
__int32 *v6; // r13
__int32 v7; // eax
v5 = a2;
std::string::push_back(&a1[5], (unsigned int)a1[1].m128i_i8[4]);
LOBYTE(v3) = 1;
if ( a3 )
{
v6 = &a2[a3];
while ( 1 )
{
nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get(a1);
v7 = a1[1].m128i_i32[1];
if ( *v5 > v7 || v7 > v5[1] )
break;
std::string::push_back(&a1[5], (unsigned int)(char)v7);
v5 += 2;
if ( v5 == v6 )
return v3;
}
a1[7].m128i_i64[0] = (long long)"invalid string: ill-formed UTF-8 byte";
return 0;
}
return v3;
}
| |||
63,172 |
common_embd_similarity_cos(float const*, float const*, int)
|
monkey531[P]llama/common/common.cpp
|
float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
}
|
O0
|
cpp
|
common_embd_similarity_cos(float const*, float const*, int):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0xf49cd
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x48(%rsp), %rax
movslq 0x1c(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf4925
movsd 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf49e0
jp 0xf49e0
jmp 0xf49f1
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf4a2e
jp 0xf4a2e
movsd 0x28(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf4a23
jp 0xf4a23
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf4a23
jp 0xf4a23
movss 0x1145f5(%rip), %xmm0 # 0x209010
movss %xmm0, 0x54(%rsp)
jmp 0xf4a77
xorps %xmm0, %xmm0
movss %xmm0, 0x54(%rsp)
jmp 0xf4a77
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x5a880
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x5a880
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x54(%rsp)
movss 0x54(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
|
_Z26common_embd_similarity_cosPKfS0_i:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_1C], edx
xorps xmm0, xmm0
movsd [rsp+58h+var_28], xmm0
xorps xmm0, xmm0
movsd [rsp+58h+var_30], xmm0
xorps xmm0, xmm0
movsd [rsp+58h+var_38], xmm0
mov [rsp+58h+var_3C], 0
loc_F4925:
mov eax, [rsp+58h+var_3C]
cmp eax, [rsp+58h+var_1C]
jge loc_F49CD
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_3C]
movss xmm0, dword ptr [rax+rcx*4]
mov rax, [rsp+58h+var_18]
movsxd rcx, [rsp+58h+var_3C]
mulss xmm0, dword ptr [rax+rcx*4]
cvtss2sd xmm0, xmm0
addsd xmm0, [rsp+58h+var_28]
movsd [rsp+58h+var_28], xmm0
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_3C]
movss xmm0, dword ptr [rax+rcx*4]
mov rax, [rsp+58h+var_10]
movsxd rcx, [rsp+58h+var_3C]
mulss xmm0, dword ptr [rax+rcx*4]
cvtss2sd xmm0, xmm0
addsd xmm0, [rsp+58h+var_30]
movsd [rsp+58h+var_30], xmm0
mov rax, [rsp+58h+var_18]
movsxd rcx, [rsp+58h+var_3C]
movss xmm0, dword ptr [rax+rcx*4]
mov rax, [rsp+58h+var_18]
movsxd rcx, [rsp+58h+var_3C]
mulss xmm0, dword ptr [rax+rcx*4]
cvtss2sd xmm0, xmm0
addsd xmm0, [rsp+58h+var_38]
movsd [rsp+58h+var_38], xmm0
mov eax, [rsp+58h+var_3C]
add eax, 1
mov [rsp+58h+var_3C], eax
jmp loc_F4925
loc_F49CD:
movsd xmm0, [rsp+58h+var_30]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_F49E0
jp short loc_F49E0
jmp short loc_F49F1
loc_F49E0:
movsd xmm0, [rsp+58h+var_38]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_F4A2E
jp short loc_F4A2E
loc_F49F1:
movsd xmm0, [rsp+58h+var_30]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_F4A23
jp short loc_F4A23
movsd xmm0, [rsp+58h+var_38]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_F4A23
jp short loc_F4A23
movss xmm0, cs:flt_209010
movss [rsp+58h+var_4], xmm0
jmp short loc_F4A77
loc_F4A23:
xorps xmm0, xmm0
movss [rsp+58h+var_4], xmm0
jmp short loc_F4A77
loc_F4A2E:
movsd xmm0, [rsp+58h+var_28]
movsd [rsp+58h+var_48], xmm0
movsd xmm0, [rsp+58h+var_30]
call _sqrt
movsd [rsp+58h+var_50], xmm0
movsd xmm0, [rsp+58h+var_38]
call _sqrt
movsd xmm1, [rsp+58h+var_50]
movaps xmm2, xmm0
movsd xmm0, [rsp+58h+var_48]
mulsd xmm1, xmm2
divsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
movss [rsp+58h+var_4], xmm0
loc_F4A77:
movss xmm0, [rsp+58h+var_4]
add rsp, 58h
retn
|
float common_embd_similarity_cos(const float *a1, const float *a2, int a3)
{
double v5; // [rsp+8h] [rbp-50h]
int i; // [rsp+1Ch] [rbp-3Ch]
double v7; // [rsp+20h] [rbp-38h]
double v8; // [rsp+28h] [rbp-30h]
double v9; // [rsp+30h] [rbp-28h]
v9 = 0.0;
v8 = 0.0;
v7 = 0.0;
for ( i = 0; i < a3; ++i )
{
v9 = (float)(a1[i] * a2[i]) + v9;
v8 = (float)(a1[i] * a1[i]) + v8;
v7 = (float)(a2[i] * a2[i]) + v7;
}
if ( v8 == 0.0 || v7 == 0.0 )
{
if ( v8 == 0.0 && v7 == 0.0 )
return 1.0;
else
return 0.0;
}
else
{
v5 = sqrt(v8);
return v9 / (v5 * sqrt(v7));
}
}
|
common_embd_similarity_cos:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV dword ptr [RSP + 0x3c],EDX
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x30],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x28],XMM0
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0x20],XMM0
MOV dword ptr [RSP + 0x1c],0x0
LAB_001f4925:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x3c]
JGE 0x001f49cd
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MULSS XMM0,dword ptr [RAX + RCX*0x4]
CVTSS2SD XMM0,XMM0
ADDSD XMM0,qword ptr [RSP + 0x30]
MOVSD qword ptr [RSP + 0x30],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MULSS XMM0,dword ptr [RAX + RCX*0x4]
CVTSS2SD XMM0,XMM0
ADDSD XMM0,qword ptr [RSP + 0x28]
MOVSD qword ptr [RSP + 0x28],XMM0
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MULSS XMM0,dword ptr [RAX + RCX*0x4]
CVTSS2SD XMM0,XMM0
ADDSD XMM0,qword ptr [RSP + 0x20]
MOVSD qword ptr [RSP + 0x20],XMM0
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001f4925
LAB_001f49cd:
MOVSD XMM0,qword ptr [RSP + 0x28]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001f49e0
JP 0x001f49e0
JMP 0x001f49f1
LAB_001f49e0:
MOVSD XMM0,qword ptr [RSP + 0x20]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001f4a2e
JP 0x001f4a2e
LAB_001f49f1:
MOVSD XMM0,qword ptr [RSP + 0x28]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001f4a23
JP 0x001f4a23
MOVSD XMM0,qword ptr [RSP + 0x20]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001f4a23
JP 0x001f4a23
MOVSS XMM0,dword ptr [0x00309010]
MOVSS dword ptr [RSP + 0x54],XMM0
JMP 0x001f4a77
LAB_001f4a23:
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0x54],XMM0
JMP 0x001f4a77
LAB_001f4a2e:
MOVSD XMM0,qword ptr [RSP + 0x30]
MOVSD qword ptr [RSP + 0x10],XMM0
MOVSD XMM0,qword ptr [RSP + 0x28]
CALL 0x0015a880
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x20]
CALL 0x0015a880
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVAPS XMM2,XMM0
MOVSD XMM0,qword ptr [RSP + 0x10]
MULSD XMM1,XMM2
DIVSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RSP + 0x54],XMM0
LAB_001f4a77:
MOVSS XMM0,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
double dVar1;
double dVar2;
int local_3c;
double local_38;
double local_30;
double local_28;
float local_4;
local_28 = 0.0;
local_30 = 0.0;
local_38 = 0.0;
for (local_3c = 0; local_3c < param_3; local_3c = local_3c + 1) {
local_28 = (double)(param_1[local_3c] * param_2[local_3c]) + local_28;
local_30 = (double)(param_1[local_3c] * param_1[local_3c]) + local_30;
local_38 = (double)(param_2[local_3c] * param_2[local_3c]) + local_38;
}
if (((local_30 == 0.0) && (!NAN(local_30))) || ((local_38 == 0.0 && (!NAN(local_38))))) {
if ((((local_30 != 0.0) || (NAN(local_30))) || (local_38 != 0.0)) || (NAN(local_38))) {
local_4 = 0.0;
}
else {
local_4 = DAT_00309010;
}
}
else {
dVar1 = sqrt(local_30);
dVar2 = sqrt(local_38);
local_4 = (float)(local_28 / (dVar1 * dVar2));
}
return local_4;
}
|
|
63,173 |
ps_fetch_bin
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_bin(MYSQL_BIND *r_param,
const MYSQL_FIELD *field,
unsigned char **row)
{
if (field->charsetnr == 63)
{
ulong field_length= *r_param->length= net_field_length(row);
uchar *current_pos= (*row) + r_param->offset,
*end= (*row) + field_length;
size_t copylen= 0;
if (current_pos < end)
{
copylen= end - current_pos;
if (r_param->buffer_length)
memcpy(r_param->buffer, current_pos, MIN(copylen, r_param->buffer_length));
}
if (copylen < r_param->buffer_length &&
(r_param->buffer_type == MYSQL_TYPE_STRING ||
r_param->buffer_type == MYSQL_TYPE_JSON))
((char *)r_param->buffer)[copylen]= 0;
*r_param->error= copylen > r_param->buffer_length;
(*row)+= field_length;
}
else
ps_fetch_string(r_param, field, row);
}
|
O0
|
c
|
ps_fetch_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3f, 0x6c(%rax)
jne 0x375aa
movq -0x18(%rbp), %rdi
callq 0x1e1d0
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x48(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x37542
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x37540
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x37523
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x3752f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
callq 0x13360
jmp 0x37542
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x3757a
movq -0x8(%rbp), %rax
cmpl $0xfe, 0x60(%rax)
je 0x3756a
movq -0x8(%rbp), %rax
cmpl $0xf5, 0x60(%rax)
jne 0x3757a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x375bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37420
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ps_fetch_bin:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
cmp dword ptr [rax+6Ch], 3Fh ; '?'
jnz loc_375AA
mov rdi, [rbp+var_18]
call net_field_length
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov [rcx], rax
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov rcx, [rbp+var_8]
add rax, [rcx+48h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax]
add rax, [rbp+var_20]
mov [rbp+var_30], rax
mov [rbp+var_38], 0
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_37542
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+40h], 0
jz short loc_37540
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
cmp rax, [rcx+40h]
jnb short loc_37523
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
jmp short loc_3752F
loc_37523:
mov rax, [rbp+var_8]
mov rax, [rax+40h]
mov [rbp+var_50], rax
loc_3752F:
mov rsi, [rbp+var_40]
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_50]
call _memcpy
loc_37540:
jmp short $+2
loc_37542:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
cmp rax, [rcx+40h]
jnb short loc_3757A
mov rax, [rbp+var_8]
cmp dword ptr [rax+60h], 0FEh
jz short loc_3756A
mov rax, [rbp+var_8]
cmp dword ptr [rax+60h], 0F5h
jnz short loc_3757A
loc_3756A:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rbp+var_38]
mov byte ptr [rax+rcx], 0
loc_3757A:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
cmp rax, [rcx+40h]
setnbe al
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov [rax], cl
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
add rcx, [rax]
mov [rax], rcx
jmp short loc_375BB
loc_375AA:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call ps_fetch_string
loc_375BB:
add rsp, 50h
pop rbp
retn
|
unsigned __int8 ** ps_fetch_bin(long long a1, long long a2, unsigned __int8 **a3)
{
long long v3; // rax
unsigned __int8 **result; // rax
long long v5; // [rsp+8h] [rbp-48h]
unsigned long long v6; // [rsp+18h] [rbp-38h]
unsigned __int8 *v7; // [rsp+20h] [rbp-30h]
unsigned __int8 *v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
if ( *(_DWORD *)(a2 + 108) != 63 )
return ps_fetch_string(a1, a2, a3);
v3 = net_field_length(a3);
**(_QWORD **)a1 = v3;
v9 = v3;
v8 = &(*a3)[*(_QWORD *)(a1 + 72)];
v7 = &(*a3)[v3];
v6 = 0LL;
if ( v8 < v7 )
{
v6 = v7 - v8;
if ( *(_QWORD *)(a1 + 64) )
{
v5 = *(_QWORD *)(a1 + 16);
if ( v6 >= *(_QWORD *)(a1 + 64) )
memcpy(v5, v8, *(_QWORD *)(a1 + 64));
else
memcpy(v5, v8, v6);
}
}
if ( v6 < *(_QWORD *)(a1 + 64) && (*(_DWORD *)(a1 + 96) == 254 || *(_DWORD *)(a1 + 96) == 245) )
*(_BYTE *)(*(_QWORD *)(a1 + 16) + v6) = 0;
**(_BYTE **)(a1 + 24) = v6 > *(_QWORD *)(a1 + 64);
result = a3;
*a3 += v9;
return result;
}
|
ps_fetch_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x6c],0x3f
JNZ 0x001375aa
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0011e1d0
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RCX],RAX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RCX + 0x48]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00137542
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x00137540
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x40]
JNC 0x00137523
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0013752f
LAB_00137523:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x50],RAX
LAB_0013752f:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00113360
LAB_00137540:
JMP 0x00137542
LAB_00137542:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x40]
JNC 0x0013757a
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x60],0xfe
JZ 0x0013756a
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x60],0xf5
JNZ 0x0013757a
LAB_0013756a:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0013757a:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x40]
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x001375bb
LAB_001375aa:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00137420
LAB_001375bb:
ADD RSP,0x50
POP RBP
RET
|
void ps_fetch_bin(int8 *param_1,long param_2,long *param_3)
{
long lVar1;
void *__src;
size_t local_58;
ulong local_40;
if (*(int *)(param_2 + 0x6c) == 0x3f) {
lVar1 = net_field_length(param_3);
*(long *)*param_1 = lVar1;
__src = (void *)(*param_3 + param_1[9]);
local_40 = 0;
if ((__src < (void *)(*param_3 + lVar1)) &&
(local_40 = (*param_3 + lVar1) - (long)__src, param_1[8] != 0)) {
local_58 = local_40;
if ((ulong)param_1[8] <= local_40) {
local_58 = param_1[8];
}
memcpy((void *)param_1[2],__src,local_58);
}
if ((local_40 < (ulong)param_1[8]) &&
((*(int *)(param_1 + 0xc) == 0xfe || (*(int *)(param_1 + 0xc) == 0xf5)))) {
*(int1 *)(param_1[2] + local_40) = 0;
}
*(bool *)param_1[3] = (ulong)param_1[8] < local_40;
*param_3 = lVar1 + *param_3;
}
else {
ps_fetch_string(param_1,param_2,param_3);
}
return;
}
|
|
63,174 |
inline_mysql_mutex_init
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
}
|
O0
|
c
|
inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x28271e(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_mutex_init_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
|
long long inline_mysql_mutex_init_0(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
|
inline_mysql_mutex_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a330
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
|
|
63,175 |
createHelperWindow
|
aimrt_mujoco_sim/_deps/glfw3-src/src/x11_init.c
|
static Window createHelperWindow(void)
{
XSetWindowAttributes wa;
wa.event_mask = PropertyChangeMask;
return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
0, 0, 1, 1, 0, 0,
InputOnly,
DefaultVisual(_glfw.x11.display, _glfw.x11.screen),
CWEventMask, &wa);
}
|
O0
|
c
|
createHelperWindow:
subq $0xa8, %rsp
movq $0x400000, 0x80(%rsp) # imm = 0x400000
leaq 0x13f7f6(%rip), %rax # 0x50c860
movq 0x20640(%rax), %rdi
leaq 0x13f7e8(%rip), %rax # 0x50c860
movq 0x20650(%rax), %rsi
leaq 0x13f7da(%rip), %rax # 0x50c860
movq 0x20640(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x13f7c5(%rip), %rcx # 0x50c860
movslq 0x20648(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x40(%rax), %r10
xorl %ecx, %ecx
movl $0x1, %r9d
leaq 0x38(%rsp), %rax
movl %ecx, %edx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x2, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x800, 0x20(%rsp) # imm = 0x800
movq %rax, 0x28(%rsp)
callq 0x8c600
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
|
createHelperWindow:
sub rsp, 0A8h
mov [rsp+0A8h+var_28], (offset a05000000c82d00_1+0F2h); "y:a3,start:b11,x:b4,y:b3,platform:Linux"...
lea rax, _glfw
mov rdi, [rax+20640h]
lea rax, _glfw
mov rsi, [rax+20650h]
lea rax, _glfw
mov rax, [rax+20640h]
mov rax, [rax+0E8h]
lea rcx, _glfw
movsxd rcx, dword ptr [rcx+20648h]
shl rcx, 7
add rax, rcx
mov r10, [rax+40h]
xor ecx, ecx
mov r9d, 1
lea rax, [rsp+0A8h+var_70]
mov edx, ecx
mov r8d, r9d
mov [rsp+0A8h+var_A8], 0
mov [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_98], 2
mov [rsp+0A8h+var_90], r10
mov [rsp+0A8h+var_88], 800h
mov [rsp+0A8h+var_80], rax
call _XCreateWindow
add rsp, 0A8h
retn
|
long long createHelperWindow()
{
_BYTE v1[72]; // [rsp+38h] [rbp-70h] BYREF
char *v2; // [rsp+80h] [rbp-28h]
v2 = "y:a3,start:b11,x:b4,y:b3,platform:Linux,";
return XCreateWindow(
*(_QWORD *)&glfw[33168],
*(_QWORD *)&glfw[33172],
0LL,
0LL,
1LL,
1LL,
0,
0,
2,
*(_QWORD *)(((long long)glfw[33170] << 7) + *(_QWORD *)(*(_QWORD *)&glfw[33168] + 232LL) + 64),
2048LL,
v1);
}
|
OneofOptions:
SUB RSP,0xc8
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RSI
MOV RDI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x40],RDI
CALL 0x002540b0
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[0x5ff0f0]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x68],RDI
ADD RDI,0x10
MOV qword ptr [RSP + 0x48],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x50],RAX
LAB_003cd095:
CALL 0x00333310
JMP 0x003cd09c
LAB_003cd09c:
MOV RDI,qword ptr [RSP + 0x50]
ADD RDI,0x18
MOV RSI,qword ptr [RSP + 0x70]
ADD RSI,0x28
LAB_003cd0ae:
CALL 0x003dfbe0
LAB_003cd0b3:
JMP 0x003cd0b5
LAB_003cd0b5:
MOV RDI,qword ptr [RSP + 0x50]
ADD RDI,0x30
MOV qword ptr [RSP + 0x28],RDI
XOR ESI,ESI
MOV EDX,0x4
CALL 0x0018db70
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x002540e0
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x8
MOV RAX,qword ptr [RSP + 0x70]
ADD RAX,0x8
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xc0],RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RAX]
AND RAX,0x1
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0x3f],AL
MOV AL,byte ptr [RSP + 0x3f]
TEST AL,0x1
JNZ 0x003cd14f
JMP 0x003cd1fb
LAB_003cd14f:
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0x98],0x0
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV RAX,qword ptr [RAX]
AND RAX,0x1
CMP RAX,0x0
JZ 0x003cd1bd
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00255370
ADD RAX,0x8
MOV qword ptr [RSP + 0xa8],RAX
JMP 0x003cd1db
LAB_003cd1bd:
MOV RAX,qword ptr [RSP + 0x98]
LAB_003cd1c5:
CALL RAX
MOV qword ptr [RSP + 0x18],RAX
JMP 0x003cd1ce
LAB_003cd1ce:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xa8],RAX
LAB_003cd1db:
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00255200
JMP 0x003cd1f9
LAB_003cd1f9:
JMP 0x003cd1fb
LAB_003cd1fb:
JMP 0x003cd1fd
LAB_003cd1fd:
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x10
MOV qword ptr [RSP],RAX
CALL 0x0038db70
MOV qword ptr [RSP + 0x8],RAX
JMP 0x003cd216
LAB_003cd216:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x70]
ADD RDX,0x10
CALL 0x00326bc0
LAB_003cd22d:
JMP 0x003cd22f
LAB_003cd22f:
ADD RSP,0xc8
RET
|
/* google::protobuf::OneofOptions::OneofOptions(google::protobuf::OneofOptions const&) */
void __thiscall
google::protobuf::OneofOptions::OneofOptions(OneofOptions *this,OneofOptions *param_1)
{
InternalMetadata *this_00;
MessageLite *pMVar1;
UnknownFieldSet *local_20;
Message::Message((Message *)this);
*(int ***)this = &PTR__OneofOptions_005ff0f0;
/* try { // try from 003cd095 to 003cd099 has its CatchHandler @ 003cd237 */
internal::ExtensionSet::ExtensionSet((ExtensionSet *)(this + 0x10));
/* try { // try from 003cd0ae to 003cd0b2 has its CatchHandler @ 003cd247 */
RepeatedPtrField<google::protobuf::UninterpretedOption>::RepeatedPtrField
((RepeatedPtrField<google::protobuf::UninterpretedOption> *)(this + 0x28),
(RepeatedPtrField *)(param_1 + 0x28));
memset((CachedSize *)(this + 0x40),0,4);
internal::CachedSize::CachedSize((CachedSize *)(this + 0x40));
this_00 = (InternalMetadata *)(param_1 + 8);
if ((*(ulong *)this_00 & 1) != 0) {
if ((*(ulong *)this_00 & 1) == 0) {
/* try { // try from 003cd1c5 to 003cd22c has its CatchHandler @ 003cd237 */
local_20 = (UnknownFieldSet *)(*(code *)0x0)();
}
else {
local_20 = (UnknownFieldSet *)
internal::InternalMetadata::
PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>
(this_00);
local_20 = (UnknownFieldSet *)((Container *)local_20 + 8);
}
internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8),local_20);
}
pMVar1 = (MessageLite *)internal_default_instance();
internal::ExtensionSet::MergeFrom
((ExtensionSet *)(this + 0x10),pMVar1,(ExtensionSet *)(param_1 + 0x10));
return;
}
|
|
63,176 |
YAML::Exp::Escape[abi:cxx11](YAML::Stream&)
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/src/exp.cpp
|
std::string Escape(Stream& in) {
// eat slash
char escape = in.get();
// switch on escape character
char ch = in.get();
// first do single quote, since it's easier
if (escape == '\'' && ch == '\'')
return "\'";
// now do the slash (we're not gonna check if it's a slash - you better pass
// one!)
switch (ch) {
case '0':
return std::string(1, '\x00');
case 'a':
return "\x07";
case 'b':
return "\x08";
case 't':
case '\t':
return "\x09";
case 'n':
return "\x0A";
case 'v':
return "\x0B";
case 'f':
return "\x0C";
case 'r':
return "\x0D";
case 'e':
return "\x1B";
case ' ':
return R"( )";
case '\"':
return "\"";
case '\'':
return "\'";
case '\\':
return "\\";
case '/':
return "/";
case 'N':
return "\x85";
case '_':
return "\xA0";
case 'L':
return "\xE2\x80\xA8"; // LS (#x2028)
case 'P':
return "\xE2\x80\xA9"; // PS (#x2029)
case 'x':
return Escape(in, 2);
case 'u':
return Escape(in, 4);
case 'U':
return Escape(in, 8);
}
std::stringstream msg;
throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
}
|
O3
|
cpp
|
YAML::Exp::Escape[abi:cxx11](YAML::Stream&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6d726
movl %eax, %r15d
movq %r14, %rdi
callq 0x6d726
movl %eax, %ebp
xorb $0x27, %r15b
xorb $0x27, %al
orb %r15b, %al
jne 0x719e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1005b4(%rip), %rsi # 0x171f74
leaq 0x1005ae(%rip), %rdx # 0x171f75
movq %rbx, %rdi
callq 0x2c610
movq %rbx, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %eax
cmpl $0x5b, %eax
jle 0x71a1c
addl $-0x5c, %eax
cmpl $0x1c, %eax
ja 0x71c43
leaq 0xf3a54(%rip), %rcx # 0x165450
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf3afd(%rip), %rsi # 0x165510
leaq 0xf3af7(%rip), %rdx # 0x165511
jmp 0x719c7
cmpl $0x2e, %eax
jg 0x71a4e
cmpl $0x21, %eax
jg 0x71a80
cmpl $0x9, %eax
je 0x71a93
cmpl $0x20, %eax
jne 0x71c43
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xfcc97(%rip), %rsi # 0x16e6d9
leaq 0xfcc91(%rip), %rdx # 0x16e6da
jmp 0x719c7
leal -0x4c(%rax), %ecx
cmpl $0x9, %ecx
ja 0x71aad
leaq 0xf39cb(%rip), %rax # 0x165428
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf3aa2(%rip), %rsi # 0x165516
leaq 0xf3a9e(%rip), %rdx # 0x165519
jmp 0x719c7
cmpl $0x22, %eax
je 0x71ad9
cmpl $0x27, %eax
je 0x719b2
jmp 0x71c43
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf38dc(%rip), %rsi # 0x16537d
leaq 0xf38d6(%rip), %rdx # 0x16537e
jmp 0x719c7
cmpl $0x2f, %eax
je 0x71c29
cmpl $0x30, %eax
jne 0x71c43
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movw $0x0, 0x10(%rbx)
movq $0x1, 0x8(%rbx)
jmp 0x719cf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xfb461(%rip), %rsi # 0x16cf48
leaq 0xfb45b(%rip), %rdx # 0x16cf49
jmp 0x719c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
jmp 0x71c1f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xfa54e(%rip), %rsi # 0x16c05f
leaq 0xfa548(%rip), %rdx # 0x16c060
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf39df(%rip), %rsi # 0x16550a
leaq 0xf39d9(%rip), %rdx # 0x16550b
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf39c7(%rip), %rsi # 0x16550c
leaq 0xf39c1(%rip), %rdx # 0x16550d
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf39a9(%rip), %rsi # 0x165508
leaq 0xf39a3(%rip), %rdx # 0x165509
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf3995(%rip), %rsi # 0x16550e
leaq 0xf398f(%rip), %rdx # 0x16550f
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf3973(%rip), %rsi # 0x165506
leaq 0xf396d(%rip), %rdx # 0x165507
jmp 0x719c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
jmp 0x71c1f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf394a(%rip), %rsi # 0x165504
leaq 0xf3944(%rip), %rdx # 0x165505
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf3940(%rip), %rsi # 0x165514
leaq 0xf393a(%rip), %rdx # 0x165515
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf392c(%rip), %rsi # 0x16551a
leaq 0xf3928(%rip), %rdx # 0x16551d
jmp 0x719c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xf390a(%rip), %rsi # 0x165512
leaq 0xf3904(%rip), %rdx # 0x165513
jmp 0x719c7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x710be
jmp 0x719cf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x10cc9f(%rip), %rsi # 0x17e8d6
leaq 0x10cc99(%rip), %rdx # 0x17e8d7
jmp 0x719c7
leaq 0x50(%rsp), %rdi
callq 0x2cc30
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
movq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
movq %rax, (%rsp)
movl %ecx, 0x8(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf38a4(%rip), %rsi # 0x16551e
leaq 0xf38b7(%rip), %rdx # 0x165538
leaq 0x10(%rsp), %rdi
callq 0x2c610
movsbl %bpl, %edx
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ca70
movb $0x1, %bpl
movq %rsp, %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x47336
leaq 0x197838(%rip), %rax # 0x2094f0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x197850(%rip), %rsi # 0x209518
leaq -0x115a3(%rip), %rdx # 0x6072c
movq %rbx, %rdi
callq 0x2e0f0
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71cf5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2d2d0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x71d0c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2d2d0
testb %bpl, %bpl
jne 0x71d32
jmp 0x71d3a
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x71d32
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2d2d0
jmp 0x71d32
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cc80
movq 0x19e117(%rip), %rsi # 0x20fe58
leaq 0x50(%rsp), %rdi
callq 0x2cce0
leaq 0xd0(%rsp), %rdi
callq 0x2c4d0
movq %r14, %rdi
callq 0x2e220
|
_ZN4YAML3Exp6EscapeB5cxx11ERNS_6StreamE:
push rbp
push r15
push r14
push rbx
sub rsp, 1D8h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi; this
call _ZN4YAML6Stream3getEv; YAML::Stream::get(void)
mov r15d, eax
mov rdi, r14; this
call _ZN4YAML6Stream3getEv; YAML::Stream::get(void)
mov ebp, eax
xor r15b, 27h
xor al, 27h
or al, r15b
jnz short loc_719E0
loc_719B2:
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aRepeatedMapKey+12h; "'"
lea rdx, aRepeatedMapKey+13h; ""
loc_719C7:
mov rdi, rbx
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_719CF:
mov rax, rbx
add rsp, 1D8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_719E0:
movzx eax, bpl
cmp eax, 5Bh ; '['
jle short loc_71A1C
add eax, 0FFFFFFA4h; switch 29 cases
cmp eax, 1Ch
ja def_71A03; jumptable 0000000000071A03 default case, cases 93,94,96,99,100,103-109,111-113,115,119
lea rcx, jpt_71A03
movsxd rax, ds:(jpt_71A03 - 165450h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_71A05:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 92
mov [rbx], rax
lea rsi, asc_16550C+4; "\\"
lea rdx, asc_16550C+5; ""
jmp short loc_719C7
loc_71A1C:
cmp eax, 2Eh ; '.'
jg short loc_71A4E
cmp eax, 21h ; '!'
jg short loc_71A80
cmp eax, 9
jz short loc_71A93; jumptable 0000000000071A03 case 116
cmp eax, 20h ; ' '
jnz def_71A03; jumptable 0000000000071A03 default case, cases 93,94,96,99,100,103-109,111-113,115,119
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aParsingAttempt+12h; " "
lea rdx, aParsingAttempt+13h; ""
jmp loc_719C7
loc_71A4E:
lea ecx, [rax-4Ch]; switch 10 cases
cmp ecx, 9
ja short def_71A64; jumptable 0000000000071A64 default case
lea rax, jpt_71A64
movsxd rcx, ds:(jpt_71A64 - 165428h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_71A66:
lea rax, [rbx+10h]; jumptable 0000000000071A64 case 76
mov [rbx], rax
lea rsi, unk_165516
lea rdx, unk_165519
jmp loc_719C7
loc_71A80:
cmp eax, 22h ; '"'
jz short loc_71AD9
cmp eax, 27h ; '''
jz loc_719B2
jmp def_71A03; jumptable 0000000000071A03 default case, cases 93,94,96,99,100,103-109,111-113,115,119
loc_71A93:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 116
mov [rbx], rax
lea rsi, asc_16537C+1; "\t"
lea rdx, asc_16537C+2; ""
jmp loc_719C7
def_71A64:
cmp eax, 2Fh ; '/'; jumptable 0000000000071A64 default case
jz loc_71C29
cmp eax, 30h ; '0'
jnz def_71A03; jumptable 0000000000071A03 default case, cases 93,94,96,99,100,103-109,111-113,115,119
lea rax, [rbx+10h]
mov [rbx], rax
mov word ptr [rbx+10h], 0
mov qword ptr [rbx+8], 1
jmp loc_719CF
loc_71AD9:
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aNoteThatEnumVa+82h; "\""
lea rdx, aNoteThatEnumVa+83h; ""
jmp loc_719C7
loc_71AF3:
mov rdi, rbx; jumptable 0000000000071A03 case 120
mov rsi, r14
mov edx, 2
jmp loc_71C1F
loc_71B03:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 110
mov [rbx], rax
lea rsi, aSyntax0+0Fh; "\n"
lea rdx, aSyntax0+10h; ""
jmp loc_719C7
loc_71B1D:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 102
mov [rbx], rax
lea rsi, unk_16550A
lea rdx, unk_16550B
jmp loc_719C7
loc_71B37:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 114
mov [rbx], rax
lea rsi, asc_16550C; "\r\x1B\\"
lea rdx, asc_16550C+1; "ᬀ尀"
jmp loc_719C7
loc_71B51:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 118
mov [rbx], rax
lea rsi, asc_165504+4; "\v"
lea rdx, asc_165504+5; ""
jmp loc_719C7
loc_71B6B:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 101
mov [rbx], rax
lea rsi, asc_16550C+2; "\x1B\\"
lea rdx, asc_16550C+3; "尀"
jmp loc_719C7
loc_71B85:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 98
mov [rbx], rax
lea rsi, asc_165504+2; "\b\v"
lea rdx, asc_165504+3; "\u0B00"
jmp loc_719C7
loc_71B9F:
mov rdi, rbx; jumptable 0000000000071A03 case 117
mov rsi, r14
mov edx, 4
jmp short loc_71C1F
loc_71BAC:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 97
mov [rbx], rax
lea rsi, asc_165504; "\a\b\v"
lea rdx, asc_165504+1; "ࠀ\u0B00"
jmp loc_719C7
loc_71BC6:
lea rax, [rbx+10h]; jumptable 0000000000071A03 case 95
mov [rbx], rax
lea rsi, unk_165514
lea rdx, unk_165515
jmp loc_719C7
loc_71BE0:
lea rax, [rbx+10h]; jumptable 0000000000071A64 case 80
mov [rbx], rax
lea rsi, unk_16551A
lea rdx, unk_16551D
jmp loc_719C7
loc_71BFA:
lea rax, [rbx+10h]; jumptable 0000000000071A64 case 78
mov [rbx], rax
lea rsi, unk_165512
lea rdx, unk_165513
jmp loc_719C7
loc_71C14:
mov rdi, rbx; jumptable 0000000000071A64 case 85
mov rsi, r14
mov edx, 8
loc_71C1F:
call _ZN4YAML3Exp6EscapeB5cxx11ERNS_6StreamEi; YAML::Exp::Escape(YAML::Stream &,int)
jmp loc_719CF
loc_71C29:
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aFile+6; "/"
lea rdx, aFile+7; ""
jmp loc_719C7
def_71A03:
lea rdi, [rsp+1F8h+var_1A8]; jumptable 0000000000071A03 default case, cases 93,94,96,99,100,103-109,111-113,115,119
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rax, [r14+8]
mov ecx, [r14+10h]
mov [rsp+1F8h+var_1F8], rax
mov [rsp+1F8h+var_1F0], ecx
lea r15, [rsp+1F8h+var_1D8]
mov [r15-10h], r15
lea rsi, aUnknownEscapeC; "unknown escape character: "
lea rdx, aUnknownEscapeC+1Ah; ""
lea rdi, [rsp+1F8h+var_1E8]
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)
movsx edx, bpl
lea rdi, [rsp+1F8h+var_1C8]
lea rsi, [rsp+1F8h+var_1E8]
call __ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S5_; std::operator+<char>(std::string&&,char)
mov bpl, 1
mov rsi, rsp
lea rdx, [rsp+1F8h+var_1C8]
mov rdi, rbx
call _ZN4YAML9ExceptionC2ERKNS_4MarkERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::Exception::Exception(YAML::Mark const&,std::string const&)
lea rax, _ZTVN4YAML15ParserExceptionE; `vtable for'YAML::ParserException
add rax, 10h
mov [rbx], rax
xor ebp, ebp
lea rsi, _ZTIN4YAML15ParserExceptionE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+1F8h+var_1B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_71CF5
mov rsi, [rsp+1F8h+var_1B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71CF5:
mov rdi, [rsp+1F8h+var_1E8]; void *
cmp rdi, r15
jz short loc_71D0C
mov rsi, [rsp+1F8h+var_1D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71D0C:
test bpl, bpl
jnz short loc_71D32
jmp short loc_71D3A
mov r14, rax
mov rdi, [rsp+1F8h+var_1E8]; void *
cmp rdi, r15
jz short loc_71D32
mov rsi, [rsp+1F8h+var_1D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_71D32
mov r14, rax
loc_71D32:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_71D3A:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1F8h+var_1A8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1F8h+var_128]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, r14
call __Unwind_Resume
|
long long YAML::Exp::Escape[abi:cxx11](long long a1, long long a2)
{
unsigned __int8 v2; // r15
unsigned __int8 v3; // bp
int v5; // edx
_QWORD *exception; // rbx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
int v10; // ecx
int v11; // r8d
int v12; // r9d
long long v13; // [rsp+0h] [rbp-1F8h] BYREF
long long v14; // [rsp+8h] [rbp-1F0h]
void *v15[2]; // [rsp+10h] [rbp-1E8h] BYREF
long long v16; // [rsp+20h] [rbp-1D8h] BYREF
_BYTE v17[16]; // [rsp+30h] [rbp-1C8h] BYREF
_BYTE v18[128]; // [rsp+50h] [rbp-1A8h] BYREF
v2 = YAML::Stream::get((YAML::Stream *)a2);
v3 = YAML::Stream::get((YAML::Stream *)a2);
if ( !(v2 ^ 0x27 | v3 ^ 0x27) )
{
LABEL_2:
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "'", "");
return a1;
}
if ( v3 > 0x5Bu )
{
switch ( v3 )
{
case '\\':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&asc_16550C[2], (char *)&asc_16550C[2] + 1);
return a1;
case '_':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&unk_165514, &unk_165515);
return a1;
case 'a':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)asc_165504, (char *)asc_165504 + 1);
return a1;
case 'b':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&asc_165504[1], (char *)&asc_165504[1] + 1);
return a1;
case 'e':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&asc_16550C[1], (char *)&asc_16550C[1] + 1);
return a1;
case 'f':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&unk_16550A, &unk_16550B);
return a1;
case 'n':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "\n", "");
return a1;
case 'r':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)asc_16550C, (char *)asc_16550C + 1);
return a1;
case 't':
goto LABEL_17;
case 'u':
v5 = 4;
goto LABEL_35;
case 'v':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&asc_165504[2], (char *)&asc_165504[2] + 1);
return a1;
case 'x':
v5 = 2;
goto LABEL_35;
default:
goto LABEL_37;
}
}
if ( v3 <= 0x2Eu )
{
if ( v3 > 0x21u )
{
if ( v3 == 34 )
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "\"", "");
return a1;
}
if ( v3 == 39 )
goto LABEL_2;
}
else
{
if ( v3 == 9 )
{
LABEL_17:
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "\t", "");
return a1;
}
if ( v3 == 32 )
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, " ", "");
return a1;
}
}
LABEL_37:
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v18);
exception = __cxa_allocate_exception(0x40uLL);
v7 = *(unsigned int *)(a2 + 16);
v13 = *(_QWORD *)(a2 + 8);
LODWORD(v14) = v7;
v15[0] = &v16;
std::string::_M_construct<char const*>(v15, "unknown escape character: ", "", v7, v8, v9, v13, v14);
std::operator+<char>(v17, v15, (unsigned int)(char)v3);
YAML::Exception::Exception((_DWORD)exception, (unsigned int)&v13, (unsigned int)v17, v10, v11, v12);
*exception = &`vtable for'YAML::ParserException + 2;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'YAML::ParserException,
(void (*)(void *))YAML::Exception::~Exception);
}
switch ( v3 )
{
case 'L':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, byte_165516, &unk_165519);
return a1;
case 'M':
case 'O':
case 'Q':
case 'R':
case 'S':
case 'T':
goto LABEL_37;
case 'N':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, (const char *)&unk_165512, &unk_165513);
return a1;
case 'P':
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, byte_16551A, &unk_16551D);
return a1;
case 'U':
v5 = 8;
LABEL_35:
YAML::Exp::Escape[abi:cxx11](a1, a2, v5);
return a1;
default:
if ( v3 == 47 )
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "/", "");
return a1;
}
if ( v3 != 48 )
goto LABEL_37;
*(_QWORD *)a1 = a1 + 16;
*(_WORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 8) = 1LL;
break;
}
return a1;
}
|
Escape[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x1d8
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0016d726
MOV R15D,EAX
MOV RDI,R14
CALL 0x0016d726
MOV EBP,EAX
XOR R15B,0x27
XOR AL,0x27
OR AL,R15B
JNZ 0x001719e0
LAB_001719b2:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x271f74]
LEA RDX,[0x271f75]
LAB_001719c7:
MOV RDI,RBX
CALL 0x0012c610
LAB_001719cf:
MOV RAX,RBX
ADD RSP,0x1d8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001719e0:
MOVZX EAX,BPL
CMP EAX,0x5b
JLE 0x00171a1c
ADD EAX,-0x5c
CMP EAX,0x1c
JA 0x00171c43
LEA RCX,[0x265450]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5c:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265510]
LEA RDX,[0x265511]
JMP 0x001719c7
LAB_00171a1c:
CMP EAX,0x2e
JG 0x00171a4e
CMP EAX,0x21
JG 0x00171a80
CMP EAX,0x9
JZ 0x00171a93
CMP EAX,0x20
JNZ 0x00171c43
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26e6d9]
LEA RDX,[0x26e6da]
JMP 0x001719c7
LAB_00171a4e:
LEA ECX,[RAX + -0x4c]
CMP ECX,0x9
JA 0x00171aad
LEA RAX,[0x265428]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_4c:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265516]
LEA RDX,[0x265519]
JMP 0x001719c7
LAB_00171a80:
CMP EAX,0x22
JZ 0x00171ad9
CMP EAX,0x27
JZ 0x001719b2
JMP 0x00171c43
caseD_74:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26537d]
LEA RDX,[0x26537e]
JMP 0x001719c7
default:
CMP EAX,0x2f
JZ 0x00171c29
CMP EAX,0x30
JNZ 0x00171c43
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV word ptr [RBX + 0x10],0x0
MOV qword ptr [RBX + 0x8],0x1
JMP 0x001719cf
LAB_00171ad9:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26cf48]
LEA RDX,[0x26cf49]
JMP 0x001719c7
caseD_78:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x2
JMP 0x00171c1f
caseD_6e:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26c05f]
LEA RDX,[0x26c060]
JMP 0x001719c7
caseD_66:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26550a]
LEA RDX,[0x26550b]
JMP 0x001719c7
caseD_72:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26550c]
LEA RDX,[0x26550d]
JMP 0x001719c7
caseD_76:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265508]
LEA RDX,[0x265509]
JMP 0x001719c7
caseD_65:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26550e]
LEA RDX,[0x26550f]
JMP 0x001719c7
caseD_62:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265506]
LEA RDX,[0x265507]
JMP 0x001719c7
caseD_75:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x4
JMP 0x00171c1f
caseD_61:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265504]
LEA RDX,[0x265505]
JMP 0x001719c7
caseD_5f:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265514]
LEA RDX,[0x265515]
JMP 0x001719c7
caseD_50:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x26551a]
LEA RDX,[0x26551d]
JMP 0x001719c7
caseD_4e:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x265512]
LEA RDX,[0x265513]
JMP 0x001719c7
caseD_55:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x8
LAB_00171c1f:
CALL 0x001710be
JMP 0x001719cf
LAB_00171c29:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x27e8d6]
LEA RDX,[0x27e8d7]
JMP 0x001719c7
caseD_5d:
LEA RDI,[RSP + 0x50]
CALL 0x0012cc30
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x10]
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0x8],ECX
LEA R15,[RSP + 0x20]
MOV qword ptr [R15 + -0x10],R15
LAB_00171c73:
LEA RSI,[0x26551e]
LEA RDX,[0x265538]
LEA RDI,[RSP + 0x10]
CALL 0x0012c610
LAB_00171c8b:
MOVSX EDX,BPL
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
CALL 0x0012ca70
MOV BPL,0x1
LAB_00171ca1:
MOV RSI,RSP
LEA RDX,[RSP + 0x30]
MOV RDI,RBX
CALL 0x00147336
LEA RAX,[0x3094f0]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
XOR EBP,EBP
LEA RSI,[0x309518]
LEA RDX,[0x16072c]
MOV RDI,RBX
CALL 0x0012e0f0
|
/* YAML::Exp::Escape[abi:cxx11](YAML::Stream&) */
Exp * __thiscall YAML::Exp::Escape_abi_cxx11_(Exp *this,Stream *param_1)
{
char cVar1;
byte bVar2;
Exception *this_00;
int iVar3;
char *pcVar4;
char *pcVar5;
int8 local_1f8;
int4 local_1f0;
int1 *local_1e8 [2];
int1 local_1d8 [16];
string local_1c8 [32];
stringstream local_1a8 [392];
cVar1 = Stream::get(param_1);
bVar2 = Stream::get(param_1);
if (bVar2 == 0x27 && cVar1 == '\'') {
LAB_001719b2:
*(Exp **)this = this + 0x10;
pcVar5 = "\'";
pcVar4 = "";
goto LAB_001719c7;
}
if (bVar2 < 0x5c) {
if (0x2e < bVar2) {
switch(bVar2) {
case 0x4c:
*(Exp **)this = this + 0x10;
pcVar5 = &DAT_00265516;
pcVar4 = "";
break;
case 0x4d:
case 0x4f:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
switchD_00171a03_caseD_5d:
std::__cxx11::stringstream::stringstream(local_1a8);
this_00 = (Exception *)__cxa_allocate_exception(0x40);
local_1f8 = *(int8 *)(param_1 + 8);
local_1f0 = *(int4 *)(param_1 + 0x10);
local_1e8[0] = local_1d8;
/* try { // try from 00171c73 to 00171c8a has its CatchHandler @ 00171d2f */
std::__cxx11::string::_M_construct<char_const*>(local_1e8,"unknown escape character: ","");
/* try { // try from 00171c8b to 00171c9d has its CatchHandler @ 00171d13 */
std::operator+(local_1c8,(char)local_1e8);
/* try { // try from 00171ca1 to 00171cd6 has its CatchHandler @ 00171cd7 */
Exception::Exception(this_00,(Mark *)&local_1f8,local_1c8);
*(int ***)this_00 = &PTR__BadInsert_00309500;
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&ParserException::typeinfo,BadInsert::~BadInsert);
case 0x4e:
*(Exp **)this = this + 0x10;
pcVar5 = &DAT_00265512;
pcVar4 = "";
break;
case 0x50:
*(Exp **)this = this + 0x10;
pcVar5 = &DAT_0026551a;
pcVar4 = "";
break;
case 0x55:
iVar3 = 8;
goto LAB_00171c1f;
default:
if (bVar2 != 0x2f) {
if (bVar2 == 0x30) {
*(Exp **)this = this + 0x10;
*(int2 *)(this + 0x10) = 0;
*(int8 *)(this + 8) = 1;
return this;
}
goto switchD_00171a03_caseD_5d;
}
*(Exp **)this = this + 0x10;
pcVar5 = "/";
pcVar4 = "";
}
goto LAB_001719c7;
}
if (0x21 < bVar2) {
if (bVar2 == 0x22) {
*(Exp **)this = this + 0x10;
pcVar5 = "\"";
pcVar4 = "";
goto LAB_001719c7;
}
if (bVar2 != 0x27) goto switchD_00171a03_caseD_5d;
goto LAB_001719b2;
}
if (bVar2 != 9) {
if (bVar2 != 0x20) goto switchD_00171a03_caseD_5d;
*(Exp **)this = this + 0x10;
pcVar5 = " ";
pcVar4 = "";
goto LAB_001719c7;
}
switchD_00171a03_caseD_74:
*(Exp **)this = this + 0x10;
pcVar5 = "\t";
pcVar4 = "";
goto LAB_001719c7;
}
switch(bVar2) {
case 0x5c:
*(Exp **)this = this + 0x10;
pcVar5 = "\\";
pcVar4 = "";
break;
default:
goto switchD_00171a03_caseD_5d;
case 0x5f:
*(Exp **)this = this + 0x10;
pcVar5 = &DAT_00265514;
pcVar4 = "";
break;
case 0x61:
*(Exp **)this = this + 0x10;
pcVar5 = "\a";
pcVar4 = "";
break;
case 0x62:
*(Exp **)this = this + 0x10;
pcVar5 = "\b";
pcVar4 = "";
break;
case 0x65:
*(Exp **)this = this + 0x10;
pcVar5 = "\x1b";
pcVar4 = "";
break;
case 0x66:
*(Exp **)this = this + 0x10;
pcVar5 = "\f";
pcVar4 = "";
break;
case 0x6e:
*(Exp **)this = this + 0x10;
pcVar5 = "\n";
pcVar4 = "";
break;
case 0x72:
*(Exp **)this = this + 0x10;
pcVar5 = "\r";
pcVar4 = "";
break;
case 0x74:
goto switchD_00171a03_caseD_74;
case 0x75:
iVar3 = 4;
goto LAB_00171c1f;
case 0x76:
*(Exp **)this = this + 0x10;
pcVar5 = "\v";
pcVar4 = "";
break;
case 0x78:
iVar3 = 2;
LAB_00171c1f:
Escape_abi_cxx11_(this,param_1,iVar3);
return this;
}
LAB_001719c7:
std::__cxx11::string::_M_construct<char_const*>(this,pcVar5,pcVar4);
return this;
}
|
|
63,177 |
ha_federated::real_query(char const*, unsigned long)
|
eloqsql/storage/federated/ha_federated.cc
|
int ha_federated::real_query(const char *query, size_t length)
{
int rc= 0;
DBUG_ENTER("ha_federated::real_query");
if (!query || !length)
goto end;
if (!mysql && (rc= real_connect()))
goto end;
mysql->net.thd= table->in_use;
rc= mysql_real_query(mysql, query, (uint) length);
end:
DBUG_RETURN(rc);
}
|
O3
|
cpp
|
ha_federated::real_query(char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
testq %rsi, %rsi
sete %cl
testq %rdx, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xa1d5
movq %rsi, %rbx
movq %rdi, %r15
movq 0x540(%rdi), %rax
testq %rax, %rax
je 0xa1c2
movq 0x10(%r15), %rcx
movq 0x48(%rcx), %rcx
movq %rcx, 0x88(%rax)
movq 0x540(%r15), %rdi
movl %r14d, %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8110
movq %r15, %rdi
callq 0x81d0
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0xa1e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x540(%r15), %rax
jmp 0xa197
nop
|
_ZN12ha_federated10real_queryEPKcm:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rdx
test rsi, rsi
setz cl
test rdx, rdx
setz dl
xor eax, eax
or dl, cl
jnz short loc_A1D5
mov rbx, rsi
mov r15, rdi
mov rax, [rdi+540h]
test rax, rax
jz short loc_A1C2
loc_A197:
mov rcx, [r15+10h]
mov rcx, [rcx+48h]
mov [rax+88h], rcx
mov rdi, [r15+540h]
mov edx, r14d
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _mysql_real_query
loc_A1C2:
mov rdi, r15; this
call __ZN12ha_federated12real_connectEv; ha_federated::real_connect(void)
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jz short loc_A1E0
loc_A1D5:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_A1E0:
mov rax, [r15+540h]
jmp short loc_A197
|
long long ha_federated::real_query(ha_federated *this, const char *a2, long long a3)
{
unsigned int v3; // r14d
long long result; // rax
long long v5; // rax
int v6; // ecx
v3 = a3;
result = 0LL;
if ( a2 != 0LL && a3 != 0 )
{
v5 = *((_QWORD *)this + 168);
if ( v5 )
{
LABEL_3:
*(_QWORD *)(v5 + 136) = *(_QWORD *)(*((_QWORD *)this + 2) + 72LL);
return mysql_real_query(*((_QWORD *)this + 168), a2, v3);
}
v6 = ha_federated::real_connect(this);
result = 0xFFFFFFFFLL;
if ( !v6 )
{
v5 = *((_QWORD *)this + 168);
goto LABEL_3;
}
}
return result;
}
|
real_query:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
TEST RSI,RSI
SETZ CL
TEST RDX,RDX
SETZ DL
XOR EAX,EAX
OR DL,CL
JNZ 0x0010a1d5
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x540]
TEST RAX,RAX
JZ 0x0010a1c2
LAB_0010a197:
MOV RCX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [RCX + 0x48]
MOV qword ptr [RAX + 0x88],RCX
MOV RDI,qword ptr [R15 + 0x540]
MOV EDX,R14D
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00108110
LAB_0010a1c2:
MOV RDI,R15
CALL 0x001081d0
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JZ 0x0010a1e0
LAB_0010a1d5:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0010a1e0:
MOV RAX,qword ptr [R15 + 0x540]
JMP 0x0010a197
|
/* ha_federated::real_query(char const*, unsigned long) */
int8 __thiscall ha_federated::real_query(ha_federated *this,char *param_1,ulong param_2)
{
int iVar1;
long lVar2;
int8 uVar3;
if (param_2 == 0 || param_1 == (char *)0x0) {
return 0;
}
lVar2 = *(long *)(this + 0x540);
if (lVar2 == 0) {
iVar1 = real_connect(this);
if (iVar1 != 0) {
return 0xffffffff;
}
lVar2 = *(long *)(this + 0x540);
}
*(int8 *)(lVar2 + 0x88) = *(int8 *)(*(long *)(this + 0x10) + 0x48);
uVar3 = mysql_real_query(*(int8 *)(this + 0x540),param_1,param_2 & 0xffffffff);
return uVar3;
}
|
|
63,178 |
ma_make_key
|
eloqsql/storage/maria/ma_key.c
|
MARIA_KEY *_ma_make_key(MARIA_HA *info, MARIA_KEY *int_key, uint keynr,
uchar *key, const uchar *record,
MARIA_RECORD_POS filepos, ulonglong trid)
{
const uchar *pos;
reg1 HA_KEYSEG *keyseg;
my_bool is_ft;
DBUG_ENTER("_ma_make_key");
int_key->data= key;
int_key->flag= 0; /* Always return full key */
int_key->keyinfo= info->s->keyinfo + keynr;
is_ft= int_key->keyinfo->flag & HA_FULLTEXT;
for (keyseg= int_key->keyinfo->seg ; keyseg->type ;keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint length=keyseg->length;
uint char_length;
CHARSET_INFO *cs=keyseg->charset;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
*key++= 0; /* NULL in key */
continue;
}
*key++=1; /* Not NULL */
}
char_length= ((!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
length);
pos= record+keyseg->start;
if (type == HA_KEYTYPE_BIT)
{
if (keyseg->bit_length)
{
uchar bits= get_rec_bits(record + keyseg->bit_pos,
keyseg->bit_start, keyseg->bit_length);
*key++= (char) bits;
length--;
}
memcpy(key, pos, length);
key+= length;
continue;
}
if (keyseg->flag & HA_SPACE_PACK)
{
if (type != HA_KEYTYPE_NUM)
{
length= (uint) my_ci_lengthsp(cs, (const char*)pos, length);
}
else
{
const uchar *end= pos + length;
while (pos < end && pos[0] == ' ')
pos++;
length= (uint) (end-pos);
}
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos, (size_t) char_length);
key+=char_length;
continue;
}
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= (keyseg->bit_start == 1 ? 1 : 2);
uint tmp_length= (pack_length == 1 ? (uint) *pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key,pos,(size_t) char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length= _ma_calc_blob_length(keyseg->bit_start,pos);
uchar *blob_pos;
memcpy(&blob_pos, pos+keyseg->bit_start,sizeof(char*));
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, blob_pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, blob_pos, (size_t) char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_SWAP_KEY)
{ /* Numerical column */
if (type == HA_KEYTYPE_FLOAT)
{
float nr;
float4get(nr,pos);
if (isnan(nr))
{
/* Replace NAN with zero */
bzero(key,length);
key+=length;
continue;
}
}
else if (type == HA_KEYTYPE_DOUBLE)
{
double nr;
float8get(nr,pos);
if (isnan(nr))
{
bzero(key,length);
key+=length;
continue;
}
}
pos+=length;
while (length--)
{
*key++ = *--pos;
}
continue;
}
FIX_LENGTH(cs, pos, length, char_length);
memcpy(key, pos, char_length);
if (length > char_length)
my_ci_fill(cs, (char*) key+char_length, length-char_length, ' ');
key+= length;
}
_ma_dpointer(info->s, key, filepos);
int_key->data_length= (uint)(key - int_key->data);
int_key->ref_length= info->s->rec_reflength;
int_key->flag= 0;
if (_ma_have_versioning(info) && trid)
{
int_key->ref_length+= transid_store_packed(info,
key + int_key->ref_length,
(TrID) trid);
int_key->flag|= SEARCH_USER_KEY_HAS_TRANSID;
}
DBUG_PRINT("exit",("keynr: %d",keynr));
DBUG_DUMP_KEY("key", int_key);
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE, int_key););
DBUG_RETURN(int_key);
}
|
O3
|
c
|
ma_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x58(%rbp)
movq %rcx, (%rsi)
movl $0x0, 0x18(%rsi)
movq %rdi, -0x60(%rbp)
movq (%rdi), %rax
movq 0x570(%rax), %rdi
movl %edx, %eax
imulq $0x118, %rax, %rdx # imm = 0x118
leaq (%rdi,%rdx), %rax
movq %rsi, -0x68(%rbp)
movq %rax, 0x8(%rsi)
movq 0xc0(%rdi,%rdx), %r13
movb 0x18(%r13), %sil
testb %sil, %sil
je 0x3f947
movq %r8, %r14
movzwl 0xa2(%rax), %eax
movw %ax, -0x32(%rbp)
leaq -0x1(%r8), %rax
movq %rax, -0x50(%rbp)
movq %r8, -0x40(%rbp)
movzwl 0x14(%r13), %ebx
movq (%r13), %r15
movb 0x19(%r13), %al
testb %al, %al
je 0x3f5ab
movl 0xc(%r13), %edx
leaq 0x1(%rcx), %rdi
testb %al, (%r14,%rdx)
je 0x3f5b0
movb $0x0, (%rcx)
jmp 0x3f893
movq %rcx, %rdi
jmp 0x3f5b3
movb $0x1, (%rcx)
cmpb $0x0, -0x32(%rbp)
setns %al
testq %r15, %r15
setne %cl
andb %al, %cl
movl %ebx, %edx
cmpb $0x1, %cl
jne 0x3f5df
movl 0x9c(%r15), %ecx
movl %ebx, %edx
cmpl $0x2, %ecx
jb 0x3f5df
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %edx
movl 0x8(%r13), %eax
leaq (%r14,%rax), %r12
cmpb $0x13, %sil
jne 0x3f650
movzbl 0x1b(%r13), %eax
testl %eax, %eax
je 0x3f635
movq %rdi, %r8
movzwl 0x10(%r13), %esi
movzbl 0x1a(%r13), %ecx
movzbl (%r14,%rsi), %edx
leal (%rcx,%rax), %edi
cmpl $0x9, %edi
jb 0x3f61b
movzbl 0x1(%r14,%rsi), %esi
shll $0x8, %esi
orl %esi, %edx
movq %r8, %rdi
shrl %cl, %edx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %esi
notl %esi
andl %edx, %esi
movb %sil, (%r8)
incq %rdi
decl %ebx
movl %ebx, %ebx
movq %rdi, %r15
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2a0a0
movq %r15, %rdi
addq %rbx, %rdi
jmp 0x3f893
movzwl 0x12(%r13), %ecx
testb $0x1, %cl
jne 0x3f6f1
testb $0x8, %cl
jne 0x3f718
movq %rdx, -0x48(%rbp)
testb $0x20, %cl
jne 0x3f7b6
testb $0x40, %cl
jne 0x3f8ac
movq -0x48(%rbp), %rax
cmpl %ebx, %eax
jae 0x3f6a1
leaq (%r12,%rbx), %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %rdi, %r14
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r14, %rdi
cmpl %ebx, %eax
movl %ebx, %r14d
cmovbl %eax, %r14d
movq %rdi, -0x30(%rbp)
movq %r12, %rsi
movq %rax, %r12
movq %r14, %rdx
callq 0x2a0a0
cmpl %ebx, %r12d
movq -0x30(%rbp), %r12
jae 0x3f6e2
movq %r14, %rsi
addq %r12, %rsi
movl %ebx, %edx
subl %r14d, %edx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movl $0x20, %ecx
callq *0x78(%rax)
addq %rbx, %r12
movq -0x40(%rbp), %r14
movq %r12, %rdi
jmp 0x3f893
cmpb $0x7, %sil
movq %rdi, -0x30(%rbp)
jne 0x3f732
leaq (%r12,%rbx), %r14
testq %rbx, %rbx
je 0x3f713
cmpb $0x20, (%r12)
jne 0x3f713
incq %r12
cmpq %r14, %r12
jb 0x3f704
subq %r12, %r14
jmp 0x3f74e
cmpb $0x1, 0x1a(%r13)
jne 0x3f81d
movzbl (%r12), %eax
movl $0x1, %ecx
jmp 0x3f827
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rdx, %r14
movq %rbx, %rdx
callq *0x18(%rax)
movq %r14, %rdx
movq %rax, %r14
cmpl %r14d, %edx
jae 0x3f771
movq %rdx, %rax
movl %r14d, %edx
addq %r12, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %rax, %rdx
movq -0x30(%rbp), %rcx
cmpl %r14d, %edx
cmovael %r14d, %edx
cmpl $0xff, %edx
jae 0x3f78c
leaq 0x1(%rcx), %rbx
movl %edx, %eax
jmp 0x3f798
movb %dl, 0x2(%rcx)
movb %dh, 0x1(%rcx)
leaq 0x3(%rcx), %rbx
movb $-0x1, %al
movb %al, (%rcx)
movl %edx, %r14d
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2a0a0
addq %r14, %rbx
movq %rbx, %rdi
jmp 0x3f88f
movq %rdi, -0x30(%rbp)
movzbl 0x1a(%r13), %edi
movq %r12, %rsi
callq 0x4750b
movq %rax, %rdx
movzbl 0x1a(%r13), %eax
movq (%r12,%rax), %r14
cmpl %edx, %ebx
cmovbl %ebx, %edx
movq -0x48(%rbp), %rax
cmpl %eax, %edx
jbe 0x3f7fd
movq %rdx, %rbx
movl %ebx, %edx
addq %r14, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rbx, %rdx
movq -0x30(%rbp), %rcx
cmpl %edx, %eax
cmovbl %eax, %edx
cmpl $0xff, %edx
jae 0x3f8d9
leaq 0x1(%rcx), %rbx
movl %edx, %eax
jmp 0x3f8e5
movzwl (%r12), %eax
movl $0x2, %ecx
addq %rcx, %r12
cmpl %ebx, %eax
cmovbl %eax, %ebx
cmpl %edx, %ebx
jbe 0x3f856
movq %rdx, %rax
movl %ebx, %edx
addq %r12, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %rdi, %r14
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rdx
cmpl %ebx, %edx
cmovbl %edx, %ebx
cmpl $0xff, %ebx
jae 0x3f86b
leaq 0x1(%rdi), %r14
movl %ebx, %eax
jmp 0x3f877
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
leaq 0x3(%rdi), %r14
movb $-0x1, %al
movb %al, (%rdi)
movl %ebx, %ebx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2a0a0
addq %rbx, %r14
movq %r14, %rdi
movq -0x40(%rbp), %r14
movb 0x38(%r13), %sil
addq $0x20, %r13
movq %rdi, %rcx
testb %sil, %sil
jne 0x3f584
jmp 0x3f94a
cmpb $0x6, %sil
je 0x3f900
movzbl %sil, %ecx
cmpl $0x5, %ecx
jne 0x3f90c
movss (%r12), %xmm0
ucomiss %xmm0, %xmm0
jnp 0x3f90c
movq %rdi, %r15
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2a290
leaq (%rbx,%r15), %rdi
jmp 0x3f893
movb %dl, 0x2(%rcx)
movb %dh, 0x1(%rcx)
leaq 0x3(%rcx), %rbx
movb $-0x1, %al
movb %al, (%rcx)
movl %edx, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2a0a0
addq %r15, %rbx
jmp 0x3f7ae
movsd (%r12), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3f935
testl %ebx, %ebx
je 0x3f893
addq %rbx, %rax
addq -0x50(%rbp), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movb (%rax,%rcx), %sil
movb %sil, (%rdi,%rdx)
decq %rcx
incq %rdx
cmpl %edx, %ebx
jne 0x3f91b
subq %rcx, %rdi
jmp 0x3f893
movq %rdi, %r15
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2a290
jmp 0x3f645
movq %rcx, %rdi
movq -0x60(%rbp), %r14
movq %rdi, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rdx
callq 0x3b720
movq %rbx, %rsi
movq -0x68(%rbp), %rbx
movl (%rbx), %eax
movl %esi, %ecx
subl %eax, %ecx
movl %ecx, 0x10(%rbx)
movq (%r14), %rax
movl 0x740(%rax), %eax
movl %eax, 0x14(%rbx)
movl $0x0, 0x18(%rbx)
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x3f9aa
movl 0x618(%r14), %ecx
andl $0x1, %ecx
je 0x3f9aa
addq %rax, %rsi
movq %r14, %rdi
callq 0x3f440
addl %eax, 0x14(%rbx)
orb $0x8, 0x1a(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_58], r9
mov [rsi], rcx
mov dword ptr [rsi+18h], 0
mov [rbp+var_60], rdi
mov rax, [rdi]
mov rdi, [rax+570h]
mov eax, edx
imul rdx, rax, 118h
lea rax, [rdi+rdx]
mov [rbp+var_68], rsi
mov [rsi+8], rax
mov r13, [rdi+rdx+0C0h]
mov sil, [r13+18h]
test sil, sil
jz loc_3F947
mov r14, r8
movzx eax, word ptr [rax+0A2h]
mov [rbp+var_32], ax
lea rax, [r8-1]
mov [rbp+var_50], rax
mov [rbp+var_40], r8
loc_3F584:
movzx ebx, word ptr [r13+14h]
mov r15, [r13+0]
mov al, [r13+19h]
test al, al
jz short loc_3F5AB
mov edx, [r13+0Ch]
lea rdi, [rcx+1]
test [r14+rdx], al
jz short loc_3F5B0
mov byte ptr [rcx], 0
jmp loc_3F893
loc_3F5AB:
mov rdi, rcx
jmp short loc_3F5B3
loc_3F5B0:
mov byte ptr [rcx], 1
loc_3F5B3:
cmp byte ptr [rbp+var_32], 0
setns al
test r15, r15
setnz cl
and cl, al
mov edx, ebx
cmp cl, 1
jnz short loc_3F5DF
mov ecx, [r15+9Ch]
mov edx, ebx
cmp ecx, 2
jb short loc_3F5DF
mov eax, ebx
xor edx, edx
div ecx
mov edx, eax
loc_3F5DF:
mov eax, [r13+8]
lea r12, [r14+rax]
cmp sil, 13h
jnz short loc_3F650
movzx eax, byte ptr [r13+1Bh]
test eax, eax
jz short loc_3F635
mov r8, rdi
movzx esi, word ptr [r13+10h]
movzx ecx, byte ptr [r13+1Ah]
movzx edx, byte ptr [r14+rsi]
lea edi, [rcx+rax]
cmp edi, 9
jb short loc_3F61B
movzx esi, byte ptr [r14+rsi+1]
shl esi, 8
or edx, esi
loc_3F61B:
mov rdi, r8
shr edx, cl
mov esi, 0FFFFFFFFh
mov ecx, eax
shl esi, cl
not esi
and esi, edx
mov [r8], sil
inc rdi
dec ebx
loc_3F635:
mov ebx, ebx
mov r15, rdi
mov rsi, r12
mov rdx, rbx
call _memcpy
loc_3F645:
mov rdi, r15
add rdi, rbx
jmp loc_3F893
loc_3F650:
movzx ecx, word ptr [r13+12h]
test cl, 1
jnz loc_3F6F1
test cl, 8
jnz loc_3F718
mov [rbp+var_48], rdx
test cl, 20h
jnz loc_3F7B6
test cl, 40h
jnz loc_3F8AC
mov rax, [rbp+var_48]
cmp eax, ebx
jnb short loc_3F6A1
lea rdx, [r12+rbx]
mov ecx, eax
mov rax, [r15+0B8h]
mov r14, rdi
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdi, r14
loc_3F6A1:
cmp eax, ebx
mov r14d, ebx
cmovb r14d, eax
mov [rbp+var_30], rdi
mov rsi, r12
mov r12, rax
mov rdx, r14
call _memcpy
cmp r12d, ebx
mov r12, [rbp+var_30]
jnb short loc_3F6E2
mov rsi, r14
add rsi, r12
mov edx, ebx
sub edx, r14d
mov rax, [r15+0B8h]
mov rdi, r15
mov ecx, 20h ; ' '
call qword ptr [rax+78h]
loc_3F6E2:
add r12, rbx
mov r14, [rbp+var_40]
mov rdi, r12
jmp loc_3F893
loc_3F6F1:
cmp sil, 7
mov [rbp+var_30], rdi
jnz short loc_3F732
lea r14, [r12+rbx]
test rbx, rbx
jz short loc_3F713
loc_3F704:
cmp byte ptr [r12], 20h ; ' '
jnz short loc_3F713
inc r12
cmp r12, r14
jb short loc_3F704
loc_3F713:
sub r14, r12
jmp short loc_3F74E
loc_3F718:
cmp byte ptr [r13+1Ah], 1
jnz loc_3F81D
movzx eax, byte ptr [r12]
mov ecx, 1
jmp loc_3F827
loc_3F732:
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov r14, rdx
mov rdx, rbx
call qword ptr [rax+18h]
mov rdx, r14
mov r14, rax
loc_3F74E:
cmp edx, r14d
jnb short loc_3F771
mov rax, rdx
mov edx, r14d
add rdx, r12
mov ecx, eax
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdx, rax
loc_3F771:
mov rcx, [rbp+var_30]
cmp edx, r14d
cmovnb edx, r14d
cmp edx, 0FFh
jnb short loc_3F78C
lea rbx, [rcx+1]
mov eax, edx
jmp short loc_3F798
loc_3F78C:
mov [rcx+2], dl
mov [rcx+1], dh
lea rbx, [rcx+3]
mov al, 0FFh
loc_3F798:
mov [rcx], al
mov r14d, edx
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _memcpy
add rbx, r14
loc_3F7AE:
mov rdi, rbx
jmp loc_3F88F
loc_3F7B6:
mov [rbp+var_30], rdi
movzx edi, byte ptr [r13+1Ah]
mov rsi, r12
call _ma_calc_blob_length
mov rdx, rax
movzx eax, byte ptr [r13+1Ah]
mov r14, [r12+rax]
cmp ebx, edx
cmovb edx, ebx
mov rax, [rbp+var_48]
cmp edx, eax
jbe short loc_3F7FD
mov rbx, rdx
mov edx, ebx
add rdx, r14
mov ecx, eax
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r14
call qword ptr [rax+10h]
mov rdx, rbx
loc_3F7FD:
mov rcx, [rbp+var_30]
cmp eax, edx
cmovb edx, eax
cmp edx, 0FFh
jnb loc_3F8D9
lea rbx, [rcx+1]
mov eax, edx
jmp loc_3F8E5
loc_3F81D:
movzx eax, word ptr [r12]
mov ecx, 2
loc_3F827:
add r12, rcx
cmp eax, ebx
cmovb ebx, eax
cmp ebx, edx
jbe short loc_3F856
mov rax, rdx
mov edx, ebx
add rdx, r12
mov ecx, eax
mov rax, [r15+0B8h]
mov r14, rdi
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdi, r14
mov rdx, rax
loc_3F856:
cmp edx, ebx
cmovb ebx, edx
cmp ebx, 0FFh
jnb short loc_3F86B
lea r14, [rdi+1]
mov eax, ebx
jmp short loc_3F877
loc_3F86B:
mov [rdi+2], bl
mov [rdi+1], bh
lea r14, [rdi+3]
mov al, 0FFh
loc_3F877:
mov [rdi], al
mov ebx, ebx
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call _memcpy
add r14, rbx
mov rdi, r14
loc_3F88F:
mov r14, [rbp+var_40]
loc_3F893:
mov sil, [r13+38h]
add r13, 20h ; ' '
mov rcx, rdi
test sil, sil
jnz loc_3F584
jmp loc_3F94A
loc_3F8AC:
cmp sil, 6
jz short loc_3F900
movzx ecx, sil
cmp ecx, 5
jnz short loc_3F90C
movss xmm0, dword ptr [r12]
ucomiss xmm0, xmm0
jnp short loc_3F90C
mov r15, rdi
xor esi, esi
mov rdx, rbx
call _memset
lea rdi, [rbx+r15]
jmp short loc_3F893
loc_3F8D9:
mov [rcx+2], dl
mov [rcx+1], dh
lea rbx, [rcx+3]
mov al, 0FFh
loc_3F8E5:
mov [rcx], al
mov r15d, edx
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _memcpy
add rbx, r15
jmp loc_3F7AE
loc_3F900:
movsd xmm0, qword ptr [r12]
ucomisd xmm0, xmm0
jp short loc_3F935
loc_3F90C:
test ebx, ebx
jz short loc_3F893
add rax, rbx
add rax, [rbp+var_50]
xor edx, edx
xor ecx, ecx
loc_3F91B:
mov sil, [rax+rcx]
mov [rdi+rdx], sil
dec rcx
inc rdx
cmp ebx, edx
jnz short loc_3F91B
sub rdi, rcx
jmp loc_3F893
loc_3F935:
mov r15, rdi
xor esi, esi
mov rdx, rbx
call _memset
jmp loc_3F645
loc_3F947:
mov rdi, rcx
loc_3F94A:
mov r14, [rbp+var_60]
mov rbx, rdi
mov rdi, [r14]
mov rsi, rbx
mov rdx, [rbp+var_58]
call _ma_dpointer
mov rsi, rbx
mov rbx, [rbp+var_68]
mov eax, [rbx]
mov ecx, esi
sub ecx, eax
mov [rbx+10h], ecx
mov rax, [r14]
mov eax, [rax+740h]
mov [rbx+14h], eax
mov dword ptr [rbx+18h], 0
mov rdx, [rbp+arg_0]
test rdx, rdx
jz short loc_3F9AA
mov ecx, [r14+618h]
and ecx, 1
jz short loc_3F9AA
add rsi, rax
mov rdi, r14
call transid_store_packed
add [rbx+14h], eax
or byte ptr [rbx+1Ah], 8
loc_3F9AA:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_make_key(long long a1, long long a2, unsigned int a3, char *a4, long long a5, long long a6, long long a7)
{
long long v7; // rax
long long *v8; // r13
char v9; // si
long long v10; // r14
long long v11; // rbx
long long v12; // r15
unsigned __int8 v13; // al
char *v14; // rdi
unsigned int v15; // edx
unsigned int v16; // ecx
long long v17; // rax
_BYTE *v18; // r12
int v19; // eax
long long v20; // rsi
int v21; // ecx
unsigned int v22; // edx
__int16 v23; // cx
unsigned int v24; // eax
long long v25; // r14
_BYTE *v26; // rsi
unsigned int v27; // r12d
_BYTE *v28; // r14
unsigned int v29; // r14d
unsigned int v30; // eax
long long v31; // rcx
unsigned int v32; // r14d
unsigned int v33; // eax
_BYTE *v34; // rbx
char v35; // al
long long v36; // r14
char *v37; // rbx
unsigned int v38; // edx
long long v39; // r14
unsigned int v40; // eax
unsigned int v41; // ebx
_BYTE *v42; // rbx
char v43; // al
_BYTE *v44; // r12
_BYTE *v45; // r14
char v46; // al
long long v47; // r15
long long v48; // rax
long long v49; // rdx
long long v50; // rcx
long long v51; // rax
long long v56; // [rsp+20h] [rbp-50h]
unsigned int v57; // [rsp+28h] [rbp-48h]
__int16 v59; // [rsp+3Eh] [rbp-32h]
*(_QWORD *)a2 = a4;
*(_DWORD *)(a2 + 24) = 0;
v7 = *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 280LL * a3;
*(_QWORD *)(a2 + 8) = v7;
v8 = *(long long **)(v7 + 192);
v9 = *((_BYTE *)v8 + 24);
if ( v9 )
{
v10 = a5;
v59 = *(_WORD *)(v7 + 162);
v56 = a5 - 1;
while ( 1 )
{
v11 = *((unsigned __int16 *)v8 + 10);
v12 = *v8;
v13 = *((_BYTE *)v8 + 25);
if ( !v13 )
break;
v14 = a4 + 1;
if ( (v13 & *(_BYTE *)(v10 + *((unsigned int *)v8 + 3))) == 0 )
{
*a4 = 1;
goto LABEL_8;
}
*a4 = 0;
LABEL_65:
v9 = *((_BYTE *)v8 + 56);
v8 += 4;
a4 = v14;
if ( !v9 )
goto LABEL_75;
}
v14 = a4;
LABEL_8:
v15 = v11;
if ( (v59 & 0x80u) == 0 && v12 != 0 )
{
v16 = *(_DWORD *)(v12 + 156);
v15 = v11;
if ( v16 >= 2 )
v15 = (unsigned int)v11 / v16;
}
v17 = *((unsigned int *)v8 + 2);
v18 = (_BYTE *)(v10 + v17);
if ( v9 == 19 )
{
v19 = *((unsigned __int8 *)v8 + 27);
if ( *((_BYTE *)v8 + 27) )
{
v20 = *((unsigned __int16 *)v8 + 8);
v21 = *((unsigned __int8 *)v8 + 26);
v22 = *(unsigned __int8 *)(v10 + v20);
if ( (unsigned int)(v21 + v19) >= 9 )
v22 = *(unsigned __int16 *)(v10 + v20);
*v14++ = (v22 >> v21) & ~(-1 << v19);
LODWORD(v11) = v11 - 1;
}
memcpy(v14, v18, (unsigned int)v11);
v14 += (unsigned int)v11;
goto LABEL_65;
}
v23 = *((_WORD *)v8 + 9);
if ( (v23 & 1) != 0 )
{
if ( v9 == 7 )
{
v28 = &v18[v11];
if ( v11 )
{
do
{
if ( *v18 != 32 )
break;
++v18;
}
while ( v18 < v28 );
}
v29 = (_DWORD)v28 - (_DWORD)v18;
}
else
{
v32 = v15;
v33 = (*(long long ( **)(long long, _BYTE *, long long))(*(_QWORD *)(v12 + 184) + 24LL))(v12, v18, v11);
v15 = v32;
v29 = v33;
}
if ( v15 < v29 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v18,
&v18[v29],
v15);
if ( v15 >= v29 )
v15 = v29;
if ( v15 >= 0xFF )
{
v14[2] = v15;
v14[1] = BYTE1(v15);
v34 = v14 + 3;
v35 = -1;
}
else
{
v34 = v14 + 1;
v35 = v15;
}
*v14 = v35;
v36 = v15;
memcpy(v34, v18, v15);
v37 = &v34[v36];
}
else
{
if ( (v23 & 8) != 0 )
{
if ( *((_BYTE *)v8 + 26) == 1 )
{
v30 = (unsigned __int8)*v18;
v31 = 1LL;
}
else
{
v30 = *(unsigned __int16 *)v18;
v31 = 2LL;
}
v44 = &v18[v31];
if ( v30 < (unsigned int)v11 )
LODWORD(v11) = v30;
if ( (unsigned int)v11 > v15 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v44,
&v44[(unsigned int)v11],
v15);
if ( v15 < (unsigned int)v11 )
LODWORD(v11) = v15;
if ( (unsigned int)v11 >= 0xFF )
{
v14[2] = v11;
v14[1] = BYTE1(v11);
v45 = v14 + 3;
v46 = -1;
}
else
{
v45 = v14 + 1;
v46 = v11;
}
*v14 = v46;
memcpy(v45, v44, (unsigned int)v11);
v14 = &v45[(unsigned int)v11];
goto LABEL_64;
}
v57 = v15;
if ( (v23 & 0x20) == 0 )
{
if ( (v23 & 0x40) != 0 )
{
if ( (_DWORD)v11 )
{
v48 = v56 + v11 + v17;
v49 = 0LL;
v50 = 0LL;
do
v14[v49++] = *(_BYTE *)(v48 + v50--);
while ( (_DWORD)v11 != (_DWORD)v49 );
v14 -= v50;
}
}
else
{
v24 = v15;
if ( v15 < (unsigned int)v11 )
v24 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v18,
&v18[v11],
v15);
v25 = (unsigned int)v11;
if ( v24 < (unsigned int)v11 )
v25 = v24;
v26 = v18;
v27 = v24;
memcpy(v14, v26, v25);
if ( v27 < (unsigned int)v11 )
(*(void ( **)(long long, char *, _QWORD, long long))(*(_QWORD *)(v12 + 184) + 120LL))(
v12,
&v14[v25],
(unsigned int)(v11 - v25),
32LL);
v10 = a5;
v14 += v11;
}
goto LABEL_65;
}
v38 = ma_calc_blob_length(*((unsigned __int8 *)v8 + 26), v10 + v17);
v39 = *(_QWORD *)&v18[*((unsigned __int8 *)v8 + 26)];
if ( (unsigned int)v11 < v38 )
v38 = v11;
v40 = v57;
if ( v38 > v57 )
{
v41 = v38;
v40 = (*(long long ( **)(long long, long long, long long, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v39,
v39 + v38,
v57);
v38 = v41;
}
if ( v40 < v38 )
v38 = v40;
if ( v38 >= 0xFF )
{
v14[2] = v38;
v14[1] = BYTE1(v38);
v42 = v14 + 3;
v43 = -1;
}
else
{
v42 = v14 + 1;
v43 = v38;
}
*v14 = v43;
v47 = v38;
memcpy(v42, v39, v38);
v37 = &v42[v47];
}
v14 = v37;
LABEL_64:
v10 = a5;
goto LABEL_65;
}
v14 = a4;
LABEL_75:
ma_dpointer(*(_QWORD *)a1, (long long)v14, a6);
*(_DWORD *)(a2 + 16) = (_DWORD)v14 - *(_DWORD *)a2;
v51 = *(unsigned int *)(*(_QWORD *)a1 + 1856LL);
*(_QWORD *)(a2 + 20) = (unsigned int)v51;
if ( a7 && (*(_DWORD *)(a1 + 1560) & 1) != 0 )
{
*(_DWORD *)(a2 + 20) += transid_store_packed(a1, &v14[v51], a7);
*(_BYTE *)(a2 + 26) |= 8u;
}
return a2;
}
|
_ma_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x58],R9
MOV qword ptr [RSI],RCX
MOV dword ptr [RSI + 0x18],0x0
MOV qword ptr [RBP + -0x60],RDI
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RAX + 0x570]
MOV EAX,EDX
IMUL RDX,RAX,0x118
LEA RAX,[RDI + RDX*0x1]
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RSI + 0x8],RAX
MOV R13,qword ptr [RDI + RDX*0x1 + 0xc0]
MOV SIL,byte ptr [R13 + 0x18]
TEST SIL,SIL
JZ 0x0013f947
MOV R14,R8
MOVZX EAX,word ptr [RAX + 0xa2]
MOV word ptr [RBP + -0x32],AX
LEA RAX,[R8 + -0x1]
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],R8
LAB_0013f584:
MOVZX EBX,word ptr [R13 + 0x14]
MOV R15,qword ptr [R13]
MOV AL,byte ptr [R13 + 0x19]
TEST AL,AL
JZ 0x0013f5ab
MOV EDX,dword ptr [R13 + 0xc]
LEA RDI,[RCX + 0x1]
TEST byte ptr [R14 + RDX*0x1],AL
JZ 0x0013f5b0
MOV byte ptr [RCX],0x0
JMP 0x0013f893
LAB_0013f5ab:
MOV RDI,RCX
JMP 0x0013f5b3
LAB_0013f5b0:
MOV byte ptr [RCX],0x1
LAB_0013f5b3:
CMP byte ptr [RBP + -0x32],0x0
SETNS AL
TEST R15,R15
SETNZ CL
AND CL,AL
MOV EDX,EBX
CMP CL,0x1
JNZ 0x0013f5df
MOV ECX,dword ptr [R15 + 0x9c]
MOV EDX,EBX
CMP ECX,0x2
JC 0x0013f5df
MOV EAX,EBX
XOR EDX,EDX
DIV ECX
MOV EDX,EAX
LAB_0013f5df:
MOV EAX,dword ptr [R13 + 0x8]
LEA R12,[R14 + RAX*0x1]
CMP SIL,0x13
JNZ 0x0013f650
MOVZX EAX,byte ptr [R13 + 0x1b]
TEST EAX,EAX
JZ 0x0013f635
MOV R8,RDI
MOVZX ESI,word ptr [R13 + 0x10]
MOVZX ECX,byte ptr [R13 + 0x1a]
MOVZX EDX,byte ptr [R14 + RSI*0x1]
LEA EDI,[RCX + RAX*0x1]
CMP EDI,0x9
JC 0x0013f61b
MOVZX ESI,byte ptr [R14 + RSI*0x1 + 0x1]
SHL ESI,0x8
OR EDX,ESI
LAB_0013f61b:
MOV RDI,R8
SHR EDX,CL
MOV ESI,0xffffffff
MOV ECX,EAX
SHL ESI,CL
NOT ESI
AND ESI,EDX
MOV byte ptr [R8],SIL
INC RDI
DEC EBX
LAB_0013f635:
MOV EBX,EBX
MOV R15,RDI
MOV RSI,R12
MOV RDX,RBX
CALL 0x0012a0a0
LAB_0013f645:
MOV RDI,R15
ADD RDI,RBX
JMP 0x0013f893
LAB_0013f650:
MOVZX ECX,word ptr [R13 + 0x12]
TEST CL,0x1
JNZ 0x0013f6f1
TEST CL,0x8
JNZ 0x0013f718
MOV qword ptr [RBP + -0x48],RDX
TEST CL,0x20
JNZ 0x0013f7b6
TEST CL,0x40
JNZ 0x0013f8ac
MOV RAX,qword ptr [RBP + -0x48]
CMP EAX,EBX
JNC 0x0013f6a1
LEA RDX,[R12 + RBX*0x1]
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV R14,RDI
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
LAB_0013f6a1:
CMP EAX,EBX
MOV R14D,EBX
CMOVC R14D,EAX
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,R12
MOV R12,RAX
MOV RDX,R14
CALL 0x0012a0a0
CMP R12D,EBX
MOV R12,qword ptr [RBP + -0x30]
JNC 0x0013f6e2
MOV RSI,R14
ADD RSI,R12
MOV EDX,EBX
SUB EDX,R14D
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV ECX,0x20
CALL qword ptr [RAX + 0x78]
LAB_0013f6e2:
ADD R12,RBX
MOV R14,qword ptr [RBP + -0x40]
MOV RDI,R12
JMP 0x0013f893
LAB_0013f6f1:
CMP SIL,0x7
MOV qword ptr [RBP + -0x30],RDI
JNZ 0x0013f732
LEA R14,[R12 + RBX*0x1]
TEST RBX,RBX
JZ 0x0013f713
LAB_0013f704:
CMP byte ptr [R12],0x20
JNZ 0x0013f713
INC R12
CMP R12,R14
JC 0x0013f704
LAB_0013f713:
SUB R14,R12
JMP 0x0013f74e
LAB_0013f718:
CMP byte ptr [R13 + 0x1a],0x1
JNZ 0x0013f81d
MOVZX EAX,byte ptr [R12]
MOV ECX,0x1
JMP 0x0013f827
LAB_0013f732:
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV R14,RDX
MOV RDX,RBX
CALL qword ptr [RAX + 0x18]
MOV RDX,R14
MOV R14,RAX
LAB_0013f74e:
CMP EDX,R14D
JNC 0x0013f771
MOV RAX,RDX
MOV EDX,R14D
ADD RDX,R12
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDX,RAX
LAB_0013f771:
MOV RCX,qword ptr [RBP + -0x30]
CMP EDX,R14D
CMOVNC EDX,R14D
CMP EDX,0xff
JNC 0x0013f78c
LEA RBX,[RCX + 0x1]
MOV EAX,EDX
JMP 0x0013f798
LAB_0013f78c:
MOV byte ptr [RCX + 0x2],DL
MOV byte ptr [RCX + 0x1],DH
LEA RBX,[RCX + 0x3]
MOV AL,0xff
LAB_0013f798:
MOV byte ptr [RCX],AL
MOV R14D,EDX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x0012a0a0
ADD RBX,R14
LAB_0013f7ae:
MOV RDI,RBX
JMP 0x0013f88f
LAB_0013f7b6:
MOV qword ptr [RBP + -0x30],RDI
MOVZX EDI,byte ptr [R13 + 0x1a]
MOV RSI,R12
CALL 0x0014750b
MOV RDX,RAX
MOVZX EAX,byte ptr [R13 + 0x1a]
MOV R14,qword ptr [R12 + RAX*0x1]
CMP EBX,EDX
CMOVC EDX,EBX
MOV RAX,qword ptr [RBP + -0x48]
CMP EDX,EAX
JBE 0x0013f7fd
MOV RBX,RDX
MOV EDX,EBX
ADD RDX,R14
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R14
CALL qword ptr [RAX + 0x10]
MOV RDX,RBX
LAB_0013f7fd:
MOV RCX,qword ptr [RBP + -0x30]
CMP EAX,EDX
CMOVC EDX,EAX
CMP EDX,0xff
JNC 0x0013f8d9
LEA RBX,[RCX + 0x1]
MOV EAX,EDX
JMP 0x0013f8e5
LAB_0013f81d:
MOVZX EAX,word ptr [R12]
MOV ECX,0x2
LAB_0013f827:
ADD R12,RCX
CMP EAX,EBX
CMOVC EBX,EAX
CMP EBX,EDX
JBE 0x0013f856
MOV RAX,RDX
MOV EDX,EBX
ADD RDX,R12
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV R14,RDI
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
MOV RDX,RAX
LAB_0013f856:
CMP EDX,EBX
CMOVC EBX,EDX
CMP EBX,0xff
JNC 0x0013f86b
LEA R14,[RDI + 0x1]
MOV EAX,EBX
JMP 0x0013f877
LAB_0013f86b:
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
LEA R14,[RDI + 0x3]
MOV AL,0xff
LAB_0013f877:
MOV byte ptr [RDI],AL
MOV EBX,EBX
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x0012a0a0
ADD R14,RBX
MOV RDI,R14
LAB_0013f88f:
MOV R14,qword ptr [RBP + -0x40]
LAB_0013f893:
MOV SIL,byte ptr [R13 + 0x38]
ADD R13,0x20
MOV RCX,RDI
TEST SIL,SIL
JNZ 0x0013f584
JMP 0x0013f94a
LAB_0013f8ac:
CMP SIL,0x6
JZ 0x0013f900
MOVZX ECX,SIL
CMP ECX,0x5
JNZ 0x0013f90c
MOVSS XMM0,dword ptr [R12]
UCOMISS XMM0,XMM0
JNP 0x0013f90c
MOV R15,RDI
XOR ESI,ESI
MOV RDX,RBX
CALL 0x0012a290
LEA RDI,[RBX + R15*0x1]
JMP 0x0013f893
LAB_0013f8d9:
MOV byte ptr [RCX + 0x2],DL
MOV byte ptr [RCX + 0x1],DH
LEA RBX,[RCX + 0x3]
MOV AL,0xff
LAB_0013f8e5:
MOV byte ptr [RCX],AL
MOV R15D,EDX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0012a0a0
ADD RBX,R15
JMP 0x0013f7ae
LAB_0013f900:
MOVSD XMM0,qword ptr [R12]
UCOMISD XMM0,XMM0
JP 0x0013f935
LAB_0013f90c:
TEST EBX,EBX
JZ 0x0013f893
ADD RAX,RBX
ADD RAX,qword ptr [RBP + -0x50]
XOR EDX,EDX
XOR ECX,ECX
LAB_0013f91b:
MOV SIL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDI + RDX*0x1],SIL
DEC RCX
INC RDX
CMP EBX,EDX
JNZ 0x0013f91b
SUB RDI,RCX
JMP 0x0013f893
LAB_0013f935:
MOV R15,RDI
XOR ESI,ESI
MOV RDX,RBX
CALL 0x0012a290
JMP 0x0013f645
LAB_0013f947:
MOV RDI,RCX
LAB_0013f94a:
MOV R14,qword ptr [RBP + -0x60]
MOV RBX,RDI
MOV RDI,qword ptr [R14]
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x0013b720
MOV RSI,RBX
MOV RBX,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBX]
MOV ECX,ESI
SUB ECX,EAX
MOV dword ptr [RBX + 0x10],ECX
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0x740]
MOV dword ptr [RBX + 0x14],EAX
MOV dword ptr [RBX + 0x18],0x0
MOV RDX,qword ptr [RBP + 0x10]
TEST RDX,RDX
JZ 0x0013f9aa
MOV ECX,dword ptr [R14 + 0x618]
AND ECX,0x1
JZ 0x0013f9aa
ADD RSI,RAX
MOV RDI,R14
CALL 0x0013f440
ADD dword ptr [RBX + 0x14],EAX
OR byte ptr [RBX + 0x1a],0x8
LAB_0013f9aa:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int * _ma_make_key(long *param_1,int *param_2,ulong param_3,byte *param_4,long param_5,
int8 param_6,long param_7)
{
double *pdVar1;
byte bVar2;
int2 uVar3;
ushort uVar4;
byte bVar5;
uint uVar6;
uint uVar7;
int iVar8;
ulong uVar9;
long lVar10;
uint uVar11;
long lVar12;
long lVar13;
uint uVar14;
ulong __n;
byte *pbVar15;
char cVar16;
double *__src;
void *pvVar17;
long *plVar18;
size_t __n_00;
char local_3a;
*(byte **)param_2 = param_4;
param_2[6] = 0;
lVar13 = *(long *)(*param_1 + 0x570);
lVar12 = (param_3 & 0xffffffff) * 0x118;
lVar10 = lVar13 + lVar12;
*(long *)(param_2 + 2) = lVar10;
plVar18 = *(long **)(lVar13 + 0xc0 + lVar12);
cVar16 = (char)plVar18[3];
if (cVar16 != '\0') {
uVar3 = *(int2 *)(lVar10 + 0xa2);
do {
uVar4 = *(ushort *)((long)plVar18 + 0x14);
__n = (ulong)uVar4;
lVar10 = *plVar18;
if (*(byte *)((long)plVar18 + 0x19) == 0) {
LAB_0013f5b3:
local_3a = (char)uVar3;
uVar11 = (uint)uVar4;
uVar9 = __n;
if (lVar10 != 0 && -1 < local_3a) {
uVar9 = (ulong)uVar4;
if (1 < *(uint *)(lVar10 + 0x9c)) {
uVar9 = (ulong)uVar11 / (ulong)*(uint *)(lVar10 + 0x9c);
}
}
uVar7 = (uint)uVar9;
uVar6 = *(uint *)(plVar18 + 1);
__src = (double *)(param_5 + (ulong)uVar6);
uVar14 = (uint)uVar4;
if (cVar16 == '\x13') {
bVar5 = *(byte *)((long)plVar18 + 0x1b);
if (bVar5 != 0) {
bVar2 = *(byte *)(param_5 + (ulong)*(ushort *)(plVar18 + 2));
uVar11 = (uint)bVar2;
if (8 < (uint)*(byte *)((long)plVar18 + 0x1a) + (uint)bVar5) {
uVar11 = (uint)CONCAT11(*(int1 *)(param_5 + 1 + (ulong)*(ushort *)(plVar18 + 2))
,bVar2);
}
*param_4 = ~(byte)(-1 << (bVar5 & 0x1f)) &
(byte)(uVar11 >> (*(byte *)((long)plVar18 + 0x1a) & 0x1f));
param_4 = param_4 + 1;
__n = (ulong)(uVar14 - 1);
}
memcpy(param_4,__src,__n);
LAB_0013f645:
param_4 = param_4 + __n;
}
else {
uVar4 = *(ushort *)((long)plVar18 + 0x12);
if ((uVar4 & 1) == 0) {
if ((uVar4 & 8) == 0) {
if ((uVar4 & 0x20) == 0) {
if ((uVar4 & 0x40) == 0) {
if (uVar7 < uVar14) {
uVar9 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,__src,(long)__src + __n,uVar9);
}
__n_00 = (size_t)uVar11;
if ((uint)uVar9 < uVar14) {
__n_00 = uVar9 & 0xffffffff;
}
memcpy(param_4,__src,__n_00);
if ((uint)uVar9 < uVar11) {
(**(code **)(*(long *)(lVar10 + 0xb8) + 0x78))
(lVar10,param_4 + __n_00,uVar14 - (int)__n_00,0x20);
}
param_4 = param_4 + __n;
}
else {
if (cVar16 == '\x06') {
if (NAN(*__src)) {
memset(param_4,0,__n);
goto LAB_0013f645;
}
}
else if ((cVar16 == '\x05') && (NAN(*(float *)__src))) {
memset(param_4,0,__n);
param_4 = param_4 + __n;
goto LAB_0013f893;
}
if (uVar14 != 0) {
lVar13 = 0;
lVar10 = 0;
do {
param_4[lVar13] = *(byte *)(uVar6 + __n + param_5 + -1 + lVar10);
lVar10 = lVar10 + -1;
lVar13 = lVar13 + 1;
} while (uVar14 != (uint)lVar13);
param_4 = param_4 + -lVar10;
}
}
}
else {
uVar6 = _ma_calc_blob_length(*(int1 *)((long)plVar18 + 0x1a),__src);
pvVar17 = *(void **)((long)__src + (ulong)*(byte *)((long)plVar18 + 0x1a));
if (uVar11 < uVar6) {
uVar6 = uVar14;
}
if (uVar7 < uVar6) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,pvVar17,(ulong)uVar6 + (long)pvVar17,uVar9);
}
if (uVar7 < uVar6) {
uVar6 = uVar7;
}
bVar5 = (byte)uVar6;
if (uVar6 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar6 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,pvVar17,(ulong)uVar6);
param_4 = pbVar15 + uVar6;
}
}
else {
if (*(char *)((long)plVar18 + 0x1a) == '\x01') {
uVar6 = (uint)*(byte *)__src;
lVar13 = 1;
}
else {
uVar6 = (uint)*(ushort *)__src;
lVar13 = 2;
}
pvVar17 = (void *)((long)__src + lVar13);
if (uVar6 < uVar11) {
uVar11 = uVar6;
}
if (uVar7 < uVar11) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,pvVar17,(ulong)uVar11 + (long)pvVar17,uVar9);
}
if (uVar7 < uVar11) {
uVar11 = uVar7;
}
bVar5 = (byte)uVar11;
if (uVar11 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar11 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,pvVar17,(ulong)uVar11);
param_4 = pbVar15 + uVar11;
}
}
else {
if (cVar16 == '\a') {
pdVar1 = (double *)((long)__src + __n);
if (__n != 0) {
do {
if (*(char *)__src != ' ') break;
__src = (double *)((long)__src + 1);
} while (__src < pdVar1);
}
uVar11 = (int)pdVar1 - (int)__src;
}
else {
uVar11 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x18))(lVar10,__src,__n);
}
if (uVar7 < uVar11) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,__src,(ulong)uVar11 + (long)__src,uVar9);
}
if (uVar11 <= uVar7) {
uVar7 = uVar11;
}
bVar5 = (byte)uVar7;
if (uVar7 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar7 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,__src,(ulong)uVar7);
param_4 = pbVar15 + uVar7;
}
}
}
else {
if ((*(byte *)(param_5 + (ulong)*(uint *)((long)plVar18 + 0xc)) &
*(byte *)((long)plVar18 + 0x19)) == 0) {
*param_4 = 1;
param_4 = param_4 + 1;
goto LAB_0013f5b3;
}
*param_4 = 0;
param_4 = param_4 + 1;
}
LAB_0013f893:
cVar16 = (char)plVar18[7];
plVar18 = plVar18 + 4;
} while (cVar16 != '\0');
}
_ma_dpointer(*param_1,param_4,param_6);
param_2[4] = (int)param_4 - *param_2;
uVar11 = *(uint *)(*param_1 + 0x740);
param_2[5] = uVar11;
param_2[6] = 0;
if ((param_7 != 0) && ((*(uint *)(param_1 + 0xc3) & 1) != 0)) {
iVar8 = transid_store_packed(param_1,param_4 + uVar11);
param_2[5] = param_2[5] + iVar8;
*(byte *)((long)param_2 + 0x1a) = *(byte *)((long)param_2 + 0x1a) | 8;
}
return param_2;
}
|
|
63,179 |
ftxui::wchar_width(wchar_t)
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/screen/string.cpp
|
int wchar_width(wchar_t ucs) {
return codepoint_width(uint32_t(ucs));
}
|
O3
|
cpp
|
ftxui::wchar_width(wchar_t):
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %edi, %edi
je 0x3a862
pushq %rbx
movl %edi, %ebx
cmpl $0x1f, %edi
ja 0x3a83e
cmpl $0xa, %ebx
je 0x3a846
jmp 0x3a861
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
jb 0x3a861
movl %ebx, %edi
callq 0x3a6d0
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x3a861
movl %ebx, %edi
callq 0x3a728
movzbl %al, %eax
incl %eax
popq %rbx
retq
|
_ZN5ftxui11wchar_widthEw:
mov eax, 0FFFFFFFFh
test edi, edi
jz short locret_3A862
push rbx
mov ebx, edi
cmp edi, 1Fh
ja short loc_3A83E
cmp ebx, 0Ah
jz short loc_3A846
jmp short loc_3A861
loc_3A83E:
lea ecx, [rbx-7Fh]
cmp ecx, 21h ; '!'
jb short loc_3A861
loc_3A846:
mov edi, ebx; this
call _ZN5ftxui11IsCombiningEj; ftxui::IsCombining(uint)
mov ecx, eax
xor eax, eax
test cl, cl
jnz short loc_3A861
mov edi, ebx; this
call _ZN5ftxui11IsFullWidthEj; ftxui::IsFullWidth(uint)
movzx eax, al
inc eax
loc_3A861:
pop rbx
locret_3A862:
retn
|
long long ftxui::wchar_width(ftxui *this)
{
long long result; // rax
bool IsCombining; // cl
result = 0xFFFFFFFFLL;
if ( (_DWORD)this )
{
if ( (unsigned int)this > 0x1F )
{
if ( (unsigned int)((_DWORD)this - 127) < 0x21 )
return result;
}
else if ( (_DWORD)this != 10 )
{
return result;
}
IsCombining = ftxui::IsCombining((ftxui *)(unsigned int)this);
result = 0LL;
if ( !IsCombining )
return (unsigned int)ftxui::IsFullWidth((ftxui *)(unsigned int)this) + 1;
}
return result;
}
|
wchar_width:
MOV EAX,0xffffffff
TEST EDI,EDI
JZ 0x0013a862
PUSH RBX
MOV EBX,EDI
CMP EDI,0x1f
JA 0x0013a83e
CMP EBX,0xa
JZ 0x0013a846
JMP 0x0013a861
LAB_0013a83e:
LEA ECX,[RBX + -0x7f]
CMP ECX,0x21
JC 0x0013a861
LAB_0013a846:
MOV EDI,EBX
CALL 0x0013a6d0
MOV ECX,EAX
XOR EAX,EAX
TEST CL,CL
JNZ 0x0013a861
MOV EDI,EBX
CALL 0x0013a728
MOVZX EAX,AL
INC EAX
LAB_0013a861:
POP RBX
LAB_0013a862:
RET
|
/* ftxui::wchar_width(wchar_t) */
int ftxui::wchar_width(wchar_t param_1)
{
char cVar1;
byte bVar2;
int iVar3;
iVar3 = -1;
if (param_1 != L'\0') {
if ((uint)param_1 < 0x20) {
if (param_1 != L'\n') {
return -1;
}
}
else if ((uint)(param_1 + L'\xffffff81') < 0x21) {
return -1;
}
cVar1 = IsCombining(param_1);
iVar3 = 0;
if (cVar1 == '\0') {
bVar2 = IsFullWidth(param_1);
iVar3 = bVar2 + 1;
}
}
return iVar3;
}
|
|
63,180 |
my_hash_sort_utf16_bin
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_utf16_bin(CHARSET_INFO *cs,
const uchar *pos, size_t len, ulong *nr1, ulong *nr2)
{
size_t lengthsp= my_ci_lengthsp(cs, (const char *) pos, len);
my_hash_sort_utf16_nopad_bin(cs, pos, lengthsp, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_utf16_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq 0xb8(%rdi), %rax
callq *0x18(%rax)
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
jle 0xc6169
addq %r15, %rax
movl %ecx, %esi
andl $0x3f, %esi
addq %rdx, %rsi
movzbl (%r15), %edi
imulq %rsi, %rdi
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rdi, %rsi
xorq %rsi, %rcx
addq $0x3, %rdx
incq %r15
cmpq %rax, %r15
jb 0xc6140
movq %rcx, (%r14)
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_sort_utf16_bin:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r15, rsi
mov rax, [rdi+0B8h]
call qword ptr [rax+18h]
mov rcx, [r14]
mov rdx, [rbx]
test rax, rax
jle short loc_C6169
add rax, r15
loc_C6140:
mov esi, ecx
and esi, 3Fh
add rsi, rdx
movzx edi, byte ptr [r15]
imul rdi, rsi
mov rsi, rcx
shl rsi, 8
add rsi, rdi
xor rcx, rsi
add rdx, 3
inc r15
cmp r15, rax
jb short loc_C6140
loc_C6169:
mov [r14], rcx
mov [rbx], rdx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_hash_sort_utf16_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
unsigned __int8 *v7; // r15
long long result; // rax
long long v9; // rcx
long long v10; // rdx
v7 = a2;
result = (*(long long ( **)(long long))(*(_QWORD *)(a1 + 184) + 24LL))(a1);
v9 = *a4;
v10 = *a5;
if ( result > 0 )
{
result += (long long)a2;
do
{
v9 ^= (v10 + (v9 & 0x3F)) * *v7 + (v9 << 8);
v10 += 3LL;
++v7;
}
while ( (unsigned long long)v7 < result );
}
*a4 = v9;
*a5 = v10;
return result;
}
|
my_hash_sort_utf16_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R15,RSI
MOV RAX,qword ptr [RDI + 0xb8]
CALL qword ptr [RAX + 0x18]
MOV RCX,qword ptr [R14]
MOV RDX,qword ptr [RBX]
TEST RAX,RAX
JLE 0x001c6169
ADD RAX,R15
LAB_001c6140:
MOV ESI,ECX
AND ESI,0x3f
ADD RSI,RDX
MOVZX EDI,byte ptr [R15]
IMUL RDI,RSI
MOV RSI,RCX
SHL RSI,0x8
ADD RSI,RDI
XOR RCX,RSI
ADD RDX,0x3
INC R15
CMP R15,RAX
JC 0x001c6140
LAB_001c6169:
MOV qword ptr [R14],RCX
MOV qword ptr [RBX],RDX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_sort_utf16_bin
(long param_1,byte *param_2,int8 param_3,ulong *param_4,long *param_5)
{
long lVar1;
byte *pbVar2;
ulong uVar3;
long lVar4;
lVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x18))();
uVar3 = *param_4;
lVar4 = *param_5;
if (0 < lVar1) {
pbVar2 = param_2 + lVar1;
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar4);
lVar4 = lVar4 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar3;
*param_5 = lVar4;
return;
}
|
|
63,181 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(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::__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>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t)
|
monkey531[P]llama/common/json.hpp
|
basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
// (many string types can be constructed from 0 via its null-pointer guise, so we get a
// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
});
// adjust type if type deduction is not wanted
if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
{
is_an_object = false;
}
// if object is wanted but impossible, throw an exception
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
}
}
if (is_an_object)
{
// the initializer list is a list of pairs -> create object
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
for (auto& element_ref : init)
{
auto element = element_ref.moved_or_copied();
m_data.m_value.object->emplace(
std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
std::move((*element.m_data.m_value.array)[1]));
}
}
else
{
// the initializer list describes an array -> create array
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>(init.begin(), init.end());
}
set_parents();
assert_invariant();
}
|
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>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r12, %rsi
callq 0xa1a7e
cmpq %r12, %rax
sete %cl
testb %r13b, %r13b
jne 0x7f4a9
cmpq %r12, %rax
sete %al
cmpb $0x2, %bpl
setne %cl
cmpb $0x1, %bpl
setne %dl
orb %al, %dl
je 0x7f554
andb %al, %cl
testb %cl, %cl
je 0x7f51e
movb $0x1, (%rbx)
movl $0x20, %edi
callq 0x1a8c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0x7f538
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa19d8
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
callq 0x5faf2
movq %r15, %rdi
xorl %esi, %esi
callq 0x58f20
movq %r15, %rdi
callq 0x5e40e
addq $0x18, %r14
addq $-0x18, %r12
jne 0x7f4dc
jmp 0x7f538
movb $0x2, (%rbx)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
callq 0xa1a2a
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a450
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x71a2e(%rip), %rsi # 0xf0fa0
leaq 0x71a51(%rip), %rdx # 0xf0fca
movq %rsp, %rdi
callq 0x22402
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x12d, %esi # imm = 0x12D
xorl %ecx, %ecx
callq 0xa1808
xorl %ebp, %ebp
leaq 0xaa9b9(%rip), %rsi # 0x129f58
leaq -0x23f08(%rip), %rdx # 0x5b69e
movq %r14, %rdi
callq 0x1af10
jmp 0x7f5b4
jmp 0x7f5b4
jmp 0x7f5b4
movq %rax, %r15
jmp 0x7f5fe
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58f20
movq %r14, %rdi
callq 0x5e40e
jmp 0x7f5fe
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f5ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0x7f5f6
jmp 0x7f5fe
movq %rax, %r15
movq %r14, %rdi
callq 0x1a690
movq %rbx, %rdi
callq 0x5e40e
movq %r15, %rdi
callq 0x1af90
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE:
push rbp; int
push r15; int
push r14; char
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov ebp, r8d
mov r13d, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdx+rdx*2]
lea r12, [rsi+rax*8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, rsi
mov rsi, r12
call _ZSt9__find_ifIPKN8nlohmann16json_abi_v3_11_36detail8json_refINS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEN9__gnu_cxx5__ops12_Iter_negateIZNSG_C1ESt16initializer_listISH_EbNS2_7value_tEEUlRSI_E_EEET_ST_ST_T0_St26random_access_iterator_tag; std::__find_if<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>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(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>> const&)#1}>>(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>> const*,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>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(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>> const&)#1}>,std::random_access_iterator_tag)
cmp rax, r12
setz cl
test r13b, r13b
jnz short loc_7F4A9
cmp rax, r12
setz al
cmp bpl, 2
setnz cl
cmp bpl, 1
setnz dl
or dl, al
jz loc_7F554
and cl, al
loc_7F4A9:
test cl, cl
jz short loc_7F51E
mov byte ptr [rbx], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [rbx+8], rax
test r15, r15
jz short loc_7F538
shl r15, 3
lea r12, [r15+r15*2]
mov r15, rsp
loc_7F4DC:
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; 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>>::moved_or_copied(void)
mov rdi, [rbx+8]
mov rax, [rsp+58h+var_50]
mov rdx, [rax]
mov rsi, [rdx+8]
add rdx, 10h
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(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>&&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 18h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_7F4DC
jmp short loc_7F538
loc_7F51E:
mov byte ptr [rbx], 2
mov rdi, rsp
mov [rdi], r14
lea rsi, [rsp+58h+var_38]
mov [rsi], r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJPKNS0_6detail8json_refISD_EESL_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,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>> const*,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>> const*>(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>> const*,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>> const* &&)
mov [rbx+8], rax
loc_7F538:
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F554:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r12, [rsp+58h+var_48]
mov [r12-10h], r12
lea rsi, aCannotCreateOb; "cannot create object from initializer l"...
lea rdx, aCannotCreateOb+2Ah; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 12Dh; int
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
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
jmp short loc_7F5B4
jmp short loc_7F5B4
jmp short $+2
loc_7F5B4:
mov r15, rax
jmp short loc_7F5FE
mov r15, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_7F5FE
mov r15, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r12
jz short loc_7F5EC
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7F5EC:
test bpl, bpl
jnz short loc_7F5F6
jmp short loc_7F5FE
mov r15, rax
loc_7F5F6:
mov rdi, r14; void *
call ___cxa_free_exception
loc_7F5FE:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r15
call __Unwind_Resume
|
basic_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDX + RDX*0x2]
LEA R12,[RSI + RAX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_0017f475:
MOV RDI,RSI
MOV RSI,R12
CALL 0x001a1a7e
CMP RAX,R12
SETZ CL
TEST R13B,R13B
JNZ 0x0017f4a9
CMP RAX,R12
SETZ AL
CMP BPL,0x2
SETNZ CL
CMP BPL,0x1
SETNZ DL
OR DL,AL
JZ 0x0017f554
AND CL,AL
LAB_0017f4a9:
TEST CL,CL
JZ 0x0017f51e
MOV byte ptr [RBX],0x1
LAB_0017f4b0:
MOV EDI,0x20
CALL 0x0011a8c0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RBX + 0x8],RAX
TEST R15,R15
JZ 0x0017f538
SHL R15,0x3
LEA R12,[R15 + R15*0x2]
MOV R15,RSP
LAB_0017f4dc:
MOV RDI,R15
MOV RSI,R14
CALL 0x001a19d8
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x8]
ADD RDX,0x10
LAB_0017f4fb:
CALL 0x0015faf2
MOV RDI,R15
XOR ESI,ESI
CALL 0x00158f20
MOV RDI,R15
CALL 0x0015e40e
ADD R14,0x18
ADD R12,-0x18
JNZ 0x0017f4dc
JMP 0x0017f538
LAB_0017f51e:
MOV byte ptr [RBX],0x2
MOV RDI,RSP
MOV qword ptr [RDI],R14
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI],R12
LAB_0017f52f:
CALL 0x001a1a2a
LAB_0017f534:
MOV qword ptr [RBX + 0x8],RAX
LAB_0017f538:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00158f20
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f554:
MOV EDI,0x20
CALL 0x0011a450
MOV R14,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_0017f56b:
LEA RSI,[0x1f0fa0]
LEA RDX,[0x1f0fca]
MOV RDI,RSP
CALL 0x00122402
MOV BPL,0x1
LAB_0017f584:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x12d
XOR ECX,ECX
CALL 0x001a1808
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15b69e]
MOV RDI,R14
CALL 0x0011af10
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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(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::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool, nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::basic_json(int8 *param_1,json_ref *param_2,long param_3,char param_4,char param_5)
{
json_ref *pjVar1;
json_ref *pjVar2;
int8 *puVar3;
vector *pvVar4;
int8 uVar5;
bool bVar6;
json_ref *local_58;
long *local_50;
json_ref local_48 [16];
json_ref *local_38;
pjVar1 = param_2 + param_3 * 0x18;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 0017f475 to 0017f47f has its CatchHandler @ 0017f5b2 */
pjVar2 = std::
__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>::_Iter_negate(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::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::_lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const&)_1_>>
(param_2,pjVar1);
bVar6 = pjVar2 == pjVar1;
if (param_4 == '\0') {
if (param_5 == '\x01' && pjVar2 != pjVar1) {
uVar5 = __cxa_allocate_exception(0x20);
local_58 = local_48;
/* try { // try from 0017f56b to 0017f580 has its CatchHandler @ 0017f5f3 */
std::__cxx11::string::_M_construct<char_const*>
(&local_58,"cannot create object from initializer list","");
/* try { // try from 0017f584 to 0017f5ad has its CatchHandler @ 0017f5d3 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(uVar5,0x12d,&local_58,0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&detail::type_error::typeinfo,detail::exception::~exception);
}
bVar6 = param_5 != '\x02' && pjVar2 == pjVar1;
}
if (bVar6) {
*(int1 *)param_1 = 1;
/* try { // try from 0017f4b0 to 0017f4b9 has its CatchHandler @ 0017f5b0 */
puVar3 = (int8 *)operator_new(0x20);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
param_1[1] = puVar3;
if (param_3 != 0) {
param_3 = param_3 * 0x18;
do {
/* try { // try from 0017f4dc to 0017f4e6 has its CatchHandler @ 0017f5b4 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 0017f4fb to 0017f4ff has its CatchHandler @ 0017f5b9 */
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace((ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)param_1[1],*(string **)(*local_50 + 8),(basic_json *)(*local_50 + 0x10));
assert_invariant(SUB81(&local_58,0));
data::~data((data *)&local_58);
param_3 = param_3 + -0x18;
} while (param_3 != 0);
}
}
else {
*(int1 *)param_1 = 2;
local_58 = param_2;
local_38 = pjVar1;
/* try { // try from 0017f52f to 0017f533 has its CatchHandler @ 0017f5ae */
pvVar4 = 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>>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*>
(&local_58,&local_38);
param_1[1] = pvVar4;
}
assert_invariant(SUB81(param_1,0));
return;
}
|
||
63,182 |
ggml_quantize_init
|
llama.cpp/ggml/src/ggml.c
|
void ggml_quantize_init(enum ggml_type type) {
ggml_critical_section_start();
switch (type) {
case GGML_TYPE_IQ2_XXS:
case GGML_TYPE_IQ2_XS:
case GGML_TYPE_IQ2_S:
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ1_M: iq2xs_init_impl(type); break;
case GGML_TYPE_IQ3_XXS: iq3xs_init_impl(256); break;
case GGML_TYPE_IQ3_S: iq3xs_init_impl(512); break;
default: // nothing
break;
}
ggml_critical_section_end();
}
|
O3
|
c
|
ggml_quantize_init:
pushq %rbx
movl %edi, %ebx
callq 0x17dc0
cmpl $0x1d, %ebx
ja 0x22e5f
movl $0x204b0000, %eax # imm = 0x204B0000
btl %ebx, %eax
jae 0x22e44
movl %ebx, %edi
callq 0x17f10
jmp 0x22e5f
cmpl $0x12, %ebx
je 0x22e55
cmpl $0x15, %ebx
jne 0x22e5f
movl $0x200, %edi # imm = 0x200
jmp 0x22e5a
movl $0x100, %edi # imm = 0x100
callq 0x178a0
popq %rbx
jmp 0x17ba0
|
ggml_quantize_init:
push rbx
mov ebx, edi
call _ggml_critical_section_start
cmp ebx, 1Dh
ja short loc_22E5F
mov eax, 204B0000h
bt eax, ebx
jnb short loc_22E44
mov edi, ebx
call _iq2xs_init_impl
jmp short loc_22E5F
loc_22E44:
cmp ebx, 12h
jz short loc_22E55
cmp ebx, 15h
jnz short loc_22E5F
mov edi, 200h
jmp short loc_22E5A
loc_22E55:
mov edi, 100h
loc_22E5A:
call _iq3xs_init_impl
loc_22E5F:
pop rbx
jmp _ggml_critical_section_end
|
long long ggml_quantize_init(long long a1)
{
int v1; // eax
long long v2; // rdi
ggml_critical_section_start(a1);
if ( (unsigned int)a1 <= 0x1D )
{
v1 = 541786112;
if ( !_bittest(&v1, a1) )
{
if ( (_DWORD)a1 == 18 )
{
v2 = 256LL;
}
else
{
if ( (_DWORD)a1 != 21 )
return ggml_critical_section_end();
v2 = 512LL;
}
iq3xs_init_impl(v2);
return ggml_critical_section_end();
}
iq2xs_init_impl((unsigned int)a1);
}
return ggml_critical_section_end();
}
|
ggml_quantize_init:
PUSH RBX
MOV EBX,EDI
CALL 0x00117dc0
CMP EBX,0x1d
JA 0x00122e5f
MOV EAX,0x204b0000
BT EAX,EBX
JNC 0x00122e44
MOV EDI,EBX
CALL 0x00117f10
JMP 0x00122e5f
LAB_00122e44:
CMP EBX,0x12
JZ 0x00122e55
CMP EBX,0x15
JNZ 0x00122e5f
MOV EDI,0x200
JMP 0x00122e5a
LAB_00122e55:
MOV EDI,0x100
LAB_00122e5a:
CALL 0x001178a0
LAB_00122e5f:
POP RBX
JMP 0x00117ba0
|
void ggml_quantize_init(uint param_1)
{
int8 uVar1;
ggml_critical_section_start();
if (param_1 < 0x1e) {
if ((0x204b0000U >> (param_1 & 0x1f) & 1) == 0) {
if (param_1 == 0x12) {
uVar1 = 0x100;
}
else {
if (param_1 != 0x15) goto LAB_00122e5f;
uVar1 = 0x200;
}
iq3xs_init_impl(uVar1);
}
else {
iq2xs_init_impl(param_1);
}
}
LAB_00122e5f:
ggml_critical_section_end();
return;
}
|
|
63,183 |
create_thd()
|
eloqsql/sql/sql_class.cc
|
MYSQL_THD create_thd()
{
THD *thd= new THD(next_thread_id());
thd->thread_stack= (char*) &thd;
thd->store_globals();
thd->set_command(COM_DAEMON);
thd->system_thread= SYSTEM_THREAD_GENERIC;
thd->security_ctx->host_or_ip="";
server_threads.insert(thd);
return thd;
}
|
O0
|
cpp
|
create_thd():
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x6948, %edi # imm = 0x6948
callq 0x4a4660
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, -0x9(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x28(%rbp)
je 0x550b93
movb $0x1, -0x9(%rbp)
callq 0x49b1d0
movq %rax, -0x38(%rbp)
jmp 0x550b78
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x544490
jmp 0x550b89
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x550b93
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq -0x8(%rbp), %rcx
movq %rcx, 0x1e98(%rax)
movq -0x8(%rbp), %rdi
callq 0x548ef0
movq -0x8(%rbp), %rdi
movl $0x1d, %esi
callq 0x4d87a0
movq -0x8(%rbp), %rax
movl $0x80, 0x3e6c(%rax)
movq -0x8(%rbp), %rax
movq 0x2570(%rax), %rax
leaq 0x87be44(%rip), %rcx # 0xdcca25
movq %rcx, 0x6a8(%rax)
movq -0x8(%rbp), %rsi
leaq 0x106b5cd(%rip), %rdi # 0x15bc1c0
callq 0x4d8600
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x550c16
jmp 0x550c24
movq -0x30(%rbp), %rdi
movl $0x6948, %esi # imm = 0x6948
callq 0x4a4730
jmp 0x550c26
movq -0x18(%rbp), %rdi
callq 0x433ff0
nop
|
_Z10create_thdv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov edi, (offset aPthreadMutexLo+1); this
call _ZN5ilinknwEm; ilink::operator new(ulong)
mov rcx, rax
mov [rbp+var_30], rcx
mov [rbp+var_9], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_28], rax
jz short loc_550B93
mov [rbp+var_9], 1
call _Z14next_thread_idv; next_thread_id(void)
mov [rbp+var_38], rax
jmp short $+2
loc_550B78:
mov rsi, [rbp+var_38]; unsigned __int64
mov rdi, [rbp+var_30]; this
xor edx, edx; bool
call _ZN3THDC2Eyb; THD::THD(ulong long,bool)
jmp short $+2
loc_550B89:
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
jmp short $+2
loc_550B93:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
lea rcx, [rbp+var_8]
mov [rax+1E98h], rcx
mov rdi, [rbp+var_8]; this
call _ZN3THD13store_globalsEv; THD::store_globals(void)
mov rdi, [rbp+var_8]
mov esi, 1Dh
call _ZN3THD11set_commandE19enum_server_command; THD::set_command(enum_server_command)
mov rax, [rbp+var_8]
mov dword ptr [rax+3E6Ch], 80h
mov rax, [rbp+var_8]
mov rax, [rax+2570h]
lea rcx, byte_DCCA25
mov [rax+6A8h], rcx
mov rsi, [rbp+var_8]; THD *
lea rdi, server_threads; this
call _ZN8THD_list6insertEP3THD; THD_list::insert(THD *)
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
test [rbp+var_9], 1
jnz short loc_550C16
jmp short loc_550C24
loc_550C16:
mov rdi, [rbp+var_30]; void *
mov esi, 6948h; unsigned __int64
call _ZN5ilinkdlEPvm; ilink::operator delete(void *,ulong)
loc_550C24:
jmp short $+2
loc_550C26:
mov rdi, [rbp+var_18]
call __Unwind_Resume
|
THD *create_thd(void)
{
long long thread_id; // [rsp+8h] [rbp-38h]
THD *v2; // [rsp+10h] [rbp-30h]
THD *v3; // [rsp+18h] [rbp-28h]
THD *v4; // [rsp+38h] [rbp-8h] BYREF
v2 = (THD *)ilink::operator new((ilink *)"thread_mutex_lock");
v3 = 0LL;
if ( v2 )
{
thread_id = next_thread_id();
THD::THD(v2, thread_id, 0);
v3 = v2;
}
v4 = v3;
*((_QWORD *)v3 + 979) = &v4;
THD::store_globals(v4);
THD::set_command((long long)v4, 29);
*((_DWORD *)v4 + 3995) = 128;
*(_QWORD *)(*((_QWORD *)v4 + 1198) + 1704LL) = &byte_DCCA25;
THD_list::insert((THD_list *)&server_threads, v4);
return v4;
}
|
__cxx_global_var_init.8:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x16d0998]
MOV ESI,0x1800000
CALL 0x005a2df0
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;
}
|
|
63,184 |
common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&))
|
monkey531[P]llama/common/arg.h
|
common_arg(
const std::initializer_list<const char *> & args,
const char * value_hint,
const std::string & help,
void (*handler)(common_params & params, const std::string &)
) : args(args), value_hint(value_hint), help(help), handler_string(handler) {}
|
O0
|
c
|
common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movl $0x0, 0x6c(%rsp)
leaq 0x6c(%rsp), %rax
movq %rax, 0x70(%rsp)
movq $0x1, 0x78(%rsp)
leaq 0x6a(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9e9c0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %r8
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x6b(%rsp), %rcx
callq 0x9e9d0
jmp 0x8f7bb
leaq 0x6a(%rsp), %rdi
callq 0x9eab0
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
callq 0x9eac0
movq 0x20(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9ead0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x9eae0
jmp 0x8f832
leaq 0x3f(%rsp), %rdi
callq 0x9eb70
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x78(%rdi)
movq $0x0, 0x80(%rdi)
movq $0x0, 0x88(%rdi)
addq $0x90, %rdi
movq 0x88(%rsp), %rsi
callq 0x5a210
jmp 0x8f879
movq 0x20(%rsp), %rax
movb $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq $0x0, 0xd0(%rax)
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6a(%rsp), %rdi
callq 0x9eab0
jmp 0x8f91d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x9eb70
jmp 0x8f909
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x9eb80
movq 0x8(%rsp), %rdi
callq 0x9ebe0
movq 0x28(%rsp), %rdi
callq 0x9ebe0
movq 0x60(%rsp), %rdi
callq 0x5abd0
nopw (%rax,%rax)
|
_ZN10common_argC2ERKSt16initializer_listIPKcES2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsSD_E:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_20], rcx
mov [rsp+0A8h+var_28], r8
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_80], rax
mov [rsp+0A8h+var_88], rax
mov [rsp+0A8h+var_3C], 0
lea rax, [rsp+0A8h+var_3C]
mov [rsp+0A8h+var_38], rax
mov [rsp+0A8h+var_30], 1
lea rdi, [rsp+0A8h+var_3E]
mov [rsp+0A8h+var_78], rdi
call _ZNSaI13llama_exampleEC2Ev; std::allocator<llama_example>::allocator(void)
mov rdi, [rsp+0A8h+var_80]
mov r8, [rsp+0A8h+var_78]
mov rsi, [rsp+0A8h+var_38]
mov rdx, [rsp+0A8h+var_30]
lea rcx, [rsp+0A8h+var_3D]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
jmp short $+2
loc_8F7BB:
lea rdi, [rsp+0A8h+var_3E]
call _ZNSaI13llama_exampleED2Ev; std::allocator<llama_example>::~allocator()
mov rax, [rsp+0A8h+var_88]
mov rdi, rax
add rdi, 30h ; '0'
mov [rsp+0A8h+var_A0], rdi
xorps xmm0, xmm0
movups xmmword ptr [rax+50h], xmm0
movups xmmword ptr [rax+40h], xmm0
movups xmmword ptr [rax+30h], xmm0
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2Ev; std::set<llama_example>::set(void)
mov rax, [rsp+0A8h+var_88]
add rax, 60h ; '`'
mov [rsp+0A8h+var_98], rax
mov rax, [rsp+0A8h+var_10]
movups xmm0, xmmword ptr [rax]
movaps [rsp+0A8h+var_68], xmm0
lea rdi, [rsp+0A8h+var_69]
mov [rsp+0A8h+var_90], rdi
call _ZNSaIPKcEC2Ev; std::allocator<char const*>::allocator(void)
mov rdi, [rsp+0A8h+var_98]
mov rcx, [rsp+0A8h+var_90]
mov rsi, qword ptr [rsp+0A8h+var_68]
mov rdx, qword ptr [rsp+0A8h+var_68+8]
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
jmp short $+2
loc_8F832:
lea rdi, [rsp+0A8h+var_69]
call _ZNSaIPKcED2Ev; std::allocator<char const*>::~allocator()
mov rdi, [rsp+0A8h+var_88]
mov rax, [rsp+0A8h+var_18]
mov [rdi+78h], rax
mov qword ptr [rdi+80h], 0
mov qword ptr [rdi+88h], 0
add rdi, 90h
mov rsi, [rsp+0A8h+var_20]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_8F879:
mov rax, [rsp+0A8h+var_88]
mov byte ptr [rax+0B0h], 0
mov qword ptr [rax+0B8h], 0
mov rcx, [rsp+0A8h+var_28]
mov [rax+0C0h], rcx
mov qword ptr [rax+0C8h], 0
mov qword ptr [rax+0D0h], 0
add rsp, 0A8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_62]
call _ZNSaI13llama_exampleED2Ev; std::allocator<llama_example>::~allocator()
jmp short loc_8F91D
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_37]
call _ZNSaIPKcED2Ev; std::allocator<char const*>::~allocator()
jmp short loc_8F909
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
call _ZNSt6vectorIPKcSaIS1_EED2Ev; std::vector<char const*>::~vector()
loc_8F909:
mov rdi, [rsp+arg_0]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EED2Ev; std::set<llama_example>::~set()
mov rdi, [rsp+arg_20]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EED2Ev; std::set<llama_example>::~set()
loc_8F91D:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
|
long long common_arg::common_arg(long long a1, __int128 *a2, long long a3, long long a4, long long a5)
{
int v5; // r9d
int v6; // r8d
int v7; // r9d
long long result; // rax
int v9; // [rsp+0h] [rbp-A8h]
char v10; // [rsp+3Fh] [rbp-69h] BYREF
__int128 v11; // [rsp+40h] [rbp-68h]
char v12; // [rsp+6Ah] [rbp-3Eh] BYREF
char v13; // [rsp+6Bh] [rbp-3Dh] BYREF
int v14; // [rsp+6Ch] [rbp-3Ch] BYREF
int *v15; // [rsp+70h] [rbp-38h]
long long v16; // [rsp+78h] [rbp-30h]
long long v17; // [rsp+80h] [rbp-28h]
long long v18; // [rsp+88h] [rbp-20h]
long long v19; // [rsp+90h] [rbp-18h]
__int128 *v20; // [rsp+98h] [rbp-10h]
long long v21; // [rsp+A0h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v14 = 0;
v15 = &v14;
v16 = 1LL;
std::allocator<llama_example>::allocator();
std::set<llama_example>::set(a1, (_DWORD)v15, v16, (unsigned int)&v13, (unsigned int)&v12, v5);
std::allocator<llama_example>::~allocator(&v12);
*(_OWORD *)(a1 + 80) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
std::set<llama_example>::set();
v11 = *v20;
std::allocator<char const*>::allocator();
std::vector<char const*>::vector(a1 + 96, v11, DWORD2(v11), (unsigned int)&v10, v6, v7, v9);
std::allocator<char const*>::~allocator(&v10);
*(_QWORD *)(a1 + 120) = v19;
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
std::string::basic_string(a1 + 144, v18);
result = a1;
*(_BYTE *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 184) = 0LL;
*(_QWORD *)(a1 + 192) = v17;
*(_QWORD *)(a1 + 200) = 0LL;
*(_QWORD *)(a1 + 208) = 0LL;
return result;
}
|
common_arg:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x80],R8
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x6c],0x0
LEA RAX,[RSP + 0x6c]
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],0x1
LEA RDI,[RSP + 0x6a]
MOV qword ptr [RSP + 0x30],RDI
CALL 0x0019e9c0
MOV RDI,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
LAB_0018f7af:
LEA RCX,[RSP + 0x6b]
CALL 0x0019e9d0
JMP 0x0018f7bb
LAB_0018f7bb:
LEA RDI,[RSP + 0x6a]
CALL 0x0019eab0
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,RAX
ADD RDI,0x30
MOV qword ptr [RSP + 0x8],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x50],XMM0
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
CALL 0x0019eac0
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x60
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0019ead0
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
LAB_0018f82b:
CALL 0x0019eae0
JMP 0x0018f832
LAB_0018f832:
LEA RDI,[RSP + 0x3f]
CALL 0x0019eb70
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RDI + 0x78],RAX
MOV qword ptr [RDI + 0x80],0x0
MOV qword ptr [RDI + 0x88],0x0
ADD RDI,0x90
MOV RSI,qword ptr [RSP + 0x88]
LAB_0018f872:
CALL 0x0015a210
LAB_0018f877:
JMP 0x0018f879
LAB_0018f879:
MOV RAX,qword ptr [RSP + 0x20]
MOV byte ptr [RAX + 0xb0],0x0
MOV qword ptr [RAX + 0xb8],0x0
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RAX + 0xc0],RCX
MOV qword ptr [RAX + 0xc8],0x0
MOV qword ptr [RAX + 0xd0],0x0
ADD RSP,0xa8
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, char const*,
std::__cxx11::string const&, void (*)(common_params&, std::__cxx11::string const&)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,char *param_2,string *param_3,
_func_void_common_params_ptr_string_ptr *param_4)
{
allocator<char_const*> local_69;
int8 local_68;
int8 uStack_60;
allocator<llama_example> local_3e;
int1 local_3d;
int4 local_3c;
int4 *local_38;
int8 local_30;
_func_void_common_params_ptr_string_ptr *local_28;
string *local_20;
char *local_18;
int8 *local_10;
common_arg *local_8;
local_3c = 0;
local_38 = &local_3c;
local_30 = 1;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = (int8 *)param_1;
local_8 = this;
std::allocator<llama_example>::allocator(&local_3e);
/* try { // try from 0018f7af to 0018f7b8 has its CatchHandler @ 0018f8bd */
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,local_38,local_30,&local_3d,&local_3e);
std::allocator<llama_example>::~allocator(&local_3e);
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
((set<llama_example,std::less<llama_example>,std::allocator<llama_example>> *)
(this + 0x30));
local_68 = *local_10;
uStack_60 = local_10[1];
std::allocator<char_const*>::allocator(&local_69);
/* try { // try from 0018f82b to 0018f82f has its CatchHandler @ 0018f8d7 */
std::vector<char_const*,std::allocator<char_const*>>::vector
(this + 0x60,local_68,uStack_60,&local_69);
std::allocator<char_const*>::~allocator(&local_69);
*(char **)(this + 0x78) = local_18;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
/* try { // try from 0018f872 to 0018f876 has its CatchHandler @ 0018f8f1 */
std::__cxx11::string::string((string *)(this + 0x90),local_20);
this[0xb0] = (common_arg)0x0;
*(int8 *)(this + 0xb8) = 0;
*(_func_void_common_params_ptr_string_ptr **)(this + 0xc0) = local_28;
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = 0;
return;
}
|
|
63,185 |
testing::internal::ParseFlagValue(char const*, char const*, bool)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
static const char* ParseFlagValue(const char* str, const char* flag_name,
bool def_optional) {
// str and flag must not be NULL.
if (str == nullptr || flag_name == nullptr) return nullptr;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str =
std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
const size_t flag_len = flag_str.length();
if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
// Skips the flag name.
const char* flag_end = str + flag_len;
// When def_optional is true, it's OK to not have a "=value" part.
if (def_optional && (flag_end[0] == '\0')) {
return flag_end;
}
// If def_optional is true and there are more characters after the
// flag name, or if def_optional is false, there must be a '=' after
// the flag name.
if (flag_end[0] != '=') return nullptr;
// Returns the string after "=".
return flag_end + 1;
}
|
O0
|
cpp
|
testing::internal::ParseFlagValue(char const*, char const*, bool):
subq $0xc8, %rsp
movb %dl, %al
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
cmpq $0x0, 0xb8(%rsp)
je 0xe46f8
cmpq $0x0, 0xb0(%rsp)
jne 0xe4709
movq $0x0, 0xc0(%rsp)
jmp 0xe48b8
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x16d00
movq 0x10(%rsp), %rdx
leaq 0x3995b(%rip), %rsi # 0x11e07f
leaq 0x48(%rsp), %rdi
callq 0x1dbb0
jmp 0xe4730
leaq 0x3813a(%rip), %rdx # 0x11c871
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x42350
jmp 0xe4748
movq 0xb0(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x42350
jmp 0xe4764
leaq 0x68(%rsp), %rdi
callq 0x1dfd0
leaq 0x48(%rsp), %rdi
callq 0x1dfd0
leaq 0x47(%rsp), %rdi
callq 0x16790
leaq 0x88(%rsp), %rdi
callq 0x1ec30
movq %rax, 0x28(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1f1e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0x162f0
cmpl $0x0, %eax
je 0xe482f
movq $0x0, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0xe48ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xe4820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xe4816
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1dfd0
leaq 0x48(%rsp), %rdi
callq 0x1dfd0
leaq 0x47(%rsp), %rdi
callq 0x16790
jmp 0xe48c8
movq 0xb8(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0xaf(%rsp)
je 0xe486f
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xe486f
movq 0x18(%rsp), %rax
movq %rax, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0xe48ab
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0xe4892
movq $0x0, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0xe48ab
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1dfd0
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
|
_ZN7testing8internalL14ParseFlagValueEPKcS2_b:
sub rsp, 0C8h
mov al, dl
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_18], rsi
and al, 1
mov [rsp+0C8h+var_19], al
cmp [rsp+0C8h+var_10], 0
jz short loc_E46F8
cmp [rsp+0C8h+var_18], 0
jnz short loc_E4709
loc_E46F8:
mov [rsp+0C8h+var_8], 0
jmp loc_E48B8
loc_E4709:
lea rdi, [rsp+0C8h+var_81]
mov [rsp+0C8h+var_B8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+0C8h+var_B8]
lea rsi, aTheValueOfFlag+12h; "--"
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_E4730:
lea rdx, aGtest; "gtest_"
lea rdi, [rsp+0C8h+var_60]
lea rsi, [rsp+0C8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_E4748:
mov rdx, [rsp+0C8h+var_18]
lea rdi, [rsp+0C8h+var_40]
lea rsi, [rsp+0C8h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_E4764:
lea rdi, [rsp+0C8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+0C8h+var_40]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rsp+0C8h+var_A0], rax
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
lea rdi, [rsp+0C8h+var_40]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+0C8h+var_C0]
mov rsi, rax
mov rdx, [rsp+0C8h+var_A0]
call _strncmp
cmp eax, 0
jz short loc_E482F
mov [rsp+0C8h+var_8], 0
mov [rsp+0C8h+var_A4], 1
jmp loc_E48AB
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
jmp short loc_E4820
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
jmp short loc_E4816
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_E4816:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_E4820:
lea rdi, [rsp+arg_3F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_E48C8
loc_E482F:
mov rax, [rsp+0C8h+var_10]
add rax, [rsp+0C8h+var_A0]
mov [rsp+0C8h+var_B0], rax
test [rsp+0C8h+var_19], 1
jz short loc_E486F
mov rax, [rsp+0C8h+var_B0]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_E486F
mov rax, [rsp+0C8h+var_B0]
mov [rsp+0C8h+var_8], rax
mov [rsp+0C8h+var_A4], 1
jmp short loc_E48AB
loc_E486F:
mov rax, [rsp+0C8h+var_B0]
movsx eax, byte ptr [rax]
cmp eax, 3Dh ; '='
jz short loc_E4892
mov [rsp+0C8h+var_8], 0
mov [rsp+0C8h+var_A4], 1
jmp short loc_E48AB
loc_E4892:
mov rax, [rsp+0C8h+var_B0]
add rax, 1
mov [rsp+0C8h+var_8], rax
mov [rsp+0C8h+var_A4], 1
loc_E48AB:
lea rdi, [rsp+0C8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_E48B8:
mov rax, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
loc_E48C8:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
_BYTE * testing::internal::ParseFlagValue(testing::internal *this, const char *a2, const char *a3)
{
long long v3; // rax
testing::internal *v5; // [rsp+8h] [rbp-C0h]
_BYTE *v6; // [rsp+18h] [rbp-B0h]
long long v7; // [rsp+28h] [rbp-A0h]
char v8; // [rsp+47h] [rbp-81h] BYREF
_BYTE v9[32]; // [rsp+48h] [rbp-80h] BYREF
char v10[32]; // [rsp+68h] [rbp-60h] BYREF
_BYTE v11[39]; // [rsp+88h] [rbp-40h] BYREF
char v12; // [rsp+AFh] [rbp-19h]
const char *v13; // [rsp+B0h] [rbp-18h]
testing::internal *v14; // [rsp+B8h] [rbp-10h]
_BYTE *v15; // [rsp+C0h] [rbp-8h]
v14 = this;
v13 = a2;
v12 = (unsigned __int8)a3 & 1;
if ( !this || !v13 )
return 0LL;
std::allocator<char>::allocator(&v8, a2, a3);
std::string::basic_string<std::allocator<char>>((long long)v9, (long long)"--", (long long)&v8);
std::operator+<char>((long long)v10, (long long)v9, (long long)"gtest_");
std::operator+<char>((long long)v11, (long long)v10, (long long)v13);
std::string::~string(v10);
std::string::~string(v9);
std::allocator<char>::~allocator(&v8, v10);
v7 = std::string::length((long long)v11);
v5 = v14;
v3 = std::string::c_str((long long)v11);
if ( !(unsigned int)strncmp(v5, v3, v7) )
{
v6 = (char *)v14 + v7;
if ( (v12 & 1) == 0 || *v6 )
{
if ( *v6 == 61 )
v15 = v6 + 1;
else
v15 = 0LL;
}
else
{
v15 = (char *)v14 + v7;
}
}
else
{
v15 = 0LL;
}
std::string::~string(v11);
return v15;
}
|
ParseFlagValue:
SUB RSP,0xc8
MOV AL,DL
MOV qword ptr [RSP + 0xb8],RDI
MOV qword ptr [RSP + 0xb0],RSI
AND AL,0x1
MOV byte ptr [RSP + 0xaf],AL
CMP qword ptr [RSP + 0xb8],0x0
JZ 0x001e46f8
CMP qword ptr [RSP + 0xb0],0x0
JNZ 0x001e4709
LAB_001e46f8:
MOV qword ptr [RSP + 0xc0],0x0
JMP 0x001e48b8
LAB_001e4709:
LEA RDI,[RSP + 0x47]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00116d00
MOV RDX,qword ptr [RSP + 0x10]
LAB_001e471d:
LEA RSI,[0x21e07f]
LEA RDI,[RSP + 0x48]
CALL 0x0011dbb0
JMP 0x001e4730
LAB_001e4730:
LEA RDX,[0x21c871]
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x48]
CALL 0x00142350
JMP 0x001e4748
LAB_001e4748:
MOV RDX,qword ptr [RSP + 0xb0]
LAB_001e4750:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
CALL 0x00142350
LAB_001e4762:
JMP 0x001e4764
LAB_001e4764:
LEA RDI,[RSP + 0x68]
CALL 0x0011dfd0
LEA RDI,[RSP + 0x48]
CALL 0x0011dfd0
LEA RDI,[RSP + 0x47]
CALL 0x00116790
LEA RDI,[RSP + 0x88]
CALL 0x0011ec30
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x88]
CALL 0x0011f1e0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x001162f0
CMP EAX,0x0
JZ 0x001e482f
MOV qword ptr [RSP + 0xc0],0x0
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001e48ab
LAB_001e482f:
MOV RAX,qword ptr [RSP + 0xb8]
ADD RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x18],RAX
TEST byte ptr [RSP + 0xaf],0x1
JZ 0x001e486f
MOV RAX,qword ptr [RSP + 0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001e486f
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xc0],RAX
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001e48ab
LAB_001e486f:
MOV RAX,qword ptr [RSP + 0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3d
JZ 0x001e4892
MOV qword ptr [RSP + 0xc0],0x0
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001e48ab
LAB_001e4892:
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0xc0],RAX
MOV dword ptr [RSP + 0x24],0x1
LAB_001e48ab:
LEA RDI,[RSP + 0x88]
CALL 0x0011dfd0
LAB_001e48b8:
MOV RAX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* testing::internal::ParseFlagValue(char const*, char const*, bool) */
char * testing::internal::ParseFlagValue(char *param_1,char *param_2,bool param_3)
{
char *__s1;
int iVar1;
size_t __n;
char *__s2;
allocator local_81;
string local_80 [32];
string local_60 [32];
string local_40 [39];
byte local_19;
char *local_18;
char *local_10;
char *local_8;
if ((param_1 == (char *)0x0) || (param_2 == (char *)0x0)) {
local_8 = (char *)0x0;
}
else {
local_19 = param_3;
local_18 = param_2;
local_10 = param_1;
std::allocator<char>::allocator();
/* try { // try from 001e471d to 001e472d has its CatchHandler @ 001e47de */
std::__cxx11::string::string<std::allocator<char>>(local_80,"--",&local_81);
/* try { // try from 001e4730 to 001e4745 has its CatchHandler @ 001e47ee */
std::operator+(local_60,(char *)local_80);
/* try { // try from 001e4750 to 001e4761 has its CatchHandler @ 001e47fe */
std::operator+(local_40,(char *)local_60);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string(local_80);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
__n = std::__cxx11::string::length(local_40);
__s1 = local_10;
__s2 = (char *)std::__cxx11::string::c_str(local_40);
iVar1 = strncmp(__s1,__s2,__n);
if (iVar1 == 0) {
local_8 = local_10 + __n;
if (((local_19 & 1) == 0) || (*local_8 != '\0')) {
if (*local_8 == '=') {
local_8 = local_8 + 1;
}
else {
local_8 = (char *)0x0;
}
}
}
else {
local_8 = (char *)0x0;
}
std::__cxx11::string::~string(local_40);
}
return local_8;
}
|
|
63,186 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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>> const&)
|
monkey531[P]llama/common/json.hpp
|
void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
assert_invariant();
}
// add element to object
auto res = m_data.m_value.object->insert(val);
set_parent(res.first->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>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> 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>> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xb8e6c
movb $0x1, (%r14)
movl $0x20, %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
jmp 0xb8e71
cmpl $0x1, %eax
jne 0xb8e85
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xb9086
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f5fc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x39f91(%rip), %rsi # 0xf2e3a
leaq 0x10(%rsp), %rdi
callq 0x86fb9
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x5f3a4
xorl %ebp, %ebp
leaq 0x73064(%rip), %rsi # 0x12bf38
leaq -0x5d6a9(%rip), %rdx # 0x5b832
movq %rbx, %rdi
callq 0x1bf00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb8f01
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8c0
testb %bpl, %bpl
jne 0xb8f0b
jmp 0xb8f13
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_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_B8E6C
mov byte ptr [r14], 1
mov edi, 20h ; ' '; 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)
jmp short loc_B8E71
loc_B8E6C:
cmp eax, 1
jnz short loc_B8E85
loc_B8E71:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::insert(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&)
loc_B8E85:
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, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; 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_B8F01
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B8F01:
test bpl, bpl
jnz short loc_B8F0B
jmp short loc_B8F13
mov r14, rax
loc_B8F0B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B8F13:
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>::push_back(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v5 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v6,
(long long)"cannot use push_back() with ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
308,
v6);
__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);
}
}
else
{
*(_BYTE *)a1 = 1;
v2 = operator new(0x20uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::insert(
*(_QWORD *)(a1 + 8),
a2);
}
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001b8e6c
MOV byte ptr [R14],0x1
MOV EDI,0x20
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
JMP 0x001b8e71
LAB_001b8e6c:
CMP EAX,0x1
JNZ 0x001b8e85
LAB_001b8e71:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001b9086
LAB_001b8e85:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f5fc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001b8ea2:
LEA RSI,[0x1f2e3a]
LEA RDI,[RSP + 0x10]
CALL 0x00186fb9
MOV BPL,0x1
LAB_001b8eb6:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
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>::push_back(std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > const&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,pair *param_1)
{
int8 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
puVar1 = (int8 *)operator_new(0x20);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001b8ea2 to 001b8eb2 has its CatchHandler @ 001b8f08 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 001b8eb6 to 001b8ee2 has its CatchHandler @ 001b8ee3 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::insert(*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8),param_1);
return;
}
|
|
63,187 |
codegen_type_conversion_code
|
tsotchke[P]eshkol/src/backend/codegen/type_conversion.c
|
const char* codegen_type_conversion_code(CodegenContext* context, Type* from, Type* to) {
assert(context != NULL);
assert(from != NULL);
assert(to != NULL);
// Same type
if (type_equals(from, to)) {
return "";
}
// Get C types
const char* from_type = codegen_type_to_c_type(from);
const char* to_type = codegen_type_to_c_type(to);
// Generate conversion
if (from->kind == TYPE_INTEGER && to->kind == TYPE_FLOAT) {
return "(float)";
} else if (from->kind == TYPE_FLOAT && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_CHAR && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_INTEGER && to->kind == TYPE_CHAR) {
return "(char)";
} else if (to->kind == TYPE_ANY) {
// Special case for string to void*
if (from->kind == TYPE_STRING) {
return "(void*)(char*)";
}
// Special case for numeric to void*
else if (from->kind == TYPE_INTEGER || from->kind == TYPE_FLOAT) {
// For scientific computing, we need to be careful with numeric conversions
// We'll use a more explicit cast to void*
Arena* arena = codegen_context_get_arena(context);
char* result = arena_alloc(arena, strlen(from_type) + 20);
sprintf(result, "({ %s temp = ", from_type);
return result;
}
return "(void*)";
} else {
// Default cast
char* result = arena_alloc(codegen_context_get_arena(context), strlen(to_type) + 3);
sprintf(result, "(%s)", to_type);
return result;
}
}
|
O2
|
c
|
codegen_type_conversion_code:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1363f
movq %rsi, %r13
testq %rsi, %rsi
je 0x1365e
movq %rdx, %r12
testq %rdx, %rdx
je 0x1367d
movq %rdi, %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x15824
testb %al, %al
je 0x13545
leaq 0x7c20(%rip), %rbx # 0x1b160
jmp 0x13632
movq %r13, %rdi
callq 0x13324
movq %rax, %r14
movq %r12, %rdi
callq 0x13324
movq %rax, %r15
movl (%r13), %eax
movl (%r12), %ecx
cmpl $0x4, %eax
je 0x1358c
cmpl $0x3, %eax
je 0x1358c
cmpl $0x2, %eax
jne 0x13595
cmpl $0x3, %ecx
je 0x1362b
cmpl $0x4, %ecx
jne 0x13595
leaq 0xbccf(%rip), %rbx # 0x1f256
jmp 0x13632
cmpl $0x2, %ecx
je 0x13619
cmpl $0xc, %ecx
jne 0x135d3
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1360b
movq %rbx, %rdi
callq 0xa55e
movq %rax, %rbx
movq %r14, %rdi
callq 0x2100
leaq 0x14(%rax), %rsi
movq %rbx, %rdi
callq 0x2fb9
movq %rax, %rbx
leaq 0xbca1(%rip), %rsi # 0x1f26c
movq %rax, %rdi
movq %r14, %rdx
jmp 0x13602
movq %rbx, %rdi
callq 0xa55e
movq %rax, %rbx
movq %r15, %rdi
callq 0x2100
leaq 0x3(%rax), %rsi
movq %rbx, %rdi
callq 0x2fb9
movq %rax, %rbx
leaq 0xc938(%rip), %rsi # 0x1ff34
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x13632
cmpl $0x5, %eax
jne 0x13622
leaq 0xbc46(%rip), %rbx # 0x1f25d
jmp 0x13632
leaq 0xbc30(%rip), %rbx # 0x1f250
jmp 0x13632
leaq 0xbc51(%rip), %rbx # 0x1f27a
jmp 0x13632
leaq 0xbc16(%rip), %rbx # 0x1f248
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4719(%rip), %rdi # 0x17d5f
leaq 0xba2f(%rip), %rsi # 0x1f07c
leaq 0xbba9(%rip), %rcx # 0x1f1fd
movl $0x9e, %edx
callq 0x2180
leaq 0xbb51(%rip), %rdi # 0x1f1b6
leaq 0xba10(%rip), %rsi # 0x1f07c
leaq 0xbb8a(%rip), %rcx # 0x1f1fd
movl $0x9f, %edx
callq 0x2180
leaq 0xbb6e(%rip), %rdi # 0x1f1f2
leaq 0xb9f1(%rip), %rsi # 0x1f07c
leaq 0xbb6b(%rip), %rcx # 0x1f1fd
movl $0xa0, %edx
callq 0x2180
|
codegen_type_conversion_code:
push r15
push r14
push r13
push r12
push rbx
test rdi, rdi
jz loc_1363F
mov r13, rsi
test rsi, rsi
jz loc_1365E
mov r12, rdx
test rdx, rdx
jz loc_1367D
mov rbx, rdi
mov rdi, r13
mov rsi, r12
call type_equals
test al, al
jz short loc_13545
lea rbx, aIncludeCoreAut+1Ch; ""
jmp loc_13632
loc_13545:
mov rdi, r13
call codegen_type_to_c_type
mov r14, rax
mov rdi, r12
call codegen_type_to_c_type
mov r15, rax
mov eax, [r13+0]
mov ecx, [r12]
cmp eax, 4
jz short loc_1358C
cmp eax, 3
jz short loc_1358C
cmp eax, 2
jnz short loc_13595
cmp ecx, 3
jz loc_1362B
cmp ecx, 4
jnz short loc_13595
lea rbx, aChar_1; "(char)"
jmp loc_13632
loc_1358C:
cmp ecx, 2
jz loc_13619
loc_13595:
cmp ecx, 0Ch
jnz short loc_135D3
lea ecx, [rax-2]
cmp ecx, 2
jnb short loc_1360B
mov rdi, rbx
call codegen_context_get_arena
mov rbx, rax
mov rdi, r14
call _strlen
lea rsi, [rax+14h]
mov rdi, rbx
call arena_alloc
mov rbx, rax
lea rsi, aSTemp; "({ %s temp = "
mov rdi, rax
mov rdx, r14
jmp short loc_13602
loc_135D3:
mov rdi, rbx
call codegen_context_get_arena
mov rbx, rax
mov rdi, r15
call _strlen
lea rsi, [rax+3]
mov rdi, rbx
call arena_alloc
mov rbx, rax
lea rsi, aVoidCharS+0Eh; "(%s)"
mov rdi, rax
mov rdx, r15
loc_13602:
xor eax, eax
call _sprintf
jmp short loc_13632
loc_1360B:
cmp eax, 5
jnz short loc_13622
lea rbx, aVoidChar; "(void*)(char*)"
jmp short loc_13632
loc_13619:
lea rbx, aInt_1; "(int)"
jmp short loc_13632
loc_13622:
lea rbx, aVoid_2; "(void*)"
jmp short loc_13632
loc_1362B:
lea rbx, aFloat_0; "(float)"
loc_13632:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_1363F:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 9Eh
call ___assert_fail
loc_1365E:
lea rdi, aFromNull; "from != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 9Fh
call ___assert_fail
loc_1367D:
lea rdi, aToNull; "to != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 0A0h
call ___assert_fail
|
char * codegen_type_conversion_code(long long a1, int *a2, int *a3)
{
long long v4; // rbx
const char *v5; // r14
const char *v6; // r15
int v7; // eax
int v8; // ecx
long long v9; // rbx
long long v10; // rax
long long v11; // rcx
long long v12; // r8
char *v13; // rsi
long long v14; // rdi
const char *v15; // rdx
long long arena; // rbx
long long v17; // rax
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
158LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a2 )
__assert_fail(
"from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
159LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a3 )
__assert_fail(
"to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
160LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( (unsigned __int8)type_equals(a2, a3) )
return "";
v5 = codegen_type_to_c_type(a2);
v6 = codegen_type_to_c_type(a3);
v7 = *a2;
v8 = *a3;
if ( *a2 == 4 || v7 == 3 )
{
if ( v8 == 2 )
return "(int)";
}
else if ( v7 == 2 )
{
if ( v8 == 3 )
return "(float)";
if ( v8 == 4 )
return "(char)";
}
if ( v8 != 12 )
{
arena = codegen_context_get_arena(a1);
v17 = strlen(v6);
v4 = arena_alloc(arena, v17 + 3);
v13 = "(%s)";
v14 = v4;
v15 = v6;
goto LABEL_17;
}
if ( (unsigned int)(v7 - 2) < 2 )
{
v9 = codegen_context_get_arena(a1);
v10 = strlen(v5);
v4 = arena_alloc(v9, v10 + 20);
v13 = "({ %s temp = ";
v14 = v4;
v15 = v5;
LABEL_17:
sprintf(v14, v13, v15, v11, v12);
return (char *)v4;
}
if ( v7 == 5 )
return "(void*)(char*)";
else
return "(void*)";
}
|
codegen_type_conversion_code:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDI,RDI
JZ 0x0011363f
MOV R13,RSI
TEST RSI,RSI
JZ 0x0011365e
MOV R12,RDX
TEST RDX,RDX
JZ 0x0011367d
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R12
CALL 0x00115824
TEST AL,AL
JZ 0x00113545
LEA RBX,[0x11b160]
JMP 0x00113632
LAB_00113545:
MOV RDI,R13
CALL 0x00113324
MOV R14,RAX
MOV RDI,R12
CALL 0x00113324
MOV R15,RAX
MOV EAX,dword ptr [R13]
MOV ECX,dword ptr [R12]
CMP EAX,0x4
JZ 0x0011358c
CMP EAX,0x3
JZ 0x0011358c
CMP EAX,0x2
JNZ 0x00113595
CMP ECX,0x3
JZ 0x0011362b
CMP ECX,0x4
JNZ 0x00113595
LEA RBX,[0x11f256]
JMP 0x00113632
LAB_0011358c:
CMP ECX,0x2
JZ 0x00113619
LAB_00113595:
CMP ECX,0xc
JNZ 0x001135d3
LEA ECX,[RAX + -0x2]
CMP ECX,0x2
JNC 0x0011360b
MOV RDI,RBX
CALL 0x0010a55e
MOV RBX,RAX
MOV RDI,R14
CALL 0x00102100
LEA RSI,[RAX + 0x14]
MOV RDI,RBX
CALL 0x00102fb9
MOV RBX,RAX
LEA RSI,[0x11f26c]
MOV RDI,RAX
MOV RDX,R14
JMP 0x00113602
LAB_001135d3:
MOV RDI,RBX
CALL 0x0010a55e
MOV RBX,RAX
MOV RDI,R15
CALL 0x00102100
LEA RSI,[RAX + 0x3]
MOV RDI,RBX
CALL 0x00102fb9
MOV RBX,RAX
LEA RSI,[0x11ff34]
MOV RDI,RAX
MOV RDX,R15
LAB_00113602:
XOR EAX,EAX
CALL 0x001022b0
JMP 0x00113632
LAB_0011360b:
CMP EAX,0x5
JNZ 0x00113622
LEA RBX,[0x11f25d]
JMP 0x00113632
LAB_00113619:
LEA RBX,[0x11f250]
JMP 0x00113632
LAB_00113622:
LEA RBX,[0x11f27a]
JMP 0x00113632
LAB_0011362b:
LEA RBX,[0x11f248]
LAB_00113632:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0011363f:
LEA RDI,[0x117d5f]
LEA RSI,[0x11f07c]
LEA RCX,[0x11f1fd]
MOV EDX,0x9e
CALL 0x00102180
LAB_0011365e:
LEA RDI,[0x11f1b6]
LEA RSI,[0x11f07c]
LEA RCX,[0x11f1fd]
MOV EDX,0x9f
CALL 0x00102180
LAB_0011367d:
LEA RDI,[0x11f1f2]
LEA RSI,[0x11f07c]
LEA RCX,[0x11f1fd]
MOV EDX,0xa0
CALL 0x00102180
|
char * codegen_type_conversion_code(long param_1,int *param_2,int *param_3)
{
int iVar1;
int iVar2;
char cVar3;
char *__s;
char *__s_00;
int8 uVar4;
size_t sVar5;
char *__s_01;
char *__format;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9e,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
if (param_2 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9f,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
if (param_3 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xa0,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
cVar3 = type_equals(param_2,param_3);
if (cVar3 == '\0') {
__s = (char *)codegen_type_to_c_type(param_2);
__s_00 = (char *)codegen_type_to_c_type(param_3);
iVar1 = *param_2;
iVar2 = *param_3;
if ((iVar1 == 4) || (iVar1 == 3)) {
if (iVar2 == 2) {
return "(int)";
}
}
else if (iVar1 == 2) {
if (iVar2 == 3) {
return "(float)";
}
if (iVar2 == 4) {
return "(char)";
}
}
if (iVar2 == 0xc) {
if (1 < iVar1 - 2U) {
if (iVar1 == 5) {
return "(void*)(char*)";
}
return "(void*)";
}
uVar4 = codegen_context_get_arena(param_1);
sVar5 = strlen(__s);
__s_01 = (char *)arena_alloc(uVar4,sVar5 + 0x14);
__format = "({ %s temp = ";
__s_00 = __s;
}
else {
uVar4 = codegen_context_get_arena(param_1);
sVar5 = strlen(__s_00);
__s_01 = (char *)arena_alloc(uVar4,sVar5 + 3);
__format = "(%s)";
}
sprintf(__s_01,__format,__s_00);
return __s_01;
}
return "";
}
|
|
63,188 |
codegen_type_conversion_code
|
tsotchke[P]eshkol/src/backend/codegen/type_conversion.c
|
const char* codegen_type_conversion_code(CodegenContext* context, Type* from, Type* to) {
assert(context != NULL);
assert(from != NULL);
assert(to != NULL);
// Same type
if (type_equals(from, to)) {
return "";
}
// Get C types
const char* from_type = codegen_type_to_c_type(from);
const char* to_type = codegen_type_to_c_type(to);
// Generate conversion
if (from->kind == TYPE_INTEGER && to->kind == TYPE_FLOAT) {
return "(float)";
} else if (from->kind == TYPE_FLOAT && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_CHAR && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_INTEGER && to->kind == TYPE_CHAR) {
return "(char)";
} else if (to->kind == TYPE_ANY) {
// Special case for string to void*
if (from->kind == TYPE_STRING) {
return "(void*)(char*)";
}
// Special case for numeric to void*
else if (from->kind == TYPE_INTEGER || from->kind == TYPE_FLOAT) {
// For scientific computing, we need to be careful with numeric conversions
// We'll use a more explicit cast to void*
Arena* arena = codegen_context_get_arena(context);
char* result = arena_alloc(arena, strlen(from_type) + 20);
sprintf(result, "({ %s temp = ", from_type);
return result;
}
return "(void*)";
} else {
// Default cast
char* result = arena_alloc(codegen_context_get_arena(context), strlen(to_type) + 3);
sprintf(result, "(%s)", to_type);
return result;
}
}
|
O3
|
c
|
codegen_type_conversion_code:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x15019
movq %rsi, %r13
testq %rsi, %rsi
je 0x15038
movq %rdx, %r12
testq %rdx, %rdx
je 0x15057
movq %rdi, %rbx
movq %r13, %rdi
movq %r12, %rsi
callq 0x174ec
testb %al, %al
je 0x14f1f
leaq 0x8246(%rip), %rbx # 0x1d160
jmp 0x1500c
movq %r13, %rdi
callq 0x14cec
movq %rax, %r14
movq %r12, %rdi
callq 0x14cec
movq %rax, %r15
movl (%r13), %eax
movl (%r12), %ecx
cmpl $0x4, %eax
je 0x14f66
cmpl $0x3, %eax
je 0x14f66
cmpl $0x2, %eax
jne 0x14f6f
cmpl $0x3, %ecx
je 0x15005
cmpl $0x4, %ecx
jne 0x14f6f
leaq 0xc28d(%rip), %rbx # 0x211ee
jmp 0x1500c
cmpl $0x2, %ecx
je 0x14ff3
cmpl $0xc, %ecx
jne 0x14fad
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x14fe5
movq %rbx, %rdi
callq 0xb317
movq %rax, %rbx
movq %r14, %rdi
callq 0x2100
leaq 0x14(%rax), %rsi
movq %rbx, %rdi
callq 0x32d3
movq %rax, %rbx
leaq 0xc25f(%rip), %rsi # 0x21204
movq %rax, %rdi
movq %r14, %rdx
jmp 0x14fdc
movq %rbx, %rdi
callq 0xb317
movq %rax, %rbx
movq %r15, %rdi
callq 0x2100
leaq 0x3(%rax), %rsi
movq %rbx, %rdi
callq 0x32d3
movq %rax, %rbx
leaq 0xcf3a(%rip), %rsi # 0x21f10
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x1500c
cmpl $0x5, %eax
jne 0x14ffc
leaq 0xc204(%rip), %rbx # 0x211f5
jmp 0x1500c
leaq 0xc1ee(%rip), %rbx # 0x211e8
jmp 0x1500c
leaq 0xc20f(%rip), %rbx # 0x21212
jmp 0x1500c
leaq 0xc1d4(%rip), %rbx # 0x211e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4d3f(%rip), %rdi # 0x19d5f
leaq 0xbfed(%rip), %rsi # 0x21014
leaq 0xc167(%rip), %rcx # 0x21195
movl $0x9e, %edx
callq 0x2180
leaq 0xc10f(%rip), %rdi # 0x2114e
leaq 0xbfce(%rip), %rsi # 0x21014
leaq 0xc148(%rip), %rcx # 0x21195
movl $0x9f, %edx
callq 0x2180
leaq 0xc12c(%rip), %rdi # 0x2118a
leaq 0xbfaf(%rip), %rsi # 0x21014
leaq 0xc129(%rip), %rcx # 0x21195
movl $0xa0, %edx
callq 0x2180
|
codegen_type_conversion_code:
push r15
push r14
push r13
push r12
push rbx
test rdi, rdi
jz loc_15019
mov r13, rsi
test rsi, rsi
jz loc_15038
mov r12, rdx
test rdx, rdx
jz loc_15057
mov rbx, rdi
mov rdi, r13
mov rsi, r12
call type_equals
test al, al
jz short loc_14F1F
lea rbx, aIncludeCoreAut+1Ch; ""
jmp loc_1500C
loc_14F1F:
mov rdi, r13
call codegen_type_to_c_type
mov r14, rax
mov rdi, r12
call codegen_type_to_c_type
mov r15, rax
mov eax, [r13+0]
mov ecx, [r12]
cmp eax, 4
jz short loc_14F66
cmp eax, 3
jz short loc_14F66
cmp eax, 2
jnz short loc_14F6F
cmp ecx, 3
jz loc_15005
cmp ecx, 4
jnz short loc_14F6F
lea rbx, aChar_1; "(char)"
jmp loc_1500C
loc_14F66:
cmp ecx, 2
jz loc_14FF3
loc_14F6F:
cmp ecx, 0Ch
jnz short loc_14FAD
lea ecx, [rax-2]
cmp ecx, 2
jnb short loc_14FE5
mov rdi, rbx
call codegen_context_get_arena
mov rbx, rax
mov rdi, r14
call _strlen
lea rsi, [rax+14h]
mov rdi, rbx
call arena_alloc
mov rbx, rax
lea rsi, aSTemp; "({ %s temp = "
mov rdi, rax
mov rdx, r14
jmp short loc_14FDC
loc_14FAD:
mov rdi, rbx
call codegen_context_get_arena
mov rbx, rax
mov rdi, r15
call _strlen
lea rsi, [rax+3]
mov rdi, rbx
call arena_alloc
mov rbx, rax
lea rsi, aVoidCharS+0Eh; "(%s)"
mov rdi, rax
mov rdx, r15
loc_14FDC:
xor eax, eax
call _sprintf
jmp short loc_1500C
loc_14FE5:
cmp eax, 5
jnz short loc_14FFC
lea rbx, aVoidChar; "(void*)(char*)"
jmp short loc_1500C
loc_14FF3:
lea rbx, aInt_1; "(int)"
jmp short loc_1500C
loc_14FFC:
lea rbx, aVoid_2; "(void*)"
jmp short loc_1500C
loc_15005:
lea rbx, aFloat_0; "(float)"
loc_1500C:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_15019:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 9Eh
call ___assert_fail
loc_15038:
lea rdi, aFromNull; "from != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 9Fh
call ___assert_fail
loc_15057:
lea rdi, aToNull; "to != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
mov edx, 0A0h
call ___assert_fail
|
char * codegen_type_conversion_code(long long a1, int *a2, int *a3)
{
long long v4; // rbx
const char *v5; // r14
const char *v6; // r15
int v7; // eax
int v8; // ecx
long long v9; // rbx
long long v10; // rax
long long v11; // rcx
long long v12; // r8
char *v13; // rsi
long long v14; // rdi
const char *v15; // rdx
long long arena; // rbx
long long v17; // rax
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
158LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a2 )
__assert_fail(
"from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
159LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a3 )
__assert_fail(
"to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
160LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( (unsigned __int8)type_equals(a2, a3) )
return "";
v5 = codegen_type_to_c_type(a2);
v6 = codegen_type_to_c_type(a3);
v7 = *a2;
v8 = *a3;
if ( *a2 == 4 || v7 == 3 )
{
if ( v8 == 2 )
return "(int)";
}
else if ( v7 == 2 )
{
if ( v8 == 3 )
return "(float)";
if ( v8 == 4 )
return "(char)";
}
if ( v8 != 12 )
{
arena = codegen_context_get_arena(a1);
v17 = strlen(v6);
v4 = arena_alloc(arena, v17 + 3);
v13 = "(%s)";
v14 = v4;
v15 = v6;
goto LABEL_17;
}
if ( (unsigned int)(v7 - 2) < 2 )
{
v9 = codegen_context_get_arena(a1);
v10 = strlen(v5);
v4 = arena_alloc(v9, v10 + 20);
v13 = "({ %s temp = ";
v14 = v4;
v15 = v5;
LABEL_17:
sprintf(v14, v13, v15, v11, v12);
return (char *)v4;
}
if ( v7 == 5 )
return "(void*)(char*)";
else
return "(void*)";
}
|
codegen_type_conversion_code:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDI,RDI
JZ 0x00115019
MOV R13,RSI
TEST RSI,RSI
JZ 0x00115038
MOV R12,RDX
TEST RDX,RDX
JZ 0x00115057
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R12
CALL 0x001174ec
TEST AL,AL
JZ 0x00114f1f
LEA RBX,[0x11d160]
JMP 0x0011500c
LAB_00114f1f:
MOV RDI,R13
CALL 0x00114cec
MOV R14,RAX
MOV RDI,R12
CALL 0x00114cec
MOV R15,RAX
MOV EAX,dword ptr [R13]
MOV ECX,dword ptr [R12]
CMP EAX,0x4
JZ 0x00114f66
CMP EAX,0x3
JZ 0x00114f66
CMP EAX,0x2
JNZ 0x00114f6f
CMP ECX,0x3
JZ 0x00115005
CMP ECX,0x4
JNZ 0x00114f6f
LEA RBX,[0x1211ee]
JMP 0x0011500c
LAB_00114f66:
CMP ECX,0x2
JZ 0x00114ff3
LAB_00114f6f:
CMP ECX,0xc
JNZ 0x00114fad
LEA ECX,[RAX + -0x2]
CMP ECX,0x2
JNC 0x00114fe5
MOV RDI,RBX
CALL 0x0010b317
MOV RBX,RAX
MOV RDI,R14
CALL 0x00102100
LEA RSI,[RAX + 0x14]
MOV RDI,RBX
CALL 0x001032d3
MOV RBX,RAX
LEA RSI,[0x121204]
MOV RDI,RAX
MOV RDX,R14
JMP 0x00114fdc
LAB_00114fad:
MOV RDI,RBX
CALL 0x0010b317
MOV RBX,RAX
MOV RDI,R15
CALL 0x00102100
LEA RSI,[RAX + 0x3]
MOV RDI,RBX
CALL 0x001032d3
MOV RBX,RAX
LEA RSI,[0x121f10]
MOV RDI,RAX
MOV RDX,R15
LAB_00114fdc:
XOR EAX,EAX
CALL 0x001022b0
JMP 0x0011500c
LAB_00114fe5:
CMP EAX,0x5
JNZ 0x00114ffc
LEA RBX,[0x1211f5]
JMP 0x0011500c
LAB_00114ff3:
LEA RBX,[0x1211e8]
JMP 0x0011500c
LAB_00114ffc:
LEA RBX,[0x121212]
JMP 0x0011500c
LAB_00115005:
LEA RBX,[0x1211e0]
LAB_0011500c:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00115019:
LEA RDI,[0x119d5f]
LEA RSI,[0x121014]
LEA RCX,[0x121195]
MOV EDX,0x9e
CALL 0x00102180
LAB_00115038:
LEA RDI,[0x12114e]
LEA RSI,[0x121014]
LEA RCX,[0x121195]
MOV EDX,0x9f
CALL 0x00102180
LAB_00115057:
LEA RDI,[0x12118a]
LEA RSI,[0x121014]
LEA RCX,[0x121195]
MOV EDX,0xa0
CALL 0x00102180
|
char * codegen_type_conversion_code(long param_1,int *param_2,int *param_3)
{
int iVar1;
int iVar2;
char cVar3;
char *__s;
char *__s_00;
int8 uVar4;
size_t sVar5;
char *__s_01;
char *__format;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9e,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
if (param_2 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9f,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
if (param_3 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xa0,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
cVar3 = type_equals(param_2,param_3);
if (cVar3 == '\0') {
__s = (char *)codegen_type_to_c_type(param_2);
__s_00 = (char *)codegen_type_to_c_type(param_3);
iVar1 = *param_2;
iVar2 = *param_3;
if ((iVar1 == 4) || (iVar1 == 3)) {
if (iVar2 == 2) {
return "(int)";
}
}
else if (iVar1 == 2) {
if (iVar2 == 3) {
return "(float)";
}
if (iVar2 == 4) {
return "(char)";
}
}
if (iVar2 == 0xc) {
if (1 < iVar1 - 2U) {
if (iVar1 == 5) {
return "(void*)(char*)";
}
return "(void*)";
}
uVar4 = codegen_context_get_arena(param_1);
sVar5 = strlen(__s);
__s_01 = (char *)arena_alloc(uVar4,sVar5 + 0x14);
__format = "({ %s temp = ";
__s_00 = __s;
}
else {
uVar4 = codegen_context_get_arena(param_1);
sVar5 = strlen(__s_00);
__s_01 = (char *)arena_alloc(uVar4,sVar5 + 3);
__format = "(%s)";
}
sprintf(__s_01,__format,__s_00);
return __s_01;
}
return "";
}
|
|
63,189 |
read_block_primary
|
eloqsql/mysys/mf_keycache.c
|
static void read_block_primary(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, uint read_length,
uint min_length)
{
size_t got_length;
/* On entry cache_lock is locked */
KEYCACHE_THREAD_TRACE("read_block_primary");
/*
This code is executed only by threads that submitted primary
requests. Until block->status contains BLOCK_READ, all other
request for the block become secondary requests. For a primary
request the block must be properly initialized.
*/
DBUG_ASSERT(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
KEYCACHE_DBUG_PRINT("read_block_primary",
("page to be read by primary request"));
keycache->global_cache_read++;
/* Page is not in buffer yet, is to be read from disk */
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
got_length= my_pread(block->hash_link->file, block->buffer,
read_length, block->hash_link->diskpos, MYF(0));
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
The block can now have been marked for free (in case of
FLUSH_RELEASE). Otherwise the state must be unchanged.
*/
DBUG_ASSERT(((block->status & ~(BLOCK_REASSIGNED |
BLOCK_FOR_UPDATE)) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
if (got_length < min_length)
block->status|= BLOCK_ERROR;
else
{
block->status|= BLOCK_READ;
block->length= (uint)got_length;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
}
KEYCACHE_DBUG_PRINT("read_block_primary",
("primary request: new page in cache"));
/* Signal that all pending requests for this page now can be processed */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
DBUG_ASSERT(keycache->can_be_used);
}
|
O0
|
c
|
read_block_primary:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
jmp 0xe83d8
jmp 0xe83da
jmp 0xe83dc
jmp 0xe83de
jmp 0xe83e0
jmp 0xe83e2
jmp 0xe83e4
jmp 0xe83e6
jmp 0xe83e8
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x158(%rax)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe8360
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0xfce20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x759f8(%rip), %rsi # 0x15de4a
movl $0xa63, %edx # imm = 0xA63
callq 0xe7940
jmp 0xe845e
jmp 0xe8460
jmp 0xe8462
jmp 0xe8464
jmp 0xe8466
jmp 0xe8468
jmp 0xe846a
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
jae 0xe8485
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x50(%rax)
jmp 0xe849f
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x50(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0xe84a1
jmp 0xe84a3
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xe9760
jmp 0xe84b2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
read_block_primary:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
jmp short $+2
loc_E83D8:
jmp short $+2
loc_E83DA:
jmp short $+2
loc_E83DC:
jmp short $+2
loc_E83DE:
jmp short $+2
loc_E83E0:
jmp short $+2
loc_E83E2:
jmp short $+2
loc_E83E4:
jmp short $+2
loc_E83E6:
jmp short $+2
loc_E83E8:
mov rax, [rbp+var_8]
mov rcx, [rax+158h]
add rcx, 1
mov [rax+158h], rcx
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax+40h]
mov eax, [rbp+var_14]
mov edx, eax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rcx, [rax+20h]
xor eax, eax
mov r8d, eax
call my_pread
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_37; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0A63h
call inline_mysql_mutex_lock_24
jmp short $+2
loc_E845E:
jmp short $+2
loc_E8460:
jmp short $+2
loc_E8462:
jmp short $+2
loc_E8464:
jmp short $+2
loc_E8466:
jmp short $+2
loc_E8468:
jmp short $+2
loc_E846A:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_18]
cmp rax, rcx
jnb short loc_E8485
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
or ecx, 1
mov [rax+50h], ecx
jmp short loc_E849F
loc_E8485:
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
or ecx, 2
mov [rax+50h], ecx
mov rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+4Ch], ecx
loc_E849F:
jmp short $+2
loc_E84A1:
jmp short $+2
loc_E84A3:
mov rdi, [rbp+var_10]
add rdi, 28h ; '('
call release_whole_queue
jmp short $+2
loc_E84B2:
add rsp, 20h
pop rbp
retn
|
long long read_block_primary(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
unsigned long long v5; // [rsp+0h] [rbp-20h]
++*(_QWORD *)(a1 + 344);
inline_mysql_mutex_unlock_25(a1 + 192);
v5 = my_pread(
*(unsigned int *)(*(_QWORD *)(a2 + 32) + 24LL),
*(_QWORD *)(a2 + 64),
a3,
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 32LL),
0LL);
inline_mysql_mutex_lock_24(a1 + 192, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0xA63u);
if ( v5 >= a4 )
{
*(_DWORD *)(a2 + 80) |= 2u;
*(_DWORD *)(a2 + 76) = v5;
}
else
{
*(_DWORD *)(a2 + 80) |= 1u;
}
return release_whole_queue(a2 + 40);
}
|
read_block_primary:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
JMP 0x001e83d8
LAB_001e83d8:
JMP 0x001e83da
LAB_001e83da:
JMP 0x001e83dc
LAB_001e83dc:
JMP 0x001e83de
LAB_001e83de:
JMP 0x001e83e0
LAB_001e83e0:
JMP 0x001e83e2
LAB_001e83e2:
JMP 0x001e83e4
LAB_001e83e4:
JMP 0x001e83e6
LAB_001e83e6:
JMP 0x001e83e8
LAB_001e83e8:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x158]
ADD RCX,0x1
MOV qword ptr [RAX + 0x158],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e8360
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x40]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x20]
XOR EAX,EAX
MOV R8D,EAX
CALL 0x001fce20
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x25de4a]
MOV EDX,0xa63
CALL 0x001e7940
JMP 0x001e845e
LAB_001e845e:
JMP 0x001e8460
LAB_001e8460:
JMP 0x001e8462
LAB_001e8462:
JMP 0x001e8464
LAB_001e8464:
JMP 0x001e8466
LAB_001e8466:
JMP 0x001e8468
LAB_001e8468:
JMP 0x001e846a
LAB_001e846a:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x18]
CMP RAX,RCX
JNC 0x001e8485
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x1
MOV dword ptr [RAX + 0x50],ECX
JMP 0x001e849f
LAB_001e8485:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x2
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4c],ECX
LAB_001e849f:
JMP 0x001e84a1
LAB_001e84a1:
JMP 0x001e84a3
LAB_001e84a3:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x28
CALL 0x001e9760
JMP 0x001e84b2
LAB_001e84b2:
ADD RSP,0x20
POP RBP
RET
|
void read_block_primary(long param_1,long param_2,int4 param_3,uint param_4)
{
ulong uVar1;
*(long *)(param_1 + 0x158) = *(long *)(param_1 + 0x158) + 1;
inline_mysql_mutex_unlock(param_1 + 0xc0);
uVar1 = my_pread(*(int4 *)(*(long *)(param_2 + 0x20) + 0x18),*(int8 *)(param_2 + 0x40)
,param_3,*(int8 *)(*(long *)(param_2 + 0x20) + 0x20),0);
inline_mysql_mutex_lock
(param_1 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xa63);
if (uVar1 < param_4) {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 1;
}
else {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 2;
*(int *)(param_2 + 0x4c) = (int)uVar1;
}
release_whole_queue(param_2 + 0x28);
return;
}
|
|
63,190 |
read_block_primary
|
eloqsql/mysys/mf_keycache.c
|
static void read_block_primary(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, uint read_length,
uint min_length)
{
size_t got_length;
/* On entry cache_lock is locked */
KEYCACHE_THREAD_TRACE("read_block_primary");
/*
This code is executed only by threads that submitted primary
requests. Until block->status contains BLOCK_READ, all other
request for the block become secondary requests. For a primary
request the block must be properly initialized.
*/
DBUG_ASSERT(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
KEYCACHE_DBUG_PRINT("read_block_primary",
("page to be read by primary request"));
keycache->global_cache_read++;
/* Page is not in buffer yet, is to be read from disk */
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
got_length= my_pread(block->hash_link->file, block->buffer,
read_length, block->hash_link->diskpos, MYF(0));
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
The block can now have been marked for free (in case of
FLUSH_RELEASE). Otherwise the state must be unchanged.
*/
DBUG_ASSERT(((block->status & ~(BLOCK_REASSIGNED |
BLOCK_FOR_UPDATE)) == BLOCK_IN_USE) ||
fail_block(block));
DBUG_ASSERT((block->length == 0) || fail_block(block));
DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
fail_block(block));
DBUG_ASSERT((block->requests > 0) || fail_block(block));
if (got_length < min_length)
block->status|= BLOCK_ERROR;
else
{
block->status|= BLOCK_READ;
block->length= (uint)got_length;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
}
KEYCACHE_DBUG_PRINT("read_block_primary",
("primary request: new page in cache"));
/* Signal that all pending requests for this page now can be processed */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
DBUG_ASSERT(keycache->can_be_used);
}
|
O3
|
c
|
read_block_primary:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r13d
movq %rdi, %r12
incq 0x158(%rdi)
movq %rsi, %rbx
leaq 0xc0(%rdi), %r15
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
jne 0x9ba81
movq %r15, %rdi
callq 0x2a1e0
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rsi
movl 0x18(%rax), %edi
movl %r13d, %edx
movq 0x20(%rax), %rcx
xorl %r8d, %r8d
callq 0xa6c7c
movq %rax, %r13
cmpq $0x0, 0x100(%r12)
jne 0x9ba96
movq %r15, %rdi
callq 0x2a220
movl %r14d, %ecx
movl 0x50(%rbx), %eax
cmpq %rcx, %r13
jae 0x9ba5d
orl $0x1, %eax
movl %eax, 0x50(%rbx)
jmp 0x9ba67
orl $0x2, %eax
movl %eax, 0x50(%rbx)
movl %r13d, 0x4c(%rbx)
addq $0x28, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9c401
leaq 0x2f37d0(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9ba12
leaq 0x4848f(%rip), %rsi # 0xe3f2c
movq %r15, %rdi
movl $0xa63, %edx # imm = 0xA63
callq 0x30603
jmp 0x9ba4a
|
read_block_primary:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, ecx
mov r13d, edx
mov r12, rdi
inc qword ptr [rdi+158h]
mov rbx, rsi
lea r15, [rdi+0C0h]
mov rdi, [rdi+100h]
test rdi, rdi
jnz short loc_9BA81
loc_9BA12:
mov rdi, r15
call _pthread_mutex_unlock
mov rax, [rbx+20h]
mov rsi, [rbx+40h]
mov edi, [rax+18h]
mov edx, r13d
mov rcx, [rax+20h]
xor r8d, r8d
call my_pread
mov r13, rax
cmp qword ptr [r12+100h], 0
jnz short loc_9BA96
mov rdi, r15
call _pthread_mutex_lock
loc_9BA4A:
mov ecx, r14d
mov eax, [rbx+50h]
cmp r13, rcx
jnb short loc_9BA5D
or eax, 1
mov [rbx+50h], eax
jmp short loc_9BA67
loc_9BA5D:
or eax, 2
mov [rbx+50h], eax
mov [rbx+4Ch], r13d
loc_9BA67:
add rbx, 28h ; '('
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp release_whole_queue
loc_9BA81:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_9BA12
loc_9BA96:
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0A63h
call psi_mutex_lock
jmp short loc_9BA4A
|
long long read_block_primary(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
long long v7; // r15
long long v8; // rdi
unsigned long long v9; // r13
int v10; // eax
++*(_QWORD *)(a1 + 344);
v7 = a1 + 192;
v8 = *(_QWORD *)(a1 + 256);
if ( v8 )
((void ( *)(long long))PSI_server[44])(v8);
pthread_mutex_unlock(v7);
v9 = my_pread(
*(unsigned int *)(*(_QWORD *)(a2 + 32) + 24LL),
*(_QWORD *)(a2 + 64),
a3,
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 32LL),
0LL);
if ( *(_QWORD *)(a1 + 256) )
psi_mutex_lock(v7, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0xA63u);
else
pthread_mutex_lock(v7);
v10 = *(_DWORD *)(a2 + 80);
if ( v9 >= a4 )
{
*(_DWORD *)(a2 + 80) = v10 | 2;
*(_DWORD *)(a2 + 76) = v9;
}
else
{
*(_DWORD *)(a2 + 80) = v10 | 1;
}
return release_whole_queue(a2 + 40);
}
|
read_block_primary:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ECX
MOV R13D,EDX
MOV R12,RDI
INC qword ptr [RDI + 0x158]
MOV RBX,RSI
LEA R15,[RDI + 0xc0]
MOV RDI,qword ptr [RDI + 0x100]
TEST RDI,RDI
JNZ 0x0019ba81
LAB_0019ba12:
MOV RDI,R15
CALL 0x0012a1e0
MOV RAX,qword ptr [RBX + 0x20]
MOV RSI,qword ptr [RBX + 0x40]
MOV EDI,dword ptr [RAX + 0x18]
MOV EDX,R13D
MOV RCX,qword ptr [RAX + 0x20]
XOR R8D,R8D
CALL 0x001a6c7c
MOV R13,RAX
CMP qword ptr [R12 + 0x100],0x0
JNZ 0x0019ba96
MOV RDI,R15
CALL 0x0012a220
LAB_0019ba4a:
MOV ECX,R14D
MOV EAX,dword ptr [RBX + 0x50]
CMP R13,RCX
JNC 0x0019ba5d
OR EAX,0x1
MOV dword ptr [RBX + 0x50],EAX
JMP 0x0019ba67
LAB_0019ba5d:
OR EAX,0x2
MOV dword ptr [RBX + 0x50],EAX
MOV dword ptr [RBX + 0x4c],R13D
LAB_0019ba67:
ADD RBX,0x28
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0019c401
LAB_0019ba81:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019ba12
LAB_0019ba96:
LEA RSI,[0x1e3f2c]
MOV RDI,R15
MOV EDX,0xa63
CALL 0x00130603
JMP 0x0019ba4a
|
void read_block_primary(long param_1,long param_2,int4 param_3,ulong param_4)
{
pthread_mutex_t *__mutex;
ulong uVar1;
*(long *)(param_1 + 0x158) = *(long *)(param_1 + 0x158) + 1;
__mutex = (pthread_mutex_t *)(param_1 + 0xc0);
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar1 = my_pread(*(int4 *)(*(long *)(param_2 + 0x20) + 0x18),*(int8 *)(param_2 + 0x40)
,param_3,*(int8 *)(*(long *)(param_2 + 0x20) + 0x20),0);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xa63);
}
if (uVar1 < (param_4 & 0xffffffff)) {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 1;
}
else {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 2;
*(int *)(param_2 + 0x4c) = (int)uVar1;
}
release_whole_queue(param_2 + 0x28);
return;
}
|
|
63,191 |
FTB_WORD_cmp
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
{
int i;
/* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v)
return -1;
/* ORDER BY docid, ndepth DESC */
i=CMP_NUM(a->docid[0], b->docid[0]);
if (!i)
i=CMP_NUM(b->ndepth,a->ndepth);
return i;
}
|
O3
|
c
|
FTB_WORD_cmp:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rsi), %rcx
testq %rdi, %rdi
je 0x71c19
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq (%rdi), %rcx
je 0x71c3c
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
setne %al
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
testl %eax, %eax
jne 0x71c3c
movl 0x44(%rdx), %edx
xorl %eax, %eax
cmpl 0x44(%rsi), %edx
setne %al
cmovbl %ecx, %eax
popq %rbp
retq
|
FTB_WORD_cmp:
push rbp
mov rbp, rsp
mov rcx, [rsi+10h]
test rdi, rdi
jz short loc_71C19
mov eax, 0FFFFFFFFh
cmp rcx, [rdi]
jz short loc_71C3C
loc_71C19:
xor eax, eax
cmp rcx, [rdx+10h]
setnz al
mov ecx, 0FFFFFFFFh
cmovb eax, ecx
test eax, eax
jnz short loc_71C3C
mov edx, [rdx+44h]
xor eax, eax
cmp edx, [rsi+44h]
setnz al
cmovb eax, ecx
loc_71C3C:
pop rbp
retn
|
long long FTB_WORD_cmp(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v3; // rcx
long long result; // rax
unsigned int v5; // edx
v3 = *(_QWORD *)(a2 + 16);
if ( !a1 || (result = 0xFFFFFFFFLL, v3 != *a1) )
{
result = v3 != *(_QWORD *)(a3 + 16);
if ( v3 < *(_QWORD *)(a3 + 16) )
result = 0xFFFFFFFFLL;
if ( !(_DWORD)result )
{
v5 = *(_DWORD *)(a3 + 68);
result = v5 != *(_DWORD *)(a2 + 68);
if ( v5 < *(_DWORD *)(a2 + 68) )
return 0xFFFFFFFFLL;
}
}
return result;
}
|
FTB_WORD_cmp:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RSI + 0x10]
TEST RDI,RDI
JZ 0x00171c19
MOV EAX,0xffffffff
CMP RCX,qword ptr [RDI]
JZ 0x00171c3c
LAB_00171c19:
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x10]
SETNZ AL
MOV ECX,0xffffffff
CMOVC EAX,ECX
TEST EAX,EAX
JNZ 0x00171c3c
MOV EDX,dword ptr [RDX + 0x44]
XOR EAX,EAX
CMP EDX,dword ptr [RSI + 0x44]
SETNZ AL
CMOVC EAX,ECX
LAB_00171c3c:
POP RBP
RET
|
uint FTB_WORD_cmp(ulong *param_1,long param_2,long param_3)
{
ulong uVar1;
uint uVar2;
uVar1 = *(ulong *)(param_2 + 0x10);
if ((param_1 == (ulong *)0x0) || (uVar2 = 0xffffffff, uVar1 != *param_1)) {
uVar2 = (uint)(uVar1 != *(ulong *)(param_3 + 0x10));
if (uVar1 < *(ulong *)(param_3 + 0x10)) {
uVar2 = 0xffffffff;
}
if ((uVar2 == 0) &&
(uVar2 = (uint)(*(uint *)(param_3 + 0x44) != *(uint *)(param_2 + 0x44)),
*(uint *)(param_3 + 0x44) < *(uint *)(param_2 + 0x44))) {
uVar2 = 0xffffffff;
}
}
return uVar2;
}
|
|
63,192 |
machine_state_add_exit
|
navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/tool/machine.c
|
bool
machine_state_add_exit (STATEMACHINE_STATE_T* state, STATE_DATA_T value )
{
if (!state) return 0 ;
uint32_t start = state->events + state->deferred + state->entry + state->exit++ ;
uint32_t count = state->action ;
if (count) _shift_data(state, start, count) ;
state->data[start] = value ;
state->size += sizeof(STATE_DATA_T) ;
return 1 ;
}
|
O3
|
c
|
machine_state_add_exit:
testq %rdi, %rdi
je 0x970c
movzbl 0x24(%rdi), %eax
movzbl 0x25(%rdi), %ecx
addl %eax, %ecx
movzbl 0x26(%rdi), %eax
movzbl 0x27(%rdi), %edx
leal 0x1(%rdx), %r8d
movb %r8b, 0x27(%rdi)
addl %edx, %eax
addl %ecx, %eax
movzbl 0x28(%rdi), %ecx
testl %ecx, %ecx
je 0x9702
pushq %rbp
movq %rsp, %rbp
leal (%rax,%rcx), %edx
leaq (%rdi,%rdx,4), %rdx
addq $0x2a, %rdx
movl -0x4(%rdx), %r8d
movl %r8d, (%rdx)
addq $-0x4, %rdx
decl %ecx
jne 0x96f2
popq %rbp
movl %eax, %eax
movl %esi, 0x2a(%rdi,%rax,4)
addw $0x4, (%rdi)
testq %rdi, %rdi
setne %al
retq
|
machine_state_add_exit:
test rdi, rdi
jz short loc_970C
movzx eax, byte ptr [rdi+24h]
movzx ecx, byte ptr [rdi+25h]
add ecx, eax
movzx eax, byte ptr [rdi+26h]
movzx edx, byte ptr [rdi+27h]
lea r8d, [rdx+1]
mov [rdi+27h], r8b
add eax, edx
add eax, ecx
movzx ecx, byte ptr [rdi+28h]
test ecx, ecx
jz short loc_9702
push rbp
mov rbp, rsp
lea edx, [rax+rcx]
lea rdx, [rdi+rdx*4]
add rdx, 2Ah ; '*'
loc_96F2:
mov r8d, [rdx-4]
mov [rdx], r8d
add rdx, 0FFFFFFFFFFFFFFFCh
dec ecx
jnz short loc_96F2
pop rbp
loc_9702:
mov eax, eax
mov [rdi+rax*4+2Ah], esi
add word ptr [rdi], 4
loc_970C:
test rdi, rdi
setnz al
retn
|
bool machine_state_add_exit(long long a1, int a2)
{
int v2; // ecx
int v3; // eax
int v4; // edx
unsigned int v5; // eax
int v6; // ecx
_DWORD *v7; // rdx
if ( a1 )
{
v2 = *(unsigned __int8 *)(a1 + 36) + *(unsigned __int8 *)(a1 + 37);
v3 = *(unsigned __int8 *)(a1 + 38);
v4 = *(unsigned __int8 *)(a1 + 39);
*(_BYTE *)(a1 + 39) = v4 + 1;
v5 = v2 + v4 + v3;
v6 = *(unsigned __int8 *)(a1 + 40);
if ( *(_BYTE *)(a1 + 40) )
{
v7 = (_DWORD *)(a1 + 4LL * (v5 + v6) + 42);
do
{
*v7 = *(v7 - 1);
--v7;
--v6;
}
while ( v6 );
}
*(_DWORD *)(a1 + 4LL * v5 + 42) = a2;
*(_WORD *)a1 += 4;
}
return a1 != 0;
}
|
machine_state_add_exit:
TEST RDI,RDI
JZ 0x0010970c
MOVZX EAX,byte ptr [RDI + 0x24]
MOVZX ECX,byte ptr [RDI + 0x25]
ADD ECX,EAX
MOVZX EAX,byte ptr [RDI + 0x26]
MOVZX EDX,byte ptr [RDI + 0x27]
LEA R8D,[RDX + 0x1]
MOV byte ptr [RDI + 0x27],R8B
ADD EAX,EDX
ADD EAX,ECX
MOVZX ECX,byte ptr [RDI + 0x28]
TEST ECX,ECX
JZ 0x00109702
PUSH RBP
MOV RBP,RSP
LEA EDX,[RAX + RCX*0x1]
LEA RDX,[RDI + RDX*0x4]
ADD RDX,0x2a
LAB_001096f2:
MOV R8D,dword ptr [RDX + -0x4]
MOV dword ptr [RDX],R8D
ADD RDX,-0x4
DEC ECX
JNZ 0x001096f2
POP RBP
LAB_00109702:
MOV EAX,EAX
MOV dword ptr [RDI + RAX*0x4 + 0x2a],ESI
ADD word ptr [RDI],0x4
LAB_0010970c:
TEST RDI,RDI
SETNZ AL
RET
|
bool machine_state_add_exit(short *param_1,int4 param_2)
{
byte bVar1;
uint uVar2;
uint uVar3;
short *psVar4;
if (param_1 != (short *)0x0) {
bVar1 = *(byte *)((long)param_1 + 0x27);
*(byte *)((long)param_1 + 0x27) = bVar1 + 1;
uVar2 = (uint)*(byte *)(param_1 + 0x13) + (uint)bVar1 +
(uint)*(byte *)((long)param_1 + 0x25) + (uint)*(byte *)(param_1 + 0x12);
uVar3 = (uint)*(byte *)(param_1 + 0x14);
if (*(byte *)(param_1 + 0x14) != 0) {
psVar4 = param_1 + (ulong)(uVar2 + uVar3) * 2 + 0x15;
do {
*(int4 *)psVar4 = *(int4 *)(psVar4 + -2);
psVar4 = psVar4 + -2;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
}
*(int4 *)(param_1 + (ulong)uVar2 * 2 + 0x15) = param_2;
*param_1 = *param_1 + 4;
}
return param_1 != (short *)0x0;
}
|
|
63,193 |
string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/common.cpp
|
std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
}
|
O2
|
cpp
|
string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x21ac0
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbp
jae 0x492d2
testq %rbp, %rbp
je 0x492be
movq %r12, %rdi
movq %r14, %rsi
callq 0x216f0
movq (%r15), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x216f0
incq %rbp
addq $0x20, %r13
jmp 0x49298
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21ce0
movq %rsp, %rdi
callq 0x21190
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x492fe
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21190
movq %rbx, %rdi
callq 0x21e50
|
_Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 178h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r12, rsp
mov rdi, r12
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
xor r13d, r13d
xor ebp, ebp
loc_49298:
mov rsi, [r15]
mov rax, [r15+8]
sub rax, rsi
sar rax, 5
cmp rbp, rax
jnb short loc_492D2
test rbp, rbp
jz short loc_492BE
mov rdi, r12
mov rsi, r14
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rsi, [r15]
loc_492BE:
add rsi, r13
mov rdi, r12
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
inc rbp
add r13, 20h ; ' '
jmp short loc_49298
loc_492D2:
lea rsi, [rsp+1A8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, rbx
add rsp, 178h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_492FE:
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rbx
call __Unwind_Resume
|
long long string_join(long long a1, long long *a2, long long a3)
{
long long v5; // r13
unsigned long long i; // rbp
long long v7; // rsi
long long v9; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v10[416]; // [rsp+8h] [rbp-1A0h] BYREF
std::ostringstream::basic_ostringstream(&v9);
v5 = 0LL;
for ( i = 0LL; ; ++i )
{
v7 = *a2;
if ( i >= (a2[1] - *a2) >> 5 )
break;
if ( i )
{
std::operator<<<char>(&v9, a3);
v7 = *a2;
}
std::operator<<<char>(&v9, v5 + v7);
v5 += 32LL;
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(&v9);
return a1;
}
|
string_join:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x178
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R12,RSP
MOV RDI,R12
CALL 0x00121ac0
XOR R13D,R13D
XOR EBP,EBP
LAB_00149298:
MOV RSI,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,RSI
SAR RAX,0x5
CMP RBP,RAX
JNC 0x001492d2
TEST RBP,RBP
JZ 0x001492be
LAB_001492b0:
MOV RDI,R12
MOV RSI,R14
CALL 0x001216f0
MOV RSI,qword ptr [R15]
LAB_001492be:
ADD RSI,R13
MOV RDI,R12
CALL 0x001216f0
INC RBP
ADD R13,0x20
JMP 0x00149298
LAB_001492d2:
LEA RSI,[RSP + 0x8]
LAB_001492d7:
MOV RDI,RBX
CALL 0x00121ce0
LAB_001492df:
MOV RDI,RSP
CALL 0x00121190
MOV RAX,RBX
ADD RSP,0x178
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_join(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::__cxx11::string const&) */
vector * string_join(vector *param_1,string *param_2)
{
string *in_RDX;
ulong uVar1;
long lVar2;
long lVar3;
ostringstream aoStack_1a8 [376];
std::__cxx11::ostringstream::ostringstream(aoStack_1a8);
lVar3 = 0;
for (uVar1 = 0; lVar2 = *(long *)param_2, uVar1 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 5);
uVar1 = uVar1 + 1) {
if (uVar1 != 0) {
/* try { // try from 001492b0 to 001492c8 has its CatchHandler @ 001492fe */
std::operator<<((ostream *)aoStack_1a8,in_RDX);
lVar2 = *(long *)param_2;
}
std::operator<<((ostream *)aoStack_1a8,(string *)(lVar2 + lVar3));
lVar3 = lVar3 + 0x20;
}
/* try { // try from 001492d7 to 001492de has its CatchHandler @ 001492fc */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(aoStack_1a8);
return param_1;
}
|
|
63,194 |
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t const&)
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
static std::string position_string(const position_t& pos)
{
return concat(" at line ", std::to_string(pos.lines_read + 1),
", column ", std::to_string(pos.chars_read_current_line));
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
incq %r15
movl $0x1, %ebp
movabsq $0x346dc5d63886594b, %r13 # imm = 0x346DC5D63886594B
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x1f8d2
movl $0x4, %esi
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x1f8cb
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x1f8d0
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x1f8d2
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f895
addl $-0x3, %esi
jmp 0x1f8d2
addl $-0x2, %esi
jmp 0x1f8d2
decl %esi
movl %esi, %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x11b70
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x118f0
movq 0x8(%r14), %r14
cmpq $0xa, %r14
jb 0x1f94c
movl $0x4, %ebp
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x1f945
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x1f94a
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x1f94c
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %ebp
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f90f
addl $-0x3, %ebp
jmp 0x1f94c
addl $-0x2, %ebp
jmp 0x1f94c
decl %ebp
movl %ebp, %esi
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x11b70
leaq 0x28(%rsp), %r15
movq (%r15), %rdi
movl 0x8(%r15), %esi
movq %r14, %rdx
callq 0x118f0
leaq 0x61cc(%rip), %rsi # 0x25b4b
leaq 0x61cf(%rip), %rcx # 0x25b55
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %r8
callq 0x11540
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f9ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x119b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1f9c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x119b0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f9fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x119b0
jmp 0x1f9fa
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1fa16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x119b0
movq %rbx, %rdi
callq 0x12010
|
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error15position_stringB5cxx11ERKNS1_10position_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov r15, [rsi+10h]
inc r15
mov ebp, 1
mov r13, 346DC5D63886594Bh
mov esi, 1
cmp r15, 0Ah
jb short loc_1F8D2
mov esi, 4
mov rcx, r15
loc_1F895:
cmp rcx, 63h ; 'c'
jbe short loc_1F8CB
cmp rcx, 3E7h
jbe short loc_1F8D0
cmp rcx, 2710h
jb short loc_1F8D2
mov rax, rcx
mul r13
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_1F895
add esi, 0FFFFFFFDh
jmp short loc_1F8D2
loc_1F8CB:
add esi, 0FFFFFFFEh
jmp short loc_1F8D2
loc_1F8D0:
dec esi
loc_1F8D2:
mov esi, esi
lea rax, [rsp+78h+var_60]
mov [rax-10h], rax
lea r12, [rsp+78h+var_70]
mov rdi, r12
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [r12]
mov esi, [r12+8]
mov rdx, r15
call __ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov r14, [r14+8]
cmp r14, 0Ah
jb short loc_1F94C
mov ebp, 4
mov rcx, r14
loc_1F90F:
cmp rcx, 63h ; 'c'
jbe short loc_1F945
cmp rcx, 3E7h
jbe short loc_1F94A
cmp rcx, 2710h
jb short loc_1F94C
mov rax, rcx
mul r13
shr rdx, 0Bh
add ebp, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_1F90F
add ebp, 0FFFFFFFDh
jmp short loc_1F94C
loc_1F945:
add ebp, 0FFFFFFFEh
jmp short loc_1F94C
loc_1F94A:
dec ebp
loc_1F94C:
mov esi, ebp
lea r12, [rsp+78h+var_40]
mov [r12-10h], r12
lea rdi, [rsp+78h+var_50]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
lea r15, [rsp+78h+var_50]
mov rdi, [r15]
mov esi, [r15+8]
mov rdx, r14
call __ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
lea rsi, aAtLine; " at line "
lea rcx, aColumn; ", column "
lea rdx, [rsp+78h+var_70]
mov rdi, rbx
mov r8, r15
call __ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA10_KcS8_SB_S8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(char const(&)[10],std::string,char const(&)[10],std::string &&)
mov rdi, [rsp+78h+var_50]; void *
cmp rdi, r12
jz short loc_1F9AD
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F9AD:
mov rdi, [rsp+78h+var_70]; void *
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz short loc_1F9C9
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F9C9:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_1F9FA
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F9FA
mov rbx, rax
loc_1F9FA:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_1FA16
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1FA16:
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](long long a1, long long a2)
{
unsigned long long v3; // r15
unsigned int v4; // ebp
unsigned int v5; // esi
unsigned long long v6; // rcx
bool v7; // cc
unsigned long long v8; // r14
unsigned long long v9; // rcx
void *v11; // [rsp+8h] [rbp-70h] BYREF
unsigned int v12; // [rsp+10h] [rbp-68h]
_QWORD v13[2]; // [rsp+18h] [rbp-60h] BYREF
void *v14; // [rsp+28h] [rbp-50h] BYREF
unsigned int v15; // [rsp+30h] [rbp-48h]
_QWORD v16[8]; // [rsp+38h] [rbp-40h] BYREF
v3 = *(_QWORD *)(a2 + 16) + 1LL;
v4 = 1;
v5 = 1;
if ( v3 >= 0xA )
{
v5 = 4;
v6 = v3;
while ( 1 )
{
if ( v6 <= 0x63 )
{
v5 -= 2;
goto LABEL_10;
}
if ( v6 <= 0x3E7 )
break;
if ( v6 < 0x2710 )
goto LABEL_10;
v5 += 4;
v7 = v6 <= 0x1869F;
v6 /= 0x2710uLL;
if ( v7 )
{
v5 -= 3;
goto LABEL_10;
}
}
--v5;
}
LABEL_10:
v11 = v13;
std::string::_M_construct(&v11, v5, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v11, v12, v3);
v8 = *(_QWORD *)(a2 + 8);
if ( v8 >= 0xA )
{
v4 = 4;
v9 = v8;
while ( 1 )
{
if ( v9 <= 0x63 )
{
v4 -= 2;
goto LABEL_19;
}
if ( v9 <= 0x3E7 )
break;
if ( v9 < 0x2710 )
goto LABEL_19;
v4 += 4;
v7 = v9 <= 0x1869F;
v9 /= 0x2710uLL;
if ( v7 )
{
v4 -= 3;
goto LABEL_19;
}
}
--v4;
}
LABEL_19:
v14 = v16;
std::string::_M_construct(&v14, v4, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v14, v15, v8);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(
a1,
" at line ",
&v11,
", column ",
&v14);
if ( v14 != v16 )
operator delete(v14, v16[0] + 1LL);
if ( v11 != v13 )
operator delete(v11, v13[0] + 1LL);
return a1;
}
|
position_string[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV R15,qword ptr [RSI + 0x10]
INC R15
MOV EBP,0x1
MOV R13,0x346dc5d63886594b
MOV ESI,0x1
CMP R15,0xa
JC 0x0011f8d2
MOV ESI,0x4
MOV RCX,R15
LAB_0011f895:
CMP RCX,0x63
JBE 0x0011f8cb
CMP RCX,0x3e7
JBE 0x0011f8d0
CMP RCX,0x2710
JC 0x0011f8d2
MOV RAX,RCX
MUL R13
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x0011f895
ADD ESI,-0x3
JMP 0x0011f8d2
LAB_0011f8cb:
ADD ESI,-0x2
JMP 0x0011f8d2
LAB_0011f8d0:
DEC ESI
LAB_0011f8d2:
MOV ESI,ESI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
XOR EDX,EDX
CALL 0x00111b70
MOV RDI,qword ptr [R12]
MOV ESI,dword ptr [R12 + 0x8]
MOV RDX,R15
CALL 0x001118f0
MOV R14,qword ptr [R14 + 0x8]
CMP R14,0xa
JC 0x0011f94c
MOV EBP,0x4
MOV RCX,R14
LAB_0011f90f:
CMP RCX,0x63
JBE 0x0011f945
CMP RCX,0x3e7
JBE 0x0011f94a
CMP RCX,0x2710
JC 0x0011f94c
MOV RAX,RCX
MUL R13
SHR RDX,0xb
ADD EBP,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x0011f90f
ADD EBP,-0x3
JMP 0x0011f94c
LAB_0011f945:
ADD EBP,-0x2
JMP 0x0011f94c
LAB_0011f94a:
DEC EBP
LAB_0011f94c:
MOV ESI,EBP
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LAB_0011f958:
LEA RDI,[RSP + 0x28]
XOR EDX,EDX
CALL 0x00111b70
LEA R15,[RSP + 0x28]
MOV RDI,qword ptr [R15]
MOV ESI,dword ptr [R15 + 0x8]
MOV RDX,R14
CALL 0x001118f0
LAB_0011f978:
LEA RSI,[0x125b4b]
LEA RCX,[0x125b55]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV R8,R15
CALL 0x00111540
LAB_0011f996:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x0011f9ad
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001119b0
LAB_0011f9ad:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0011f9c9
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001119b0
LAB_0011f9c9:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t
const&) */
parse_error * __thiscall
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string_abi_cxx11_
(parse_error *this,position_t *param_1)
{
bool bVar1;
char cVar2;
ulong uVar3;
char cVar4;
char cVar5;
ulong uVar6;
long *local_70;
uint local_68;
long local_60 [2];
long *local_50;
uint local_48;
long local_40 [2];
uVar6 = *(long *)(param_1 + 0x10) + 1;
cVar4 = '\x01';
cVar5 = '\x01';
if (9 < uVar6) {
uVar3 = uVar6;
cVar2 = '\x04';
do {
cVar5 = cVar2;
if (uVar3 < 100) {
cVar5 = cVar5 + -2;
goto LAB_0011f8d2;
}
if (uVar3 < 1000) {
cVar5 = cVar5 + -1;
goto LAB_0011f8d2;
}
if (uVar3 < 10000) goto LAB_0011f8d2;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
cVar2 = cVar5 + '\x04';
} while (bVar1);
cVar5 = cVar5 + '\x01';
}
LAB_0011f8d2:
local_70 = local_60;
std::__cxx11::string::_M_construct((ulong)&local_70,cVar5);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_70,local_68,uVar6);
uVar6 = *(ulong *)(param_1 + 8);
if (9 < uVar6) {
uVar3 = uVar6;
cVar5 = '\x04';
do {
cVar4 = cVar5;
if (uVar3 < 100) {
cVar4 = cVar4 + -2;
goto LAB_0011f94c;
}
if (uVar3 < 1000) {
cVar4 = cVar4 + -1;
goto LAB_0011f94c;
}
if (uVar3 < 10000) goto LAB_0011f94c;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
cVar5 = cVar4 + '\x04';
} while (bVar1);
cVar4 = cVar4 + '\x01';
}
LAB_0011f94c:
/* try { // try from 0011f958 to 0011f963 has its CatchHandler @ 0011f9f7 */
local_50 = local_40;
std::__cxx11::string::_M_construct((ulong)&local_50,cVar4);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_50,local_48,uVar6);
/* try { // try from 0011f978 to 0011f995 has its CatchHandler @ 0011f9db */
concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>
((detail *)this," at line ",(string *)&local_70,", column ",(string *)&local_50);
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
return this;
}
|
|
63,195 |
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t const&)
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
static std::string position_string(const position_t& pos)
{
return concat(" at line ", std::to_string(pos.lines_read + 1),
", column ", std::to_string(pos.chars_read_current_line));
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
incq %r15
movl $0x1, %ebp
movabsq $0x346dc5d63886594b, %r13 # imm = 0x346DC5D63886594B
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x1f548
movl $0x4, %esi
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x1f541
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x1f546
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x1f548
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f50b
addl $-0x3, %esi
jmp 0x1f548
addl $-0x2, %esi
jmp 0x1f548
decl %esi
movl %esi, %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x11b50
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x118e0
movq 0x8(%r14), %r14
cmpq $0xa, %r14
jb 0x1f5c2
movl $0x4, %ebp
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x1f5bb
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x1f5c0
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x1f5c2
movq %rcx, %rax
mulq %r13
shrq $0xb, %rdx
addl $0x4, %ebp
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f585
addl $-0x3, %ebp
jmp 0x1f5c2
addl $-0x2, %ebp
jmp 0x1f5c2
decl %ebp
movl %ebp, %esi
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x11b50
leaq 0x28(%rsp), %r15
movq (%r15), %rdi
movl 0x8(%r15), %esi
movq %r14, %rdx
callq 0x118e0
leaq 0x5556(%rip), %rsi # 0x24b4b
leaq 0x5559(%rip), %rcx # 0x24b55
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %r8
callq 0x11530
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f623
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x119a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1f63f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x119a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f670
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x119a0
jmp 0x1f670
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1f68c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x119a0
movq %rbx, %rdi
callq 0x11fe0
|
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error15position_stringB5cxx11ERKNS1_10position_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov r15, [rsi+10h]
inc r15
mov ebp, 1
mov r13, 346DC5D63886594Bh
mov esi, 1
cmp r15, 0Ah
jb short loc_1F548
mov esi, 4
mov rcx, r15
loc_1F50B:
cmp rcx, 63h ; 'c'
jbe short loc_1F541
cmp rcx, 3E7h
jbe short loc_1F546
cmp rcx, 2710h
jb short loc_1F548
mov rax, rcx
mul r13
shr rdx, 0Bh
add esi, 4
cmp rcx, offset loc_1869F
mov rcx, rdx
ja short loc_1F50B
add esi, 0FFFFFFFDh
jmp short loc_1F548
loc_1F541:
add esi, 0FFFFFFFEh
jmp short loc_1F548
loc_1F546:
dec esi
loc_1F548:
mov esi, esi
lea rax, [rsp+78h+var_60]
mov [rax-10h], rax
lea r12, [rsp+78h+var_70]
mov rdi, r12
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [r12]
mov esi, [r12+8]
mov rdx, r15
call __ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov r14, [r14+8]
cmp r14, 0Ah
jb short loc_1F5C2
mov ebp, 4
mov rcx, r14
loc_1F585:
cmp rcx, 63h ; 'c'
jbe short loc_1F5BB
cmp rcx, 3E7h
jbe short loc_1F5C0
cmp rcx, 2710h
jb short loc_1F5C2
mov rax, rcx
mul r13
shr rdx, 0Bh
add ebp, 4
cmp rcx, offset loc_1869F
mov rcx, rdx
ja short loc_1F585
add ebp, 0FFFFFFFDh
jmp short loc_1F5C2
loc_1F5BB:
add ebp, 0FFFFFFFEh
jmp short loc_1F5C2
loc_1F5C0:
dec ebp
loc_1F5C2:
mov esi, ebp
lea r12, [rsp+78h+var_40]
mov [r12-10h], r12
lea rdi, [rsp+78h+var_50]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
lea r15, [rsp+78h+var_50]
mov rdi, [r15]
mov esi, [r15+8]
mov rdx, r14
call __ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
lea rsi, aAtLine; " at line "
lea rcx, aColumn; ", column "
lea rdx, [rsp+78h+var_70]
mov rdi, rbx
mov r8, r15
call __ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA10_KcS8_SB_S8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(char const(&)[10],std::string,char const(&)[10],std::string &&)
mov rdi, [rsp+78h+var_50]; void *
cmp rdi, r12
jz short loc_1F623
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F623:
mov rdi, [rsp+78h+var_70]; void *
lea rax, [rsp+78h+var_60]
cmp rdi, rax
jz short loc_1F63F
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F63F:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_1F670
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1F670
mov rbx, rax
loc_1F670:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_1F68C
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1F68C:
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](long long a1, long long a2)
{
unsigned long long v3; // r15
unsigned int v4; // ebp
unsigned int v5; // esi
unsigned long long v6; // rcx
bool v7; // cc
unsigned long long v8; // r14
unsigned long long v9; // rcx
void *v11; // [rsp+8h] [rbp-70h] BYREF
unsigned int v12; // [rsp+10h] [rbp-68h]
_QWORD v13[2]; // [rsp+18h] [rbp-60h] BYREF
void *v14; // [rsp+28h] [rbp-50h] BYREF
unsigned int v15; // [rsp+30h] [rbp-48h]
_QWORD v16[8]; // [rsp+38h] [rbp-40h] BYREF
v3 = *(_QWORD *)(a2 + 16) + 1LL;
v4 = 1;
v5 = 1;
if ( v3 >= 0xA )
{
v5 = 4;
v6 = v3;
while ( 1 )
{
if ( v6 <= 0x63 )
{
v5 -= 2;
goto LABEL_10;
}
if ( v6 <= 0x3E7 )
break;
if ( v6 < 0x2710 )
goto LABEL_10;
v5 += 4;
v7 = v6 <= (unsigned long long)&loc_1869F;
v6 /= 0x2710uLL;
if ( v7 )
{
v5 -= 3;
goto LABEL_10;
}
}
--v5;
}
LABEL_10:
v11 = v13;
std::string::_M_construct(&v11, v5, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v11, v12, v3);
v8 = *(_QWORD *)(a2 + 8);
if ( v8 >= 0xA )
{
v4 = 4;
v9 = v8;
while ( 1 )
{
if ( v9 <= 0x63 )
{
v4 -= 2;
goto LABEL_19;
}
if ( v9 <= 0x3E7 )
break;
if ( v9 < 0x2710 )
goto LABEL_19;
v4 += 4;
v7 = v9 <= (unsigned long long)&loc_1869F;
v9 /= 0x2710uLL;
if ( v7 )
{
v4 -= 3;
goto LABEL_19;
}
}
--v4;
}
LABEL_19:
v14 = v16;
std::string::_M_construct(&v14, v4, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v14, v15, v8);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(
a1,
" at line ",
&v11,
", column ",
&v14);
if ( v14 != v16 )
operator delete(v14, v16[0] + 1LL);
if ( v11 != v13 )
operator delete(v11, v13[0] + 1LL);
return a1;
}
|
position_string[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV R15,qword ptr [RSI + 0x10]
INC R15
MOV EBP,0x1
MOV R13,0x346dc5d63886594b
MOV ESI,0x1
CMP R15,0xa
JC 0x0011f548
MOV ESI,0x4
MOV RCX,R15
LAB_0011f50b:
CMP RCX,0x63
JBE 0x0011f541
CMP RCX,0x3e7
JBE 0x0011f546
CMP RCX,0x2710
JC 0x0011f548
MOV RAX,RCX
MUL R13
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x0011f50b
ADD ESI,-0x3
JMP 0x0011f548
LAB_0011f541:
ADD ESI,-0x2
JMP 0x0011f548
LAB_0011f546:
DEC ESI
LAB_0011f548:
MOV ESI,ESI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA R12,[RSP + 0x8]
MOV RDI,R12
XOR EDX,EDX
CALL 0x00111b50
MOV RDI,qword ptr [R12]
MOV ESI,dword ptr [R12 + 0x8]
MOV RDX,R15
CALL 0x001118e0
MOV R14,qword ptr [R14 + 0x8]
CMP R14,0xa
JC 0x0011f5c2
MOV EBP,0x4
MOV RCX,R14
LAB_0011f585:
CMP RCX,0x63
JBE 0x0011f5bb
CMP RCX,0x3e7
JBE 0x0011f5c0
CMP RCX,0x2710
JC 0x0011f5c2
MOV RAX,RCX
MUL R13
SHR RDX,0xb
ADD EBP,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x0011f585
ADD EBP,-0x3
JMP 0x0011f5c2
LAB_0011f5bb:
ADD EBP,-0x2
JMP 0x0011f5c2
LAB_0011f5c0:
DEC EBP
LAB_0011f5c2:
MOV ESI,EBP
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LAB_0011f5ce:
LEA RDI,[RSP + 0x28]
XOR EDX,EDX
CALL 0x00111b50
LEA R15,[RSP + 0x28]
MOV RDI,qword ptr [R15]
MOV ESI,dword ptr [R15 + 0x8]
MOV RDX,R14
CALL 0x001118e0
LAB_0011f5ee:
LEA RSI,[0x124b4b]
LEA RCX,[0x124b55]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV R8,R15
CALL 0x00111530
LAB_0011f60c:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x0011f623
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001119a0
LAB_0011f623:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0011f63f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001119a0
LAB_0011f63f:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](nlohmann::json_abi_v3_11_3::detail::position_t
const&) */
parse_error * __thiscall
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string_abi_cxx11_
(parse_error *this,position_t *param_1)
{
bool bVar1;
char cVar2;
ulong uVar3;
char cVar4;
char cVar5;
ulong uVar6;
long *local_70;
uint local_68;
long local_60 [2];
long *local_50;
uint local_48;
long local_40 [2];
uVar6 = *(long *)(param_1 + 0x10) + 1;
cVar4 = '\x01';
cVar5 = '\x01';
if (9 < uVar6) {
uVar3 = uVar6;
cVar2 = '\x04';
do {
cVar5 = cVar2;
if (uVar3 < 100) {
cVar5 = cVar5 + -2;
goto LAB_0011f548;
}
if (uVar3 < 1000) {
cVar5 = cVar5 + -1;
goto LAB_0011f548;
}
if (uVar3 < 10000) goto LAB_0011f548;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
cVar2 = cVar5 + '\x04';
} while (bVar1);
cVar5 = cVar5 + '\x01';
}
LAB_0011f548:
local_70 = local_60;
std::__cxx11::string::_M_construct((ulong)&local_70,cVar5);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_70,local_68,uVar6);
uVar6 = *(ulong *)(param_1 + 8);
if (9 < uVar6) {
uVar3 = uVar6;
cVar5 = '\x04';
do {
cVar4 = cVar5;
if (uVar3 < 100) {
cVar4 = cVar4 + -2;
goto LAB_0011f5c2;
}
if (uVar3 < 1000) {
cVar4 = cVar4 + -1;
goto LAB_0011f5c2;
}
if (uVar3 < 10000) goto LAB_0011f5c2;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
cVar5 = cVar4 + '\x04';
} while (bVar1);
cVar4 = cVar4 + '\x01';
}
LAB_0011f5c2:
/* try { // try from 0011f5ce to 0011f5d9 has its CatchHandler @ 0011f66d */
local_50 = local_40;
std::__cxx11::string::_M_construct((ulong)&local_50,cVar4);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_50,local_48,uVar6);
/* try { // try from 0011f5ee to 0011f60b has its CatchHandler @ 0011f651 */
concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>
((detail *)this," at line ",(string *)&local_70,", column ",(string *)&local_50);
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
return this;
}
|
|
63,196 |
PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::sanitize(PFS_mutex*)
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
value_type *sanitize(value_type *unsafe)
{
value_type *safe= NULL;
for (int i=0; i < PFS_PARTITION_COUNT; i++)
{
safe= m_partitions[i]->sanitize(unsafe);
if (safe != NULL)
{
return safe;
}
}
return safe;
}
|
O3
|
c
|
PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::sanitize(PFS_mutex*):
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movb $0x1, %cl
xorl %edx, %edx
movq (%rdi,%rdx,8), %rdx
xorl %esi, %esi
movq 0xa8(%rdx,%rsi,8), %r9
testq %r9, %r9
je 0x39741
movq 0x48(%r9), %r8
cmpq %rax, %r8
ja 0x39741
movq 0x50(%r9), %r9
shlq $0x7, %r9
addq %r8, %r9
cmpq %rax, %r9
jbe 0x39741
movl %eax, %r9d
subl %r8d, %r9d
testb $0x7f, %r9b
je 0x3975e
incq %rsi
cmpq $0x400, %rsi # imm = 0x400
jne 0x3970f
movl $0x1, %edx
testb $0x1, %cl
movl $0x0, %ecx
jne 0x39709
jmp 0x39776
testq %rax, %rax
sete %sil
movl $0x1, %edx
testb %cl, %sil
movl $0x0, %ecx
jne 0x39709
jmp 0x39778
xorl %eax, %eax
popq %rbp
retq
|
_ZN41PFS_partitioned_buffer_scalable_containerI29PFS_buffer_scalable_containerI9PFS_mutexLi1024ELi1024E24PFS_buffer_default_arrayIS1_E28PFS_buffer_default_allocatorIS1_EELi2EE8sanitizeEPS1_:
push rbp
mov rbp, rsp
mov rax, rsi
mov cl, 1
xor edx, edx
loc_39709:
mov rdx, [rdi+rdx*8]
xor esi, esi
loc_3970F:
mov r9, [rdx+rsi*8+0A8h]
test r9, r9
jz short loc_39741
mov r8, [r9+48h]
cmp r8, rax
ja short loc_39741
mov r9, [r9+50h]
shl r9, 7
add r9, r8
cmp r9, rax
jbe short loc_39741
mov r9d, eax
sub r9d, r8d
test r9b, 7Fh
jz short loc_3975E
loc_39741:
inc rsi
cmp rsi, 400h
jnz short loc_3970F
mov edx, 1
test cl, 1
mov ecx, 0
jnz short loc_39709
jmp short loc_39776
loc_3975E:
test rax, rax
setz sil
mov edx, 1
test sil, cl
mov ecx, 0
jnz short loc_39709
jmp short loc_39778
loc_39776:
xor eax, eax
loc_39778:
pop rbp
retn
|
unsigned long long PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>::sanitize(
long long a1,
unsigned long long a2)
{
unsigned long long result; // rax
char v3; // cl
long long v4; // rdx
long long v5; // rdx
long long v6; // rsi
long long v7; // r9
unsigned long long v8; // r8
bool v9; // zf
result = a2;
v3 = 1;
v4 = 0LL;
LABEL_2:
while ( 2 )
{
v5 = *(_QWORD *)(a1 + 8 * v4);
v6 = 0LL;
while ( 1 )
{
v7 = *(_QWORD *)(v5 + 8 * v6 + 168);
if ( v7 )
{
v8 = *(_QWORD *)(v7 + 72);
if ( v8 <= result && v8 + (*(_QWORD *)(v7 + 80) << 7) > result && (((_BYTE)result - (_BYTE)v8) & 0x7F) == 0 )
break;
}
if ( ++v6 == 1024 )
{
v4 = 1LL;
v9 = (v3 & 1) == 0;
v3 = 0;
if ( !v9 )
goto LABEL_2;
return 0LL;
}
}
v4 = 1LL;
v9 = ((unsigned __int8)v3 & (result == 0)) == 0;
v3 = 0;
if ( !v9 )
continue;
return result;
}
}
|
sanitize:
PUSH RBP
MOV RBP,RSP
MOV RAX,RSI
MOV CL,0x1
XOR EDX,EDX
LAB_00139709:
MOV RDX,qword ptr [RDI + RDX*0x8]
XOR ESI,ESI
LAB_0013970f:
MOV R9,qword ptr [RDX + RSI*0x8 + 0xa8]
TEST R9,R9
JZ 0x00139741
MOV R8,qword ptr [R9 + 0x48]
CMP R8,RAX
JA 0x00139741
MOV R9,qword ptr [R9 + 0x50]
SHL R9,0x7
ADD R9,R8
CMP R9,RAX
JBE 0x00139741
MOV R9D,EAX
SUB R9D,R8D
TEST R9B,0x7f
JZ 0x0013975e
LAB_00139741:
INC RSI
CMP RSI,0x400
JNZ 0x0013970f
MOV EDX,0x1
TEST CL,0x1
MOV ECX,0x0
JNZ 0x00139709
JMP 0x00139776
LAB_0013975e:
TEST RAX,RAX
SETZ SIL
MOV EDX,0x1
TEST SIL,CL
MOV ECX,0x0
JNZ 0x00139709
JMP 0x00139778
LAB_00139776:
XOR EAX,EAX
LAB_00139778:
POP RBP
RET
|
/* PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024,
PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex> >,
2>::sanitize(PFS_mutex*) */
PFS_mutex * __thiscall
PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
::sanitize(PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
*this,PFS_mutex *param_1)
{
long lVar1;
PFS_mutex *pPVar2;
bool bVar3;
bool bVar4;
long lVar5;
long lVar6;
lVar5 = 0;
bVar4 = true;
LAB_00139709:
do {
lVar6 = 0;
do {
lVar1 = *(long *)(*(long *)(this + lVar5 * 8) + 0xa8 + lVar6 * 8);
if ((((lVar1 != 0) && (pPVar2 = *(PFS_mutex **)(lVar1 + 0x48), pPVar2 <= param_1)) &&
(param_1 < pPVar2 + *(long *)(lVar1 + 0x50) * 0x80)) &&
(((int)param_1 - (int)pPVar2 & 0x7fU) == 0)) {
lVar5 = 1;
bVar3 = (bool)(param_1 == (PFS_mutex *)0x0 & bVar4);
bVar4 = false;
if (!bVar3) {
return param_1;
}
goto LAB_00139709;
}
lVar6 = lVar6 + 1;
} while (lVar6 != 0x400);
lVar5 = 1;
bVar3 = !bVar4;
bVar4 = false;
if (bVar3) {
return (PFS_mutex *)0x0;
}
} while( true );
}
|
|
63,197 |
compact_properties
|
bluesky950520[P]quickjs/quickjs.c
|
static int compact_properties(JSContext *ctx, JSObject *p)
{
JSShape *sh, *old_sh;
void *sh_alloc;
intptr_t h;
uint32_t new_hash_size, i, j, new_hash_mask, new_size;
JSShapeProperty *old_pr, *pr;
JSProperty *prop, *new_prop;
sh = p->shape;
assert(!sh->is_hashed);
new_size = max_int(JS_PROP_INITIAL_SIZE,
sh->prop_count - sh->deleted_prop_count);
assert(new_size <= sh->prop_size);
new_hash_size = sh->prop_hash_mask + 1;
while ((new_hash_size / 2) >= new_size)
new_hash_size = new_hash_size / 2;
new_hash_mask = new_hash_size - 1;
/* resize the hash table and the properties */
old_sh = sh;
sh_alloc = js_malloc(ctx, get_shape_size(new_hash_size, new_size));
if (!sh_alloc)
return -1;
sh = get_shape_from_alloc(sh_alloc, new_hash_size);
list_del(&old_sh->header.link);
memcpy(sh, old_sh, sizeof(JSShape));
list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
memset(prop_hash_end(sh) - new_hash_size, 0,
sizeof(prop_hash_end(sh)[0]) * new_hash_size);
j = 0;
old_pr = old_sh->prop;
pr = sh->prop;
prop = p->prop;
for(i = 0; i < sh->prop_count; i++) {
if (old_pr->atom != JS_ATOM_NULL) {
pr->atom = old_pr->atom;
pr->flags = old_pr->flags;
h = ((uintptr_t)old_pr->atom & new_hash_mask);
pr->hash_next = prop_hash_end(sh)[-h - 1];
prop_hash_end(sh)[-h - 1] = j + 1;
prop[j] = prop[i];
j++;
pr++;
}
old_pr++;
}
assert(j == (sh->prop_count - sh->deleted_prop_count));
sh->prop_hash_mask = new_hash_mask;
sh->prop_size = new_size;
sh->deleted_prop_count = 0;
sh->prop_count = j;
p->shape = sh;
js_free(ctx, get_alloc_from_shape(old_sh));
/* reduce the size of the object properties */
new_prop = js_realloc(ctx, p->prop, sizeof(new_prop[0]) * new_size);
if (new_prop)
p->prop = new_prop;
return 0;
}
|
O0
|
c
|
compact_properties:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movl 0x28(%rax), %esi
movq 0x68(%rsp), %rax
subl 0x2c(%rax), %esi
movl $0x2, %edi
callq 0x5c050
movl %eax, 0x3c(%rsp)
movq 0x68(%rsp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
shrl %eax
cmpl 0x3c(%rsp), %eax
jb 0x606e4
movl 0x4c(%rsp), %eax
shrl %eax
movl %eax, 0x4c(%rsp)
jmp 0x606cc
movl 0x4c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %edi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x2ad80
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x209f0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x6073e
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x609be
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x5c970
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
addq $0x8, %rdi
callq 0x22970
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl $0x40, %edx
callq 0xe5a0
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rsi
addq $0x98, %rsi
callq 0x22790
movq 0x68(%rsp), %rdi
callq 0x5c5f0
movq %rax, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x2, %rax
addq %rax, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0xe340
movl $0x0, 0x44(%rsp)
movq 0x60(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x68(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x6091e
movq 0x30(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x60900
movq 0x30(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x30(%rsp), %rax
movl (%rax), %edx
shrl $0x1a, %edx
movq 0x28(%rsp), %rax
movl (%rax), %ecx
andl $0x3f, %edx
shll $0x1a, %edx
andl $0x3ffffff, %ecx # imm = 0x3FFFFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl 0x40(%rsp), %ecx
andq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0x5c5f0
xorl %ecx, %ecx
subq 0x50(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %edx
movq 0x28(%rsp), %rax
movl (%rax), %ecx
andl $0x3ffffff, %edx # imm = 0x3FFFFFF
andl $0xfc000000, %ecx # imm = 0xFC000000
orl %edx, %ecx
movl %ecx, (%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x68(%rsp), %rdi
callq 0x5c5f0
movl 0xc(%rsp), %edx
xorl %ecx, %ecx
subq 0x50(%rsp), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movl 0x44(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
movl 0x48(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x607fd
movl 0x40(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x3c(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x68(%rsp), %rax
movl $0x0, 0x2c(%rax)
movl 0x44(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
callq 0x5c5a0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x20af0
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x20(%rax), %rsi
movl 0x3c(%rsp), %eax
movl %eax, %edx
shlq $0x4, %rdx
callq 0x20b20
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x609b3
movq 0x18(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
|
compact_properties:
sub rsp, 88h
mov [rsp+88h+var_10], rdi
mov [rsp+88h+var_18], rsi
mov rax, [rsp+88h+var_18]
mov rax, [rax+18h]
mov [rsp+88h+var_20], rax
mov rax, [rsp+88h+var_20]
mov esi, [rax+28h]
mov rax, [rsp+88h+var_20]
sub esi, [rax+2Ch]
mov edi, 2
call max_int_0
mov [rsp+88h+var_4C], eax
mov rax, [rsp+88h+var_20]
mov eax, [rax+20h]
add eax, 1
mov [rsp+88h+var_3C], eax
loc_606CC:
mov eax, [rsp+88h+var_3C]
shr eax, 1
cmp eax, [rsp+88h+var_4C]
jb short loc_606E4
mov eax, [rsp+88h+var_3C]
shr eax, 1
mov [rsp+88h+var_3C], eax
jmp short loc_606CC
loc_606E4:
mov eax, [rsp+88h+var_3C]
sub eax, 1
mov [rsp+88h+var_48], eax
mov rax, [rsp+88h+var_20]
mov [rsp+88h+var_28], rax
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_78], rax
mov eax, [rsp+88h+var_3C]
mov edi, eax
mov eax, [rsp+88h+var_4C]
mov esi, eax
call get_shape_size
mov rdi, [rsp+88h+var_78]
mov rsi, rax
call js_malloc
mov [rsp+88h+var_30], rax
cmp [rsp+88h+var_30], 0
jnz short loc_6073E
mov [rsp+88h+var_4], 0FFFFFFFFh
jmp loc_609BE
loc_6073E:
mov rdi, [rsp+88h+var_30]
mov eax, [rsp+88h+var_3C]
mov esi, eax
call get_shape_from_alloc
mov [rsp+88h+var_20], rax
mov rdi, [rsp+88h+var_28]
add rdi, 8
call list_del_0
mov rdi, [rsp+88h+var_20]
mov rsi, [rsp+88h+var_28]
mov edx, 40h ; '@'
call _memcpy
mov rdi, [rsp+88h+var_20]
add rdi, 8
mov rax, [rsp+88h+var_10]
mov rsi, [rax+18h]
add rsi, 98h
call list_add_tail_0
mov rdi, [rsp+88h+var_20]
call prop_hash_end
mov rdi, rax
mov eax, [rsp+88h+var_3C]
mov ecx, eax
xor eax, eax
sub rax, rcx
shl rax, 2
add rdi, rax
mov eax, [rsp+88h+var_3C]
mov edx, eax
shl rdx, 2
xor esi, esi
call _memset
mov [rsp+88h+var_44], 0
mov rax, [rsp+88h+var_28]
add rax, 40h ; '@'
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_20]
add rax, 40h ; '@'
mov [rsp+88h+var_60], rax
mov rax, [rsp+88h+var_18]
mov rax, [rax+20h]
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_40], 0
loc_607FD:
mov eax, [rsp+88h+var_40]
mov rcx, [rsp+88h+var_20]
cmp eax, [rcx+28h]
jnb loc_6091E
mov rax, [rsp+88h+var_58]
cmp dword ptr [rax+4], 0
jz loc_60900
mov rax, [rsp+88h+var_58]
mov ecx, [rax+4]
mov rax, [rsp+88h+var_60]
mov [rax+4], ecx
mov rax, [rsp+88h+var_58]
mov edx, [rax]
shr edx, 1Ah
mov rax, [rsp+88h+var_60]
mov ecx, [rax]
and edx, 3Fh
shl edx, 1Ah
and ecx, 3FFFFFFh
or ecx, edx
mov [rax], ecx
mov rax, [rsp+88h+var_58]
mov eax, [rax+4]
mov ecx, [rsp+88h+var_48]
and rax, rcx
mov [rsp+88h+var_38], rax
mov rdi, [rsp+88h+var_20]
call prop_hash_end
xor ecx, ecx
sub rcx, [rsp+88h+var_38]
sub rcx, 1
mov edx, [rax+rcx*4]
mov rax, [rsp+88h+var_60]
mov ecx, [rax]
and edx, 3FFFFFFh
and ecx, 0FC000000h
or ecx, edx
mov [rax], ecx
mov eax, [rsp+88h+var_44]
add eax, 1
mov [rsp+88h+var_7C], eax
mov rdi, [rsp+88h+var_20]
call prop_hash_end
mov edx, [rsp+88h+var_7C]
xor ecx, ecx
sub rcx, [rsp+88h+var_38]
sub rcx, 1
mov [rax+rcx*4], edx
mov rax, [rsp+88h+var_68]
mov ecx, [rsp+88h+var_44]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+88h+var_68]
mov edx, [rsp+88h+var_40]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov eax, [rsp+88h+var_44]
add eax, 1
mov [rsp+88h+var_44], eax
mov rax, [rsp+88h+var_60]
add rax, 8
mov [rsp+88h+var_60], rax
loc_60900:
mov rax, [rsp+88h+var_58]
add rax, 8
mov [rsp+88h+var_58], rax
mov eax, [rsp+88h+var_40]
add eax, 1
mov [rsp+88h+var_40], eax
jmp loc_607FD
loc_6091E:
mov ecx, [rsp+88h+var_48]
mov rax, [rsp+88h+var_20]
mov [rax+20h], ecx
mov ecx, [rsp+88h+var_4C]
mov rax, [rsp+88h+var_20]
mov [rax+24h], ecx
mov rax, [rsp+88h+var_20]
mov dword ptr [rax+2Ch], 0
mov ecx, [rsp+88h+var_44]
mov rax, [rsp+88h+var_20]
mov [rax+28h], ecx
mov rcx, [rsp+88h+var_20]
mov rax, [rsp+88h+var_18]
mov [rax+18h], rcx
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_88], rax
mov rdi, [rsp+88h+var_28]
call get_alloc_from_shape
mov rdi, [rsp+88h+var_88]
mov rsi, rax
call js_free
mov rdi, [rsp+88h+var_10]
mov rax, [rsp+88h+var_18]
mov rsi, [rax+20h]
mov eax, [rsp+88h+var_4C]
mov edx, eax
shl rdx, 4
call js_realloc
mov [rsp+88h+var_70], rax
cmp [rsp+88h+var_70], 0
jz short loc_609B3
mov rcx, [rsp+88h+var_70]
mov rax, [rsp+88h+var_18]
mov [rax+20h], rcx
loc_609B3:
mov [rsp+88h+var_4], 0
loc_609BE:
mov eax, [rsp+88h+var_4]
add rsp, 88h
retn
|
long long compact_properties(long long a1, long long a2)
{
long long shape_size; // rax
long long v3; // rax
_QWORD *v4; // rax
_QWORD *v5; // rcx
long long alloc_from_shape; // rax
long long v8; // [rsp+18h] [rbp-70h]
long long v9; // [rsp+20h] [rbp-68h]
_DWORD *v10; // [rsp+28h] [rbp-60h]
_DWORD *v11; // [rsp+30h] [rbp-58h]
unsigned int v12; // [rsp+3Ch] [rbp-4Ch]
unsigned int v13; // [rsp+40h] [rbp-48h]
unsigned int v14; // [rsp+44h] [rbp-44h]
unsigned int j; // [rsp+48h] [rbp-40h]
unsigned int i; // [rsp+4Ch] [rbp-3Ch]
long long v17; // [rsp+50h] [rbp-38h]
long long v18; // [rsp+58h] [rbp-30h]
long long v19; // [rsp+60h] [rbp-28h]
_DWORD *v20; // [rsp+68h] [rbp-20h]
_DWORD *shape_from_alloc; // [rsp+68h] [rbp-20h]
v20 = *(_DWORD **)(a2 + 24);
v12 = max_int_0(2u, v20[10] - v20[11]);
for ( i = v20[8] + 1; i >> 1 >= v12; i >>= 1 )
;
v13 = i - 1;
v19 = (long long)v20;
shape_size = get_shape_size(i, v12);
v18 = js_malloc(a1, shape_size);
if ( v18 )
{
shape_from_alloc = (_DWORD *)get_shape_from_alloc(v18, i);
list_del_0((_QWORD *)(v19 + 8));
memcpy(shape_from_alloc, v19, 64LL);
list_add_tail_0((long long)(shape_from_alloc + 2), (_QWORD *)(*(_QWORD *)(a1 + 24) + 152LL));
v3 = prop_hash_end((long long)shape_from_alloc);
memset(-4LL * i + v3, 0LL, 4LL * i);
v14 = 0;
v11 = (_DWORD *)(v19 + 64);
v10 = shape_from_alloc + 16;
v9 = *(_QWORD *)(a2 + 32);
for ( j = 0; j < shape_from_alloc[10]; ++j )
{
if ( v11[1] )
{
v10[1] = v11[1];
*v10 = ((unsigned __int8)HIBYTE(*v11) >> 2 << 26) | *v10 & 0x3FFFFFF;
v17 = v13 & v11[1];
*v10 = *(_DWORD *)(prop_hash_end((long long)shape_from_alloc) + 4 * (-v17 - 1)) & 0x3FFFFFF | *v10 & 0xFC000000;
*(_DWORD *)(prop_hash_end((long long)shape_from_alloc) + 4 * (-v17 - 1)) = v14 + 1;
v4 = (_QWORD *)(16LL * v14 + v9);
v5 = (_QWORD *)(16LL * j + v9);
*v4 = *v5;
v4[1] = v5[1];
++v14;
v10 += 2;
}
v11 += 2;
}
shape_from_alloc[8] = v13;
shape_from_alloc[9] = v12;
shape_from_alloc[11] = 0;
shape_from_alloc[10] = v14;
*(_QWORD *)(a2 + 24) = shape_from_alloc;
alloc_from_shape = get_alloc_from_shape(v19);
js_free(a1, alloc_from_shape);
v8 = js_realloc(a1, *(_QWORD *)(a2 + 32), 16LL * v12);
if ( v8 )
*(_QWORD *)(a2 + 32) = v8;
return 0;
}
else
{
return (unsigned int)-1;
}
}
|
compact_properties:
SUB RSP,0x88
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RSI
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RAX + 0x28]
MOV RAX,qword ptr [RSP + 0x68]
SUB ESI,dword ptr [RAX + 0x2c]
MOV EDI,0x2
CALL 0x0015c050
MOV dword ptr [RSP + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x68]
MOV EAX,dword ptr [RAX + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4c],EAX
LAB_001606cc:
MOV EAX,dword ptr [RSP + 0x4c]
SHR EAX,0x1
CMP EAX,dword ptr [RSP + 0x3c]
JC 0x001606e4
MOV EAX,dword ptr [RSP + 0x4c]
SHR EAX,0x1
MOV dword ptr [RSP + 0x4c],EAX
JMP 0x001606cc
LAB_001606e4:
MOV EAX,dword ptr [RSP + 0x4c]
SUB EAX,0x1
MOV dword ptr [RSP + 0x40],EAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV EDI,EAX
MOV EAX,dword ptr [RSP + 0x3c]
MOV ESI,EAX
CALL 0x0012ad80
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x001209f0
MOV qword ptr [RSP + 0x58],RAX
CMP qword ptr [RSP + 0x58],0x0
JNZ 0x0016073e
MOV dword ptr [RSP + 0x84],0xffffffff
JMP 0x001609be
LAB_0016073e:
MOV RDI,qword ptr [RSP + 0x58]
MOV EAX,dword ptr [RSP + 0x4c]
MOV ESI,EAX
CALL 0x0015c970
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
ADD RDI,0x8
CALL 0x00122970
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x60]
MOV EDX,0x40
CALL 0x0010e5a0
MOV RDI,qword ptr [RSP + 0x68]
ADD RDI,0x8
MOV RAX,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x98
CALL 0x00122790
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0015c5f0
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
SHL RAX,0x2
ADD RDI,RAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV EDX,EAX
SHL RDX,0x2
XOR ESI,ESI
CALL 0x0010e340
MOV dword ptr [RSP + 0x44],0x0
MOV RAX,qword ptr [RSP + 0x60]
ADD RAX,0x40
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,0x40
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x48],0x0
LAB_001607fd:
MOV EAX,dword ptr [RSP + 0x48]
MOV RCX,qword ptr [RSP + 0x68]
CMP EAX,dword ptr [RCX + 0x28]
JNC 0x0016091e
MOV RAX,qword ptr [RSP + 0x30]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x00160900
MOV RAX,qword ptr [RSP + 0x30]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RSP + 0x30]
MOV EDX,dword ptr [RAX]
SHR EDX,0x1a
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX]
AND EDX,0x3f
SHL EDX,0x1a
AND ECX,0x3ffffff
OR ECX,EDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RAX + 0x4]
MOV ECX,dword ptr [RSP + 0x40]
AND RAX,RCX
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0015c5f0
XOR ECX,ECX
SUB RCX,qword ptr [RSP + 0x50]
SUB RCX,0x1
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX]
AND EDX,0x3ffffff
AND ECX,0xfc000000
OR ECX,EDX
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0015c5f0
MOV EDX,dword ptr [RSP + 0xc]
XOR ECX,ECX
SUB RCX,qword ptr [RSP + 0x50]
SUB RCX,0x1
MOV dword ptr [RAX + RCX*0x4],EDX
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x44]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0x48]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,0x1
MOV dword ptr [RSP + 0x44],EAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x8
MOV qword ptr [RSP + 0x28],RAX
LAB_00160900:
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,0x8
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x48]
ADD EAX,0x1
MOV dword ptr [RSP + 0x48],EAX
JMP 0x001607fd
LAB_0016091e:
MOV ECX,dword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x20],ECX
MOV ECX,dword ptr [RSP + 0x3c]
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x2c],0x0
MOV ECX,dword ptr [RSP + 0x44]
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x28],ECX
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0015c5a0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x00120af0
MOV RDI,qword ptr [RSP + 0x78]
MOV RAX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RAX + 0x20]
MOV EAX,dword ptr [RSP + 0x3c]
MOV EDX,EAX
SHL RDX,0x4
CALL 0x00120b20
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JZ 0x001609b3
MOV RCX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RAX + 0x20],RCX
LAB_001609b3:
MOV dword ptr [RSP + 0x84],0x0
LAB_001609be:
MOV EAX,dword ptr [RSP + 0x84]
ADD RSP,0x88
RET
|
int4 compact_properties(int8 param_1,long param_2)
{
void *__src;
uint uVar1;
int8 uVar2;
long lVar3;
void *__dest;
ulong uVar4;
long lVar5;
int8 *puVar6;
int8 *puVar7;
uint *local_60;
uint *local_58;
uint local_44;
uint local_40;
uint local_3c;
int4 local_4;
__src = *(void **)(param_2 + 0x18);
uVar1 = max_int(2,*(int *)((long)__src + 0x28) - *(int *)((long)__src + 0x2c));
for (local_3c = *(int *)((long)__src + 0x20) + 1; uVar1 <= local_3c >> 1; local_3c = local_3c >> 1
) {
}
uVar2 = get_shape_size(local_3c,uVar1);
lVar3 = js_malloc(param_1,uVar2);
if (lVar3 == 0) {
local_4 = 0xffffffff;
}
else {
__dest = (void *)get_shape_from_alloc(lVar3,local_3c);
list_del((long)__src + 8);
memcpy(__dest,__src,0x40);
list_add_tail((long)__dest + 8);
lVar3 = prop_hash_end(__dest);
memset((void *)(lVar3 + (ulong)local_3c * -4),0,(ulong)local_3c << 2);
local_44 = 0;
local_58 = (uint *)((long)__src + 0x40);
local_60 = (uint *)((long)__dest + 0x40);
lVar3 = *(long *)(param_2 + 0x20);
for (local_40 = 0; local_40 < *(uint *)((long)__dest + 0x28); local_40 = local_40 + 1) {
if (local_58[1] != 0) {
local_60[1] = local_58[1];
*local_60 = *local_60 & 0x3ffffff | *local_58 & 0xfc000000;
uVar4 = (ulong)(local_58[1] & local_3c - 1);
lVar5 = prop_hash_end(__dest);
*local_60 = *local_60 & 0xfc000000 | *(uint *)(lVar5 + (-1 - uVar4) * 4) & 0x3ffffff;
lVar5 = prop_hash_end(__dest);
*(uint *)(lVar5 + (-1 - uVar4) * 4) = local_44 + 1;
puVar6 = (int8 *)(lVar3 + (ulong)local_44 * 0x10);
puVar7 = (int8 *)(lVar3 + (ulong)local_40 * 0x10);
*puVar6 = *puVar7;
puVar6[1] = puVar7[1];
local_44 = local_44 + 1;
local_60 = local_60 + 2;
}
local_58 = local_58 + 2;
}
*(uint *)((long)__dest + 0x20) = local_3c - 1;
*(uint *)((long)__dest + 0x24) = uVar1;
*(int4 *)((long)__dest + 0x2c) = 0;
*(uint *)((long)__dest + 0x28) = local_44;
*(void **)(param_2 + 0x18) = __dest;
uVar2 = get_alloc_from_shape(__src);
js_free(param_1,uVar2);
lVar3 = js_realloc(param_1,*(int8 *)(param_2 + 0x20),(ulong)uVar1 << 4);
if (lVar3 != 0) {
*(long *)(param_2 + 0x20) = lVar3;
}
local_4 = 0;
}
return local_4;
}
|
|
63,198 |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int)
|
monkey531[P]llama/common/json.hpp
|
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
JSON_ASSERT(min_exp < 0);
JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
// v = buf * 10^(n-k)
// k is the length of the buffer (number of decimal digits)
// n is the position of the decimal point relative to the start of the buffer.
if (k <= n && n <= max_exp)
{
// digits[000]
// len <= max_exp + 2
std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
// Make it look like a floating-point number (#362, #378)
buf[n + 0] = '.';
buf[n + 1] = '0';
return buf + (static_cast<size_t>(n) + 2);
}
if (0 < n && n <= max_exp)
{
// dig.its
// len <= max_digits10 + 1
JSON_ASSERT(k > n);
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
buf[n] = '.';
return buf + (static_cast<size_t>(k) + 1U);
}
if (min_exp < n && n <= 0)
{
// 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10
std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
buf[0] = '0';
buf[1] = '.';
std::memset(buf + 2, '0', static_cast<size_t>(-n));
return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
}
if (k == 1)
{
// dE+123
// len <= 1 + 5
buf += 1;
}
else
{
// d.igitsE+123
// len <= max_digits10 + 1 + 5
std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
buf[1] = '.';
buf += 1 + static_cast<size_t>(k);
}
*buf++ = 'e';
return append_exponent(buf, n - 1);
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jns 0x8aeb4
testl %r8d, %r8d
jle 0x8aed0
movq %rdi, %rbx
leal (%rdx,%rsi), %r14d
testl %edx, %edx
sets %al
cmpl %r8d, %r14d
setg %dil
orb %al, %dil
je 0x8ae03
cmpl %r8d, %r14d
setg %al
testl %r14d, %r14d
setle %dil
orb %al, %dil
je 0x8ae2c
testl %r14d, %r14d
setg %al
cmpl %ecx, %r14d
setle %cl
orb %al, %cl
jne 0x8ae70
negl %r14d
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movslq %esi, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x23f60
movw $0x2e30, (%rbx) # imm = 0x2E30
addq $0x2, %rbx
pushq $0x30
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x23560
addq %r12, %r15
jmp 0x8ae61
movslq %esi, %rax
leaq (%rbx,%rax), %rdi
movslq %r14d, %r14
movq %r14, %rdx
subq %rax, %rdx
pushq $0x30
popq %rsi
callq 0x23560
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movw $0x302e, -0x2(%r15) # imm = 0x302E
jmp 0x8ae61
testl %edx, %edx
jns 0x8aef1
movl %r14d, %ecx
leaq (%rbx,%rcx), %rax
leaq (%rbx,%rcx), %r14
incq %r14
movl %esi, %r15d
movq %r15, %rdx
subq %rcx, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x23f60
movb $0x2e, -0x1(%r14)
addq %rbx, %r15
incq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, %esi
je 0x8ae93
leaq 0x2(%rbx), %rdi
leaq 0x1(%rbx), %rax
movslq %esi, %r15
leaq -0x1(%r15), %rdx
movq %rax, %rsi
callq 0x23f60
movb $0x2e, 0x1(%rbx)
addq %r15, %rbx
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8b809
leaq 0x28ce1(%rip), %rdi # 0xb3b9c
leaq 0x22733(%rip), %rdx # 0xad5f5
leaq 0x2e614(%rip), %rcx # 0xb94dd
movl $0x45e3, %esi # imm = 0x45E3
jmp 0x8aeea
leaq 0x28cc5(%rip), %rdi # 0xb3b9c
leaq 0x22717(%rip), %rdx # 0xad5f5
leaq 0x2e604(%rip), %rcx # 0xb94e9
movl $0x45e4, %esi # imm = 0x45E4
xorl %eax, %eax
callq 0x23fe0
leaq 0x28ca4(%rip), %rdi # 0xb3b9c
leaq 0x226f6(%rip), %rdx # 0xad5f5
leaq 0x2e5ef(%rip), %rcx # 0xb94f5
movl $0x45fe, %esi # imm = 0x45FE
jmp 0x8aeea
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl13format_bufferEPciiii:
push r15
push r14
push r12
push rbx
push rax
test ecx, ecx
jns loc_8AEB4
test r8d, r8d
jle loc_8AED0
mov rbx, rdi
lea r14d, [rdx+rsi]
test edx, edx
sets al
cmp r14d, r8d
setnle dil
or dil, al
jz short loc_8AE03
cmp r14d, r8d
setnle al
test r14d, r14d
setle dil
or dil, al
jz short loc_8AE2C
test r14d, r14d
setnle al
cmp r14d, ecx
setle cl
or cl, al
jnz loc_8AE70
neg r14d
lea r15, [rbx+r14]
add r15, 2
movsxd r12, esi
mov rdi, r15
mov rsi, rbx
mov rdx, r12
call _memmove
mov word ptr [rbx], 2E30h
add rbx, 2
push 30h ; '0'
pop rsi
mov rdi, rbx
mov rdx, r14
call _memset
add r15, r12
jmp short loc_8AE61
loc_8AE03:
movsxd rax, esi
lea rdi, [rbx+rax]
movsxd r14, r14d
mov rdx, r14
sub rdx, rax
push 30h ; '0'
pop rsi
call _memset
lea r15, [rbx+r14]
add r15, 2
mov word ptr [r15-2], 302Eh
jmp short loc_8AE61
loc_8AE2C:
test edx, edx
jns loc_8AEF1
mov ecx, r14d
lea rax, [rbx+rcx]
lea r14, [rbx+rcx]
inc r14
mov r15d, esi
mov rdx, r15
sub rdx, rcx
mov rdi, r14
mov rsi, rax
call _memmove
mov byte ptr [r14-1], 2Eh ; '.'
add r15, rbx
inc r15
loc_8AE61:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_8AE70:
cmp esi, 1
jz short loc_8AE93
lea rdi, [rbx+2]
lea rax, [rbx+1]
movsxd r15, esi
lea rdx, [r15-1]
mov rsi, rax
call _memmove
mov byte ptr [rbx+1], 2Eh ; '.'
add rbx, r15
loc_8AE93:
mov byte ptr [rbx+1], 65h ; 'e'
add rbx, 2
dec r14d
mov rdi, rbx; this
mov esi, r14d; char *
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl15append_exponentEPci; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char *,int)
loc_8AEB4:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMinExp0; "min_exp < 0"
mov esi, 45E3h
jmp short loc_8AEEA
loc_8AED0:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMaxExp0; "max_exp > 0"
mov esi, 45E4h
loc_8AEEA:
xor eax, eax
call _ggml_abort
loc_8AEF1:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKN; "k > n"
mov esi, 45FEh
jmp short loc_8AEEA
|
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
char *a2,
int a3,
int a4,
int a5)
{
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v5; // rbx
int v6; // r14d
long long v7; // r14
char *v8; // r15
long long v9; // rcx
char *v10; // r14
if ( a4 >= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17891LL,
"GGML_ASSERT(%s) failed",
"min_exp < 0");
goto LABEL_16;
}
if ( a5 <= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17892LL,
"GGML_ASSERT(%s) failed",
"max_exp > 0");
goto LABEL_16;
}
v5 = this;
v6 = a3 + (_DWORD)a2;
if ( a3 >= 0 && a3 + (int)a2 <= a5 )
{
memset((char *)this + (int)a2, 48LL, v6 - (long long)(int)a2);
v8 = (char *)this + v6 + 2;
*(_WORD *)((char *)this + v6) = 12334;
return v8;
}
if ( v6 <= a5 && v6 > 0 )
{
if ( a3 < 0 )
{
v9 = (unsigned int)v6;
v10 = (char *)this + (unsigned int)v6 + 1;
memmove(v10, (char *)this + v9, (unsigned int)a2 - v9);
*(v10 - 1) = 46;
return (char *)this + (unsigned int)a2 + 1;
}
while ( 1 )
LABEL_16:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17918LL,
"GGML_ASSERT(%s) failed",
"k > n");
}
if ( v6 <= 0 && v6 > a4 )
{
v7 = (unsigned int)-v6;
memmove((char *)this + v7 + 2, this, (int)a2);
*(_WORD *)this = 11824;
memset((char *)this + 2, 48LL, v7);
return (char *)this + v7 + (int)a2 + 2;
}
if ( (_DWORD)a2 != 1 )
{
memmove((char *)this + 2, (char *)this + 1, (int)a2 - 1LL);
*((_BYTE *)this + 1) = 46;
v5 = (nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)((char *)this + (int)a2);
}
*((_BYTE *)v5 + 1) = 101;
return (char *)nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)((char *)v5 + 2),
(char *)(unsigned int)(v6 - 1),
a3);
}
|
format_buffer:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
TEST ECX,ECX
JNS 0x0018aeb4
TEST R8D,R8D
JLE 0x0018aed0
MOV RBX,RDI
LEA R14D,[RDX + RSI*0x1]
TEST EDX,EDX
SETS AL
CMP R14D,R8D
SETG DIL
OR DIL,AL
JZ 0x0018ae03
CMP R14D,R8D
SETG AL
TEST R14D,R14D
SETLE DIL
OR DIL,AL
JZ 0x0018ae2c
TEST R14D,R14D
SETG AL
CMP R14D,ECX
SETLE CL
OR CL,AL
JNZ 0x0018ae70
NEG R14D
LEA R15,[RBX + R14*0x1]
ADD R15,0x2
MOVSXD R12,ESI
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
CALL 0x00123f60
MOV word ptr [RBX],0x2e30
ADD RBX,0x2
PUSH 0x30
POP RSI
MOV RDI,RBX
MOV RDX,R14
CALL 0x00123560
ADD R15,R12
JMP 0x0018ae61
LAB_0018ae03:
MOVSXD RAX,ESI
LEA RDI,[RBX + RAX*0x1]
MOVSXD R14,R14D
MOV RDX,R14
SUB RDX,RAX
PUSH 0x30
POP RSI
CALL 0x00123560
LEA R15,[RBX + R14*0x1]
ADD R15,0x2
MOV word ptr [R15 + -0x2],0x302e
JMP 0x0018ae61
LAB_0018ae2c:
TEST EDX,EDX
JNS 0x0018aef1
MOV ECX,R14D
LEA RAX,[RBX + RCX*0x1]
LEA R14,[RBX + RCX*0x1]
INC R14
MOV R15D,ESI
MOV RDX,R15
SUB RDX,RCX
MOV RDI,R14
MOV RSI,RAX
CALL 0x00123f60
MOV byte ptr [R14 + -0x1],0x2e
ADD R15,RBX
INC R15
LAB_0018ae61:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0018ae70:
CMP ESI,0x1
JZ 0x0018ae93
LEA RDI,[RBX + 0x2]
LEA RAX,[RBX + 0x1]
MOVSXD R15,ESI
LEA RDX,[R15 + -0x1]
MOV RSI,RAX
CALL 0x00123f60
MOV byte ptr [RBX + 0x1],0x2e
ADD RBX,R15
LAB_0018ae93:
MOV byte ptr [RBX + 0x1],0x65
ADD RBX,0x2
DEC R14D
MOV RDI,RBX
MOV ESI,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x0018b809
LAB_0018aeb4:
LEA RDI,[0x1b3b9c]
LEA RDX,[0x1ad5f5]
LEA RCX,[0x1b94dd]
MOV ESI,0x45e3
JMP 0x0018aeea
LAB_0018aed0:
LEA RDI,[0x1b3b9c]
LEA RDX,[0x1ad5f5]
LEA RCX,[0x1b94e9]
MOV ESI,0x45e4
LAB_0018aeea:
XOR EAX,EAX
CALL 0x00123fe0
LAB_0018aef1:
LEA RDI,[0x1b3b9c]
LEA RDX,[0x1ad5f5]
LEA RCX,[0x1b94f5]
MOV ESI,0x45fe
JMP 0x0018aeea
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int) */
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer
(char *param_1,int param_2,int param_3,int param_4,int param_5)
{
char *pcVar1;
ulong uVar2;
int8 uVar3;
uint uVar4;
char *pcVar5;
if (param_4 < 0) {
if (0 < param_5) {
uVar4 = param_3 + param_2;
if (param_5 < (int)uVar4 || param_3 < 0) {
if ((int)uVar4 < 1 || param_5 < (int)uVar4) {
if ((int)uVar4 <= param_4 || 0 < (int)uVar4) {
if (param_2 != 1) {
memmove(param_1 + 2,param_1 + 1,(long)param_2 - 1);
param_1[1] = '.';
param_1 = param_1 + param_2;
}
param_1[1] = 'e';
pcVar1 = (char *)append_exponent(param_1 + 2,uVar4 - 1);
return pcVar1;
}
memmove(param_1 + (ulong)-uVar4 + 2,param_1,(long)param_2);
param_1[0] = '0';
param_1[1] = '.';
memset(param_1 + 2,0x30,(ulong)-uVar4);
pcVar5 = param_1 + (ulong)-uVar4 + 2 + param_2;
}
else {
if (-1 < param_3) {
pcVar1 = "k > n";
uVar3 = 0x45fe;
goto LAB_0018aeea;
}
uVar2 = (ulong)uVar4;
memmove(param_1 + uVar2 + 1,param_1 + uVar2,(uint)param_2 - uVar2);
param_1[uVar2] = '.';
pcVar5 = param_1 + (ulong)(uint)param_2 + 1;
}
}
else {
memset(param_1 + param_2,0x30,(long)(int)uVar4 - (long)param_2);
pcVar1 = param_1 + (int)uVar4;
pcVar5 = pcVar1 + 2;
pcVar1[0] = '.';
pcVar1[1] = '0';
}
return pcVar5;
}
pcVar1 = "max_exp > 0";
uVar3 = 0x45e4;
}
else {
pcVar1 = "min_exp < 0";
uVar3 = 0x45e3;
}
LAB_0018aeea:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar1);
}
|
|
63,199 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array()
|
monkey531[P]llama/common/json.hpp
|
bool end_array()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_array());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array():
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x4f6b4
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x4f6d0
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x5ddc3(%rip), %rdi # 0xad47e
leaq 0x5c597(%rip), %rdx # 0xabc59
leaq 0x5f2c7(%rip), %rcx # 0xae990
movl $0x1b01, %esi # imm = 0x1B01
jmp 0x4f6ea
leaq 0x5dda7(%rip), %rdi # 0xad47e
leaq 0x5c57b(%rip), %rdx # 0xabc59
leaq 0x5f521(%rip), %rcx # 0xaec06
movl $0x1b02, %esi # imm = 0x1B02
xorl %eax, %eax
callq 0x18b50
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
push rax
mov rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_4F6B4
mov rcx, [rax-8]
cmp byte ptr [rcx], 2
jnz short loc_4F6D0
add rax, 0FFFFFFFFFFFFFFF8h
mov [rdi+10h], rax
mov al, 1
pop rcx
retn
loc_4F6B4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1B01h
jmp short loc_4F6EA
loc_4F6D0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs_0; "ref_stack.back()->is_array()"
mov esi, 1B02h
loc_4F6EA:
xor eax, eax
call _ggml_abort
nop
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_array(
long long a1)
{
long long v1; // rax
long long v3; // rsi
long long v4; // rdx
long long v5; // rcx
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v1 )
{
v3 = 6913LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6913LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
}
else
{
if ( **(_BYTE **)(v1 - 8) == 2 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
return 1;
}
v3 = 6914LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6914LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_array()");
}
return nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::out_of_range>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v3,
v4,
v5);
}
|
end_array:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x0014f6b4
MOV RCX,qword ptr [RAX + -0x8]
CMP byte ptr [RCX],0x2
JNZ 0x0014f6d0
ADD RAX,-0x8
MOV qword ptr [RDI + 0x10],RAX
MOV AL,0x1
POP RCX
RET
LAB_0014f6b4:
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1ae990]
MOV ESI,0x1b01
JMP 0x0014f6ea
LAB_0014f6d0:
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1aec06]
MOV ESI,0x1b02
LAB_0014f6ea:
XOR EAX,EAX
CALL 0x00118b50
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_array(json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long lVar1;
char *pcVar2;
int8 uVar3;
lVar1 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar1) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1b01;
}
else {
if (**(char **)(lVar1 + -8) == '\x02') {
*(long *)(this + 0x10) = lVar1 + -8;
return CONCAT71((int7)((ulong)(lVar1 + -8) >> 8),1);
}
pcVar2 = "ref_stack.back()->is_array()";
uVar3 = 0x1b02;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.