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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
13,900
|
std::unique_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::default_delete<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> nglog::internal::MakeCheckOpString<nglog::LogSeverity, int>(nglog::LogSeverity const&, int const&, char const*)
|
ng-log[P]ng-log/src/ng-log/logging.h
|
std::unique_ptr<std::string> MakeCheckOpString(const T1& v1, const T2& v2,
const char* exprtext) {
CheckOpMessageBuilder comb(exprtext);
MakeCheckOpValueString(comb.ForVar1(), v1);
MakeCheckOpValueString(comb.ForVar2(), v2);
return comb.NewString();
}
|
O1
|
c
|
std::unique_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::default_delete<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> nglog::internal::MakeCheckOpString<nglog::LogSeverity, int>(nglog::LogSeverity const&, int const&, char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0xdf8a
movq (%r12), %rdi
movl (%r15), %esi
callq 0x7950
movq (%rsp), %rdi
leaq 0x10b8c(%rip), %rsi # 0x228bf
movl $0x5, %edx
callq 0x7610
movq (%rsp), %rdi
movl (%r14), %esi
callq 0x7950
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe042
movq %rsp, %rdi
callq 0xe014
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe014
movq %rbx, %rdi
callq 0x7970
|
_ZN5nglog8internal17MakeCheckOpStringINS_11LogSeverityEiEESt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS9_EERKT_RKT0_PKc:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r12, rsp
mov rdi, r12; this
mov rsi, rcx; char *
call _ZN5nglog8internal21CheckOpMessageBuilderC2EPKc; nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(char const*)
mov rdi, [r12]
mov esi, [r15]
call __ZNSolsEi; std::ostream::operator<<(int)
mov rdi, [rsp+28h+var_28]
lea rsi, aVs; " vs. "
mov edx, 5
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+28h+var_28]
mov esi, [r14]
call __ZNSolsEi; std::ostream::operator<<(int)
mov rsi, rsp
mov rdi, rbx
call _ZN5nglog8internal21CheckOpMessageBuilder9NewStringB5cxx11Ev; nglog::internal::CheckOpMessageBuilder::NewString(void)
mov rdi, rsp; this
call _ZN5nglog8internal21CheckOpMessageBuilderD2Ev; nglog::internal::CheckOpMessageBuilder::~CheckOpMessageBuilder()
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5nglog8internal21CheckOpMessageBuilderD2Ev; nglog::internal::CheckOpMessageBuilder::~CheckOpMessageBuilder()
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * nglog::internal::MakeCheckOpString<nglog::LogSeverity,int>(
_QWORD *a1,
unsigned int *a2,
unsigned int *a3,
const char *a4)
{
long long v4; // rax
_QWORD v7[5]; // [rsp+0h] [rbp-28h] BYREF
v7[0] = v4;
nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder((nglog::internal::CheckOpMessageBuilder *)v7, a4);
std::ostream::operator<<(v7[0], *a2);
std::__ostream_insert<char,std::char_traits<char>>(v7[0], " vs. ", 5LL);
std::ostream::operator<<(v7[0], *a3);
nglog::internal::CheckOpMessageBuilder::NewString[abi:cxx11](a1, v7);
nglog::internal::CheckOpMessageBuilder::~CheckOpMessageBuilder((nglog::internal::CheckOpMessageBuilder *)v7);
return a1;
}
|
MakeCheckOpString<nglog::LogSeverity,int>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R12,RSP
MOV RDI,R12
MOV RSI,RCX
CALL 0x0010df8a
MOV RDI,qword ptr [R12]
MOV ESI,dword ptr [R15]
LAB_00111d23:
CALL 0x00107950
MOV RDI,qword ptr [RSP]
LEA RSI,[0x1228bf]
MOV EDX,0x5
CALL 0x00107610
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [R14]
CALL 0x00107950
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0010e042
LAB_00111d54:
MOV RDI,RSP
CALL 0x0010e014
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::unique_ptr<std::__cxx11::string, std::default_delete<std::__cxx11::string > >
nglog::internal::MakeCheckOpString<nglog::LogSeverity, int>(nglog::LogSeverity const&, int
const&, char const*) */
internal * __thiscall
nglog::internal::MakeCheckOpString<nglog::LogSeverity,int>
(internal *this,LogSeverity *param_1,int *param_2,char *param_3)
{
ostream *in_RAX;
ostream *local_28;
local_28 = in_RAX;
CheckOpMessageBuilder::CheckOpMessageBuilder((CheckOpMessageBuilder *)&local_28,param_3);
/* try { // try from 00111d23 to 00111d53 has its CatchHandler @ 00111d6b */
std::ostream::operator<<(local_28,*(int *)param_1);
std::__ostream_insert<char,std::char_traits<char>>(local_28," vs. ",5);
std::ostream::operator<<(local_28,*param_2);
CheckOpMessageBuilder::NewString_abi_cxx11_();
CheckOpMessageBuilder::~CheckOpMessageBuilder((CheckOpMessageBuilder *)&local_28);
return this;
}
|
|
13,901
|
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder(OpenSubdiv::v3_6_0::Bfr::FaceSurface const&, OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::Options const&)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/irregularPatchBuilder.cpp
|
IrregularPatchBuilder::IrregularPatchBuilder(
FaceSurface const & surfaceDescription, Options const & options) :
_surface(surfaceDescription),
_options(options) {
initializeControlHullInventory();
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder(OpenSubdiv::v3_6_0::Bfr::FaceSurface const&, OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::Options const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
movl 0x8(%rdx), %eax
movl %eax, 0x10(%rdi)
leaq 0x38(%rdi), %r15
movq %r15, 0x28(%rdi)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x30(%rdi)
xorl %eax, %eax
movq %rax, 0xd8(%rdi)
leaq 0xe8(%rdi), %rcx
movl $0x0, 0xe8(%rdi)
movq %rax, 0xf0(%rdi)
movq %rcx, 0xf8(%rdi)
movq %rcx, 0x100(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%rdi)
movups %xmm0, 0x118(%rdi)
callq 0x3b7b0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x8b883
movq 0x120(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
leaq 0xe0(%rbx), %rdi
callq 0x38eb0
movq 0xd8(%rbx), %rdi
callq 0x3a0a0
movq %r15, 0x28(%rbx)
movl $0x8, 0x34(%rbx)
movq %r14, %rdi
callq 0x3bd30
|
_ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilderC2ERKNS1_11FaceSurfaceERKNS2_7OptionsE:
push r15; Alternative name is 'OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder(OpenSubdiv::v3_6_0::Bfr::FaceSurface const&, OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::Options const&)'
push r14
push rbx
mov rbx, rdi
mov [rdi], rsi
mov rax, [rdx]
mov [rdi+8], rax
mov eax, [rdx+8]
mov [rdi+10h], eax
lea r15, [rdi+38h]
mov [rdi+28h], r15
mov rax, 800000000h
mov [rdi+30h], rax
xor eax, eax
mov [rdi+0D8h], rax
lea rcx, [rdi+0E8h]
mov dword ptr [rdi+0E8h], 0
mov [rdi+0F0h], rax
mov [rdi+0F8h], rcx
mov [rdi+100h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rdi+108h], xmm0
movups xmmword ptr [rdi+118h], xmm0
call __ZN10OpenSubdiv6v3_6_03Bfr21IrregularPatchBuilder30initializeControlHullInventoryEv; OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlHullInventory(void)
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx+110h]; void *
test rdi, rdi
jz short loc_8B883
mov rsi, [rbx+120h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8B883:
lea rdi, [rbx+0E0h]
call __ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EED2Ev; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::~_Rb_tree()
mov rdi, [rbx+0D8h]; void *
call __ZdlPv; operator delete(void *)
mov [rbx+28h], r15
mov dword ptr [rbx+34h], 8
mov rdi, r14
call __Unwind_Resume
|
long long OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder(
long long a1,
long long a2,
long long a3)
{
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = *(_QWORD *)a3;
*(_DWORD *)(a1 + 16) = *(_DWORD *)(a3 + 8);
*(_QWORD *)(a1 + 40) = a1 + 56;
*(_QWORD *)(a1 + 48) = 0x800000000LL;
*(_QWORD *)(a1 + 216) = 0LL;
*(_DWORD *)(a1 + 232) = 0;
*(_QWORD *)(a1 + 240) = 0LL;
*(_QWORD *)(a1 + 248) = a1 + 232;
*(_QWORD *)(a1 + 256) = a1 + 232;
*(_OWORD *)(a1 + 264) = 0LL;
*(_OWORD *)(a1 + 280) = 0LL;
return OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::initializeControlHullInventory((OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder *)a1);
}
|
IrregularPatchBuilder:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RSI
MOV RAX,qword ptr [RDX]
MOV qword ptr [RDI + 0x8],RAX
MOV EAX,dword ptr [RDX + 0x8]
MOV dword ptr [RDI + 0x10],EAX
LEA R15,[RDI + 0x38]
MOV qword ptr [RDI + 0x28],R15
MOV RAX,0x800000000
MOV qword ptr [RDI + 0x30],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0xd8],RAX
LEA RCX,[RDI + 0xe8]
MOV dword ptr [RDI + 0xe8],0x0
MOV qword ptr [RDI + 0xf0],RAX
MOV qword ptr [RDI + 0xf8],RCX
MOV qword ptr [RDI + 0x100],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x108],XMM0
MOVUPS xmmword ptr [RDI + 0x118],XMM0
LAB_0018b85a:
CALL 0x0013b7b0
LAB_0018b85f:
POP RBX
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder(OpenSubdiv::v3_6_0::Bfr::FaceSurface
const&, OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::Options const&) */
void __thiscall
OpenSubdiv::v3_6_0::Bfr::IrregularPatchBuilder::IrregularPatchBuilder
(IrregularPatchBuilder *this,FaceSurface *param_1,Options *param_2)
{
*(FaceSurface **)this = param_1;
*(int8 *)(this + 8) = *(int8 *)param_2;
*(int4 *)(this + 0x10) = *(int4 *)(param_2 + 8);
*(IrregularPatchBuilder **)(this + 0x28) = this + 0x38;
*(int8 *)(this + 0x30) = 0x800000000;
*(int8 *)(this + 0xd8) = 0;
*(int4 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xf0) = 0;
*(IrregularPatchBuilder **)(this + 0xf8) = this + 0xe8;
*(IrregularPatchBuilder **)(this + 0x100) = this + 0xe8;
*(int8 *)(this + 0x108) = 0;
*(int8 *)(this + 0x110) = 0;
*(int8 *)(this + 0x118) = 0;
*(int8 *)(this + 0x120) = 0;
/* try { // try from 0018b85a to 0018b85e has its CatchHandler @ 0018b865 */
initializeControlHullInventory(this);
return;
}
|
|
13,902
|
net_get_error
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void net_get_error(char *buf, size_t buf_len,
char *error, size_t error_len,
unsigned int *error_no,
char *sqlstate)
{
char *p= buf;
size_t error_msg_len= 0;
if (buf_len > 2)
{
*error_no= uint2korr(p);
p+= 2;
/* since 4.1 sqlstate is following */
if (*p == '#')
{
memcpy(sqlstate, ++p, SQLSTATE_LENGTH);
p+= SQLSTATE_LENGTH;
}
error_msg_len= buf_len - (p - buf);
error_msg_len= MIN(error_msg_len, error_len - 1);
memcpy(error, p, error_msg_len);
}
else
{
*error_no= CR_UNKNOWN_ERROR;
memcpy(sqlstate, SQLSTATE_UNKNOWN, SQLSTATE_LENGTH);
}
}
|
O3
|
c
|
net_get_error:
pushq %rbp
movq %rsp, %rbp
cmpq $0x3, %rsi
jb 0x3a9d5
movzwl (%rdi), %eax
movl %eax, (%r8)
cmpb $0x23, 0x2(%rdi)
jne 0x3a9f4
movb 0x7(%rdi), %al
movb %al, 0x4(%r9)
movl 0x3(%rdi), %eax
movl %eax, (%r9)
leaq 0x8(%rdi), %rax
jmp 0x3a9f8
movl $0x7d0, (%r8) # imm = 0x7D0
leaq 0x30128d(%rip), %rax # 0x33bc70
movq (%rax), %rax
movb 0x4(%rax), %cl
movb %cl, 0x4(%r9)
movl (%rax), %eax
movl %eax, (%r9)
popq %rbp
retq
leaq 0x2(%rdi), %rax
addq %rsi, %rdi
subq %rax, %rdi
decq %rcx
cmpq %rcx, %rdi
cmovbq %rdi, %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x360b0
|
net_get_error:
push rbp
mov rbp, rsp
cmp rsi, 3
jb short loc_3A9D5
movzx eax, word ptr [rdi]
mov [r8], eax
cmp byte ptr [rdi+2], 23h ; '#'
jnz short loc_3A9F4
mov al, [rdi+7]
mov [r9+4], al
mov eax, [rdi+3]
mov [r9], eax
lea rax, [rdi+8]
jmp short loc_3A9F8
loc_3A9D5:
mov dword ptr [r8], 7D0h
lea rax, SQLSTATE_UNKNOWN
mov rax, [rax]
mov cl, [rax+4]
mov [r9+4], cl
mov eax, [rax]
mov [r9], eax
pop rbp
retn
loc_3A9F4:
lea rax, [rdi+2]
loc_3A9F8:
add rdi, rsi
sub rdi, rax
dec rcx
cmp rdi, rcx
cmovb rcx, rdi
mov rdi, rdx
mov rsi, rax
mov rdx, rcx
pop rbp
jmp _memcpy
|
long long net_get_error(
unsigned __int16 *a1,
unsigned long long a2,
long long a3,
long long a4,
_DWORD *a5,
long long a6)
{
unsigned __int16 *v6; // rax
char *v7; // rax
long long result; // rax
char *v9; // rdi
char *v10; // rcx
if ( a2 < 3 )
{
*a5 = 2000;
v7 = SQLSTATE_UNKNOWN;
*(_BYTE *)(a6 + 4) = SQLSTATE_UNKNOWN[4];
result = *(unsigned int *)v7;
*(_DWORD *)a6 = result;
}
else
{
*a5 = *a1;
if ( *((_BYTE *)a1 + 2) == 35 )
{
*(_BYTE *)(a6 + 4) = *((_BYTE *)a1 + 7);
*(_DWORD *)a6 = *(_DWORD *)((char *)a1 + 3);
v6 = a1 + 4;
}
else
{
v6 = a1 + 1;
}
v9 = (char *)((char *)a1 + a2 - (char *)v6);
v10 = (char *)(a4 - 1);
if ( v9 < v10 )
v10 = v9;
return memcpy(a3, v6, v10);
}
return result;
}
|
net_get_error:
PUSH RBP
MOV RBP,RSP
CMP RSI,0x3
JC 0x0013a9d5
MOVZX EAX,word ptr [RDI]
MOV dword ptr [R8],EAX
CMP byte ptr [RDI + 0x2],0x23
JNZ 0x0013a9f4
MOV AL,byte ptr [RDI + 0x7]
MOV byte ptr [R9 + 0x4],AL
MOV EAX,dword ptr [RDI + 0x3]
MOV dword ptr [R9],EAX
LEA RAX,[RDI + 0x8]
JMP 0x0013a9f8
LAB_0013a9d5:
MOV dword ptr [R8],0x7d0
LEA RAX,[0x43bc70]
MOV RAX,qword ptr [RAX]
MOV CL,byte ptr [RAX + 0x4]
MOV byte ptr [R9 + 0x4],CL
MOV EAX,dword ptr [RAX]
MOV dword ptr [R9],EAX
POP RBP
RET
LAB_0013a9f4:
LEA RAX,[RDI + 0x2]
LAB_0013a9f8:
ADD RDI,RSI
SUB RDI,RAX
DEC RCX
CMP RDI,RCX
CMOVC RCX,RDI
MOV RDI,RDX
MOV RSI,RAX
MOV RDX,RCX
POP RBP
JMP 0x001360b0
|
void net_get_error(ushort *param_1,ulong param_2,void *param_3,long param_4,uint *param_5,
int4 *param_6)
{
int *puVar1;
ushort *__src;
ulong __n;
ulong uVar2;
if (2 < param_2) {
*param_5 = (uint)*param_1;
if ((char)param_1[1] == '#') {
*(int1 *)(param_6 + 1) = *(int1 *)((long)param_1 + 7);
*param_6 = *(int4 *)((long)param_1 + 3);
__src = param_1 + 4;
}
else {
__src = param_1 + 1;
}
uVar2 = (long)param_1 + (param_2 - (long)__src);
__n = param_4 - 1U;
if (uVar2 < param_4 - 1U) {
__n = uVar2;
}
memcpy(param_3,__src,__n);
return;
}
*param_5 = 2000;
puVar1 = SQLSTATE_UNKNOWN;
*(int *)(param_6 + 1) = SQLSTATE_UNKNOWN[4];
*param_6 = *(int4 *)puVar1;
return;
}
|
|
13,903
|
intx::subc(unsigned long, unsigned long, bool)
|
corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp
|
inline constexpr result_with_carry<uint64_t> subc(
uint64_t x, uint64_t y, bool carry = false) noexcept
{
#if __has_builtin(__builtin_subcll)
if (!std::is_constant_evaluated())
{
unsigned long long carryout = 0; // NOLINT(google-runtime-int)
const auto d = __builtin_subcll(x, y, carry, &carryout);
static_assert(sizeof(d) == sizeof(uint64_t));
return {d, static_cast<bool>(carryout)};
}
#elif __has_builtin(__builtin_ia32_sbb_u64)
if (!std::is_constant_evaluated())
{
unsigned long long d = 0; // NOLINT(google-runtime-int)
static_assert(sizeof(d) == sizeof(uint64_t));
const auto carryout = __builtin_ia32_sbb_u64(carry, x, y, &d);
return {d, static_cast<bool>(carryout)};
}
#endif
const auto d = x - y;
const auto carry1 = x < y;
const auto e = d - carry;
const auto carry2 = d < uint64_t{carry};
return {e, carry1 || carry2};
}
|
O0
|
cpp
|
intx::subc(unsigned long, unsigned long, bool):
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl -0x21(%rbp), %edx
btl $0x0, %edx
sbbq %rcx, %rax
setb %cl
movzbl %cl, %ecx
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
testq %rax, %rax
setne -0x8(%rbp)
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN4intx4subcEmmb:
push rbp
mov rbp, rsp
mov al, dl
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
and al, 1
mov [rbp+var_21], al
mov [rbp+var_30], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_20]
movzx edx, [rbp+var_21]
bt edx, 0
sbb rax, rcx
setb cl
movzx ecx, cl
mov [rbp+var_30], rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_30]
test rax, rax
setnz [rbp+var_8]
mov rax, [rbp+var_10]
mov dl, [rbp+var_8]
pop rbp
retn
|
long long intx::subc(intx *this, long long a2, char a3)
{
return (long long)this - ((a3 & 1) != 0) - a2;
}
|
subc:
PUSH RBP
MOV RBP,RSP
MOV AL,DL
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x21],AL
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX EDX,byte ptr [RBP + -0x21]
BT EDX,0x0
SBB RAX,RCX
SETC CL
MOVZX ECX,CL
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x30]
TEST RAX,RAX
SETNZ byte ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV DL,byte ptr [RBP + -0x8]
POP RBP
RET
|
/* intx::subc(unsigned long, unsigned long, bool) */
int1 [16] intx::subc(ulong param_1,ulong param_2,bool param_3)
{
int1 auVar1 [16];
auVar1._0_8_ = (param_1 - param_2) - (ulong)param_3;
auVar1[8] = param_1 < param_2 || param_1 - param_2 < (ulong)param_3;
auVar1._9_7_ = 0;
return auVar1;
}
|
|
13,904
|
my_realloc
|
eloqsql/mysys/my_malloc.c
|
void *my_realloc(PSI_memory_key key, void *old_point, size_t size, myf my_flags)
{
my_memory_header *old_mh, *mh;
void *point;
size_t old_size;
my_bool old_flags;
DBUG_ENTER("my_realloc");
DBUG_PRINT("my",("ptr: %p size: %zu flags: %lu", old_point, size, my_flags));
DBUG_ASSERT(size > 0);
if (!old_point && (my_flags & MY_ALLOW_ZERO_PTR))
DBUG_RETURN(my_malloc(key, size, my_flags));
old_mh= USER_TO_HEADER(old_point);
old_size= old_mh->m_size & ~1;
old_flags= old_mh->m_size & 1;
DBUG_ASSERT(old_mh->m_key == key || old_mh->m_key == PSI_NOT_INSTRUMENTED);
DBUG_ASSERT(old_flags == MY_TEST(my_flags & MY_THREAD_SPECIFIC));
size= ALIGN_SIZE(size);
mh= sf_realloc(old_mh, size + HEADER_SIZE, my_flags);
if (mh == NULL)
{
if (size < old_size)
DBUG_RETURN(old_point);
my_errno=errno;
if (my_flags & MY_FREE_ON_ERROR)
{
/* my_free will take care of size accounting */
my_free(old_point);
old_point= 0;
}
if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL + ME_FATAL), size);
point= NULL;
}
else
{
mh->m_size= size | old_flags;
mh->m_key= PSI_CALL_memory_realloc(key, old_size, size, & mh->m_owner);
update_malloc_size((longlong)size - (longlong)old_size, old_flags);
point= HEADER_TO_USER(mh);
}
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN(point);
}
|
O0
|
c
|
my_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0xf4dc9
jmp 0xf4dcb
jmp 0xf4dcd
cmpq $0x0, -0x18(%rbp)
jne 0xf4dfd
movq -0x28(%rbp), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0xf4dfd
jmp 0xf4de4
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xf4be0
movq %rax, -0x8(%rbp)
jmp 0xf4f47
movq -0x18(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x2, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
movb %al, -0x49(%rbp)
jmp 0xf4e2a
jmp 0xf4e2c
jmp 0xf4e2e
movq -0x20(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
callq 0x2a0a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xf4ed9
movq -0x20(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xf4e77
jmp 0xf4e6a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf4f47
callq 0x2a760
movl (%rax), %eax
movl %eax, -0x50(%rbp)
callq 0xf7440
movl -0x50(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0xf4eac
movq -0x18(%rbp), %rdi
callq 0xf4f60
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xf4ecf
movq -0x20(%rbp), %rdx
movl $0x5, %edi
movl $0x1004, %esi # imm = 0x1004
movb $0x0, %al
callq 0xf0ef0
movq $0x0, -0x40(%rbp)
jmp 0xf4f39
movq -0x20(%rbp), %rcx
movsbq -0x49(%rbp), %rax
orq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x1cc264(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x3e8(%rax), %rax
movl -0xc(%rbp), %edi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x1cbd11(%rip), %rax # 0x2c0c30
movq -0x20(%rbp), %rdi
subq -0x48(%rbp), %rdi
movsbl -0x49(%rbp), %esi
callq *%rax
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
jmp 0xf4f3b
jmp 0xf4f3d
jmp 0xf4f3f
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_realloc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
jmp short $+2
loc_F4DC9:
jmp short $+2
loc_F4DCB:
jmp short $+2
loc_F4DCD:
cmp [rbp+var_18], 0
jnz short loc_F4DFD
mov rax, [rbp+var_28]
and rax, 40h
cmp rax, 0
jz short loc_F4DFD
jmp short $+2
loc_F4DE4:
mov edi, [rbp+var_C]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call my_malloc
mov [rbp+var_8], rax
jmp loc_F4F47
loc_F4DFD:
mov rax, [rbp+var_18]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax+8]
and rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
mov rax, [rax+8]
and rax, 1
mov [rbp+var_49], al
jmp short $+2
loc_F4E2A:
jmp short $+2
loc_F4E2C:
jmp short $+2
loc_F4E2E:
mov rax, [rbp+var_20]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
add rsi, 18h
call _realloc
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_F4ED9
mov rax, [rbp+var_20]
cmp rax, [rbp+var_48]
jnb short loc_F4E77
jmp short $+2
loc_F4E6A:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp loc_F4F47
loc_F4E77:
call ___errno_location
mov eax, [rax]
mov [rbp+var_50], eax
call _my_thread_var
mov ecx, [rbp+var_50]
mov [rax], ecx
mov rax, [rbp+var_28]
and rax, 80h
cmp rax, 0
jz short loc_F4EAC
mov rdi, [rbp+var_18]
call my_free
mov [rbp+var_18], 0
loc_F4EAC:
mov rax, [rbp+var_28]
and rax, 18h
cmp rax, 0
jz short loc_F4ECF
mov rdx, [rbp+var_20]
mov edi, 5
mov esi, 1004h
mov al, 0
call my_error
loc_F4ECF:
mov [rbp+var_40], 0
jmp short loc_F4F39
loc_F4ED9:
mov rcx, [rbp+var_20]
movsx rax, [rbp+var_49]
or rcx, rax
mov rax, [rbp+var_38]
mov [rax+8], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+3E8h]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_38]
call rax
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, cs:update_malloc_size
mov rdi, [rbp+var_20]
sub rdi, [rbp+var_48]
movsx esi, [rbp+var_49]
call rax ; dummy
mov rax, [rbp+var_38]
add rax, 18h
mov [rbp+var_40], rax
loc_F4F39:
jmp short $+2
loc_F4F3B:
jmp short $+2
loc_F4F3D:
jmp short $+2
loc_F4F3F:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_F4F47:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
long long my_realloc(unsigned int a1, long long a2, const char *a3, char a4)
{
int v5; // [rsp+0h] [rbp-50h]
char v6; // [rsp+7h] [rbp-49h]
unsigned long long v7; // [rsp+8h] [rbp-48h]
long long v9; // [rsp+18h] [rbp-38h]
unsigned long long v11; // [rsp+30h] [rbp-20h]
if ( a2 || (a4 & 0x40) == 0 )
{
v7 = *(_QWORD *)(a2 - 24 + 8) & 0xFFFFFFFFFFFFFFFELL;
v6 = *(_BYTE *)(a2 - 24 + 8) & 1;
v11 = (unsigned long long)(a3 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v9 = realloc(a2 - 24, v11 + 24);
if ( v9 )
{
*(_QWORD *)(v9 + 8) = v6 | v11;
*(_DWORD *)(v9 + 16) = ((long long ( *)(_QWORD, unsigned long long, unsigned long long, long long))PSI_server[125])(
a1,
v7,
v11,
v9);
update_malloc_size(v11 - v7, v6);
return v9 + 24;
}
else
{
if ( v11 < v7 )
return a2;
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a2 - 24, (const char *)(v11 + 24)) = v5;
if ( a4 < 0 )
my_free(a2);
if ( (a4 & 0x18) != 0 )
my_error(5u, 4100LL, v11);
return 0LL;
}
}
return my_malloc(a1, a3, a4);
}
|
my_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
JMP 0x001f4dc9
LAB_001f4dc9:
JMP 0x001f4dcb
LAB_001f4dcb:
JMP 0x001f4dcd
LAB_001f4dcd:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001f4dfd
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x40
CMP RAX,0x0
JZ 0x001f4dfd
JMP 0x001f4de4
LAB_001f4de4:
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001f4be0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f4f47
LAB_001f4dfd:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,-0x18
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,-0x2
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,0x1
MOV byte ptr [RBP + -0x49],AL
JMP 0x001f4e2a
LAB_001f4e2a:
JMP 0x001f4e2c
LAB_001f4e2c:
JMP 0x001f4e2e
LAB_001f4e2e:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x18
CALL 0x0012a0a0
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001f4ed9
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x001f4e77
JMP 0x001f4e6a
LAB_001f4e6a:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f4f47
LAB_001f4e77:
CALL 0x0012a760
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
CALL 0x001f7440
MOV ECX,dword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x80
CMP RAX,0x0
JZ 0x001f4eac
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001f4f60
MOV qword ptr [RBP + -0x18],0x0
LAB_001f4eac:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001f4ecf
MOV RDX,qword ptr [RBP + -0x20]
MOV EDI,0x5
MOV ESI,0x1004
MOV AL,0x0
CALL 0x001f0ef0
LAB_001f4ecf:
MOV qword ptr [RBP + -0x40],0x0
JMP 0x001f4f39
LAB_001f4ed9:
MOV RCX,qword ptr [RBP + -0x20]
MOVSX RAX,byte ptr [RBP + -0x49]
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3e8]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x38]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [0x003c0c30]
MOV RDI,qword ptr [RBP + -0x20]
SUB RDI,qword ptr [RBP + -0x48]
MOVSX ESI,byte ptr [RBP + -0x49]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x18
MOV qword ptr [RBP + -0x40],RAX
LAB_001f4f39:
JMP 0x001f4f3b
LAB_001f4f3b:
JMP 0x001f4f3d
LAB_001f4f3d:
JMP 0x001f4f3f
LAB_001f4f3f:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f4f47:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long my_realloc(int4 param_1,long param_2,long param_3,ulong param_4)
{
int iVar1;
byte bVar2;
int4 uVar3;
ulong uVar4;
ulong uVar5;
void *pvVar6;
int *piVar7;
long local_48;
long local_10;
if ((param_2 == 0) && ((param_4 & 0x40) != 0)) {
local_10 = my_malloc(param_1,param_3,param_4);
}
else {
uVar4 = *(ulong *)(param_2 + -0x10) & 0xfffffffffffffffe;
bVar2 = (byte)*(int8 *)(param_2 + -0x10) & 1;
uVar5 = param_3 + 7U & 0xfffffffffffffff8;
pvVar6 = realloc((void *)(param_2 + -0x18),uVar5 + 0x18);
if (pvVar6 == (void *)0x0) {
if (uVar5 < uVar4) {
return param_2;
}
piVar7 = __errno_location();
iVar1 = *piVar7;
piVar7 = (int *)_my_thread_var();
*piVar7 = iVar1;
if ((param_4 & 0x80) != 0) {
my_free(param_2);
}
if ((param_4 & 0x18) != 0) {
my_error(5,0x1004,uVar5);
}
local_48 = 0;
}
else {
*(ulong *)((long)pvVar6 + 8) = uVar5 | (long)(char)bVar2;
uVar3 = (**(code **)(PSI_server + 1000))(param_1,uVar4,uVar5,pvVar6);
*(int4 *)((long)pvVar6 + 0x10) = uVar3;
(*(code *)update_malloc_size)(uVar5 - uVar4,bVar2);
local_48 = (long)pvVar6 + 0x18;
}
local_10 = local_48;
}
return local_10;
}
|
|
13,905
|
my_strnxfrm_8bit_bin
|
eloqsql/strings/ctype-bin.c
|
static size_t
my_strnxfrm_8bit_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (srclen && dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, dst, dst + srclen, dst + dstlen,
(uint)(nweights - srclen), flags, 0);
}
|
O3
|
c
|
my_strnxfrm_8bit_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x10(%rbp), %r9d
cmpq %rdx, %r13
cmovaeq %rdx, %r13
movl %ecx, %eax
cmpq %rax, %r13
cmovaeq %rax, %r13
testq %r13, %r13
sete %al
cmpq %r8, %rsi
sete %cl
orb %al, %cl
jne 0x426ee
movq %r12, %rdi
movq %r8, %rsi
movq %r13, %rdx
callq 0x33240
movl 0x10(%rbp), %r9d
leaq (%r12,%r13), %rdx
addq %r12, %r14
subl %r13d, %ebx
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x4aa64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_8bit_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov ebx, ecx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov r9d, [rbp+arg_0]
cmp r13, rdx
cmovnb r13, rdx
mov eax, ecx
cmp r13, rax
cmovnb r13, rax
test r13, r13
setz al
cmp rsi, r8
setz cl
or cl, al
jnz short loc_426EE
mov rdi, r12
mov rsi, r8
mov rdx, r13
call _memcpy
mov r9d, [rbp+arg_0]
loc_426EE:
lea rdx, [r12+r13]
add r14, r12
sub ebx, r13d
mov [rsp+30h+var_30], 0
mov rdi, r15
mov rsi, r12
mov rcx, r14
mov r8d, ebx
call my_strxfrm_pad_desc_and_reverse
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnxfrm_8bit_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
int v9; // r14d
int v10; // r9d
v9 = a3;
v10 = a7;
if ( a6 >= a3 )
a6 = a3;
if ( a6 >= a4 )
a6 = a4;
if ( a6 != 0 && a2 != a5 )
{
memcpy(a2, a5, a6);
v10 = a7;
}
return my_strxfrm_pad_desc_and_reverse(a1, a2, (int)a2 + (int)a6, (int)a2 + v9, a4 - (unsigned int)a6, v10, 0);
}
|
my_strnxfrm_8bit_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV EBX,ECX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV R9D,dword ptr [RBP + 0x10]
CMP R13,RDX
CMOVNC R13,RDX
MOV EAX,ECX
CMP R13,RAX
CMOVNC R13,RAX
TEST R13,R13
SETZ AL
CMP RSI,R8
SETZ CL
OR CL,AL
JNZ 0x001426ee
MOV RDI,R12
MOV RSI,R8
MOV RDX,R13
CALL 0x00133240
MOV R9D,dword ptr [RBP + 0x10]
LAB_001426ee:
LEA RDX,[R12 + R13*0x1]
ADD R14,R12
SUB EBX,R13D
MOV dword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R12
MOV RCX,R14
MOV R8D,EBX
CALL 0x0014aa64
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnxfrm_8bit_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
uint uVar1;
uVar1 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 <= param_6) {
param_6 = param_3;
}
if (param_4 <= param_6) {
param_6 = (ulong)param_4;
}
if (param_2 != param_5 && param_6 != 0) {
memcpy(param_2,param_5,param_6);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + param_6,param_3 + (long)param_2,param_4 - (int)param_6,
param_7,(ulong)uVar1 << 0x20);
return;
}
|
|
13,906
|
maria_rtree_overlapping_area
|
eloqsql/storage/maria/ma_rt_mbr.c
|
double maria_rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
uint key_length)
{
double res= 1;
for (; (int) key_length > 0 ; keyseg += 2)
{
uint32 keyseg_length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_OVL_AREA_KORR(int8, mi_sint1korr, 1);
break;
case HA_KEYTYPE_BINARY:
RT_OVL_AREA_KORR(uint8, mi_uint1korr, 1);
break;
case HA_KEYTYPE_SHORT_INT:
RT_OVL_AREA_KORR(int16, mi_sint2korr, 2);
break;
case HA_KEYTYPE_USHORT_INT:
RT_OVL_AREA_KORR(uint16, mi_uint2korr, 2);
break;
case HA_KEYTYPE_INT24:
RT_OVL_AREA_KORR(int32, mi_sint3korr, 3);
break;
case HA_KEYTYPE_UINT24:
RT_OVL_AREA_KORR(uint32, mi_uint3korr, 3);
break;
case HA_KEYTYPE_LONG_INT:
RT_OVL_AREA_KORR(int32, mi_sint4korr, 4);
break;
case HA_KEYTYPE_ULONG_INT:
RT_OVL_AREA_KORR(uint32, mi_uint4korr, 4);
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
case HA_KEYTYPE_ULONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_OVL_AREA_GET(float, mi_float4get, 4);
break;
case HA_KEYTYPE_DOUBLE:
RT_OVL_AREA_GET(double, mi_float8get, 8);
break;
case HA_KEYTYPE_END:
return res;
default:
return -1;
}
keyseg_length= keyseg->length * 2;
key_length-= keyseg_length;
a+= keyseg_length;
b+= keyseg_length;
}
return res;
}
|
O3
|
c
|
maria_rtree_overlapping_area:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
testl %ecx, %ecx
jle 0x6e4ae
addq $0x18, %rdi
movsd 0x72da9(%rip), %xmm0 # 0xe0e38
movsd 0x72db9(%rip), %xmm1 # 0xe0e50
leaq 0x733f6(%rip), %rax # 0xe1494
movzbl (%rdi), %r8d
cmpq $0xe, %r8
ja 0x6e4c3
movslq (%rax,%r8,4), %r8
addq %rax, %r8
jmpq *%r8
movq (%rsi), %r9
movq 0x8(%rsi), %r10
bswapq %r9
movq (%rdx), %r11
movq 0x8(%rdx), %r8
bswapq %r11
bswapq %r10
bswapq %r8
cmpq %r11, %r9
cmovgq %r9, %r11
cmpq %r8, %r10
cmovlq %r10, %r8
subq %r11, %r8
jg 0x6e2a7
jmp 0x6e4b8
movzbl (%rsi), %r11d
movl %r11d, %r8d
shll $0x10, %r8d
movzbl 0x1(%rsi), %r9d
shll $0x8, %r9d
movzbl 0x2(%rsi), %r10d
testb %r11b, %r11b
js 0x6e3cf
orl %r10d, %r8d
orl %r9d, %r8d
jmp 0x6e3dc
movzwl 0x1(%rsi), %r8d
movzwl 0x4(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzbl (%rsi), %r8d
shll $0x10, %r8d
orl %r10d, %r8d
movzwl 0x1(%rdx), %r10d
movzwl 0x4(%rdx), %r11d
rolw $0x8, %r10w
movzwl %r10w, %r10d
movzbl (%rdx), %ebx
shll $0x10, %ebx
orl %r10d, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
movzbl 0x3(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
rolw $0x8, %r11w
movzwl %r11w, %r11d
movzbl 0x3(%rdx), %r9d
shll $0x10, %r9d
orl %r11d, %r9d
cmpl %ebx, %r8d
cmoval %r8d, %ebx
cmpl %r9d, %r10d
cmovbl %r10d, %r9d
subl %ebx, %r9d
jbe 0x6e4b8
xorps %xmm2, %xmm2
cvtsi2sd %r9, %xmm2
jmp 0x6e48d
movq (%rsi), %r8
movq 0x8(%rsi), %r9
bswapq %r8
movq %r8, %xmm3
movq (%rdx), %r8
bswapq %r8
movq 0x8(%rdx), %r10
movq %r8, %xmm2
bswapq %r9
maxsd %xmm2, %xmm3
movq %r9, %xmm2
bswapq %r10
movq %r10, %xmm4
minsd %xmm4, %xmm2
ucomisd %xmm2, %xmm3
jae 0x6e4b8
subsd %xmm3, %xmm2
jmp 0x6e48d
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmovgl %r9d, %r11d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
subl %r11d, %r8d
jg 0x6e269
jmp 0x6e4b8
movzwl (%rsi), %r8d
movzwl 0x2(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzwl (%rdx), %r8d
rolw $0x8, %r8w
movzwl 0x2(%rdx), %r11d
movzwl %r8w, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
rolw $0x8, %r11w
movzwl %r11w, %r8d
cmpl %ebx, %r10d
cmoval %r10d, %ebx
cmpl %r8d, %r9d
cmovbl %r9d, %r8d
subl %ebx, %r8d
jbe 0x6e4b8
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
jmp 0x6e48d
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmoval %r9d, %r11d
cmpl %r8d, %r10d
cmovbl %r10d, %r8d
subl %r11d, %r8d
jbe 0x6e4b8
xorps %xmm2, %xmm2
cvtsi2sd %r8, %xmm2
jmp 0x6e48d
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r9), %r10d
leal 0x1(%r8), %r11d
cmpb %r8b, %r9b
cmovgl %r9d, %r8d
movzbl %r10b, %r10d
movzbl %r11b, %r9d
cmpb %r9b, %r10b
cmovll %r10d, %r9d
cmpb %r9b, %r8b
jge 0x6e4b8
movsbl %r9b, %r9d
movsbl %r8b, %r8d
jmp 0x6e370
movzwl (%rsi), %r10d
movzwl 0x2(%rsi), %r11d
rolw $0x8, %r10w
movzwl (%rdx), %r8d
movzwl 0x2(%rdx), %r9d
rolw $0x8, %r8w
rolw $0x8, %r11w
rolw $0x8, %r9w
cmpw %r8w, %r10w
cmovgl %r10d, %r8d
cmpw %r9w, %r11w
cmovll %r11d, %r9d
cmpw %r9w, %r8w
jge 0x6e4b8
movswl %r9w, %r9d
movswl %r8w, %r8d
jmp 0x6e370
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r8), %r10d
cmpb %r8b, %r9b
cmoval %r9d, %r8d
incl %r9d
movzbl %r9b, %r11d
movzbl %r10b, %r9d
cmpb %r9b, %r11b
cmovbl %r11d, %r9d
cmpb %r9b, %r8b
jae 0x6e4b8
movzbl %r9b, %r9d
movzbl %r8b, %r8d
subl %r8d, %r9d
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
jmp 0x6e48d
movl (%rsi), %r8d
movl 0x4(%rsi), %r9d
bswapl %r8d
movd %r8d, %xmm2
movl (%rdx), %r8d
movl 0x4(%rdx), %r10d
bswapl %r8d
movd %r8d, %xmm3
maxss %xmm3, %xmm2
bswapl %r9d
movd %r9d, %xmm3
bswapl %r10d
movd %r10d, %xmm4
minss %xmm4, %xmm3
ucomiss %xmm3, %xmm2
jae 0x6e4b8
subss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
jmp 0x6e48d
orl %r10d, %r9d
addl %r9d, %r8d
addl $0xff000000, %r8d # imm = 0xFF000000
movzbl (%rdx), %ebx
movl %ebx, %r9d
shll $0x10, %r9d
movzbl 0x1(%rdx), %r10d
shll $0x8, %r10d
movzbl 0x2(%rdx), %r11d
testb %bl, %bl
js 0x6e400
orl %r11d, %r9d
orl %r10d, %r9d
jmp 0x6e40d
orl %r11d, %r10d
addl %r10d, %r9d
addl $0xff000000, %r9d # imm = 0xFF000000
movzbl 0x3(%rsi), %r14d
movl %r14d, %r10d
shll $0x10, %r10d
movzbl 0x4(%rsi), %r11d
shll $0x8, %r11d
movzbl 0x5(%rsi), %ebx
testb %r14b, %r14b
js 0x6e433
orl %ebx, %r10d
orl %r11d, %r10d
jmp 0x6e440
orl %ebx, %r11d
addl %r11d, %r10d
addl $0xff000000, %r10d # imm = 0xFF000000
movzbl 0x3(%rdx), %r15d
movl %r15d, %r11d
shll $0x10, %r11d
movzbl 0x4(%rdx), %ebx
shll $0x8, %ebx
movzbl 0x5(%rdx), %r14d
testb %r15b, %r15b
js 0x6e465
orl %r14d, %r11d
orl %ebx, %r11d
jmp 0x6e472
orl %r14d, %ebx
addl %ebx, %r11d
addl $0xff000000, %r11d # imm = 0xFF000000
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
cmpl %r11d, %r10d
cmovll %r10d, %r11d
subl %r9d, %r11d
jle 0x6e4b8
xorps %xmm2, %xmm2
cvtsi2sd %r11d, %xmm2
mulsd %xmm2, %xmm0
movzwl -0x4(%rdi), %r8d
addl %r8d, %r8d
addq %r8, %rsi
addq %r8, %rdx
addq $0x40, %rdi
subl %r8d, %ecx
jg 0x6e09e
jmp 0x6e4bc
movsd 0x72982(%rip), %xmm0 # 0xe0e38
jmp 0x6e4bc
xorpd %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movapd %xmm1, %xmm0
jmp 0x6e4bc
|
maria_rtree_overlapping_area:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
test ecx, ecx
jle loc_6E4AE
add rdi, 18h
movsd xmm0, cs:qword_E0E38
movsd xmm1, cs:qword_E0E50
lea rax, jpt_6E0B3
loc_6E09E:
movzx r8d, byte ptr [rdi]
cmp r8, 0Eh; switch 15 cases
ja def_6E0B3; jumptable 000000000006E0B3 default case, cases 1,7
movsxd r8, ds:(jpt_6E0B3 - 0E1494h)[rax+r8*4]
add r8, rax
jmp r8; switch jump
loc_6E0B6:
mov r9, [rsi]; jumptable 000000000006E0B3 cases 10,11
mov r10, [rsi+8]
bswap r9
mov r11, [rdx]
mov r8, [rdx+8]
bswap r11
bswap r10
bswap r8
cmp r9, r11
cmovg r11, r9
cmp r10, r8
cmovl r8, r10
sub r8, r11
jg loc_6E2A7
jmp loc_6E4B8
loc_6E0EC:
movzx r11d, byte ptr [rsi]; jumptable 000000000006E0B3 case 12
mov r8d, r11d
shl r8d, 10h
movzx r9d, byte ptr [rsi+1]
shl r9d, 8
movzx r10d, byte ptr [rsi+2]
test r11b, r11b
js loc_6E3CF
or r8d, r10d
or r8d, r9d
jmp loc_6E3DC
loc_6E119:
movzx r8d, word ptr [rsi+1]; jumptable 000000000006E0B3 case 13
movzx r9d, word ptr [rsi+4]
rol r8w, 8
movzx r10d, r8w
movzx r8d, byte ptr [rsi]
shl r8d, 10h
or r8d, r10d
movzx r10d, word ptr [rdx+1]
movzx r11d, word ptr [rdx+4]
rol r10w, 8
movzx r10d, r10w
movzx ebx, byte ptr [rdx]
shl ebx, 10h
or ebx, r10d
rol r9w, 8
movzx r9d, r9w
movzx r10d, byte ptr [rsi+3]
shl r10d, 10h
or r10d, r9d
rol r11w, 8
movzx r11d, r11w
movzx r9d, byte ptr [rdx+3]
shl r9d, 10h
or r9d, r11d
cmp r8d, ebx
cmova ebx, r8d
cmp r10d, r9d
cmovb r9d, r10d
sub r9d, ebx
jbe loc_6E4B8
xorps xmm2, xmm2
cvtsi2sd xmm2, r9
jmp loc_6E48D
loc_6E1A1:
mov r8, [rsi]; jumptable 000000000006E0B3 case 6
mov r9, [rsi+8]
bswap r8
movq xmm3, r8
mov r8, [rdx]
bswap r8
mov r10, [rdx+8]
movq xmm2, r8
bswap r9
maxsd xmm3, xmm2
movq xmm2, r9
bswap r10
movq xmm4, r10
minsd xmm2, xmm4
ucomisd xmm3, xmm2
jnb loc_6E4B8
subsd xmm2, xmm3
jmp loc_6E48D
loc_6E1EA:
mov r9d, [rsi]; jumptable 000000000006E0B3 case 4
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmovg r11d, r9d
cmp r10d, r8d
cmovl r8d, r10d
sub r8d, r11d
jg short loc_6E269
jmp loc_6E4B8
loc_6E21C:
movzx r8d, word ptr [rsi]; jumptable 000000000006E0B3 case 8
movzx r9d, word ptr [rsi+2]
rol r8w, 8
movzx r10d, r8w
movzx r8d, word ptr [rdx]
rol r8w, 8
movzx r11d, word ptr [rdx+2]
movzx ebx, r8w
rol r9w, 8
movzx r9d, r9w
rol r11w, 8
movzx r8d, r11w
cmp r10d, ebx
cmova ebx, r10d
cmp r9d, r8d
cmovb r8d, r9d
sub r8d, ebx
jbe loc_6E4B8
loc_6E269:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8d
jmp loc_6E48D
loc_6E276:
mov r9d, [rsi]; jumptable 000000000006E0B3 case 9
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmova r11d, r9d
cmp r10d, r8d
cmovb r8d, r10d
sub r8d, r11d
jbe loc_6E4B8
loc_6E2A7:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8
jmp loc_6E48D
loc_6E2B4:
movzx r9d, byte ptr [rsi]; jumptable 000000000006E0B3 case 14
movzx r8d, byte ptr [rdx]
lea r10d, [r9+1]
lea r11d, [r8+1]
cmp r9b, r8b
cmovg r8d, r9d
movzx r10d, r10b
movzx r9d, r11b
cmp r10b, r9b
cmovl r9d, r10d
cmp r8b, r9b
jge loc_6E4B8
movsx r9d, r9b
movsx r8d, r8b
jmp loc_6E370
loc_6E2F0:
movzx r10d, word ptr [rsi]; jumptable 000000000006E0B3 case 3
movzx r11d, word ptr [rsi+2]
rol r10w, 8
movzx r8d, word ptr [rdx]
movzx r9d, word ptr [rdx+2]
rol r8w, 8
rol r11w, 8
rol r9w, 8
cmp r10w, r8w
cmovg r8d, r10d
cmp r11w, r9w
cmovl r9d, r11d
cmp r8w, r9w
jge loc_6E4B8
movsx r9d, r9w
movsx r8d, r8w
jmp short loc_6E370
loc_6E33A:
movzx r9d, byte ptr [rsi]; jumptable 000000000006E0B3 case 2
movzx r8d, byte ptr [rdx]
lea r10d, [r8+1]
cmp r9b, r8b
cmova r8d, r9d
inc r9d
movzx r11d, r9b
movzx r9d, r10b
cmp r11b, r9b
cmovb r9d, r11d
cmp r8b, r9b
jnb loc_6E4B8
movzx r9d, r9b
movzx r8d, r8b
loc_6E370:
sub r9d, r8d
xorps xmm2, xmm2
cvtsi2sd xmm2, r9d
jmp loc_6E48D
loc_6E380:
mov r8d, [rsi]; jumptable 000000000006E0B3 case 5
mov r9d, [rsi+4]
bswap r8d
movd xmm2, r8d
mov r8d, [rdx]
mov r10d, [rdx+4]
bswap r8d
movd xmm3, r8d
maxss xmm2, xmm3
bswap r9d
movd xmm3, r9d
bswap r10d
movd xmm4, r10d
minss xmm3, xmm4
ucomiss xmm2, xmm3
jnb loc_6E4B8
subss xmm3, xmm2
xorps xmm2, xmm2
cvtss2sd xmm2, xmm3
jmp loc_6E48D
loc_6E3CF:
or r9d, r10d
add r8d, r9d
add r8d, 0FF000000h
loc_6E3DC:
movzx ebx, byte ptr [rdx]
mov r9d, ebx
shl r9d, 10h
movzx r10d, byte ptr [rdx+1]
shl r10d, 8
movzx r11d, byte ptr [rdx+2]
test bl, bl
js short loc_6E400
or r9d, r11d
or r9d, r10d
jmp short loc_6E40D
loc_6E400:
or r10d, r11d
add r9d, r10d
add r9d, 0FF000000h
loc_6E40D:
movzx r14d, byte ptr [rsi+3]
mov r10d, r14d
shl r10d, 10h
movzx r11d, byte ptr [rsi+4]
shl r11d, 8
movzx ebx, byte ptr [rsi+5]
test r14b, r14b
js short loc_6E433
or r10d, ebx
or r10d, r11d
jmp short loc_6E440
loc_6E433:
or r11d, ebx
add r10d, r11d
add r10d, 0FF000000h
loc_6E440:
movzx r15d, byte ptr [rdx+3]
mov r11d, r15d
shl r11d, 10h
movzx ebx, byte ptr [rdx+4]
shl ebx, 8
movzx r14d, byte ptr [rdx+5]
test r15b, r15b
js short loc_6E465
or r11d, r14d
or r11d, ebx
jmp short loc_6E472
loc_6E465:
or ebx, r14d
add r11d, ebx
add r11d, 0FF000000h
loc_6E472:
cmp r8d, r9d
cmovg r9d, r8d
cmp r10d, r11d
cmovl r11d, r10d
sub r11d, r9d
jle short loc_6E4B8
xorps xmm2, xmm2
cvtsi2sd xmm2, r11d
loc_6E48D:
mulsd xmm0, xmm2
movzx r8d, word ptr [rdi-4]
add r8d, r8d
add rsi, r8
add rdx, r8
add rdi, 40h ; '@'
sub ecx, r8d
jg loc_6E09E
jmp short loc_6E4BC; jumptable 000000000006E0B3 case 0
loc_6E4AE:
movsd xmm0, cs:qword_E0E38
jmp short loc_6E4BC; jumptable 000000000006E0B3 case 0
loc_6E4B8:
xorpd xmm0, xmm0
loc_6E4BC:
pop rbx; jumptable 000000000006E0B3 case 0
pop r14
pop r15
pop rbp
retn
def_6E0B3:
movapd xmm0, xmm1; jumptable 000000000006E0B3 default case, cases 1,7
jmp short loc_6E4BC; jumptable 000000000006E0B3 case 0
|
double maria_rtree_overlapping_area(long long a1, _WORD *a2, _WORD *a3, int a4)
{
_BYTE *v4; // rdi
double result; // xmm0_8
signed long long v6; // r9
signed long long v7; // r11
signed long long v8; // r10
signed long long v9; // r8
bool v10; // cc
int v11; // r8d
int v12; // r8d
int v13; // r9d
int v14; // r10d
int v15; // r8d
unsigned int v16; // r8d
unsigned int v17; // ebx
unsigned int v18; // r10d
unsigned int v19; // r9d
int v20; // r9d
double v21; // xmm2_8
double v22; // xmm3_8
double v23; // xmm2_8
signed __int32 v24; // r9d
signed __int32 v25; // r11d
signed __int32 v26; // r10d
signed __int32 v27; // r8d
int v28; // r8d
unsigned int v29; // r10d
unsigned int v30; // ebx
unsigned int v31; // r9d
unsigned int v32; // r8d
unsigned __int32 v33; // r9d
unsigned __int32 v34; // r11d
unsigned __int32 v35; // r10d
unsigned __int32 v36; // r8d
int v37; // r8d
int v38; // r9d
__int16 v39; // r10
__int16 v40; // r11
float v41; // xmm2_4
float v42; // xmm3_4
int v43; // r9d
int v44; // r10d
int v45; // r11d
int v46; // r9d
int v47; // r10d
int v48; // r11d
int v49; // ebx
int v50; // r10d
int v51; // r11d
int v52; // ebx
int v53; // r14d
int v54; // r11d
int v55; // r11d
long long v56; // r8
if ( a4 <= 0 )
return 1.0;
v4 = (_BYTE *)(a1 + 24);
result = 1.0;
while ( 2 )
{
switch ( *v4 )
{
case 0:
return result;
case 2:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (unsigned __int8)(*(_BYTE *)a2 + 1) < (unsigned __int8)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (unsigned __int8)v37 >= (unsigned __int8)v38 )
return 0.0;
v38 = (unsigned __int8)v38;
v37 = (unsigned __int8)v37;
goto LABEL_56;
case 3:
v39 = __ROL2__(*a2, 8);
LOWORD(v37) = __ROL2__(*a3, 8);
v40 = __ROL2__(a2[1], 8);
LOWORD(v38) = __ROL2__(a3[1], 8);
if ( v39 > (__int16)v37 )
LOWORD(v37) = v39;
if ( v40 < (__int16)v38 )
LOWORD(v38) = v40;
if ( (__int16)v37 >= (__int16)v38 )
return 0.0;
v38 = (__int16)v38;
v37 = (__int16)v37;
goto LABEL_56;
case 4:
v24 = _byteswap_ulong(*(_DWORD *)a2);
v25 = _byteswap_ulong(*(_DWORD *)a3);
v26 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v27 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v24 > v25 )
v25 = v24;
if ( v26 < v27 )
v27 = v26;
v10 = v27 <= v25;
v28 = v27 - v25;
if ( v10 )
return 0.0;
goto LABEL_31;
case 5:
v41 = fmaxf(COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a2)), COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a3)));
v42 = fminf(
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a2 + 1))),
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a3 + 1))));
if ( v41 >= v42 )
return 0.0;
v21 = (float)(v42 - v41);
goto LABEL_75;
case 6:
v22 = fmax(COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a2)), COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a3)));
v23 = fmin(
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a2 + 1))),
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a3 + 1))));
if ( v22 >= v23 )
return 0.0;
v21 = v23 - v22;
goto LABEL_75;
case 8:
v29 = (unsigned __int16)__ROL2__(*a2, 8);
v30 = (unsigned __int16)__ROL2__(*a3, 8);
v31 = (unsigned __int16)__ROL2__(a2[1], 8);
v32 = (unsigned __int16)__ROL2__(a3[1], 8);
if ( v29 > v30 )
v30 = v29;
if ( v31 < v32 )
v32 = v31;
v10 = v32 <= v30;
v28 = v32 - v30;
if ( v10 )
return 0.0;
LABEL_31:
v21 = (double)v28;
goto LABEL_75;
case 9:
v33 = _byteswap_ulong(*(_DWORD *)a2);
v34 = _byteswap_ulong(*(_DWORD *)a3);
v35 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v36 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v33 > v34 )
v34 = v33;
if ( v35 < v36 )
v36 = v35;
v10 = v36 <= v34;
v11 = v36 - v34;
if ( !v10 )
goto LABEL_37;
return 0.0;
case 0xA:
case 0xB:
v6 = _byteswap_uint64(*(_QWORD *)a2);
v7 = _byteswap_uint64(*(_QWORD *)a3);
v8 = _byteswap_uint64(*((_QWORD *)a2 + 1));
v9 = _byteswap_uint64(*((_QWORD *)a3 + 1));
if ( v6 > v7 )
v7 = v6;
if ( v8 < v9 )
v9 = v8;
v10 = v9 <= v7;
v11 = v9 - v7;
if ( v10 )
return 0.0;
LABEL_37:
v21 = (double)v11;
goto LABEL_75;
case 0xC:
v12 = *(unsigned __int8 *)a2 << 16;
v13 = *((unsigned __int8 *)a2 + 1) << 8;
v14 = *((unsigned __int8 *)a2 + 2);
if ( *(char *)a2 < 0 )
v15 = (v14 | v13) + v12 - 0x1000000;
else
v15 = v13 | v14 | v12;
v43 = *(unsigned __int8 *)a3 << 16;
v44 = *((unsigned __int8 *)a3 + 1) << 8;
v45 = *((unsigned __int8 *)a3 + 2);
if ( *(char *)a3 < 0 )
v46 = (v45 | v44) + v43 - 0x1000000;
else
v46 = v44 | v45 | v43;
v47 = *((unsigned __int8 *)a2 + 3) << 16;
v48 = *((unsigned __int8 *)a2 + 4) << 8;
v49 = *((unsigned __int8 *)a2 + 5);
if ( *((char *)a2 + 3) < 0 )
v50 = (v49 | v48) + v47 - 0x1000000;
else
v50 = v48 | v49 | v47;
v51 = *((unsigned __int8 *)a3 + 3) << 16;
v52 = *((unsigned __int8 *)a3 + 4) << 8;
v53 = *((unsigned __int8 *)a3 + 5);
if ( *((char *)a3 + 3) < 0 )
v54 = (v53 | v52) + v51 - 0x1000000;
else
v54 = v52 | v53 | v51;
if ( v15 > v46 )
v46 = v15;
if ( v50 < v54 )
v54 = v50;
v10 = v54 <= v46;
v55 = v54 - v46;
if ( v10 )
return 0.0;
v21 = (double)v55;
goto LABEL_75;
case 0xD:
v16 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a2 + 1), 8) | (*(unsigned __int8 *)a2 << 16);
v17 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a3 + 1), 8) | (*(unsigned __int8 *)a3 << 16);
v18 = (unsigned __int16)__ROL2__(a2[2], 8) | (*((unsigned __int8 *)a2 + 3) << 16);
v19 = (unsigned __int16)__ROL2__(a3[2], 8) | (*((unsigned __int8 *)a3 + 3) << 16);
if ( v16 > v17 )
v17 = v16;
if ( v18 < v19 )
v19 = v18;
v10 = v19 <= v17;
v20 = v19 - v17;
if ( v10 )
return 0.0;
v21 = (double)v20;
goto LABEL_75;
case 0xE:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (char)(*(_BYTE *)a2 + 1) < (char)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (char)v37 < (char)v38 )
{
v38 = (char)v38;
v37 = (char)v37;
LABEL_56:
v21 = (double)(v38 - v37);
LABEL_75:
result = result * v21;
v56 = 2 * (unsigned int)*((unsigned __int16 *)v4 - 2);
a2 = (_WORD *)((char *)a2 + v56);
a3 = (_WORD *)((char *)a3 + v56);
v4 += 64;
v10 = a4 <= (int)v56;
a4 -= v56;
if ( v10 )
return result;
continue;
}
return 0.0;
default:
return -1.0;
}
}
}
|
maria_rtree_overlapping_area:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
TEST ECX,ECX
JLE 0x0016e4ae
ADD RDI,0x18
MOVSD XMM0,qword ptr [0x001e0e38]
MOVSD XMM1,qword ptr [0x001e0e50]
LEA RAX,[0x1e1494]
LAB_0016e09e:
MOVZX R8D,byte ptr [RDI]
CMP R8,0xe
JA 0x0016e4c3
MOVSXD R8,dword ptr [RAX + R8*0x4]
ADD R8,RAX
switchD:
JMP R8
caseD_a:
MOV R9,qword ptr [RSI]
MOV R10,qword ptr [RSI + 0x8]
BSWAP R9
MOV R11,qword ptr [RDX]
MOV R8,qword ptr [RDX + 0x8]
BSWAP R11
BSWAP R10
BSWAP R8
CMP R9,R11
CMOVG R11,R9
CMP R10,R8
CMOVL R8,R10
SUB R8,R11
JG 0x0016e2a7
JMP 0x0016e4b8
caseD_c:
MOVZX R11D,byte ptr [RSI]
MOV R8D,R11D
SHL R8D,0x10
MOVZX R9D,byte ptr [RSI + 0x1]
SHL R9D,0x8
MOVZX R10D,byte ptr [RSI + 0x2]
TEST R11B,R11B
JS 0x0016e3cf
OR R8D,R10D
OR R8D,R9D
JMP 0x0016e3dc
caseD_d:
MOVZX R8D,word ptr [RSI + 0x1]
MOVZX R9D,word ptr [RSI + 0x4]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,byte ptr [RSI]
SHL R8D,0x10
OR R8D,R10D
MOVZX R10D,word ptr [RDX + 0x1]
MOVZX R11D,word ptr [RDX + 0x4]
ROL R10W,0x8
MOVZX R10D,R10W
MOVZX EBX,byte ptr [RDX]
SHL EBX,0x10
OR EBX,R10D
ROL R9W,0x8
MOVZX R9D,R9W
MOVZX R10D,byte ptr [RSI + 0x3]
SHL R10D,0x10
OR R10D,R9D
ROL R11W,0x8
MOVZX R11D,R11W
MOVZX R9D,byte ptr [RDX + 0x3]
SHL R9D,0x10
OR R9D,R11D
CMP R8D,EBX
CMOVA EBX,R8D
CMP R10D,R9D
CMOVC R9D,R10D
SUB R9D,EBX
JBE 0x0016e4b8
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9
JMP 0x0016e48d
caseD_6:
MOV R8,qword ptr [RSI]
MOV R9,qword ptr [RSI + 0x8]
BSWAP R8
MOVQ XMM3,R8
MOV R8,qword ptr [RDX]
BSWAP R8
MOV R10,qword ptr [RDX + 0x8]
MOVQ XMM2,R8
BSWAP R9
MAXSD XMM3,XMM2
MOVQ XMM2,R9
BSWAP R10
MOVQ XMM4,R10
MINSD XMM2,XMM4
UCOMISD XMM3,XMM2
JNC 0x0016e4b8
SUBSD XMM2,XMM3
JMP 0x0016e48d
caseD_4:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVG R11D,R9D
CMP R10D,R8D
CMOVL R8D,R10D
SUB R8D,R11D
JG 0x0016e269
JMP 0x0016e4b8
caseD_8:
MOVZX R8D,word ptr [RSI]
MOVZX R9D,word ptr [RSI + 0x2]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,word ptr [RDX]
ROL R8W,0x8
MOVZX R11D,word ptr [RDX + 0x2]
MOVZX EBX,R8W
ROL R9W,0x8
MOVZX R9D,R9W
ROL R11W,0x8
MOVZX R8D,R11W
CMP R10D,EBX
CMOVA EBX,R10D
CMP R9D,R8D
CMOVC R8D,R9D
SUB R8D,EBX
JBE 0x0016e4b8
LAB_0016e269:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8D
JMP 0x0016e48d
caseD_9:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVA R11D,R9D
CMP R10D,R8D
CMOVC R8D,R10D
SUB R8D,R11D
JBE 0x0016e4b8
LAB_0016e2a7:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8
JMP 0x0016e48d
caseD_e:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R9 + 0x1]
LEA R11D,[R8 + 0x1]
CMP R9B,R8B
CMOVG R8D,R9D
MOVZX R10D,R10B
MOVZX R9D,R11B
CMP R10B,R9B
CMOVL R9D,R10D
CMP R8B,R9B
JGE 0x0016e4b8
MOVSX R9D,R9B
MOVSX R8D,R8B
JMP 0x0016e370
caseD_3:
MOVZX R10D,word ptr [RSI]
MOVZX R11D,word ptr [RSI + 0x2]
ROL R10W,0x8
MOVZX R8D,word ptr [RDX]
MOVZX R9D,word ptr [RDX + 0x2]
ROL R8W,0x8
ROL R11W,0x8
ROL R9W,0x8
CMP R10W,R8W
CMOVG R8D,R10D
CMP R11W,R9W
CMOVL R9D,R11D
CMP R8W,R9W
JGE 0x0016e4b8
MOVSX R9D,R9W
MOVSX R8D,R8W
JMP 0x0016e370
caseD_2:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R8 + 0x1]
CMP R9B,R8B
CMOVA R8D,R9D
INC R9D
MOVZX R11D,R9B
MOVZX R9D,R10B
CMP R11B,R9B
CMOVC R9D,R11D
CMP R8B,R9B
JNC 0x0016e4b8
MOVZX R9D,R9B
MOVZX R8D,R8B
LAB_0016e370:
SUB R9D,R8D
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9D
JMP 0x0016e48d
caseD_5:
MOV R8D,dword ptr [RSI]
MOV R9D,dword ptr [RSI + 0x4]
BSWAP R8D
MOVD XMM2,R8D
MOV R8D,dword ptr [RDX]
MOV R10D,dword ptr [RDX + 0x4]
BSWAP R8D
MOVD XMM3,R8D
MAXSS XMM2,XMM3
BSWAP R9D
MOVD XMM3,R9D
BSWAP R10D
MOVD XMM4,R10D
MINSS XMM3,XMM4
UCOMISS XMM2,XMM3
JNC 0x0016e4b8
SUBSS XMM3,XMM2
XORPS XMM2,XMM2
CVTSS2SD XMM2,XMM3
JMP 0x0016e48d
LAB_0016e3cf:
OR R9D,R10D
ADD R8D,R9D
ADD R8D,0xff000000
LAB_0016e3dc:
MOVZX EBX,byte ptr [RDX]
MOV R9D,EBX
SHL R9D,0x10
MOVZX R10D,byte ptr [RDX + 0x1]
SHL R10D,0x8
MOVZX R11D,byte ptr [RDX + 0x2]
TEST BL,BL
JS 0x0016e400
OR R9D,R11D
OR R9D,R10D
JMP 0x0016e40d
LAB_0016e400:
OR R10D,R11D
ADD R9D,R10D
ADD R9D,0xff000000
LAB_0016e40d:
MOVZX R14D,byte ptr [RSI + 0x3]
MOV R10D,R14D
SHL R10D,0x10
MOVZX R11D,byte ptr [RSI + 0x4]
SHL R11D,0x8
MOVZX EBX,byte ptr [RSI + 0x5]
TEST R14B,R14B
JS 0x0016e433
OR R10D,EBX
OR R10D,R11D
JMP 0x0016e440
LAB_0016e433:
OR R11D,EBX
ADD R10D,R11D
ADD R10D,0xff000000
LAB_0016e440:
MOVZX R15D,byte ptr [RDX + 0x3]
MOV R11D,R15D
SHL R11D,0x10
MOVZX EBX,byte ptr [RDX + 0x4]
SHL EBX,0x8
MOVZX R14D,byte ptr [RDX + 0x5]
TEST R15B,R15B
JS 0x0016e465
OR R11D,R14D
OR R11D,EBX
JMP 0x0016e472
LAB_0016e465:
OR EBX,R14D
ADD R11D,EBX
ADD R11D,0xff000000
LAB_0016e472:
CMP R8D,R9D
CMOVG R9D,R8D
CMP R10D,R11D
CMOVL R11D,R10D
SUB R11D,R9D
JLE 0x0016e4b8
XORPS XMM2,XMM2
CVTSI2SD XMM2,R11D
LAB_0016e48d:
MULSD XMM0,XMM2
MOVZX R8D,word ptr [RDI + -0x4]
ADD R8D,R8D
ADD RSI,R8
ADD RDX,R8
ADD RDI,0x40
SUB ECX,R8D
JG 0x0016e09e
JMP 0x0016e4bc
LAB_0016e4ae:
MOVSD XMM0,qword ptr [0x001e0e38]
JMP 0x0016e4bc
LAB_0016e4b8:
XORPD XMM0,XMM0
caseD_0:
POP RBX
POP R14
POP R15
POP RBP
RET
caseD_1:
MOVAPD XMM0,XMM1
JMP 0x0016e4bc
|
double maria_rtree_overlapping_area(long param_1,ulong *param_2,ulong *param_3,int param_4)
{
ushort *puVar1;
byte bVar2;
byte bVar3;
ulong uVar4;
int1 *puVar5;
byte bVar6;
ushort uVar7;
uint uVar8;
int iVar9;
uint uVar10;
float fVar11;
float fVar12;
ulong uVar13;
double dVar14;
double dVar15;
char cVar16;
byte bVar17;
ushort uVar18;
uint uVar19;
ulong uVar20;
ushort uVar21;
uint uVar22;
uint uVar23;
float fVar24;
ulong uVar25;
ushort uVar26;
ulong uVar27;
bool bVar28;
double dVar29;
double dVar30;
dVar29 = DAT_001e0e38;
if (param_4 < 1) {
switchD_0016e0b3_caseD_0:
return dVar29;
}
puVar5 = (int1 *)(param_1 + 0x18);
do {
switch(*puVar5) {
case 0:
goto switchD_0016e0b3_caseD_0;
default:
return DAT_001e0e50;
case 2:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if (bVar3 < bVar2) {
bVar6 = bVar2;
}
bVar17 = bVar3 + 1;
if ((byte)(bVar2 + 1) < (byte)(bVar3 + 1)) {
bVar17 = bVar2 + 1;
}
if (bVar17 <= bVar6) {
return 0.0;
}
uVar19 = (uint)bVar17;
uVar10 = (uint)bVar6;
goto LAB_0016e370;
case 3:
uVar21 = (ushort)*param_2 << 8 | (ushort)*param_2 >> 8;
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar26 = *(ushort *)((long)param_2 + 2) << 8 | *(ushort *)((long)param_2 + 2) >> 8;
uVar18 = *(ushort *)((long)param_3 + 2) << 8 | *(ushort *)((long)param_3 + 2) >> 8;
if ((short)uVar7 < (short)uVar21) {
uVar7 = uVar21;
}
if ((short)uVar26 < (short)uVar18) {
uVar18 = uVar26;
}
if ((short)uVar18 <= (short)uVar7) {
return 0.0;
}
uVar19 = (uint)(short)uVar18;
uVar10 = (uint)(short)uVar7;
goto LAB_0016e370;
case 4:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if ((int)uVar10 < (int)uVar22) {
uVar10 = uVar22;
}
if ((int)uVar23 < (int)uVar19) {
uVar19 = uVar23;
}
iVar9 = uVar19 - uVar10;
if (iVar9 == 0 || (int)uVar19 < (int)uVar10) {
return 0.0;
}
goto LAB_0016e269;
case 5:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
fVar11 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
fVar12 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
if (fVar11 <= fVar12) {
fVar11 = fVar12;
}
fVar12 = (float)(uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 |
uVar19 << 0x18);
fVar24 = (float)(uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 |
uVar8 << 0x18);
if (fVar24 <= fVar12) {
fVar12 = fVar24;
}
if (fVar12 <= fVar11) {
return 0.0;
}
dVar30 = (double)(fVar12 - fVar11);
break;
case 6:
uVar13 = *param_2;
uVar25 = param_2[1];
dVar14 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = *param_3;
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = param_3[1];
dVar30 = (double)(uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 |
(uVar25 & 0xff00) << 0x28 | uVar25 << 0x38);
if (dVar14 <= dVar15) {
dVar14 = dVar15;
}
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
if (dVar15 <= dVar30) {
dVar30 = dVar15;
}
if (dVar30 <= dVar14) {
return 0.0;
}
dVar30 = dVar30 - dVar14;
break;
case 8:
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar19 = (uint)(ushort)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
uVar10 = (uint)uVar7;
if (uVar7 < uVar19) {
uVar10 = uVar19;
}
uVar8 = (uint)(ushort)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar19 = (uint)(ushort)(*(ushort *)((long)param_3 + 2) << 8 |
*(ushort *)((long)param_3 + 2) >> 8);
if (uVar8 < uVar19) {
uVar19 = uVar8;
}
iVar9 = uVar19 - uVar10;
if (uVar19 < uVar10 || iVar9 == 0) {
return 0.0;
}
LAB_0016e269:
dVar30 = (double)iVar9;
break;
case 9:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if (uVar10 < uVar22) {
uVar10 = uVar22;
}
if (uVar23 < uVar19) {
uVar19 = uVar23;
}
uVar25 = (ulong)(uVar19 - uVar10);
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
goto LAB_0016e2a7;
case 10:
case 0xb:
uVar13 = *param_2;
uVar25 = param_2[1];
uVar20 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar13 = *param_3;
uVar4 = param_3[1];
uVar27 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar25 = uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 | (uVar25 & 0xff00) << 0x28
| uVar25 << 0x38;
uVar13 = uVar4 >> 0x38 | (uVar4 & 0xff000000000000) >> 0x28 | (uVar4 & 0xff0000000000) >> 0x18
| (uVar4 & 0xff00000000) >> 8 | (uVar4 & 0xff000000) << 8 |
(uVar4 & 0xff0000) << 0x18 | (uVar4 & 0xff00) << 0x28 | uVar4 << 0x38;
if ((long)uVar27 < (long)uVar20) {
uVar27 = uVar20;
}
if ((long)uVar25 < (long)uVar13) {
uVar13 = uVar25;
}
uVar25 = uVar13 - uVar27;
if (uVar25 == 0 || (long)uVar13 < (long)uVar27) {
return 0.0;
}
LAB_0016e2a7:
dVar30 = (double)(long)uVar25;
break;
case 0xc:
uVar10 = (uint)(byte)*param_2 * 0x10000;
if ((char)(byte)*param_2 < '\0') {
uVar10 = (uVar10 + CONCAT11(*(byte *)((long)param_2 + 1),*(byte *)((long)param_2 + 2))) -
0x1000000;
}
else {
uVar10 = uVar10 | *(byte *)((long)param_2 + 2) | (uint)*(byte *)((long)param_2 + 1) << 8;
}
uVar19 = (uint)(byte)*param_3 * 0x10000;
if ((char)(byte)*param_3 < '\0') {
uVar19 = (uVar19 + CONCAT11(*(byte *)((long)param_3 + 1),*(byte *)((long)param_3 + 2))) -
0x1000000;
}
else {
uVar19 = uVar19 | *(byte *)((long)param_3 + 2) | (uint)*(byte *)((long)param_3 + 1) << 8;
}
uVar8 = (uint)*(byte *)((long)param_2 + 3) * 0x10000;
if ((char)*(byte *)((long)param_2 + 3) < '\0') {
uVar8 = (uVar8 + CONCAT11(*(byte *)((long)param_2 + 4),*(byte *)((long)param_2 + 5))) -
0x1000000;
}
else {
uVar8 = uVar8 | *(byte *)((long)param_2 + 5) | (uint)*(byte *)((long)param_2 + 4) << 8;
}
uVar22 = (uint)*(byte *)((long)param_3 + 3) * 0x10000;
if ((char)*(byte *)((long)param_3 + 3) < '\0') {
uVar22 = (uVar22 + CONCAT11(*(byte *)((long)param_3 + 4),*(byte *)((long)param_3 + 5))) -
0x1000000;
}
else {
uVar22 = uVar22 | *(byte *)((long)param_3 + 5) | (uint)*(byte *)((long)param_3 + 4) << 8;
}
if ((int)uVar19 < (int)uVar10) {
uVar19 = uVar10;
}
if ((int)uVar8 < (int)uVar22) {
uVar22 = uVar8;
}
if (uVar22 - uVar19 == 0 || (int)uVar22 < (int)uVar19) {
return 0.0;
}
dVar30 = (double)(int)(uVar22 - uVar19);
break;
case 0xd:
uVar8 = (uint)CONCAT12((byte)*param_2,
*(ushort *)((long)param_2 + 1) << 8 |
*(ushort *)((long)param_2 + 1) >> 8);
uVar10 = (uint)CONCAT12((byte)*param_3,
*(ushort *)((long)param_3 + 1) << 8 |
*(ushort *)((long)param_3 + 1) >> 8);
uVar22 = (uint)CONCAT12(*(byte *)((long)param_2 + 3),
*(ushort *)((long)param_2 + 4) << 8 |
*(ushort *)((long)param_2 + 4) >> 8);
uVar19 = (uint)CONCAT12(*(byte *)((long)param_3 + 3),
*(ushort *)((long)param_3 + 4) << 8 |
*(ushort *)((long)param_3 + 4) >> 8);
if (uVar10 < uVar8) {
uVar10 = uVar8;
}
if (uVar22 < uVar19) {
uVar19 = uVar22;
}
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
dVar30 = (double)(uVar19 - uVar10);
break;
case 0xe:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if ((char)bVar3 < (char)bVar2) {
bVar6 = bVar2;
}
cVar16 = bVar3 + 1;
if ((char)(bVar2 + 1) < (char)(bVar3 + 1)) {
cVar16 = bVar2 + 1;
}
if (cVar16 <= (char)bVar6) {
return 0.0;
}
uVar19 = (uint)cVar16;
uVar10 = (uint)(char)bVar6;
LAB_0016e370:
dVar30 = (double)(int)(uVar19 - uVar10);
}
dVar29 = dVar29 * dVar30;
puVar1 = (ushort *)(puVar5 + -4);
uVar10 = (uint)*puVar1 * 2;
param_2 = (ulong *)((long)param_2 + (ulong)uVar10);
param_3 = (ulong *)((long)param_3 + (ulong)uVar10);
puVar5 = puVar5 + 0x40;
bVar28 = SBORROW4(param_4,uVar10);
param_4 = param_4 + (uint)*puVar1 * -2;
if (param_4 == 0 || bVar28 != param_4 < 0) {
return dVar29;
}
} while( true );
}
|
|
13,907
|
sha256_update
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/sha256.h
|
static void sha256_update(SHA256_CTX *ctx, const void *_inp, size_t len)
{
size_t n;
const unsigned char *inp = _inp;
ctx->N += len;
if ((len != 0) & ((n = ctx->off) != 0)) {
size_t rem = sizeof(ctx->buf) - n;
if (rem > len) {
sha256_bcopy(ctx->buf + n, inp, len);
ctx->off += len;
return;
} else {
sha256_bcopy(ctx->buf + n, inp, rem);
inp += rem;
len -= rem;
sha256_block_data_order(ctx->h, ctx->buf, 1);
vec_zero(ctx->buf, sizeof(ctx->buf));
ctx->off = 0;
}
}
n = len / sizeof(ctx->buf);
if (n > 0) {
sha256_block_data_order(ctx->h, inp, n);
n *= sizeof(ctx->buf);
inp += n;
len -= n;
}
if (len)
sha256_bcopy(ctx->buf, inp, ctx->off = len);
}
|
O0
|
c
|
sha256_update:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x31dec
movl $0x40, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x31d82
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e3b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
jmp 0x31e5b
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
addq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3e3b0
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movl $0x1, %edx
callq 0x3c000
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x40, %esi
callq 0x23310
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
jmp 0x31dec
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x31e37
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3c000
movq -0x20(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x31e5b
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rdx, 0x68(%rax)
callq 0x3e3b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
sha256_update:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
add rcx, [rax+20h]
mov [rax+20h], rcx
cmp [rbp+var_18], 0
setnz al
and al, 1
movzx eax, al
mov rcx, [rbp+var_8]
mov rcx, [rcx+68h]
mov [rbp+var_20], rcx
cmp rcx, 0
setnz cl
and cl, 1
movzx ecx, cl
and eax, ecx
cmp eax, 0
jz loc_31DEC
mov eax, 40h ; '@'
sub rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jbe short loc_31D82
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
add rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
call blst_sha256_bcopy
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
add rcx, [rax+68h]
mov [rax+68h], rcx
jmp loc_31E5B
loc_31D82:
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
add rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
call blst_sha256_bcopy
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
add rsi, 28h ; '('
mov edx, 1
call blst_sha256_block_data_order
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov esi, 40h ; '@'
call vec_zero
mov rax, [rbp+var_8]
mov qword ptr [rax+68h], 0
jmp short $+2
loc_31DEC:
mov rax, [rbp+var_18]
shr rax, 6
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jbe short loc_31E37
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_20]
call blst_sha256_block_data_order
mov rax, [rbp+var_20]
shl rax, 6
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
loc_31E37:
cmp [rbp+var_18], 0
jz short loc_31E5B
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+68h], rdx
call blst_sha256_bcopy
loc_31E5B:
add rsp, 30h
pop rbp
retn
|
sha256_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
ADD RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x68]
MOV qword ptr [RBP + -0x20],RCX
CMP RCX,0x0
SETNZ CL
AND CL,0x1
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,0x0
JZ 0x00131dec
MOV EAX,0x40
SUB RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00131d82
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
ADD RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0013e3b0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
ADD RCX,qword ptr [RAX + 0x68]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00131e5b
LAB_00131d82:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
ADD RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0013e3b0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x28
MOV EDX,0x1
CALL 0x0013c000
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV ESI,0x40
CALL 0x00123310
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],0x0
JMP 0x00131dec
LAB_00131dec:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x6
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JBE 0x00131e37
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0013c000
MOV RAX,qword ptr [RBP + -0x20]
SHL RAX,0x6
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_00131e37:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00131e5b
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RDX
CALL 0x0013e3b0
LAB_00131e5b:
ADD RSP,0x30
POP RBP
RET
|
void sha256_update(long param_1,long param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
long local_30;
ulong local_20;
*(ulong *)(param_1 + 0x20) = param_3 + *(long *)(param_1 + 0x20);
lVar1 = *(long *)(param_1 + 0x68);
local_30 = param_2;
local_20 = param_3;
if (param_3 != 0 && lVar1 != 0) {
local_20 = 0x40 - lVar1;
if (param_3 < local_20) {
blst_sha256_bcopy(param_1 + 0x28 + lVar1,param_2,param_3);
*(ulong *)(param_1 + 0x68) = param_3 + *(long *)(param_1 + 0x68);
return;
}
blst_sha256_bcopy(param_1 + 0x28 + lVar1,param_2,local_20);
local_30 = local_20 + param_2;
local_20 = param_3 - local_20;
blst_sha256_block_data_order(param_1,param_1 + 0x28,1);
vec_zero(param_1 + 0x28,0x40);
*(int8 *)(param_1 + 0x68) = 0;
}
uVar2 = local_20 >> 6;
if (uVar2 != 0) {
blst_sha256_block_data_order(param_1,local_30,uVar2);
local_30 = uVar2 * 0x40 + local_30;
local_20 = local_20 + uVar2 * -0x40;
}
if (local_20 != 0) {
*(ulong *)(param_1 + 0x68) = local_20;
blst_sha256_bcopy(param_1 + 0x28,local_30);
}
return;
}
|
||
13,908
|
uf_zerofill_skip_zero
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((char*) to,(uint) (end-to));
else
{
end-=rec->space_length_bits;
decode_bytes(rec,bit_buff,to,end);
bzero((char*) end,rec->space_length_bits);
}
}
|
O0
|
c
|
uf_zerofill_skip_zero:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x42767
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x4278b
jmp 0x427a7
movq -0x10(%rbp), %rdi
callq 0x422c0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x427a7
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x281d0
jmp 0x427eb
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x429d0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x281d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
uf_zerofill_skip_zero:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_42767
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_4278B
jmp short loc_427A7
loc_42767:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_427A7
loc_4278B:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
jmp short loc_427EB
loc_427A7:
mov rax, [rbp+var_8]
mov ecx, [rax+1Ch]
mov rax, [rbp+var_20]
mov ecx, ecx
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes
mov rdi, [rbp+var_20]
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov edx, eax
xor esi, esi
call _memset
loc_427EB:
add rsp, 20h
pop rbp
retn
|
long long uf_zerofill_skip_zero(long long a1, int *a2, long long a3, long long a4)
{
int v4; // eax
int v5; // ecx
long long v8; // [rsp+0h] [rbp-20h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
LABEL_6:
v8 = a4 - *(unsigned int *)(a1 + 28);
decode_bytes(a1, a2, a3, v8);
return memset(v8, 0LL, *(unsigned int *)(a1 + 28));
}
|
uf_zerofill_skip_zero:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x00142767
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0014278b
JMP 0x001427a7
LAB_00142767:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001422c0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001427a7
LAB_0014278b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001281d0
JMP 0x001427eb
LAB_001427a7:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x1c]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001429d0
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001281d0
LAB_001427eb:
ADD RSP,0x20
POP RBP
RET
|
void uf_zerofill_skip_zero(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
void *__s;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
__s = (void *)(param_4 - (ulong)*(uint *)(param_1 + 0x1c));
decode_bytes(param_1,param_2,param_3,__s);
memset(__s,0,(ulong)*(uint *)(param_1 + 0x1c));
}
else {
memset(param_3,0,(ulong)(uint)((int)param_4 - (int)param_3));
}
return;
}
|
|
13,909
|
string_format[abi:cxx11](char const*, ...)
|
monkey531[P]llama/common/common.cpp
|
std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
}
|
O2
|
cpp
|
string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x23c3a
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x20(%rsp)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20d90
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x23cf2
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x28(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x28b08
movq (%r13), %rdi
leaq 0x10(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x20d90
cmpl %r15d, %eax
jne 0x23d13
movq 0x28(%rsp), %rsi
movl %r15d, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x23264
leaq 0x28(%rsp), %rdi
callq 0x36b32
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6a84c(%rip), %rdi # 0x8e545
leaq 0x6958c(%rip), %rdx # 0x8d28c
leaq 0x6a88a(%rip), %rcx # 0x8e591
movl $0x1b2, %esi # imm = 0x1B2
xorl %eax, %eax
callq 0x20af0
leaq 0x6a82b(%rip), %rdi # 0x8e545
leaq 0x6956b(%rip), %rdx # 0x8d28c
leaq 0x6a885(%rip), %rcx # 0x8e5ad
movl $0x1b5, %esi # imm = 0x1B5
xorl %eax, %eax
callq 0x20af0
jmp 0x23d36
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x36b32
movq %rbx, %rdi
callq 0x20b90
|
_Z13string_formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_23C3A
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_23C3A:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_118], rsi
mov rax, [rcx]
mov [rsp+138h+var_128], rax
mov rax, [rcx+8]
mov [rsp+138h+var_120], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_23CF2
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_110]
lea rdx, [rsp+138h+var_129]
mov rdi, r13
mov rsi, r12
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_128]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_23D13
mov rsi, [rsp+138h+var_110]
mov edx, r15d
lea rax, [rbx+10h]
mov [rbx], rax
add rdx, rsi
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)
lea rdi, [rsp+138h+var_110]
call _ZNSt12_Vector_baseIcSaIcEED2Ev; std::_Vector_base<char>::~_Vector_base()
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_23CF2:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 1B2h
xor eax, eax
call _ggml_abort
loc_23D13:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 1B5h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_23D36:
mov rbx, rax
lea rdi, [rsp+138h+var_110]
call _ZNSt12_Vector_baseIcSaIcEED2Ev; std::_Vector_base<char>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * string_format[abi:cxx11](
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
_BYTE *v18; // rsi
long long v20; // rbx
char v21; // [rsp+Fh] [rbp-129h] BYREF
_QWORD v22[3]; // [rsp+10h] [rbp-128h] BYREF
_QWORD v23[3]; // [rsp+28h] [rbp-110h] BYREF
_QWORD v24[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v25[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v26; // [rsp+70h] [rbp-C8h]
long long v27; // [rsp+78h] [rbp-C0h]
long long v28; // [rsp+80h] [rbp-B8h]
long long v29; // [rsp+88h] [rbp-B0h]
__m128 v30; // [rsp+90h] [rbp-A8h]
__m128 v31; // [rsp+A0h] [rbp-98h]
__m128 v32; // [rsp+B0h] [rbp-88h]
__m128 v33; // [rsp+C0h] [rbp-78h]
__m128 v34; // [rsp+D0h] [rbp-68h]
__m128 v35; // [rsp+E0h] [rbp-58h]
__m128 v36; // [rsp+F0h] [rbp-48h]
__m128 v37; // [rsp+100h] [rbp-38h]
v30 = a7;
v31 = a8;
v32 = a9;
v33 = a10;
v34 = a11;
v35 = a12;
v36 = a13;
v37 = a14;
v26 = a3;
v27 = a4;
v28 = a5;
v29 = a6;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v24[2] = v25;
v22[2] = v25;
v22[0] = 0x3000000010LL;
v22[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v24);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_5:
v20 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
std::_Vector_base<char>::~_Vector_base(v23);
_Unwind_Resume(v20);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(v23, v17, &v21);
if ( (unsigned int)vsnprintf(v23[0], v17, a2, v22) != v16 )
goto LABEL_5;
v18 = (_BYTE *)v23[0];
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v18, (long long)&v18[v16]);
std::_Vector_base<char>::~_Vector_base(v23);
return a1;
}
|
string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00123c3a
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_00123c3a:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x00120d90
CMP EAX,0x7fffffff
JNC 0x00123cf2
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x28]
LEA RDX,[RSP + 0xf]
MOV RDI,R13
MOV RSI,R12
CALL 0x00128b08
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x10]
MOV RSI,R12
MOV RDX,R14
CALL 0x00120d90
CMP EAX,R15D
JNZ 0x00123d13
MOV RSI,qword ptr [RSP + 0x28]
MOV EDX,R15D
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
ADD RDX,RSI
LAB_00123ccc:
MOV RDI,RBX
CALL 0x00123264
LAB_00123cd4:
LEA RDI,[RSP + 0x28]
CALL 0x00136b32
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00123cf2:
LEA RDI,[0x18e545]
LEA RDX,[0x18d28c]
LEA RCX,[0x18e591]
MOV ESI,0x1b2
XOR EAX,EAX
CALL 0x00120af0
LAB_00123d13:
LEA RDI,[0x18e545]
LEA RDX,[0x18d28c]
LEA RCX,[0x18e5ad]
MOV ESI,0x1b5
XOR EAX,EAX
CALL 0x00120af0
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
allocator local_129;
int8 local_128;
int1 *local_120;
int1 *local_118;
char *local_110 [3];
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_118 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_120 = &stack0x00000008;
local_128 = 0x3000000010;
local_f0 = local_120;
local_e8 = local_118;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector
((vector<char,std::allocator<char>> *)local_110,(ulong)(uVar1 + 1),&local_129);
uVar2 = vsnprintf(local_110[0],(ulong)(uVar1 + 1),in_RSI,&local_128);
if (uVar2 == uVar1) {
*(char **)param_1 = param_1 + 0x10;
/* try { // try from 00123ccc to 00123cd3 has its CatchHandler @ 00123d34 */
std::__cxx11::string::_M_construct<char_const*>(param_1,local_110[0],local_110[0] + uVar1);
std::_Vector_base<char,std::allocator<char>>::~_Vector_base
((_Vector_base<char,std::allocator<char>> *)local_110);
return param_1;
}
/* try { // try from 00123d13 to 00123d33 has its CatchHandler @ 00123d36 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b5,
"GGML_ASSERT(%s) failed","size2 == size");
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
|
|
13,910
|
WriteBuffer::write_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
untodesu[P]voxelius/core/buffer.cc
|
void WriteBuffer::write_string(const std::string &value)
{
const std::size_t size = cxpr::min<std::size_t>(UINT16_MAX, value.size());
write_UI16(static_cast<std::uint16_t>(size));
for(std::size_t i = 0; i < size; m_vector.push_back(static_cast<std::byte>(value[i++])));
}
|
O1
|
cpp
|
WriteBuffer::write_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rsi), %r15
movl $0xffff, %ebx # imm = 0xFFFF
cmpq %rbx, %r15
cmovbq %r15, %rbx
addq $0x8, %r14
movb %bh, 0xe(%rsp)
leaq 0xe(%rsp), %rsi
movq %r14, %rdi
callq 0x4ff80
leaq 0xf(%rsp), %rsi
movb %bl, (%rsi)
movq %r14, %rdi
callq 0x4ff80
testq %r15, %r15
je 0x4fcbb
xorl %r13d, %r13d
leaq 0xd(%rsp), %r15
movq (%r12), %rax
movb (%rax,%r13), %al
incq %r13
movb %al, 0xd(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4ff80
cmpq %r13, %rbx
jne 0x4fc9c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN11WriteBuffer12write_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rsi
mov r14, rdi
mov r15, [rsi+8]
mov ebx, 0FFFFh
cmp r15, rbx
cmovb rbx, r15
add r14, 8
mov [rsp+38h+var_2A], bh
lea rsi, [rsp+38h+var_2A]
mov rdi, r14
call _ZNSt6vectorISt4byteSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<std::byte>::emplace_back<std::byte>(std::byte &&)
lea rsi, [rsp+38h+var_29]
mov [rsi], bl
mov rdi, r14
call _ZNSt6vectorISt4byteSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<std::byte>::emplace_back<std::byte>(std::byte &&)
test r15, r15
jz short loc_4FCBB
xor r13d, r13d
lea r15, [rsp+38h+var_2B]
loc_4FC9C:
mov rax, [r12]
mov al, [rax+r13]
inc r13
mov [rsp+38h+var_2B], al
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4byteSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<std::byte>::emplace_back<std::byte>(std::byte &&)
cmp rbx, r13
jnz short loc_4FC9C
loc_4FCBB:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long WriteBuffer::write_string(long long a1, _QWORD *a2)
{
unsigned long long v2; // r15
long long v3; // rbx
long long result; // rax
long long v5; // r13
char v6; // al
char v7; // [rsp+Dh] [rbp-2Bh] BYREF
char v8; // [rsp+Eh] [rbp-2Ah] BYREF
_BYTE v9[41]; // [rsp+Fh] [rbp-29h] BYREF
v2 = a2[1];
v3 = 0xFFFFLL;
if ( v2 < 0xFFFF )
v3 = a2[1];
v8 = BYTE1(v3);
std::vector<std::byte>::emplace_back<std::byte>(a1 + 8, &v8);
v9[0] = v3;
result = std::vector<std::byte>::emplace_back<std::byte>(a1 + 8, v9);
if ( v2 )
{
v5 = 0LL;
do
{
v6 = *(_BYTE *)(*a2 + v5++);
v7 = v6;
result = std::vector<std::byte>::emplace_back<std::byte>(a1 + 8, &v7);
}
while ( v3 != v5 );
}
return result;
}
|
write_string:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RSI
MOV R14,RDI
MOV R15,qword ptr [RSI + 0x8]
MOV EBX,0xffff
CMP R15,RBX
CMOVC RBX,R15
ADD R14,0x8
MOV byte ptr [RSP + 0xe],BH
LEA RSI,[RSP + 0xe]
MOV RDI,R14
CALL 0x0014ff80
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],BL
MOV RDI,R14
CALL 0x0014ff80
TEST R15,R15
JZ 0x0014fcbb
XOR R13D,R13D
LEA R15,[RSP + 0xd]
LAB_0014fc9c:
MOV RAX,qword ptr [R12]
MOV AL,byte ptr [RAX + R13*0x1]
INC R13
MOV byte ptr [RSP + 0xd],AL
MOV RDI,R14
MOV RSI,R15
CALL 0x0014ff80
CMP RBX,R13
JNZ 0x0014fc9c
LAB_0014fcbb:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* WriteBuffer::write_string(std::__cxx11::string const&) */
void __thiscall WriteBuffer::write_string(WriteBuffer *this,string *param_1)
{
ulong uVar1;
ulong uVar2;
vector<std::byte,std::allocator<std::byte>> *this_00;
byte local_2b;
byte local_2a;
byte local_29;
uVar2 = *(ulong *)(param_1 + 8);
uVar1 = 0xffff;
if (uVar2 < 0xffff) {
uVar1 = uVar2;
}
this_00 = (vector<std::byte,std::allocator<std::byte>> *)(this + 8);
local_2a = SUB81(uVar1 >> 8,0);
std::vector<std::byte,std::allocator<std::byte>>::emplace_back<std::byte>(this_00,&local_2a);
local_29 = SUB81(uVar1,0);
std::vector<std::byte,std::allocator<std::byte>>::emplace_back<std::byte>(this_00,&local_29);
if (uVar2 != 0) {
uVar2 = 0;
do {
local_2b = *(byte *)(*(long *)param_1 + uVar2);
uVar2 = uVar2 + 1;
std::vector<std::byte,std::allocator<std::byte>>::emplace_back<std::byte>(this_00,&local_2b);
} while (uVar1 != uVar2);
}
return;
}
|
|
13,911
|
FileDescriptor::set_blocking(bool)
|
minnow/util/file_descriptor.cc
|
void FileDescriptor::set_blocking( bool blocking )
{
int flags = CheckSystemCall( "fcntl", fcntl( fd_num(), F_GETFL ) ); // NOLINT(*-vararg)
if ( blocking ) {
flags ^= ( flags & O_NONBLOCK ); // NOLINT(*-bitwise)
} else {
flags |= O_NONBLOCK; // NOLINT(*-bitwise)
}
CheckSystemCall( "fcntl", fcntl( fd_num(), F_SETFL, flags ) ); // NOLINT(*-vararg)
internal_fd_->non_blocking_ = not blocking;
}
|
O0
|
cpp
|
FileDescriptor::set_blocking(bool):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x4c5e(%rip), %rsi # 0x1b6e5
callq 0xed90
movq -0x38(%rbp), %rdi
callq 0x12410
movl %eax, %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x51b0
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x17680
movl %eax, -0x10(%rbp)
testb $0x1, -0x9(%rbp)
je 0x16acf
movl -0x10(%rbp), %eax
andl $0x800, %eax # imm = 0x800
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x16ada
movl -0x10(%rbp), %eax
orl $0x800, %eax # imm = 0x800
movl %eax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x4c00(%rip), %rsi # 0x1b6e5
callq 0xed90
movq -0x38(%rbp), %rdi
callq 0x12410
movl %eax, %edi
movl -0x10(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x51b0
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x17680
movq -0x38(%rbp), %rdi
movb -0x9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
callq 0xd170
movb -0x39(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x6(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN14FileDescriptor12set_blockingEb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, sil
mov [rbp+var_8], rdi
and al, 1
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
lea rdi, [rbp+var_20]
lea rsi, aFcntl_0; "fcntl"
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_38]; this
call _ZNK14FileDescriptor6fd_numEv; FileDescriptor::fd_num(void)
mov edi, eax
mov esi, 3
mov al, 0
call _fcntl
mov rdi, [rbp+var_38]
mov ecx, eax
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call _ZNK14FileDescriptor15CheckSystemCallIiEET_St17basic_string_viewIcSt11char_traitsIcEES1_; FileDescriptor::CheckSystemCall<int>(std::string_view,int)
mov [rbp+var_10], eax
test [rbp+var_9], 1
jz short loc_16ACF
mov eax, [rbp+var_10]
and eax, 800h
xor eax, [rbp+var_10]
mov [rbp+var_10], eax
jmp short loc_16ADA
loc_16ACF:
mov eax, [rbp+var_10]
or eax, 800h
mov [rbp+var_10], eax
loc_16ADA:
lea rdi, [rbp+var_30]
lea rsi, aFcntl_0; "fcntl"
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rdi, [rbp+var_38]; this
call _ZNK14FileDescriptor6fd_numEv; FileDescriptor::fd_num(void)
mov edi, eax
mov edx, [rbp+var_10]
mov esi, 4
mov al, 0
call _fcntl
mov rdi, [rbp+var_38]
mov ecx, eax
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
call _ZNK14FileDescriptor15CheckSystemCallIiEET_St17basic_string_viewIcSt11char_traitsIcEES1_; FileDescriptor::CheckSystemCall<int>(std::string_view,int)
mov rdi, [rbp+var_38]
mov al, [rbp+var_9]
xor al, 0FFh
mov [rbp+var_39], al
call _ZNKSt19__shared_ptr_accessIN14FileDescriptor9FDWrapperELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov cl, [rbp+var_39]
and cl, 1
mov [rax+6], cl
add rsp, 40h
pop rbp
retn
|
long long FileDescriptor::set_blocking(FileDescriptor *this, char a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
long long result; // rax
char v7; // [rsp+7h] [rbp-39h]
long long v8[2]; // [rsp+10h] [rbp-30h] BYREF
long long v9[2]; // [rsp+20h] [rbp-20h] BYREF
int v10; // [rsp+30h] [rbp-10h]
char v11; // [rsp+37h] [rbp-9h]
FileDescriptor *v12; // [rsp+38h] [rbp-8h]
v12 = this;
v11 = a2 & 1;
std::string_view::basic_string_view(v9, (long long)"fcntl");
v2 = FileDescriptor::fd_num(this);
v3 = fcntl(v2, 3LL);
v10 = FileDescriptor::CheckSystemCall<int>(this, v9[0], v9[1], v3);
if ( (v11 & 1) != 0 )
v10 ^= v10 & 0x800;
else
v10 |= 0x800u;
std::string_view::basic_string_view(v8, (long long)"fcntl");
v4 = FileDescriptor::fd_num(this);
v5 = fcntl(v4, 4LL);
FileDescriptor::CheckSystemCall<int>(this, v8[0], v8[1], v5);
v7 = ~v11;
result = std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>::operator->((long long)this);
*(_BYTE *)(result + 6) = v7 & 1;
return result;
}
|
set_blocking:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
AND AL,0x1
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
LEA RDI,[RBP + -0x20]
LEA RSI,[0x11b6e5]
CALL 0x0010ed90
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00112410
MOV EDI,EAX
MOV ESI,0x3
MOV AL,0x0
CALL 0x001051b0
MOV RDI,qword ptr [RBP + -0x38]
MOV ECX,EAX
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00117680
MOV dword ptr [RBP + -0x10],EAX
TEST byte ptr [RBP + -0x9],0x1
JZ 0x00116acf
MOV EAX,dword ptr [RBP + -0x10]
AND EAX,0x800
XOR EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00116ada
LAB_00116acf:
MOV EAX,dword ptr [RBP + -0x10]
OR EAX,0x800
MOV dword ptr [RBP + -0x10],EAX
LAB_00116ada:
LEA RDI,[RBP + -0x30]
LEA RSI,[0x11b6e5]
CALL 0x0010ed90
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00112410
MOV EDI,EAX
MOV EDX,dword ptr [RBP + -0x10]
MOV ESI,0x4
MOV AL,0x0
CALL 0x001051b0
MOV RDI,qword ptr [RBP + -0x38]
MOV ECX,EAX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00117680
MOV RDI,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RBP + -0x9]
XOR AL,0xff
MOV byte ptr [RBP + -0x39],AL
CALL 0x0010d170
MOV CL,byte ptr [RBP + -0x39]
AND CL,0x1
MOV byte ptr [RAX + 0x6],CL
ADD RSP,0x40
POP RBP
RET
|
/* FileDescriptor::set_blocking(bool) */
void __thiscall FileDescriptor::set_blocking(FileDescriptor *this,bool param_1)
{
byte bVar1;
int iVar2;
long lVar3;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
uint local_18;
byte local_11;
FileDescriptor *local_10;
local_11 = param_1;
local_10 = this;
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_28,"fcntl");
iVar2 = fd_num(this);
iVar2 = fcntl(iVar2,3);
local_18 = CheckSystemCall<int>(this,local_28,local_20,iVar2);
if ((local_11 & 1) == 0) {
local_18 = local_18 | 0x800;
}
else {
local_18 = local_18 & 0x800 ^ local_18;
}
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_38,"fcntl");
iVar2 = fd_num(this);
iVar2 = fcntl(iVar2,4,(ulong)local_18);
CheckSystemCall<int>(this,local_38,local_30,iVar2);
bVar1 = local_11 ^ 0xff;
lVar3 = std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>
*)this);
*(byte *)(lVar3 + 6) = bVar1 & 1;
return;
}
|
|
13,912
|
mysql_stmt_execute
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt)
{
MYSQL *mysql= stmt->mysql;
char *request;
int ret;
size_t request_len= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_PREPARED)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->param_count && !stmt->bind_param_done)
{
SET_CLIENT_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state == MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler = _mysql_stmt_use_result;
stmt->default_rset_handler(stmt);
}
if (stmt->state > MYSQL_STMT_WAITING_USE_OR_STORE && stmt->state < MYSQL_STMT_FETCH_DONE && !stmt->result.data)
{
if (!stmt->cursor_exists)
do {
stmt->mysql->methods->db_stmt_flush_unbuffered(stmt);
} while(mysql_stmt_more_results(stmt));
stmt->state= MYSQL_STMT_PREPARED;
stmt->mysql->status= MYSQL_STATUS_READY;
}
/* clear data, in case mysql_stmt_store_result was called */
if (stmt->result.data)
{
ma_free_root(&stmt->result.alloc, MYF(MY_KEEP_PREALLOC));
stmt->result_cursor= stmt->result.data= 0;
}
/* CONC-344: set row count to zero */
stmt->result.rows= 0;
request= (char *)ma_stmt_execute_generate_request(stmt, &request_len, 0);
if (!request)
return 1;
ret= stmt->mysql->methods->db_command(mysql,
stmt->array_size > 0 ? COM_STMT_BULK_EXECUTE : COM_STMT_EXECUTE,
request, request_len, 1, stmt);
if (request)
free(request);
if (ret)
{
UPDATE_STMT_ERROR(stmt);
return(1);
}
if (mysql->net.extension->multi_status > COM_MULTI_OFF ||
mysql->options.extension->skip_read_response)
return(0);
return(mthd_stmt_read_execute_response(stmt));
}
|
O3
|
c
|
mysql_stmt_execute:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq $0x0, -0x30(%rbp)
testq %r14, %r14
je 0x21cfa
movl 0x50(%rbx), %eax
testl %eax, %eax
je 0x21d51
cmpl $0x0, 0x64(%rbx)
je 0x21b95
cmpb $0x0, 0xe9(%rbx)
je 0x21e03
cmpl $0x3, %eax
jne 0x21bb3
leaq -0x31b1(%rip), %rax # 0x1e9f0
movq %rax, 0x358(%rbx)
movq %rbx, %rdi
callq 0x1e9f0
movl 0x50(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0x21c03
cmpq $0x0, 0x80(%rbx)
jne 0x21c03
cmpb $0x0, 0x338(%rbx)
movq 0x38(%rbx), %rax
jne 0x21bf2
movq 0x4d0(%rax), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movq 0x38(%rbx), %rax
movzwl 0x380(%rax), %ecx
testl $0x1008, %ecx # imm = 0x1008
jne 0x21bd2
movl $0x1, 0x50(%rbx)
movl $0x0, 0x488(%rax)
cmpq $0x0, 0x80(%rbx)
je 0x21c2e
leaq 0x90(%rbx), %rdi
movl $0x1, %esi
callq 0x1de3f
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movq %rax, 0xe0(%rbx)
movq $0x0, 0xc8(%rbx)
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1fa47
testq %rax, %rax
je 0x21deb
movq %rax, %r12
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
cmpl $0x0, 0x368(%rbx)
movl $0x17, %ecx
movl $0xfa, %esi
cmovel %ecx, %esi
movq -0x30(%rbp), %rcx
movl $0x1, %r15d
movq %r14, %rdi
movq %r12, %rdx
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
movl %eax, %r13d
movq %r12, %rdi
callq 0x13570
testl %r13d, %r13d
je 0x21e4c
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
jmp 0x21df1
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x26d4e(%rip), %rax # 0x48a60
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x26d39(%rip), %rax # 0x48a70
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
jmp 0x21deb
movl $0x7de, %eax # imm = 0x7DE
movl %eax, 0x90(%r14)
leaq 0x297(%r14), %rdi
leaq 0x26cf5(%rip), %r13 # 0x48a60
movq (%r13), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x26cdf(%rip), %r12 # 0x48a70
movq 0x70(%r12), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r15b, 0x296(%r14)
movl $0x7de, %eax # imm = 0x7DE
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
movq (%r13), %rsi
movl $0x5, %edx
callq 0x13220
movb %r15b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movq 0x70(%r12), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r15b, 0x30b(%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7ef, 0x108(%rbx) # imm = 0x7EF
leaq 0x30d(%rbx), %rdi
leaq 0x26c45(%rip), %rax # 0x48a60
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x26c30(%rip), %rax # 0x48a70
movq 0xf8(%rax), %rsi
jmp 0x21d3b
movq 0x2a0(%r14), %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
jne 0x21df1
movq 0x480(%r14), %rax
cmpb $0x0, 0x148(%rax)
jne 0x21df1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21553
|
mysql_stmt_execute:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+38h]
mov [rbp+var_30], 0
test r14, r14
jz loc_21CFA
mov eax, [rbx+50h]
test eax, eax
jz loc_21D51
cmp dword ptr [rbx+64h], 0
jz short loc_21B95
cmp byte ptr [rbx+0E9h], 0
jz loc_21E03
loc_21B95:
cmp eax, 3
jnz short loc_21BB3
lea rax, _mysql_stmt_use_result
mov [rbx+358h], rax
mov rdi, rbx
call _mysql_stmt_use_result
mov eax, [rbx+50h]
loc_21BB3:
and eax, 0FFFFFFFEh
cmp eax, 4
jnz short loc_21C03
cmp qword ptr [rbx+80h], 0
jnz short loc_21C03
cmp byte ptr [rbx+338h], 0
mov rax, [rbx+38h]
jnz short loc_21BF2
loc_21BD2:
mov rax, [rax+4D0h]
mov rdi, rbx
call qword ptr [rax+78h]
mov rax, [rbx+38h]
movzx ecx, word ptr [rax+380h]
test ecx, 1008h
jnz short loc_21BD2
loc_21BF2:
mov dword ptr [rbx+50h], 1
mov dword ptr [rax+488h], 0
loc_21C03:
cmp qword ptr [rbx+80h], 0
jz short loc_21C2E
lea rdi, [rbx+90h]
mov esi, 1
call ma_free_root
xor eax, eax
mov [rbx+80h], rax
mov [rbx+0E0h], rax
loc_21C2E:
mov qword ptr [rbx+0C8h], 0
lea rsi, [rbp+var_30]
mov rdi, rbx
xor edx, edx
call ma_stmt_execute_generate_request
test rax, rax
jz loc_21DEB
mov r12, rax
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
cmp dword ptr [rbx+368h], 0
mov ecx, 17h
mov esi, 0FAh
cmovz esi, ecx
mov rcx, [rbp+var_30]
mov r15d, 1
mov rdi, r14
mov rdx, r12
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
mov r13d, eax
mov rdi, r12
call _free
test r13d, r13d
jz loc_21E4C
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
jmp loc_21DF1
loc_21CFA:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
loc_21D3B:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
jmp loc_21DEB
loc_21D51:
mov eax, 7DEh
mov [r14+90h], eax
lea rdi, [r14+297h]
lea r13, SQLSTATE_UNKNOWN
mov rsi, [r13+0]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+29Ch], r15b
lea rdi, [r14+97h]
lea r12, client_errors
mov rsi, [r12+70h]
mov edx, 1FFh
call _strncpy
mov [r14+296h], r15b
mov eax, 7DEh
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
mov rsi, [r13+0]
mov edx, 5
call _strncpy
mov [rbx+312h], r15b
lea rdi, [rbx+10Ch]
mov rsi, [r12+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r15b
loc_21DEB:
mov r15d, 1
loc_21DF1:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_21E03:
mov dword ptr [rbx+108h], 7EFh
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+0F8h]
jmp loc_21D3B
loc_21E4C:
mov rax, [r14+2A0h]
xor r15d, r15d
cmp dword ptr [rax], 0
jnz short loc_21DF1
mov rax, [r14+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_21DF1
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp mthd_stmt_read_execute_response
|
long long mysql_stmt_execute(long long a1)
{
long long v1; // rax
long long v3; // r14
int v4; // eax
long long v5; // rax
_BYTE *request; // rax
_BYTE *v7; // r12
long long v8; // rsi
unsigned int v9; // r15d
int v10; // r13d
long long v11; // rsi
long long v12; // rdi
char *v13; // rsi
long long v15[6]; // [rsp+0h] [rbp-30h] BYREF
v15[0] = v1;
v3 = *(_QWORD *)(a1 + 56);
v15[0] = 0LL;
if ( !v3 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v12 = a1 + 268;
v13 = client_errors[13];
LABEL_20:
strncpy(v12, v13, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
v4 = *(_DWORD *)(a1 + 80);
if ( !v4 )
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(v3 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v3 + 668) = 0;
strncpy(v3 + 151, client_errors[14], 511LL);
*(_BYTE *)(v3 + 662) = 0;
*(_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 1;
}
if ( *(_DWORD *)(a1 + 100) && !*(_BYTE *)(a1 + 233) )
{
*(_DWORD *)(a1 + 264) = 2031;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v12 = a1 + 268;
v13 = client_errors[31];
goto LABEL_20;
}
if ( v4 == 3 )
{
*(_QWORD *)(a1 + 856) = mysql_stmt_use_result;
mysql_stmt_use_result(a1);
v4 = *(_DWORD *)(a1 + 80);
}
if ( (v4 & 0xFFFFFFFE) == 4 && !*(_QWORD *)(a1 + 128) )
{
v5 = *(_QWORD *)(a1 + 56);
if ( !*(_BYTE *)(a1 + 824) )
{
do
{
(*(void ( **)(long long))(*(_QWORD *)(v5 + 1232) + 120LL))(a1);
v5 = *(_QWORD *)(a1 + 56);
}
while ( (*(_WORD *)(v5 + 896) & 0x1008) != 0 );
}
*(_DWORD *)(a1 + 80) = 1;
*(_DWORD *)(v5 + 1160) = 0;
}
if ( *(_QWORD *)(a1 + 128) )
{
ma_free_root(a1 + 144, 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 224) = 0LL;
}
*(_QWORD *)(a1 + 200) = 0LL;
request = ma_stmt_execute_generate_request(a1, v15, 0);
if ( !request )
return 1;
v7 = request;
v8 = 250LL;
if ( !*(_DWORD *)(a1 + 872) )
v8 = 23LL;
v9 = 1;
v10 = (*(long long ( **)(long long, long long, _BYTE *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
v3,
v8,
request,
v15[0],
1LL,
a1);
free(v7);
if ( v10 )
{
v11 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v11 + 144);
strncpy(a1 + 781, v11 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v9;
}
v9 = 0;
if ( **(_DWORD **)(v3 + 672) || *(_BYTE *)(*(_QWORD *)(v3 + 1152) + 328LL) )
return v9;
return mthd_stmt_read_execute_response(a1);
}
|
mysql_stmt_execute:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x38]
MOV qword ptr [RBP + -0x30],0x0
TEST R14,R14
JZ 0x00121cfa
MOV EAX,dword ptr [RBX + 0x50]
TEST EAX,EAX
JZ 0x00121d51
CMP dword ptr [RBX + 0x64],0x0
JZ 0x00121b95
CMP byte ptr [RBX + 0xe9],0x0
JZ 0x00121e03
LAB_00121b95:
CMP EAX,0x3
JNZ 0x00121bb3
LEA RAX,[0x11e9f0]
MOV qword ptr [RBX + 0x358],RAX
MOV RDI,RBX
CALL 0x0011e9f0
MOV EAX,dword ptr [RBX + 0x50]
LAB_00121bb3:
AND EAX,0xfffffffe
CMP EAX,0x4
JNZ 0x00121c03
CMP qword ptr [RBX + 0x80],0x0
JNZ 0x00121c03
CMP byte ptr [RBX + 0x338],0x0
MOV RAX,qword ptr [RBX + 0x38]
JNZ 0x00121bf2
LAB_00121bd2:
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBX + 0x38]
MOVZX ECX,word ptr [RAX + 0x380]
TEST ECX,0x1008
JNZ 0x00121bd2
LAB_00121bf2:
MOV dword ptr [RBX + 0x50],0x1
MOV dword ptr [RAX + 0x488],0x0
LAB_00121c03:
CMP qword ptr [RBX + 0x80],0x0
JZ 0x00121c2e
LEA RDI,[RBX + 0x90]
MOV ESI,0x1
CALL 0x0011de3f
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0xe0],RAX
LAB_00121c2e:
MOV qword ptr [RBX + 0xc8],0x0
LEA RSI,[RBP + -0x30]
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0011fa47
TEST RAX,RAX
JZ 0x00121deb
MOV R12,RAX
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
CMP dword ptr [RBX + 0x368],0x0
MOV ECX,0x17
MOV ESI,0xfa
CMOVZ ESI,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOV R15D,0x1
MOV RDI,R14
MOV RDX,R12
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
MOV R13D,EAX
MOV RDI,R12
CALL 0x00113570
TEST R13D,R13D
JZ 0x00121e4c
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
JMP 0x00121df1
LAB_00121cfa:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x148a60]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x148a70]
MOV RSI,qword ptr [RAX + 0x68]
LAB_00121d3b:
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
JMP 0x00121deb
LAB_00121d51:
MOV EAX,0x7de
MOV dword ptr [R14 + 0x90],EAX
LEA RDI,[R14 + 0x297]
LEA R13,[0x148a60]
MOV RSI,qword ptr [R13]
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [R14 + 0x29c],R15B
LEA RDI,[R14 + 0x97]
LEA R12,[0x148a70]
MOV RSI,qword ptr [R12 + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [R14 + 0x296],R15B
MOV EAX,0x7de
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
MOV RSI,qword ptr [R13]
MOV EDX,0x5
CALL 0x00113220
MOV byte ptr [RBX + 0x312],R15B
LEA RDI,[RBX + 0x10c]
MOV RSI,qword ptr [R12 + 0x70]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R15B
LAB_00121deb:
MOV R15D,0x1
LAB_00121df1:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00121e03:
MOV dword ptr [RBX + 0x108],0x7ef
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x148a60]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x148a70]
MOV RSI,qword ptr [RAX + 0xf8]
JMP 0x00121d3b
LAB_00121e4c:
MOV RAX,qword ptr [R14 + 0x2a0]
XOR R15D,R15D
CMP dword ptr [RAX],0x0
JNZ 0x00121df1
MOV RAX,qword ptr [R14 + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x00121df1
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00121553
|
int8 mysql_stmt_execute(long param_1)
{
long lVar1;
uint uVar2;
int iVar3;
long lVar4;
void *__ptr;
int8 uVar5;
char *__src;
int8 local_38;
lVar1 = *(long *)(param_1 + 0x38);
local_38 = 0;
if (lVar1 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_00148ad8;
}
else {
uVar2 = *(uint *)(param_1 + 0x50);
if (uVar2 == 0) {
*(int4 *)(lVar1 + 0x90) = 0x7de;
strncpy((char *)(lVar1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(lVar1 + 0x29c) = 0;
strncpy((char *)(lVar1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_00148ae0,0x1ff);
*(int1 *)(lVar1 + 0x296) = 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_00148ae0,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
if ((*(int *)(param_1 + 100) == 0) || (*(char *)(param_1 + 0xe9) != '\0')) {
if (uVar2 == 3) {
*(code **)(param_1 + 0x358) = _mysql_stmt_use_result;
_mysql_stmt_use_result(param_1);
uVar2 = *(uint *)(param_1 + 0x50);
}
if (((uVar2 & 0xfffffffe) == 4) && (*(long *)(param_1 + 0x80) == 0)) {
lVar4 = *(long *)(param_1 + 0x38);
if (*(char *)(param_1 + 0x338) == '\0') {
do {
(**(code **)(*(long *)(lVar4 + 0x4d0) + 0x78))(param_1);
lVar4 = *(long *)(param_1 + 0x38);
} while ((*(ushort *)(lVar4 + 0x380) & 0x1008) != 0);
}
*(int4 *)(param_1 + 0x50) = 1;
*(int4 *)(lVar4 + 0x488) = 0;
}
if (*(long *)(param_1 + 0x80) != 0) {
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 0xe0) = 0;
}
*(int8 *)(param_1 + 200) = 0;
__ptr = (void *)ma_stmt_execute_generate_request(param_1,&local_38,0);
if (__ptr == (void *)0x0) {
return 1;
}
uVar5 = 0xfa;
if (*(int *)(param_1 + 0x368) == 0) {
uVar5 = 0x17;
}
iVar3 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(lVar1,uVar5,__ptr,local_38,1,param_1);
free(__ptr);
if (iVar3 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(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;
return 1;
}
if (**(int **)(lVar1 + 0x2a0) != 0) {
return 0;
}
if (*(char *)(*(long *)(lVar1 + 0x480) + 0x148) == '\0') {
uVar5 = mthd_stmt_read_execute_response(param_1);
return uVar5;
}
return 0;
}
*(int4 *)(param_1 + 0x108) = 0x7ef;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_No_data_supplied_for_parameters_i_00148b68;
}
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
|
|
13,913
|
translog_scanner_set_last_page
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)
{
my_bool page_ok;
if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))
{
/* It is last file => we can easy find last page address by horizon */
uint pagegrest= LSN_OFFSET(scanner->horizon) % TRANSLOG_PAGE_SIZE;
scanner->last_file_page= (scanner->horizon -
(pagegrest ? pagegrest : TRANSLOG_PAGE_SIZE));
return (0);
}
scanner->last_file_page= scanner->page_addr;
return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0));
}
|
O0
|
c
|
translog_scanner_set_last_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x2008(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
jne 0x32b00
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x2008(%rcx), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2008(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x32ad9
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x32ae3
movl $0x2000, %eax # imm = 0x2000
movl %eax, -0x24(%rbp)
jmp 0x32ae3
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %eax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x32b2f
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x10(%rbp), %rdi
addq $0x2010, %rdi # imm = 0x2010
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
callq 0x2faf0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
translog_scanner_set_last_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+2000h]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+2008h]
sar rcx, 20h
cmp eax, ecx
jnz short loc_32B00
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx+2008h]
and rax, 1FFFh
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+2008h]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_32AD9
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
jmp short loc_32AE3
loc_32AD9:
mov eax, 2000h
mov [rbp+var_24], eax
jmp short $+2
loc_32AE3:
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov eax, eax
sub rcx, rax
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov [rbp+var_1], 0
jmp short loc_32B2F
loc_32B00:
mov rax, [rbp+var_10]
mov rcx, [rax+2000h]
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov rdi, [rbp+var_10]
add rdi, 2010h
lea rsi, [rbp+var_11]
xor edx, edx
call translog_get_last_page_addr
mov [rbp+var_1], al
loc_32B2F:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char translog_scanner_set_last_page(_QWORD *a1)
{
unsigned int v2; // [rsp+Ch] [rbp-24h]
bool v3; // [rsp+1Fh] [rbp-11h] BYREF
_QWORD *v4; // [rsp+20h] [rbp-10h]
v4 = a1;
if ( HIDWORD(a1[1024]) == HIDWORD(a1[1025]) )
{
if ( (v4[1025] & 0x1FFF) != 0 )
v2 = v4[1025] & 0x1FFF;
else
v2 = 0x2000;
v4[1026] = v4[1025] - v2;
return 0;
}
else
{
v4[1026] = v4[1024];
return translog_get_last_page_addr(v4 + 1026, &v3, 0);
}
}
|
translog_scanner_set_last_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2000]
SAR RAX,0x20
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x2008]
SAR RCX,0x20
CMP EAX,ECX
JNZ 0x00132b00
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x2008]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2008]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00132ad9
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00132ae3
LAB_00132ad9:
MOV EAX,0x2000
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00132ae3
LAB_00132ae3:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EAX,EAX
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00132b2f
LAB_00132b00:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x2000]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2010
LEA RSI,[RBP + -0x11]
XOR EDX,EDX
CALL 0x0012faf0
MOV byte ptr [RBP + -0x1],AL
LAB_00132b2f:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_scanner_set_last_page(long param_1)
{
uint local_2c;
int1 local_19;
long local_18;
int1 local_9;
if ((int)((ulong)*(int8 *)(param_1 + 0x2000) >> 0x20) ==
(int)((ulong)*(int8 *)(param_1 + 0x2008) >> 0x20)) {
local_2c = (uint)*(ulong *)(param_1 + 0x2008) & 0x1fff;
if ((*(ulong *)(param_1 + 0x2008) & 0x1fff) == 0) {
local_2c = 0x2000;
}
*(ulong *)(param_1 + 0x2010) = *(long *)(param_1 + 0x2008) - (ulong)local_2c;
local_9 = 0;
}
else {
*(int8 *)(param_1 + 0x2010) = *(int8 *)(param_1 + 0x2000);
local_18 = param_1;
local_9 = translog_get_last_page_addr(param_1 + 0x2010,&local_19,0);
}
return local_9;
}
|
|
13,914
|
thr_merge_locks
|
eloqsql/mysys/thr_lock.c
|
void thr_merge_locks(THR_LOCK_DATA **data, uint old_count, uint new_count)
{
THR_LOCK_DATA **pos, **end, **first_lock= 0;
DBUG_ENTER("thr_merge_lock");
/* Remove marks on old locks to make them sort before new ones */
for (pos=data, end= pos + old_count; pos < end ; pos++)
(*pos)->priority&= ~THR_LOCK_LATE_PRIV;
/* Mark new locks with LATE_PRIV to make them sort after org ones */
for (pos=data + old_count, end= pos + new_count; pos < end ; pos++)
(*pos)->priority|= THR_LOCK_LATE_PRIV;
sort_locks(data, old_count + new_count);
for (pos=data ; pos < end ; pos++)
{
/* Check if lock was unlocked before */
if (pos[0]->type == TL_UNLOCK || ! pos[0]->lock->fix_status)
{
DBUG_PRINT("info", ("lock skipped. unlocked: %d fix_status: %d",
pos[0]->type == TL_UNLOCK,
pos[0]->lock->fix_status == 0));
continue;
}
/*
If same table as previous table use pointer to previous status
information to ensure that all read/write tables shares same
state.
*/
if (first_lock && pos[0]->lock == first_lock[0]->lock)
(pos[0]->lock->fix_status)((*first_lock)->status_param,
(*pos)->status_param);
else
{
/* Different lock, use this as base for next lock */
first_lock= pos;
(pos[0]->lock->fix_status)((*first_lock)->status_param, 0);
}
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
thr_merge_locks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
leaq (%rdi,%rax,8), %rax
testl %esi, %esi
je 0xa3403
movq %rbx, %rcx
movq (%rcx), %rdi
andl $-0x2, 0x48(%rdi)
addq $0x8, %rcx
cmpq %rax, %rcx
jb 0xa33f3
movl %edx, %ecx
leaq (%rax,%rcx,8), %r14
testl %edx, %edx
je 0xa341d
movq (%rax), %rcx
orl $0x1, 0x48(%rcx)
addq $0x8, %rax
cmpq %r14, %rax
jb 0xa340d
addl %esi, %edx
movq %rbx, %rdi
movl %edx, %esi
callq 0xa32d7
cmpq %rbx, %r14
jbe 0xa3478
xorl %r15d, %r15d
movq (%rbx), %rcx
cmpl $0x0, 0x40(%rcx)
je 0xa346f
movq 0x18(%rcx), %rdx
movq 0xe0(%rdx), %rax
testq %rax, %rax
je 0xa346f
testq %r15, %r15
je 0xa3458
movq (%r15), %rsi
cmpq 0x18(%rsi), %rdx
je 0xa3465
movq 0x28(%rcx), %rdi
xorl %esi, %esi
callq *%rax
movq %rbx, %r15
jmp 0xa346f
movq 0x28(%rsi), %rdi
movq 0x28(%rcx), %rsi
callq *%rax
addq $0x8, %rbx
cmpq %r14, %rbx
jb 0xa3431
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
thr_merge_locks:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov eax, esi
lea rax, [rdi+rax*8]
test esi, esi
jz short loc_A3403
mov rcx, rbx
loc_A33F3:
mov rdi, [rcx]
and dword ptr [rdi+48h], 0FFFFFFFEh
add rcx, 8
cmp rcx, rax
jb short loc_A33F3
loc_A3403:
mov ecx, edx
lea r14, [rax+rcx*8]
test edx, edx
jz short loc_A341D
loc_A340D:
mov rcx, [rax]
or dword ptr [rcx+48h], 1
add rax, 8
cmp rax, r14
jb short loc_A340D
loc_A341D:
add edx, esi
mov rdi, rbx
mov esi, edx
call sort_locks
cmp r14, rbx
jbe short loc_A3478
xor r15d, r15d
loc_A3431:
mov rcx, [rbx]
cmp dword ptr [rcx+40h], 0
jz short loc_A346F
mov rdx, [rcx+18h]
mov rax, [rdx+0E0h]
test rax, rax
jz short loc_A346F
test r15, r15
jz short loc_A3458
mov rsi, [r15]
cmp rdx, [rsi+18h]
jz short loc_A3465
loc_A3458:
mov rdi, [rcx+28h]
xor esi, esi
call rax
mov r15, rbx
jmp short loc_A346F
loc_A3465:
mov rdi, [rsi+28h]
mov rsi, [rcx+28h]
call rax
loc_A346F:
add rbx, 8
cmp rbx, r14
jb short loc_A3431
loc_A3478:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
void thr_merge_locks(_QWORD *a1, int a2, int a3)
{
_QWORD *v3; // rbx
_QWORD *v4; // rax
_QWORD *v5; // rcx
unsigned long long v6; // r14
_QWORD *v7; // r15
long long v8; // rcx
long long v9; // rdx
void ( *v10)(_QWORD, _QWORD); // rax
v3 = a1;
v4 = &a1[a2];
if ( a2 )
{
v5 = a1;
do
*(_DWORD *)(*v5++ + 72LL) &= ~1u;
while ( v5 < v4 );
}
v6 = (unsigned long long)&v4[a3];
if ( a3 )
{
do
*(_DWORD *)(*v4++ + 72LL) |= 1u;
while ( (unsigned long long)v4 < v6 );
}
sort_locks(a1, a2 + a3);
if ( v6 > (unsigned long long)a1 )
{
v7 = 0LL;
do
{
v8 = *v3;
if ( *(_DWORD *)(*v3 + 64LL) )
{
v9 = *(_QWORD *)(v8 + 24);
v10 = *(void ( **)(_QWORD, _QWORD))(v9 + 224);
if ( v10 )
{
if ( v7 && v9 == *(_QWORD *)(*v7 + 24LL) )
{
v10(*(_QWORD *)(*v7 + 40LL), *(_QWORD *)(v8 + 40));
}
else
{
v10(*(_QWORD *)(v8 + 40), 0LL);
v7 = v3;
}
}
}
++v3;
}
while ( (unsigned long long)v3 < v6 );
}
}
|
thr_merge_locks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,ESI
LEA RAX,[RDI + RAX*0x8]
TEST ESI,ESI
JZ 0x001a3403
MOV RCX,RBX
LAB_001a33f3:
MOV RDI,qword ptr [RCX]
AND dword ptr [RDI + 0x48],0xfffffffe
ADD RCX,0x8
CMP RCX,RAX
JC 0x001a33f3
LAB_001a3403:
MOV ECX,EDX
LEA R14,[RAX + RCX*0x8]
TEST EDX,EDX
JZ 0x001a341d
LAB_001a340d:
MOV RCX,qword ptr [RAX]
OR dword ptr [RCX + 0x48],0x1
ADD RAX,0x8
CMP RAX,R14
JC 0x001a340d
LAB_001a341d:
ADD EDX,ESI
MOV RDI,RBX
MOV ESI,EDX
CALL 0x001a32d7
CMP R14,RBX
JBE 0x001a3478
XOR R15D,R15D
LAB_001a3431:
MOV RCX,qword ptr [RBX]
CMP dword ptr [RCX + 0x40],0x0
JZ 0x001a346f
MOV RDX,qword ptr [RCX + 0x18]
MOV RAX,qword ptr [RDX + 0xe0]
TEST RAX,RAX
JZ 0x001a346f
TEST R15,R15
JZ 0x001a3458
MOV RSI,qword ptr [R15]
CMP RDX,qword ptr [RSI + 0x18]
JZ 0x001a3465
LAB_001a3458:
MOV RDI,qword ptr [RCX + 0x28]
XOR ESI,ESI
CALL RAX
MOV R15,RBX
JMP 0x001a346f
LAB_001a3465:
MOV RDI,qword ptr [RSI + 0x28]
MOV RSI,qword ptr [RCX + 0x28]
CALL RAX
LAB_001a346f:
ADD RBX,0x8
CMP RBX,R14
JC 0x001a3431
LAB_001a3478:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void thr_merge_locks(long *param_1,uint param_2,uint param_3)
{
long lVar1;
code *pcVar2;
long *plVar3;
long *plVar4;
plVar3 = param_1 + param_2;
plVar4 = param_1;
if (param_2 != 0) {
do {
*(uint *)(*plVar4 + 0x48) = *(uint *)(*plVar4 + 0x48) & 0xfffffffe;
plVar4 = plVar4 + 1;
} while (plVar4 < plVar3);
}
plVar4 = plVar3 + param_3;
if (param_3 != 0) {
do {
*(uint *)(*plVar3 + 0x48) = *(uint *)(*plVar3 + 0x48) | 1;
plVar3 = plVar3 + 1;
} while (plVar3 < plVar4);
}
sort_locks(param_1,param_3 + param_2);
if (param_1 < plVar4) {
plVar3 = (long *)0x0;
do {
lVar1 = *param_1;
if (*(int *)(lVar1 + 0x40) != 0) {
pcVar2 = *(code **)(*(long *)(lVar1 + 0x18) + 0xe0);
if (pcVar2 != (code *)0x0) {
if ((plVar3 == (long *)0x0) || (*(long *)(lVar1 + 0x18) != *(long *)(*plVar3 + 0x18))) {
(*pcVar2)(*(int8 *)(lVar1 + 0x28),0);
plVar3 = param_1;
}
else {
(*pcVar2)(*(int8 *)(*plVar3 + 0x28),*(int8 *)(lVar1 + 0x28));
}
}
}
param_1 = param_1 + 1;
} while (param_1 < plVar4);
}
return;
}
|
|
13,915
|
translog_get_file_size
|
eloqsql/storage/maria/ma_loghandler.c
|
uint32 translog_get_file_size()
{
uint32 res;
translog_lock();
res= log_descriptor.log_file_max_size;
translog_unlock();
return (res);
}
|
O3
|
c
|
translog_get_file_size:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x4902b
movl 0x3b07bb(%rip), %ebx # 0x3fe7d0
movq 0xbb141c(%rip), %r14 # 0xbff438
movq 0x1000d0(%r14), %rdi
testq %rdi, %rdi
jne 0x4e03e
addq $0x100090, %r14 # imm = 0x100090
movq %r14, %rdi
callq 0x291e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x337fcb(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4e028
|
translog_get_file_size:
push rbp
mov rbp, rsp
push r14
push rbx
call translog_lock
mov ebx, cs:dword_3FE7D0
mov r14, qword ptr cs:xmmword_BFF430+8
mov rdi, ds:qword_1000D0[r14]
test rdi, rdi
jnz short loc_4E03E
loc_4E028:
add r14, 100090h
mov rdi, r14
call _pthread_mutex_unlock
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_4E03E:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4E028
|
long long translog_get_file_size()
{
unsigned int v0; // ebx
long long v1; // r14
translog_lock();
v0 = dword_3FE7D0;
v1 = *((_QWORD *)&xmmword_BFF430 + 1);
if ( *(long long *)((char *)&qword_1000D0 + *((_QWORD *)&xmmword_BFF430 + 1)) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 1048720);
return v0;
}
|
translog_get_file_size:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
CALL 0x0014902b
MOV EBX,dword ptr [0x004fe7d0]
MOV R14,qword ptr [0x00cff438]
MOV RDI,qword ptr [R14 + 0x1000d0]
TEST RDI,RDI
JNZ 0x0014e03e
LAB_0014e028:
ADD R14,0x100090
MOV RDI,R14
CALL 0x001291e0
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_0014e03e:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014e028
|
int4 translog_get_file_size(void)
{
int4 uVar1;
long lVar2;
translog_lock();
lVar2 = DAT_00cff438;
uVar1 = DAT_004fe7d0;
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + DAT_00cff438) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
return uVar1;
}
|
|
13,916
|
compile_if_expr
|
fabiosvm[P]rak/src/compiler.c
|
static inline void compile_if_expr(RakCompiler *comp, uint16_t *off, RakError *err)
{
next(comp, err);
compile_expr(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump1 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_pop_instr(), err);
if (!rak_is_ok(err)) return;
compile_block_expr(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump2 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
uint32_t instr = rak_jump_if_false_instr((uint16_t) comp->chunk.instrs.len);
patch_instr(comp, jump1, instr);
uint16_t _off;
compile_if_expr_cont(comp, &_off, err);
if (!rak_is_ok(err)) return;
patch_instr(comp, jump2, rak_jump_instr(_off));
if (off) *off = _off;
}
|
O2
|
c
|
compile_if_expr:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27f8(%rdi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x5512
cmpb $0x1, (%r15)
jne 0x505a
movq %r14, %rdi
movq %r15, %rsi
callq 0x400f
cmpb $0x1, (%r15)
jne 0x505a
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3306
cmpb $0x1, (%r15)
jne 0x505a
movl %eax, %r13d
pushq $0xc
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3306
cmpb $0x1, (%r15)
jne 0x505a
movq %r14, %rdi
movq %r15, %rsi
callq 0x5237
cmpb $0x1, (%r15)
jne 0x505a
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3306
cmpb $0x1, (%r15)
jne 0x505a
movl %eax, %ebp
movl 0xffc(%r14), %eax
movzwl %ax, %eax
shll $0x8, %eax
orl $0xe, %eax
movq 0x1000(%r14), %rcx
movzwl %r13w, %edx
movl %eax, (%rcx,%rdx,4)
pushq $0xc
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3306
movb (%r15), %al
cmpb $0x1, %al
jne 0x5034
cmpl $0x26, 0x2810(%r14)
jne 0x5012
movq %r12, %rdi
movq %r15, %rsi
callq 0x5512
movb (%r15), %al
cmpb $0x1, %al
jne 0x5034
cmpl $0x28, 0x2810(%r14)
jne 0x5069
leaq 0x6(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4eff
movb (%r15), %al
jmp 0x5034
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3306
movb (%r15), %al
cmpb $0x1, %al
jne 0x5034
movzwl 0xffc(%r14), %ecx
movw %cx, 0x6(%rsp)
testb $0x1, %al
je 0x505a
movzwl 0x6(%rsp), %eax
movl %eax, %ecx
shll $0x8, %ecx
orl $0xd, %ecx
movq 0x1000(%r14), %rdx
movzwl %bp, %esi
movl %ecx, (%rdx,%rsi,4)
testq %rbx, %rbx
je 0x505a
movw %ax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x5237
jmp 0x5020
|
compile_if_expr:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
lea r12, [rdi+27F8h]
mov rdi, r12
mov rsi, rdx
call rak_lexer_next
cmp byte ptr [r15], 1
jnz loc_505A
mov rdi, r14
mov rsi, r15
call compile_expr
cmp byte ptr [r15], 1
jnz loc_505A
mov rdi, r14
xor esi, esi
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz loc_505A
mov r13d, eax
push 0Ch
pop rsi
mov rdi, r14
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz loc_505A
mov rdi, r14
mov rsi, r15
call compile_block_expr
cmp byte ptr [r15], 1
jnz loc_505A
mov rdi, r14
xor esi, esi
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz loc_505A
mov ebp, eax
mov eax, [r14+0FFCh]
movzx eax, ax
shl eax, 8
or eax, 0Eh
mov rcx, [r14+1000h]
movzx edx, r13w
mov [rcx+rdx*4], eax
push 0Ch
pop rsi
mov rdi, r14
mov rdx, r15
call rak_chunk_append_instr
mov al, [r15]
cmp al, 1
jnz short loc_5034
cmp dword ptr [r14+2810h], 26h ; '&'
jnz short loc_5012
mov rdi, r12
mov rsi, r15
call rak_lexer_next
mov al, [r15]
cmp al, 1
jnz short loc_5034
cmp dword ptr [r14+2810h], 28h ; '('
jnz short loc_5069
lea rsi, [rsp+38h+var_32]
mov rdi, r14
mov rdx, r15
call compile_if_expr
mov al, [r15]
jmp short loc_5034
loc_5012:
push 1
pop rsi
mov rdi, r14
mov rdx, r15
call rak_chunk_append_instr
loc_5020:
mov al, [r15]
cmp al, 1
jnz short loc_5034
movzx ecx, word ptr [r14+0FFCh]
mov [rsp+38h+var_32], cx
loc_5034:
test al, 1
jz short loc_505A
movzx eax, [rsp+38h+var_32]
mov ecx, eax
shl ecx, 8
or ecx, 0Dh
mov rdx, [r14+1000h]
movzx esi, bp
mov [rdx+rsi*4], ecx
test rbx, rbx
jz short loc_505A
mov [rbx], ax
loc_505A:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5069:
mov rdi, r14
mov rsi, r15
call compile_block_expr
jmp short loc_5020
|
char compile_if_expr(long long a1, unsigned __int16 *a2, char *a3)
{
long long v3; // rax
unsigned __int16 appended; // ax
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // ecx
int v10; // r8d
int v11; // r9d
unsigned __int16 v12; // r13
int v13; // ecx
int v14; // r8d
int v15; // r9d
int v16; // r8d
int v17; // r9d
unsigned __int16 v18; // bp
long long v19; // rcx
int v20; // ecx
int v21; // r8d
int v22; // r9d
_WORD v24[25]; // [rsp+0h] [rbp-32h] BYREF
v24[0] = HIWORD(v3);
LOBYTE(appended) = rak_lexer_next(a1 + 10232, a3);
if ( *a3 != 1 )
return appended;
LOBYTE(appended) = compile_expr(a1, a3);
if ( *a3 != 1 )
return appended;
appended = rak_chunk_append_instr(a1, 0, a3, v6, v7, v8);
if ( *a3 != 1 )
return appended;
v12 = appended;
LOBYTE(appended) = rak_chunk_append_instr(a1, 12, a3, v9, v10, v11);
if ( *a3 != 1 )
return appended;
LOBYTE(appended) = compile_block_expr(a1, a3);
if ( *a3 != 1 )
return appended;
appended = rak_chunk_append_instr(a1, 0, a3, v13, v14, v15);
if ( *a3 != 1 )
return appended;
v18 = appended;
v19 = *(_QWORD *)(a1 + 4096);
*(_DWORD *)(v19 + 4LL * v12) = ((unsigned __int16)*(_DWORD *)(a1 + 4092) << 8) | 0xE;
rak_chunk_append_instr(a1, 12, a3, v19, v16, v17);
LOBYTE(appended) = *a3;
if ( *a3 == 1 )
{
if ( *(_DWORD *)(a1 + 10256) != 38 )
{
rak_chunk_append_instr(a1, 1, a3, v20, v21, v22);
goto LABEL_13;
}
rak_lexer_next(a1 + 10232, a3);
LOBYTE(appended) = *a3;
if ( *a3 == 1 )
{
if ( *(_DWORD *)(a1 + 10256) == 40 )
{
compile_if_expr(a1, v24, a3);
LOBYTE(appended) = *a3;
goto LABEL_15;
}
compile_block_expr(a1, a3);
LABEL_13:
LOBYTE(appended) = *a3;
if ( *a3 == 1 )
v24[0] = *(_WORD *)(a1 + 4092);
}
}
LABEL_15:
if ( (appended & 1) != 0 )
{
appended = v24[0];
*(_DWORD *)(*(_QWORD *)(a1 + 4096) + 4LL * v18) = (v24[0] << 8) | 0xD;
if ( a2 )
*a2 = appended;
}
return appended;
}
|
compile_if_expr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
LEA R12,[RDI + 0x27f8]
MOV RDI,R12
MOV RSI,RDX
CALL 0x00105512
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV RDI,R14
MOV RSI,R15
CALL 0x0010400f
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x00103306
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV R13D,EAX
PUSH 0xc
POP RSI
MOV RDI,R14
MOV RDX,R15
CALL 0x00103306
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV RDI,R14
MOV RSI,R15
CALL 0x00105237
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x00103306
CMP byte ptr [R15],0x1
JNZ 0x0010505a
MOV EBP,EAX
MOV EAX,dword ptr [R14 + 0xffc]
MOVZX EAX,AX
SHL EAX,0x8
OR EAX,0xe
MOV RCX,qword ptr [R14 + 0x1000]
MOVZX EDX,R13W
MOV dword ptr [RCX + RDX*0x4],EAX
PUSH 0xc
POP RSI
MOV RDI,R14
MOV RDX,R15
CALL 0x00103306
MOV AL,byte ptr [R15]
CMP AL,0x1
JNZ 0x00105034
CMP dword ptr [R14 + 0x2810],0x26
JNZ 0x00105012
MOV RDI,R12
MOV RSI,R15
CALL 0x00105512
MOV AL,byte ptr [R15]
CMP AL,0x1
JNZ 0x00105034
CMP dword ptr [R14 + 0x2810],0x28
JNZ 0x00105069
LEA RSI,[RSP + 0x6]
MOV RDI,R14
MOV RDX,R15
CALL 0x00104eff
MOV AL,byte ptr [R15]
JMP 0x00105034
LAB_00105012:
PUSH 0x1
POP RSI
MOV RDI,R14
MOV RDX,R15
CALL 0x00103306
LAB_00105020:
MOV AL,byte ptr [R15]
CMP AL,0x1
JNZ 0x00105034
MOVZX ECX,word ptr [R14 + 0xffc]
MOV word ptr [RSP + 0x6],CX
LAB_00105034:
TEST AL,0x1
JZ 0x0010505a
MOVZX EAX,word ptr [RSP + 0x6]
MOV ECX,EAX
SHL ECX,0x8
OR ECX,0xd
MOV RDX,qword ptr [R14 + 0x1000]
MOVZX ESI,BP
MOV dword ptr [RDX + RSI*0x4],ECX
TEST RBX,RBX
JZ 0x0010505a
MOV word ptr [RBX],AX
LAB_0010505a:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00105069:
MOV RDI,R14
MOV RSI,R15
CALL 0x00105237
JMP 0x00105020
|
void compile_if_expr(long param_1,ushort *param_2,byte *param_3)
{
byte bVar1;
ushort uVar2;
uint uVar3;
int8 in_RAX;
ushort local_32;
local_32 = (ushort)((ulong)in_RAX >> 0x30);
rak_lexer_next(param_1 + 0x27f8,param_3);
if (*param_3 != 1) {
return;
}
compile_expr(param_1,param_3);
if (*param_3 != 1) {
return;
}
uVar3 = rak_chunk_append_instr(param_1,0,param_3);
if (*param_3 != 1) {
return;
}
rak_chunk_append_instr(param_1,0xc,param_3);
if (*param_3 != 1) {
return;
}
compile_block_expr(param_1,param_3);
if (*param_3 != 1) {
return;
}
uVar2 = rak_chunk_append_instr(param_1,0,param_3);
if (*param_3 != 1) {
return;
}
*(uint *)(*(long *)(param_1 + 0x1000) + ((ulong)uVar3 & 0xffff) * 4) =
(*(uint *)(param_1 + 0xffc) & 0xffff) << 8 | 0xe;
rak_chunk_append_instr(param_1,0xc,param_3);
bVar1 = *param_3;
if (bVar1 != 1) goto LAB_00105034;
if (*(int *)(param_1 + 0x2810) == 0x26) {
rak_lexer_next(param_1 + 0x27f8,param_3);
bVar1 = *param_3;
if (bVar1 != 1) goto LAB_00105034;
if (*(int *)(param_1 + 0x2810) == 0x28) {
compile_if_expr(param_1,&local_32,param_3);
bVar1 = *param_3;
goto LAB_00105034;
}
compile_block_expr(param_1,param_3);
}
else {
rak_chunk_append_instr(param_1,1,param_3);
}
bVar1 = *param_3;
if (bVar1 == 1) {
local_32 = *(ushort *)(param_1 + 0xffc);
}
LAB_00105034:
if (((bVar1 & 1) != 0) &&
(*(uint *)(*(long *)(param_1 + 0x1000) + (ulong)uVar2 * 4) = (uint)local_32 << 8 | 0xd,
param_2 != (ushort *)0x0)) {
*param_2 = local_32;
}
return;
}
|
|
13,917
|
compile_if_expr
|
fabiosvm[P]rak/src/compiler.c
|
static inline void compile_if_expr(RakCompiler *comp, uint16_t *off, RakError *err)
{
next(comp, err);
compile_expr(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump1 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_pop_instr(), err);
if (!rak_is_ok(err)) return;
compile_block_expr(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump2 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
uint32_t instr = rak_jump_if_false_instr((uint16_t) comp->chunk.instrs.len);
patch_instr(comp, jump1, instr);
uint16_t _off;
compile_if_expr_cont(comp, &_off, err);
if (!rak_is_ok(err)) return;
patch_instr(comp, jump2, rak_jump_instr(_off));
if (off) *off = _off;
}
|
O3
|
c
|
compile_if_expr:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27f8(%rdi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x679a
cmpb $0x1, (%r15)
jne 0x5f66
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e2a
movb (%r15), %al
cmpb $0x1, %al
jne 0x5db4
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4ed9
movb (%r15), %al
testb $0x1, %al
je 0x5dc8
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4d4a
movb (%r15), %al
testb $0x1, %al
je 0x5f66
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x392d
cmpb $0x1, (%r15)
jne 0x5f66
movl %eax, %ebp
movq %r14, %rdi
movl $0xc, %esi
movq %r15, %rdx
callq 0x392d
cmpb $0x1, (%r15)
jne 0x5f66
movl 0x2810(%r14), %r13d
cmpl $0x8, %r13d
jne 0x5e5a
movq %r12, %rdi
movq %r15, %rsi
callq 0x679a
cmpb $0x1, (%r15)
jne 0x5ef4
movq %r14, %rdi
movq %r15, %rsi
callq 0x4bec
cmpb $0x1, (%r15)
jne 0x5ef4
leaq 0x2810(%r14), %rax
cmpl $0x9, (%rax)
jne 0x5ed7
movq %r12, %rdi
movq %r15, %rsi
callq 0x679a
jmp 0x5ef4
movl 0x2814(%r14), %eax
movl %eax, 0x28(%rsp)
movl 0x2818(%r14), %r12d
movl 0x281c(%r14), %eax
movl %eax, 0x2c(%rsp)
movq 0x2820(%r14), %rax
movq %rax, 0x30(%rsp)
movl $0x8, %edi
callq 0x6764
testl %r13d, %r13d
je 0x5eba
movl %r12d, (%rsp)
leaq 0x4609(%rip), %rsi # 0xa4a6
movq %r15, %rdi
movq %rax, %rdx
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %r8
movl 0x28(%rsp), %r9d
xorl %eax, %eax
callq 0x666c
jmp 0x5ef4
leaq 0x45bb(%rip), %rsi # 0xa47c
movq %r15, %rdi
movq %rax, %rdx
movl 0x28(%rsp), %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x666c
jmp 0x5ef4
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movl $0x9, %esi
callq 0x4b7a
cmpb $0x1, (%r15)
jne 0x5f66
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x392d
cmpb $0x1, (%r15)
jne 0x5f66
movl %eax, %r12d
movl 0xffc(%r14), %eax
movzwl %ax, %eax
shll $0x8, %eax
orl $0xe, %eax
movq 0x1000(%r14), %rcx
movzwl %bp, %edx
movl %eax, (%rcx,%rdx,4)
leaq 0x26(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x61fd
cmpb $0x1, (%r15)
jne 0x5f66
movzwl 0x26(%rsp), %eax
movl %eax, %ecx
shll $0x8, %ecx
orl $0xd, %ecx
movq 0x1000(%r14), %rdx
movzwl %r12w, %esi
movl %ecx, (%rdx,%rsi,4)
testq %rbx, %rbx
je 0x5f66
movw %ax, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
compile_if_expr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
lea r12, [rdi+27F8h]
mov rdi, r12
mov rsi, rdx
call rak_lexer_next
cmp byte ptr [r15], 1
jnz loc_5F66
mov rdi, r14
mov rsi, r15
call compile_eq_expr
mov al, [r15]
cmp al, 1
jnz short loc_5DB4
mov rdi, r14
xor esi, esi
mov rdx, r15
call compile_and_expr_cont
mov al, [r15]
loc_5DB4:
test al, 1
jz short loc_5DC8
mov rdi, r14
xor esi, esi
mov rdx, r15
call compile_or_expr_cont
mov al, [r15]
loc_5DC8:
test al, 1
jz loc_5F66
mov rdi, r14
xor esi, esi
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz loc_5F66
mov ebp, eax
mov rdi, r14
mov esi, 0Ch
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz loc_5F66
mov r13d, [r14+2810h]
cmp r13d, 8
jnz short loc_5E5A
mov rdi, r12
mov rsi, r15
call rak_lexer_next
cmp byte ptr [r15], 1
jnz loc_5EF4
mov rdi, r14
mov rsi, r15
call compile_expr
cmp byte ptr [r15], 1
jnz loc_5EF4
lea rax, [r14+2810h]
cmp dword ptr [rax], 9
jnz loc_5ED7
mov rdi, r12
mov rsi, r15
call rak_lexer_next
jmp loc_5EF4
loc_5E5A:
mov eax, [r14+2814h]
mov [rsp+68h+var_40], eax
mov r12d, [r14+2818h]
mov eax, [r14+281Ch]
mov [rsp+68h+var_3C], eax
mov rax, [r14+2820h]
mov [rsp+68h+var_38], rax
mov edi, 8
call rak_token_kind_to_cstr
test r13d, r13d
jz short loc_5EBA
mov dword ptr [rsp+68h+var_68], r12d
lea rsi, aExpectedSButGo_0; "expected %s, but got '%.*s' at %d:%d"
mov rdi, r15
mov rdx, rax
mov ecx, [rsp+68h+var_3C]
mov r8, [rsp+68h+var_38]
mov r9d, [rsp+68h+var_40]
xor eax, eax
call rak_error_set
jmp short loc_5EF4
loc_5EBA:
lea rsi, aExpectedSButGo; "expected %s, but got end of file at %d:"...
mov rdi, r15
mov rdx, rax
mov ecx, [rsp+68h+var_40]
mov r8d, r12d
xor eax, eax
call rak_error_set
jmp short loc_5EF4
loc_5ED7:
mov rcx, [rax+10h]
mov [rsp+68h+var_58], rcx
movups xmm0, xmmword ptr [rax]
movups [rsp+68h+var_68], xmm0
mov rdi, r15
mov esi, 9
call expected_token_error
loc_5EF4:
cmp byte ptr [r15], 1
jnz short loc_5F66
mov rdi, r14
xor esi, esi
mov rdx, r15
call rak_chunk_append_instr
cmp byte ptr [r15], 1
jnz short loc_5F66
mov r12d, eax
mov eax, [r14+0FFCh]
movzx eax, ax
shl eax, 8
or eax, 0Eh
mov rcx, [r14+1000h]
movzx edx, bp
mov [rcx+rdx*4], eax
lea rsi, [rsp+68h+var_42]
mov rdi, r14
mov rdx, r15
call compile_if_expr_cont
cmp byte ptr [r15], 1
jnz short loc_5F66
movzx eax, [rsp+68h+var_42]
mov ecx, eax
shl ecx, 8
or ecx, 0Dh
mov rdx, [r14+1000h]
movzx esi, r12w
mov [rdx+rsi*4], ecx
test rbx, rbx
jz short loc_5F66
mov [rbx], ax
loc_5F66:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char compile_if_expr(long long a1, unsigned __int16 *a2, char *a3)
{
long long v4; // r12
unsigned __int16 appended; // ax
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // ecx
int v10; // r8d
int v11; // r9d
unsigned __int16 v12; // bp
int v13; // r13d
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // edx
int v18; // r12d
int v19; // eax
int v20; // r9d
unsigned __int16 v21; // r12
unsigned __int16 v23; // [rsp+26h] [rbp-42h] BYREF
int v24; // [rsp+28h] [rbp-40h]
int v25; // [rsp+2Ch] [rbp-3Ch]
long long v26; // [rsp+30h] [rbp-38h]
v4 = a1 + 10232;
LOBYTE(appended) = rak_lexer_next(a1 + 10232, a3);
if ( *a3 == 1 )
{
compile_eq_expr(a1, a3);
LOBYTE(appended) = *a3;
if ( *a3 == 1 )
{
compile_and_expr_cont(a1, 0LL, a3);
LOBYTE(appended) = *a3;
}
if ( (appended & 1) != 0 )
{
compile_or_expr_cont(a1, 0LL, a3);
LOBYTE(appended) = *a3;
}
if ( (appended & 1) != 0 )
{
appended = rak_chunk_append_instr(a1, 0, a3, v6, v7, v8);
if ( *a3 == 1 )
{
v12 = appended;
LOBYTE(appended) = rak_chunk_append_instr(a1, 12, a3, v9, v10, v11);
if ( *a3 == 1 )
{
v13 = *(_DWORD *)(a1 + 10256);
if ( v13 == 8 )
{
LOBYTE(appended) = rak_lexer_next(v4, a3);
if ( *a3 == 1 )
{
LOBYTE(appended) = compile_expr(a1, a3);
if ( *a3 == 1 )
{
if ( *(_DWORD *)(a1 + 10256) == 9 )
LOBYTE(appended) = rak_lexer_next(v4, a3);
else
LOBYTE(appended) = expected_token_error(
(int)a3,
9u,
v17,
*(_QWORD *)(a1 + 10272),
v15,
v16,
*(_QWORD *)(a1 + 10256),
*(_QWORD *)(a1 + 10264),
*(_QWORD *)(a1 + 10272));
}
}
}
else
{
v24 = *(_DWORD *)(a1 + 10260);
v18 = *(_DWORD *)(a1 + 10264);
v25 = *(_DWORD *)(a1 + 10268);
v26 = *(_QWORD *)(a1 + 10272);
v19 = rak_token_kind_to_cstr(8LL);
if ( v13 )
LOBYTE(appended) = rak_error_set(
(_DWORD)a3,
(unsigned int)"expected %s, but got '%.*s' at %d:%d",
v19,
v25,
v26,
v24);
else
LOBYTE(appended) = rak_error_set(
(_DWORD)a3,
(unsigned int)"expected %s, but got end of file at %d:%d",
v19,
v24,
v18,
v20);
}
if ( *a3 == 1 )
{
appended = rak_chunk_append_instr(a1, 0, a3, v14, v15, v16);
if ( *a3 == 1 )
{
v21 = appended;
*(_DWORD *)(*(_QWORD *)(a1 + 4096) + 4LL * v12) = ((unsigned __int16)*(_DWORD *)(a1 + 4092) << 8) | 0xE;
LOBYTE(appended) = compile_if_expr_cont(a1, &v23, a3);
if ( *a3 == 1 )
{
appended = v23;
*(_DWORD *)(*(_QWORD *)(a1 + 4096) + 4LL * v21) = (v23 << 8) | 0xD;
if ( a2 )
*a2 = appended;
}
}
}
}
}
}
}
return appended;
}
|
compile_if_expr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
LEA R12,[RDI + 0x27f8]
MOV RDI,R12
MOV RSI,RDX
CALL 0x0010679a
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOV RDI,R14
MOV RSI,R15
CALL 0x00104e2a
MOV AL,byte ptr [R15]
CMP AL,0x1
JNZ 0x00105db4
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x00104ed9
MOV AL,byte ptr [R15]
LAB_00105db4:
TEST AL,0x1
JZ 0x00105dc8
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x00104d4a
MOV AL,byte ptr [R15]
LAB_00105dc8:
TEST AL,0x1
JZ 0x00105f66
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x0010392d
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOV EBP,EAX
MOV RDI,R14
MOV ESI,0xc
MOV RDX,R15
CALL 0x0010392d
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOV R13D,dword ptr [R14 + 0x2810]
CMP R13D,0x8
JNZ 0x00105e5a
MOV RDI,R12
MOV RSI,R15
CALL 0x0010679a
CMP byte ptr [R15],0x1
JNZ 0x00105ef4
MOV RDI,R14
MOV RSI,R15
CALL 0x00104bec
CMP byte ptr [R15],0x1
JNZ 0x00105ef4
LEA RAX,[R14 + 0x2810]
CMP dword ptr [RAX],0x9
JNZ 0x00105ed7
MOV RDI,R12
MOV RSI,R15
CALL 0x0010679a
JMP 0x00105ef4
LAB_00105e5a:
MOV EAX,dword ptr [R14 + 0x2814]
MOV dword ptr [RSP + 0x28],EAX
MOV R12D,dword ptr [R14 + 0x2818]
MOV EAX,dword ptr [R14 + 0x281c]
MOV dword ptr [RSP + 0x2c],EAX
MOV RAX,qword ptr [R14 + 0x2820]
MOV qword ptr [RSP + 0x30],RAX
MOV EDI,0x8
CALL 0x00106764
TEST R13D,R13D
JZ 0x00105eba
MOV dword ptr [RSP],R12D
LEA RSI,[0x10a4a6]
MOV RDI,R15
MOV RDX,RAX
MOV ECX,dword ptr [RSP + 0x2c]
MOV R8,qword ptr [RSP + 0x30]
MOV R9D,dword ptr [RSP + 0x28]
XOR EAX,EAX
CALL 0x0010666c
JMP 0x00105ef4
LAB_00105eba:
LEA RSI,[0x10a47c]
MOV RDI,R15
MOV RDX,RAX
MOV ECX,dword ptr [RSP + 0x28]
MOV R8D,R12D
XOR EAX,EAX
CALL 0x0010666c
JMP 0x00105ef4
LAB_00105ed7:
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV ESI,0x9
CALL 0x00104b7a
LAB_00105ef4:
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R15
CALL 0x0010392d
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOV R12D,EAX
MOV EAX,dword ptr [R14 + 0xffc]
MOVZX EAX,AX
SHL EAX,0x8
OR EAX,0xe
MOV RCX,qword ptr [R14 + 0x1000]
MOVZX EDX,BP
MOV dword ptr [RCX + RDX*0x4],EAX
LEA RSI,[RSP + 0x26]
MOV RDI,R14
MOV RDX,R15
CALL 0x001061fd
CMP byte ptr [R15],0x1
JNZ 0x00105f66
MOVZX EAX,word ptr [RSP + 0x26]
MOV ECX,EAX
SHL ECX,0x8
OR ECX,0xd
MOV RDX,qword ptr [R14 + 0x1000]
MOVZX ESI,R12W
MOV dword ptr [RDX + RSI*0x4],ECX
TEST RBX,RBX
JZ 0x00105f66
MOV word ptr [RBX],AX
LAB_00105f66:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void compile_if_expr(long param_1,ushort *param_2,byte *param_3)
{
long lVar1;
int iVar2;
int4 uVar3;
byte bVar4;
uint uVar5;
uint uVar6;
int8 uVar7;
ushort local_42;
int4 local_40;
int4 local_3c;
int8 local_38;
lVar1 = param_1 + 0x27f8;
rak_lexer_next(lVar1,param_3);
if (*param_3 == 1) {
compile_eq_expr(param_1,param_3);
bVar4 = *param_3;
if (bVar4 == 1) {
compile_and_expr_cont(param_1,0,param_3);
bVar4 = *param_3;
}
if ((bVar4 & 1) != 0) {
compile_or_expr_cont(param_1,0,param_3);
bVar4 = *param_3;
}
if ((bVar4 & 1) != 0) {
uVar5 = rak_chunk_append_instr(param_1,0,param_3);
if (*param_3 == 1) {
rak_chunk_append_instr(param_1,0xc,param_3);
if (*param_3 == 1) {
iVar2 = *(int *)(param_1 + 0x2810);
if (iVar2 == 8) {
rak_lexer_next(lVar1,param_3);
if (*param_3 == 1) {
compile_expr(param_1,param_3);
if (*param_3 == 1) {
if (*(int *)(param_1 + 0x2810) == 9) {
rak_lexer_next(lVar1,param_3);
}
else {
expected_token_error(param_3,9);
}
}
}
}
else {
local_40 = *(int4 *)(param_1 + 0x2814);
uVar3 = *(int4 *)(param_1 + 0x2818);
local_3c = *(int4 *)(param_1 + 0x281c);
local_38 = *(int8 *)(param_1 + 0x2820);
uVar7 = rak_token_kind_to_cstr(8);
if (iVar2 == 0) {
rak_error_set(param_3,"expected %s, but got end of file at %d:%d",uVar7,local_40,uVar3
);
}
else {
rak_error_set(param_3,"expected %s, but got \'%.*s\' at %d:%d",uVar7,local_3c,local_38
,local_40,uVar3);
}
}
if (*param_3 == 1) {
uVar6 = rak_chunk_append_instr(param_1,0,param_3);
if (*param_3 == 1) {
*(uint *)(*(long *)(param_1 + 0x1000) + ((ulong)uVar5 & 0xffff) * 4) =
(*(uint *)(param_1 + 0xffc) & 0xffff) << 8 | 0xe;
compile_if_expr_cont(param_1,&local_42,param_3);
if (*param_3 == 1) {
*(uint *)(*(long *)(param_1 + 0x1000) + ((ulong)uVar6 & 0xffff) * 4) =
(uint)local_42 << 8 | 0xd;
if (param_2 != (ushort *)0x0) {
*param_2 = local_42;
}
}
}
}
}
}
}
}
return;
}
|
|
13,918
|
MemoryManager::setShort(unsigned int, unsigned short, unsigned int*)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp
|
bool MemoryManager::setShort(uint32_t addr, uint16_t val, uint32_t *cycles) {
if (!this->isAddrExist(addr)) {
dbgprintf("Short write to invalid addr 0x%x!\n", addr);
return false;
}
this->setByte(addr, val & 0xFF, cycles);
this->setByte(addr + 1, (val >> 8) & 0xFF);
return true;
}
|
O0
|
cpp
|
MemoryManager::setShort(unsigned int, unsigned short, unsigned int*):
subq $0x28, %rsp
movw %dx, %ax
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movw %ax, 0x12(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x14(%rsp), %esi
callq 0x3430
testb $0x1, %al
jne 0x38d9
movl 0x14(%rsp), %esi
leaq 0x48d4(%rip), %rdi # 0x819f
movb $0x0, %al
callq 0x2f60
movb $0x0, 0x27(%rsp)
jmp 0x391f
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
movzwl 0x12(%rsp), %eax
andl $0xff, %eax
movq 0x8(%rsp), %rcx
movzbl %al, %edx
callq 0x3560
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
movzwl 0x12(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
xorl %ecx, %ecx
movzbl %al, %edx
callq 0x3560
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
|
_ZN13MemoryManager8setShortEjtPj:
sub rsp, 28h
mov ax, dx
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov [rsp+28h+var_16], ax
mov [rsp+28h+var_20], rcx
mov rdi, [rsp+28h+var_10]; this
mov [rsp+28h+var_28], rdi
mov esi, [rsp+28h+var_14]; unsigned int
call _ZN13MemoryManager11isAddrExistEj; MemoryManager::isAddrExist(uint)
test al, 1
jnz short loc_38D9
mov esi, [rsp+28h+var_14]
lea rdi, aShortWriteToIn; "Short write to invalid addr 0x%x!\n"
mov al, 0
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
mov [rsp+28h+var_1], 0
jmp short loc_391F
loc_38D9:
mov rdi, [rsp+28h+var_28]; this
mov esi, [rsp+28h+var_14]; unsigned int
movzx eax, [rsp+28h+var_16]
and eax, 0FFh
mov rcx, [rsp+28h+var_20]; unsigned int *
movzx edx, al; unsigned __int8
call _ZN13MemoryManager7setByteEjhPj; MemoryManager::setByte(uint,uchar,uint *)
mov rdi, [rsp+28h+var_28]; this
mov esi, [rsp+28h+var_14]
add esi, 1; unsigned int
movzx eax, [rsp+28h+var_16]
sar eax, 8
and eax, 0FFh
xor ecx, ecx; unsigned int *
movzx edx, al; unsigned __int8
call _ZN13MemoryManager7setByteEjhPj; MemoryManager::setByte(uint,uchar,uint *)
mov [rsp+28h+var_1], 1
loc_391F:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
|
char MemoryManager::setShort(
Cache **this,
unsigned int a2,
__int16 a3,
unsigned int *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
double v18; // xmm4_8
double v19; // xmm5_8
if ( MemoryManager::isAddrExist((MemoryManager *)this, a2) )
{
MemoryManager::setByte(this, a2, a3, a4, a5, a6, a7, a8, *(double *)v16.m128_u64, *(double *)v17.m128_u64, a11, a12);
MemoryManager::setByte(this, a2 + 1, HIBYTE(a3), 0LL, a5, a6, a7, a8, v18, v19, a11, a12);
return 1;
}
else
{
dbgprintf(
"Short write to invalid addr 0x%x!\n",
a2,
v12,
v13,
v14,
v15,
a5,
a6,
a7,
a8,
v16,
v17,
a11,
a12,
(char)this);
return 0;
}
}
|
setShort:
SUB RSP,0x28
MOV AX,DX
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV word ptr [RSP + 0x12],AX
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RDI
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x00103430
TEST AL,0x1
JNZ 0x001038d9
MOV ESI,dword ptr [RSP + 0x14]
LEA RDI,[0x10819f]
MOV AL,0x0
CALL 0x00102f60
MOV byte ptr [RSP + 0x27],0x0
JMP 0x0010391f
LAB_001038d9:
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x14]
MOVZX EAX,word ptr [RSP + 0x12]
AND EAX,0xff
MOV RCX,qword ptr [RSP + 0x8]
MOVZX EDX,AL
CALL 0x00103560
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x14]
ADD ESI,0x1
MOVZX EAX,word ptr [RSP + 0x12]
SAR EAX,0x8
AND EAX,0xff
XOR ECX,ECX
MOVZX EDX,AL
CALL 0x00103560
MOV byte ptr [RSP + 0x27],0x1
LAB_0010391f:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* MemoryManager::setShort(unsigned int, unsigned short, unsigned int*) */
bool __thiscall
MemoryManager::setShort(MemoryManager *this,uint param_1,ushort param_2,uint *param_3)
{
ulong uVar1;
bool bVar2;
uVar1 = isAddrExist(this,param_1);
bVar2 = (uVar1 & 1) != 0;
if (bVar2) {
setByte(this,param_1,(uchar)param_2,param_3);
setByte(this,param_1 + 1,(uchar)(param_2 >> 8),(uint *)0x0);
}
else {
dbgprintf("Short write to invalid addr 0x%x!\n",(ulong)param_1);
}
return bVar2;
}
|
|
13,919
|
MemoryManager::setShort(unsigned int, unsigned short, unsigned int*)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp
|
bool MemoryManager::setShort(uint32_t addr, uint16_t val, uint32_t *cycles) {
if (!this->isAddrExist(addr)) {
dbgprintf("Short write to invalid addr 0x%x!\n", addr);
return false;
}
this->setByte(addr, val & 0xFF, cycles);
this->setByte(addr + 1, (val >> 8) & 0xFF);
return true;
}
|
O2
|
cpp
|
MemoryManager::setShort(unsigned int, unsigned short, unsigned int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
callq 0x2b6c
movl %eax, %ebx
testb %al, %al
je 0x2dfe
movzwl %r12w, %r12d
movzbl %r12b, %edx
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rcx
callq 0x2c04
incl %ebp
shrl $0x8, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2c04
jmp 0x2e0e
leaq 0x2395(%rip), %rdi # 0x519a
movl %ebp, %esi
xorl %eax, %eax
callq 0x297d
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN13MemoryManager8setShortEjtPj:
push rbp
push r15
push r14
push r12
push rbx
mov r15, rcx
mov r12d, edx
mov ebp, esi
mov r14, rdi
call _ZN13MemoryManager11isAddrExistEj; MemoryManager::isAddrExist(uint)
mov ebx, eax
test al, al
jz short loc_2DFE
movzx r12d, r12w
movzx edx, r12b; unsigned __int8
mov rdi, r14; this
mov esi, ebp; unsigned int
mov rcx, r15; unsigned int *
call _ZN13MemoryManager7setByteEjhPj; MemoryManager::setByte(uint,uchar,uint *)
inc ebp
shr r12d, 8
mov rdi, r14; this
mov esi, ebp; unsigned int
mov edx, r12d; unsigned __int8
xor ecx, ecx; unsigned int *
call _ZN13MemoryManager7setByteEjhPj; MemoryManager::setByte(uint,uchar,uint *)
jmp short loc_2E0E
loc_2DFE:
lea rdi, aShortWriteToIn; "Short write to invalid addr 0x%x!\n"
mov esi, ebp
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
loc_2E0E:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long MemoryManager::setShort(
MemoryManager *this,
unsigned int a2,
__int16 a3,
unsigned int *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned int v14; // eax
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
unsigned int v21; // ebx
double v22; // xmm4_8
double v23; // xmm5_8
char v25; // [rsp+0h] [rbp-28h]
LOBYTE(v14) = MemoryManager::isAddrExist(this, a2);
v21 = v14;
if ( (_BYTE)v14 )
{
MemoryManager::setByte(
(Cache **)this,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
*(double *)v19.m128_u64,
*(double *)v20.m128_u64,
a11,
a12);
MemoryManager::setByte((Cache **)this, a2 + 1, HIBYTE(a3), 0LL, a5, a6, a7, a8, v22, v23, a11, a12);
}
else
{
dbgprintf("Short write to invalid addr 0x%x!\n", a2, v15, v16, v17, v18, a5, a6, a7, a8, v19, v20, a11, a12, v25);
}
return v21;
}
|
setShort:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R12D,EDX
MOV EBP,ESI
MOV R14,RDI
CALL 0x00102b6c
MOV EBX,EAX
TEST AL,AL
JZ 0x00102dfe
MOVZX R12D,R12W
MOVZX EDX,R12B
MOV RDI,R14
MOV ESI,EBP
MOV RCX,R15
CALL 0x00102c04
INC EBP
SHR R12D,0x8
MOV RDI,R14
MOV ESI,EBP
MOV EDX,R12D
XOR ECX,ECX
CALL 0x00102c04
JMP 0x00102e0e
LAB_00102dfe:
LEA RDI,[0x10519a]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x0010297d
LAB_00102e0e:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* MemoryManager::setShort(unsigned int, unsigned short, unsigned int*) */
int4 __thiscall
MemoryManager::setShort(MemoryManager *this,uint param_1,ushort param_2,uint *param_3)
{
int4 uVar1;
uVar1 = isAddrExist(this,param_1);
if ((char)uVar1 == '\0') {
dbgprintf("Short write to invalid addr 0x%x!\n",param_1);
}
else {
setByte(this,param_1,(uchar)param_2,param_3);
setByte(this,param_1 + 1,(uchar)(param_2 >> 8),(uint *)0x0);
}
return uVar1;
}
|
|
13,920
|
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h
|
void OnTestProgramEnd(const UnitTest& unit_test) override {
// Note that Google Test current only report elapsed time for each
// test iteration, not for the entire test program.
SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
// Notify the streaming server to stop.
socket_writer_->CloseConnection();
}
|
O3
|
c
|
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x34788
leaq 0x963b(%rip), %rcx # 0x42343
leaq 0xb126(%rip), %rsi # 0x43e35
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x961f(%rip), %rax # 0x42344
leaq 0xb10a(%rip), %rdx # 0x43e36
cmovneq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3911e
leaq 0xb872(%rip), %rcx # 0x445b6
movl $0x1c, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8590
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x38d7c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x38d83
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x3903c
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x38dbc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x38dd3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x38e05
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x38e05
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x38e1c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal17StreamingListener16OnTestProgramEndERKNS_8UnitTestE:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
mov rdi, [rsi+40h]; this
call _ZNK7testing8internal12UnitTestImpl6PassedEv; testing::internal::UnitTestImpl::Passed(void)
lea rcx, aFcntlPipeFd1FS+22h; "1"
lea rsi, aStaticCastSize+77h; "0"
test al, al
cmovnz rsi, rcx
lea r15, [rsp+58h+var_28]
mov [r15-10h], r15
lea rax, aFcntlPipeFd1FS+23h; ""
lea rdx, aStaticCastSize+78h; ""
cmovnz rdx, rax
lea r14, [rsp+58h+var_38]
mov rdi, r14
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 rcx, aEventTestprogr_0; "event=TestProgramEnd&passed="
mov r8d, 1Ch
mov rdi, r14
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r14, [rsp+58h+var_48]
mov [r14-10h], r14
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_38D7C
mov [rsp+58h+var_58], rdx
mov rdx, [rcx]
mov [rsp+58h+var_48], rdx
jmp short loc_38D83
loc_38D7C:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r14], xmm0
loc_38D83:
mov rdx, [rax+8]
mov rsi, rsp
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rbx+8]
call _ZN7testing8internal17StreamingListener20AbstractSocketWriter6SendLnERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::string const&)
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r14
jz short loc_38DBC
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38DBC:
mov rdi, [rsp+58h+var_38]; void *
cmp rdi, r15
jz short loc_38DD3
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38DD3:
mov rdi, [rbx+8]
mov rax, [rdi]
call qword ptr [rax+18h]
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r14
jz short loc_38E05
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_38E05
mov rbx, rax
loc_38E05:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r15
jz short loc_38E1C
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38E1C:
mov rdi, rbx
call __Unwind_Resume
|
long long testing::internal::StreamingListener::OnTestProgramEnd(
testing::internal::StreamingListener *this,
testing::internal::UnitTestImpl **a2)
{
bool v2; // al
char *v3; // rsi
char *v4; // rdx
long long v5; // rax
int v6; // r8d
int v7; // r9d
__int128 *v8; // rcx
int v9; // edx
void *v11; // [rsp+0h] [rbp-58h] BYREF
long long v12; // [rsp+8h] [rbp-50h]
__int128 v13; // [rsp+10h] [rbp-48h] BYREF
void *v14[2]; // [rsp+20h] [rbp-38h] BYREF
_QWORD v15[5]; // [rsp+30h] [rbp-28h] BYREF
v2 = testing::internal::UnitTestImpl::Passed(a2[8]);
v3 = "0";
if ( v2 )
v3 = "1";
v14[0] = v15;
v4 = "";
if ( v2 )
v4 = "";
std::string::_M_construct<char const*>(v14, v3, v4);
v5 = std::string::replace(v14, 0LL, 0LL);
v11 = &v13;
v8 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v13 = *v8;
}
else
{
v11 = *(void **)v5;
*(_QWORD *)&v13 = *(_QWORD *)v8;
}
v12 = *(_QWORD *)(v5 + 8);
v9 = v12;
*(_QWORD *)v5 = v8;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(
*((_QWORD *)this + 1),
(unsigned int)&v11,
v9,
(_DWORD)v8,
v6,
v7);
if ( v11 != &v13 )
operator delete(v11, v13 + 1);
if ( v14[0] != v15 )
operator delete(v14[0], v15[0] + 1LL);
return (*(long long ( **)(_QWORD))(**((_QWORD **)this + 1) + 24LL))(*((_QWORD *)this + 1));
}
|
OnTestProgramEnd:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
MOV RDI,qword ptr [RSI + 0x40]
CALL 0x00134788
LEA RCX,[0x142343]
LEA RSI,[0x143e35]
TEST AL,AL
CMOVNZ RSI,RCX
LEA R15,[RSP + 0x30]
MOV qword ptr [R15 + -0x10],R15
LEA RAX,[0x142344]
LEA RDX,[0x143e36]
CMOVNZ RDX,RAX
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x0013911e
LAB_00138d3d:
LEA RCX,[0x1445b6]
MOV R8D,0x1c
MOV RDI,R14
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00108590
LEA R14,[RSP + 0x10]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00138d7c
MOV qword ptr [RSP],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x10],RDX
JMP 0x00138d83
LAB_00138d7c:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R14],XMM0
LAB_00138d83:
MOV RDX,qword ptr [RAX + 0x8]
MOV RSI,RSP
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RBX + 0x8]
LAB_00138da1:
CALL 0x0013903c
LAB_00138da6:
MOV RDI,qword ptr [RSP]
CMP RDI,R14
JZ 0x00138dbc
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001084e0
LAB_00138dbc:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R15
JZ 0x00138dd3
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001084e0
LAB_00138dd3:
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&) */
void __thiscall
testing::internal::StreamingListener::OnTestProgramEnd(StreamingListener *this,UnitTest *param_1)
{
char cVar1;
long *plVar2;
long *plVar3;
char *pcVar4;
char *pcVar5;
long *local_58;
long local_50;
long local_48;
long lStack_40;
long *local_38 [2];
long local_28 [2];
cVar1 = UnitTestImpl::Passed(*(UnitTestImpl **)(param_1 + 0x40));
pcVar5 = "0";
if (cVar1 != '\0') {
pcVar5 = "1";
}
pcVar4 = "";
if (cVar1 != '\0') {
pcVar4 = "";
}
local_38[0] = local_28;
std::__cxx11::string::_M_construct<char_const*>(local_38,pcVar5,pcVar4);
/* try { // try from 00138d3d to 00138d55 has its CatchHandler @ 00138e02 */
plVar2 = (long *)std::__cxx11::string::replace((ulong)local_38,0,(char *)0x0,0x1445b6);
plVar3 = plVar2 + 2;
if ((long *)*plVar2 == plVar3) {
local_48 = *plVar3;
lStack_40 = plVar2[3];
local_58 = &local_48;
}
else {
local_48 = *plVar3;
local_58 = (long *)*plVar2;
}
local_50 = plVar2[1];
*plVar2 = (long)plVar3;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 00138da1 to 00138da5 has its CatchHandler @ 00138de7 */
AbstractSocketWriter::SendLn(*(AbstractSocketWriter **)(this + 8),(string *)&local_58);
if (local_58 != &local_48) {
operator_delete(local_58,local_48 + 1);
}
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
(**(code **)(**(long **)(this + 8) + 0x18))();
return;
}
|
|
13,921
|
ImPlot::DragLineY(int, double*, ImVec4 const&, float, int)
|
zkingston[P]unknot/build_O1/_deps/implot-src/implot.cpp
|
bool DragLineY(int n_id, double* value, const ImVec4& col, float thickness, ImPlotDragToolFlags flags) {
ImGui::PushID("#IMPLOT_DRAG_LINE_Y");
ImPlotContext& gp = *GImPlot;
IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr, "DragLineY() needs to be called between BeginPlot() and EndPlot()!");
SetupLock();
if (!ImHasFlag(flags,ImPlotDragToolFlags_NoFit) && FitThisFrame()) {
FitPointY(*value);
}
const bool input = !ImHasFlag(flags, ImPlotDragToolFlags_NoInputs);
const bool show_curs = !ImHasFlag(flags, ImPlotDragToolFlags_NoCursors);
const bool no_delay = !ImHasFlag(flags, ImPlotDragToolFlags_Delayed);
const float grab_half_size = ImMax(DRAG_GRAB_HALF_SIZE, thickness/2);
float xl = gp.CurrentPlot->PlotRect.Min.x;
float xr = gp.CurrentPlot->PlotRect.Max.x;
float y = IM_ROUND(PlotToPixels(0, *value,IMPLOT_AUTO,IMPLOT_AUTO).y);
const ImGuiID id = ImGui::GetCurrentWindow()->GetID(n_id);
ImRect rect(xl,y-grab_half_size,xr,y+grab_half_size);
bool hovered = false, held = false;
ImGui::KeepAliveID(id);
if (input)
ImGui::ButtonBehavior(rect,id,&hovered,&held);
if ((hovered || held) && show_curs)
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNS);
float len = gp.Style.MajorTickLen.y;
ImVec4 color = IsColorAuto(col) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : col;
ImU32 col32 = ImGui::ColorConvertFloat4ToU32(color);
bool dragging = false;
if (held && ImGui::IsMouseDragging(0)) {
*value = ImPlot::GetPlotMousePos(IMPLOT_AUTO,IMPLOT_AUTO).y;
dragging = true;
}
PushPlotClipRect();
ImDrawList& DrawList = *GetPlotDrawList();
if (dragging && no_delay)
y = IM_ROUND(PlotToPixels(0, *value,IMPLOT_AUTO,IMPLOT_AUTO).y);
DrawList.AddLine(ImVec2(xl,y), ImVec2(xr,y), col32, thickness);
DrawList.AddLine(ImVec2(xl,y), ImVec2(xl+len,y), col32, 3*thickness);
DrawList.AddLine(ImVec2(xr,y), ImVec2(xr-len,y), col32, 3*thickness);
PopPlotClipRect();
ImGui::PopID();
return dragging;
}
|
O1
|
cpp
|
ImPlot::DragLineY(int, double*, ImVec4 const&, float, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movss %xmm0, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %r15d
leaq 0x1d9266(%rip), %rdi # 0x29ac67
callq 0x22a4d4
movq 0x275293(%rip), %r12 # 0x336ca0
cmpq $0x0, 0x50(%r12)
jne 0xc1a21
leaq 0x1d925f(%rip), %rdi # 0x29ac7b
callq 0x2161f4
movq 0x275278(%rip), %r13 # 0x336ca0
movq 0x50(%r13), %rax
cmpb $0x0, 0x9de(%rax)
jne 0xc1a3a
callq 0xb930f
movq 0x50(%r13), %rax
movb $0x1, 0x9de(%rax)
testb $0x2, %bpl
jne 0xc1adf
movq 0x27524a(%rip), %rax # 0x336ca0
movq 0x50(%rax), %rax
cmpb $0x1, 0x9df(%rax)
jne 0xc1adf
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jp 0xc1adf
movapd 0x1d2adb(%rip), %xmm1 # 0x294550
andpd %xmm0, %xmm1
movsd 0x1d8967(%rip), %xmm2 # 0x29a3e8
ucomisd %xmm1, %xmm2
jb 0xc1adf
movslq 0x97c(%rax), %rcx
imulq $0x178, %rcx, %rcx # imm = 0x178
ucomisd 0x58(%rax,%rcx), %xmm0
jb 0xc1adf
movsd 0x60(%rax,%rcx), %xmm1
ucomisd %xmm0, %xmm1
jb 0xc1adf
addq %rcx, %rax
addq $0x18, %rax
movupd 0x28(%rax), %xmm1
movapd %xmm1, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movapd %xmm1, %xmm3
movsd %xmm0, %xmm3 # xmm3 = xmm0[0],xmm3[1]
cmpltpd %xmm2, %xmm3
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
andpd %xmm3, %xmm0
andnpd %xmm1, %xmm3
orpd %xmm0, %xmm3
movupd %xmm3, 0x28(%rax)
movss 0x10(%rsp), %xmm0
mulss 0x1cd533(%rip), %xmm0 # 0x28f020
movss 0x1d8077(%rip), %xmm1 # 0x299b6c
maxss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movq 0x50(%r12), %rax
movss 0x9a0(%rax), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x9a8(%rax), %xmm0
movss %xmm0, 0x1c(%rsp)
movsd (%rbx), %xmm1
xorps %xmm0, %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xc0360
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss 0x1cd4de(%rip), %xmm0 # 0x28f020
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x2754db(%rip), %rax # 0x337030
movq (%rax), %rax
movq 0x1368(%rax), %rdi
movb $0x1, 0xcc(%rdi)
movl %r15d, %esi
callq 0x22a414
movl %eax, %r15d
movaps 0x20(%rsp), %xmm2
movaps %xmm2, %xmm0
movss 0x14(%rsp), %xmm1
subss %xmm1, %xmm0
addss %xmm2, %xmm1
movss 0x18(%rsp), %xmm2
movss %xmm2, 0x40(%rsp)
movss %xmm0, 0x44(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
movss %xmm1, 0x4c(%rsp)
xorl %eax, %eax
movb %al, 0xf(%rsp)
movb %al, 0xe(%rsp)
movl %r15d, %edi
callq 0x21b118
testb $0x4, %bpl
jne 0xc1bdd
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
leaq 0xe(%rsp), %rcx
movl %r15d, %esi
xorl %r8d, %r8d
callq 0x256fee
cmpb $0x0, 0xf(%rsp)
je 0xc1bec
testb $0x1, %bpl
je 0xc1bf9
jmp 0xc1c03
testb $0x1, %bpl
jne 0xc1c03
cmpb $0x0, 0xe(%rsp)
je 0xc1c03
movl $0x3, %edi
callq 0x22b68a
movss 0x134(%r12), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0xc(%r14), %xmm0
ucomiss 0x1cd3e4(%rip), %xmm0 # 0x28f004
jne 0xc1c2e
jp 0xc1c2e
xorl %edi, %edi
callq 0x215eee
movq %rax, %r14
movups (%r14), %xmm0
leaq 0x50(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x213cfe
movl %eax, %r14d
cmpb $0x1, 0xe(%rsp)
jne 0xc1c77
xorl %r15d, %r15d
movss 0x1cd3b0(%rip), %xmm0 # 0x28f004
xorl %edi, %edi
callq 0x22b4f9
testb %al, %al
je 0xc1c7a
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xc062e
movsd %xmm1, (%rbx)
movb $0x1, %r15b
jmp 0xc1c7a
xorl %r15d, %r15d
andl $0x8, %ebp
shrl $0x3, %ebp
xorps %xmm0, %xmm0
callq 0xbd878
callq 0x22983c
movq %rax, %r12
movl %r15d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0xc1cc8
movsd (%rbx), %xmm1
xorps %xmm0, %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xc0360
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss 0x1cd364(%rip), %xmm0 # 0x28f020
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rbx
movss 0x18(%rsp), %xmm0
movss %xmm0, (%rbx)
movaps 0x20(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
leaq 0x30(%rsp), %r13
movss 0x1c(%rsp), %xmm1
movss %xmm1, (%r13)
movss %xmm0, 0x4(%r13)
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %r14d, %ecx
movss 0x10(%rsp), %xmm0
callq 0x23d9c0
movss 0x18(%rsp), %xmm2
movss %xmm2, (%rbx)
movaps 0x20(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
addss 0x14(%rsp), %xmm2
movss %xmm2, (%r13)
movss %xmm0, 0x4(%r13)
movss 0x10(%rsp), %xmm0
mulss 0x1d268d(%rip), %xmm0 # 0x2943d0
movss %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rbx
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x23d9c0
movss 0x1c(%rsp), %xmm0
movss %xmm0, (%rbx)
movaps 0x20(%rsp), %xmm1
movss %xmm1, 0x4(%rbx)
subss 0x14(%rsp), %xmm0
movss %xmm0, (%r13)
movss %xmm1, 0x4(%r13)
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r12, %rdi
movl %r14d, %ecx
movss 0x10(%rsp), %xmm0
callq 0x23d9c0
callq 0xbd912
callq 0x22a94d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6ImPlot9DragLineYEiPdRK6ImVec4fi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov ebp, ecx
movss [rsp+98h+var_88], xmm0
mov r14, rdx
mov rbx, rsi
mov r15d, edi
lea rdi, aImplotDragLine; "#IMPLOT_DRAG_LINE_Y"
call _ZN5ImGui6PushIDEPKc; ImGui::PushID(char const*)
mov r12, cs:GImPlot
cmp qword ptr [r12+50h], 0
jnz short loc_C1A21
lea rdi, aDraglineyNeeds; "DragLineY() needs to be called between "...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_C1A21:
mov r13, cs:GImPlot
mov rax, [r13+50h]
cmp byte ptr [rax+9DEh], 0
jnz short loc_C1A3A
call _ZN6ImPlot11SetupFinishEv; ImPlot::SetupFinish(void)
loc_C1A3A:
mov rax, [r13+50h]
mov byte ptr [rax+9DEh], 1
test bpl, 2
jnz loc_C1ADF
mov rax, cs:GImPlot
mov rax, [rax+50h]
cmp byte ptr [rax+9DFh], 1
jnz short loc_C1ADF
movsd xmm0, qword ptr [rbx]
ucomisd xmm0, xmm0
jp short loc_C1ADF
movapd xmm1, cs:xmmword_294550
andpd xmm1, xmm0
movsd xmm2, cs:qword_29A3E8
ucomisd xmm2, xmm1
jb short loc_C1ADF
movsxd rcx, dword ptr [rax+97Ch]
imul rcx, 178h
ucomisd xmm0, qword ptr [rax+rcx+58h]
jb short loc_C1ADF
movsd xmm1, qword ptr [rax+rcx+60h]
ucomisd xmm1, xmm0
jb short loc_C1ADF
add rax, rcx
add rax, 18h
movupd xmm1, xmmword ptr [rax+28h]
movapd xmm2, xmm1
unpcklpd xmm2, xmm0
movapd xmm3, xmm1
movsd xmm3, xmm0
cmpltpd xmm3, xmm2
unpcklpd xmm0, xmm0
andpd xmm0, xmm3
andnpd xmm3, xmm1
orpd xmm3, xmm0
movupd xmmword ptr [rax+28h], xmm3
loc_C1ADF:
movss xmm0, [rsp+98h+var_88]
mulss xmm0, dword ptr cs:xmmword_28F020
movss xmm1, cs:dword_299B6C
maxss xmm1, xmm0
movss [rsp+98h+var_84], xmm1
mov rax, [r12+50h]
movss xmm0, dword ptr [rax+9A0h]
movss [rsp+98h+var_80], xmm0
movss xmm0, dword ptr [rax+9A8h]
movss [rsp+98h+var_7C], xmm0
movsd xmm1, qword ptr [rbx]; double
xorps xmm0, xmm0; double
mov edi, 0FFFFFFFFh; this
mov esi, 0FFFFFFFFh; int
call _ZN6ImPlot12PlotToPixelsEddii; ImPlot::PlotToPixels(double,double,int,int)
shufps xmm0, xmm0, 55h ; 'U'
addss xmm0, dword ptr cs:xmmword_28F020
cvttps2dq xmm0, xmm0
cvtdq2ps xmm0, xmm0
movaps [rsp+98h+var_78], xmm0
lea rax, GImGui
mov rax, [rax]
mov rdi, [rax+1368h]; this
mov byte ptr [rdi+0CCh], 1
mov esi, r15d; unsigned int
call _ZN11ImGuiWindow5GetIDEi; ImGuiWindow::GetID(int)
mov r15d, eax
movaps xmm2, [rsp+98h+var_78]
movaps xmm0, xmm2
movss xmm1, [rsp+98h+var_84]
subss xmm0, xmm1
addss xmm1, xmm2
movss xmm2, [rsp+98h+var_80]
movss [rsp+98h+var_58], xmm2
movss [rsp+98h+var_54], xmm0
movss xmm0, [rsp+98h+var_7C]
movss [rsp+98h+var_50], xmm0
movss [rsp+98h+var_4C], xmm1
xor eax, eax
mov [rsp+98h+var_89], al
mov [rsp+98h+var_8A], al
mov edi, r15d; this
call _ZN5ImGui11KeepAliveIDEj; ImGui::KeepAliveID(uint)
test bpl, 4
jnz short loc_C1BDD
lea rdi, [rsp+98h+var_58]
lea rdx, [rsp+98h+var_89]
lea rcx, [rsp+98h+var_8A]
mov esi, r15d; int
xor r8d, r8d
call _ZN5ImGui14ButtonBehaviorERK6ImRectjPbS3_i; ImGui::ButtonBehavior(ImRect const&,uint,bool *,bool *,int)
loc_C1BDD:
cmp [rsp+98h+var_89], 0
jz short loc_C1BEC
test bpl, 1
jz short loc_C1BF9
jmp short loc_C1C03
loc_C1BEC:
test bpl, 1
jnz short loc_C1C03
cmp [rsp+98h+var_8A], 0
jz short loc_C1C03
loc_C1BF9:
mov edi, (offset dword_0+3); this
call _ZN5ImGui14SetMouseCursorEi; ImGui::SetMouseCursor(int)
loc_C1C03:
movss xmm0, dword ptr [r12+134h]
movss [rsp+98h+var_84], xmm0
movss xmm0, dword ptr [r14+0Ch]
ucomiss xmm0, cs:flt_28F004
jnz short loc_C1C2E
jp short loc_C1C2E
xor edi, edi; this
call _ZN5ImGui17GetStyleColorVec4Ei; ImGui::GetStyleColorVec4(int)
mov r14, rax
loc_C1C2E:
movups xmm0, xmmword ptr [r14]
lea rdi, [rsp+98h+var_48]; this
movaps xmmword ptr [rdi], xmm0
call _ZN5ImGui23ColorConvertFloat4ToU32ERK6ImVec4; ImGui::ColorConvertFloat4ToU32(ImVec4 const&)
mov r14d, eax
cmp [rsp+98h+var_8A], 1
jnz short loc_C1C77
xor r15d, r15d
movss xmm0, cs:flt_28F004; float
xor edi, edi; this
call _ZN5ImGui15IsMouseDraggingEif; ImGui::IsMouseDragging(int,float)
test al, al
jz short loc_C1C7A
mov edi, 0FFFFFFFFh; this
mov esi, 0FFFFFFFFh; int
call _ZN6ImPlot15GetPlotMousePosEii; ImPlot::GetPlotMousePos(int,int)
movsd qword ptr [rbx], xmm1
mov r15b, 1
jmp short loc_C1C7A
loc_C1C77:
xor r15d, r15d
loc_C1C7A:
and ebp, 8
shr ebp, 3
xorps xmm0, xmm0; float
call _ZN6ImPlot16PushPlotClipRectEf; ImPlot::PushPlotClipRect(float)
call _ZN5ImGui17GetWindowDrawListEv; ImGui::GetWindowDrawList(void)
mov r12, rax
mov eax, r15d
xor al, 1
or al, bpl
jnz short loc_C1CC8
movsd xmm1, qword ptr [rbx]; double
xorps xmm0, xmm0; double
mov edi, 0FFFFFFFFh; this
mov esi, 0FFFFFFFFh; int
call _ZN6ImPlot12PlotToPixelsEddii; ImPlot::PlotToPixels(double,double,int,int)
shufps xmm0, xmm0, 55h ; 'U'
addss xmm0, dword ptr cs:xmmword_28F020
cvttps2dq xmm0, xmm0
cvtdq2ps xmm0, xmm0
movaps [rsp+98h+var_78], xmm0
loc_C1CC8:
lea rbx, [rsp+98h+var_60]
movss xmm0, [rsp+98h+var_80]
movss dword ptr [rbx], xmm0
movaps xmm0, [rsp+98h+var_78]
movss dword ptr [rbx+4], xmm0
lea r13, [rsp+98h+var_68]
movss xmm1, [rsp+98h+var_7C]
movss dword ptr [r13+0], xmm1
movss dword ptr [r13+4], xmm0
mov rdi, r12; this
mov rsi, rbx
mov rdx, r13
mov ecx, r14d
movss xmm0, [rsp+98h+var_88]
call _ZN10ImDrawList7AddLineERK6ImVec2S2_jf; ImDrawList::AddLine(ImVec2 const&,ImVec2 const&,uint,float)
movss xmm2, [rsp+98h+var_80]
movss dword ptr [rbx], xmm2
movaps xmm0, [rsp+98h+var_78]
movss dword ptr [rbx+4], xmm0
addss xmm2, [rsp+98h+var_84]
movss dword ptr [r13+0], xmm2
movss dword ptr [r13+4], xmm0
movss xmm0, [rsp+98h+var_88]
mulss xmm0, cs:flt_2943D0
movss [rsp+98h+var_88], xmm0
lea rbx, [rsp+98h+var_60]
lea r13, [rsp+98h+var_68]
mov rdi, r12; this
mov rsi, rbx
mov rdx, r13
mov ecx, r14d
call _ZN10ImDrawList7AddLineERK6ImVec2S2_jf; ImDrawList::AddLine(ImVec2 const&,ImVec2 const&,uint,float)
movss xmm0, [rsp+98h+var_7C]
movss dword ptr [rbx], xmm0
movaps xmm1, [rsp+98h+var_78]
movss dword ptr [rbx+4], xmm1
subss xmm0, [rsp+98h+var_84]
movss dword ptr [r13+0], xmm0
movss dword ptr [r13+4], xmm1
lea rsi, [rsp+98h+var_60]
lea rdx, [rsp+98h+var_68]
mov rdi, r12; this
mov ecx, r14d
movss xmm0, [rsp+98h+var_88]
call _ZN10ImDrawList7AddLineERK6ImVec2S2_jf; ImDrawList::AddLine(ImVec2 const&,ImVec2 const&,uint,float)
call _ZN6ImPlot15PopPlotClipRectEv; ImPlot::PopPlotClipRect(void)
call _ZN5ImGui5PopIDEv; ImGui::PopID(void)
mov eax, r15d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ImPlot::DragLineY(unsigned int a1, char *a2, long long StyleColorVec4, char a4, float a5)
{
char *v9; // rdi
ImGui *v10; // r12
ImGui *v11; // r13
long long v12; // rax
__m128d v13; // xmm0
long long v14; // rcx
long long v15; // rax
__m128d v16; // xmm3
__m128d v17; // xmm3
long long v18; // rax
__m128 v19; // xmm0
__m128 v20; // xmm0
ImGuiWindow *v21; // rdi
long long v22; // rsi
unsigned int ID; // r15d
double v24; // xmm1_8
__m128 v25; // xmm2
long long v26; // rdi
unsigned int v27; // r15d
ImDrawList *WindowDrawList; // r12
__m128 v29; // xmm0
__m128 v30; // xmm0
char v32; // [rsp+Eh] [rbp-8Ah] BYREF
char v33; // [rsp+Fh] [rbp-89h] BYREF
float v34; // [rsp+10h] [rbp-88h]
float v35; // [rsp+14h] [rbp-84h]
float v36; // [rsp+18h] [rbp-80h]
float v37; // [rsp+1Ch] [rbp-7Ch]
__m128 v38; // [rsp+20h] [rbp-78h]
float v39; // [rsp+30h] [rbp-68h]
__int32 v40; // [rsp+34h] [rbp-64h]
float v41; // [rsp+38h] [rbp-60h] BYREF
__int32 v42; // [rsp+3Ch] [rbp-5Ch]
_DWORD v43[4]; // [rsp+40h] [rbp-58h] BYREF
_OWORD v44[4]; // [rsp+50h] [rbp-48h] BYREF
v34 = a5;
v9 = "#IMPLOT_DRAG_LINE_Y";
ImGui::PushID((ImGui *)"#IMPLOT_DRAG_LINE_Y", a2);
v10 = GImPlot;
if ( !*((_QWORD *)GImPlot + 10) )
{
v9 = "DragLineY() needs to be called between BeginPlot() and EndPlot()!";
ImGui::ErrorLog((ImGui *)"DragLineY() needs to be called between BeginPlot() and EndPlot()!", a2);
}
v11 = GImPlot;
if ( !*(_BYTE *)(*((_QWORD *)GImPlot + 10) + 2526LL) )
ImPlot::SetupFinish((ImPlot *)v9, a2);
*(_BYTE *)(*((_QWORD *)v11 + 10) + 2526LL) = 1;
if ( (a4 & 2) == 0 )
{
v12 = *((_QWORD *)GImPlot + 10);
if ( *(_BYTE *)(v12 + 2527) == 1 )
{
v13 = (__m128d)*(unsigned long long *)a2;
if ( fabs(v13.m128d_f64[0]) <= 1.797693134862316e308 )
{
v14 = 376LL * *(int *)(v12 + 2428);
if ( v13.m128d_f64[0] >= *(double *)(v12 + v14 + 88) && *(double *)(v12 + v14 + 96) >= v13.m128d_f64[0] )
{
v15 = v14 + v12 + 24;
v16.m128d_f64[1] = *(double *)(v15 + 48);
v16.m128d_f64[0] = v13.m128d_f64[0];
v17 = _mm_cmplt_pd(v16, _mm_unpacklo_pd(*(__m128d *)(v15 + 40), v13));
*(__m128d *)(v15 + 40) = _mm_or_pd(
_mm_andn_pd(v17, *(__m128d *)(v15 + 40)),
_mm_and_pd(_mm_unpacklo_pd(v13, v13), v17));
}
}
}
}
v35 = fmaxf(4.0, v34 * 0.5);
v18 = *((_QWORD *)v10 + 10);
v36 = *(float *)(v18 + 2464);
v37 = *(float *)(v18 + 2472);
v19 = ImPlot::PlotToPixels(
(ImPlot *)0xFFFFFFFFLL,
(__m128d)0LL,
(__m128d)*(unsigned long long *)a2,
(const char *)0xFFFFFFFFLL);
v20 = _mm_shuffle_ps(v19, v19, 85);
v20.m128_f32[0] = v20.m128_f32[0] + 0.5;
v38 = _mm_cvtepi32_ps(_mm_cvttps_epi32(v20));
v21 = (ImGuiWindow *)*((_QWORD *)GImGui + 621);
*((_BYTE *)v21 + 204) = 1;
v22 = a1;
ID = ImGuiWindow::GetID(v21, a1);
*(_QWORD *)&v24 = LODWORD(v35);
*(float *)&v24 = v35 + v38.m128_f32[0];
v25 = (__m128)LODWORD(v36);
*(float *)v43 = v36;
*(float *)&v43[1] = v38.m128_f32[0] - v35;
*(float *)&v43[2] = v37;
*(float *)&v43[3] = v35 + v38.m128_f32[0];
v33 = 0;
v32 = 0;
ImGui::KeepAliveID((ImGui *)ID, v22);
if ( (a4 & 4) == 0 )
{
v22 = ID;
ImGui::ButtonBehavior(v43, ID, &v33, &v32, 0LL);
}
if ( v33 )
{
if ( (a4 & 1) != 0 )
goto LABEL_19;
LABEL_18:
ImGui::SetMouseCursor((ImGui *)((char *)&dword_0 + 3), v22);
goto LABEL_19;
}
if ( (a4 & 1) == 0 && v32 )
goto LABEL_18;
LABEL_19:
v35 = *((float *)v10 + 77);
if ( *(float *)(StyleColorVec4 + 12) == -1.0 )
StyleColorVec4 = ImGui::GetStyleColorVec4(0LL, v22);
v26 = (long long)v44;
v44[0] = *(_OWORD *)StyleColorVec4;
ImGui::ColorConvertFloat4ToU32(v44);
if ( v32 == 1 )
{
v27 = 0;
v26 = 0LL;
if ( (unsigned __int8)ImGui::IsMouseDragging(0LL, v22, -1.0) )
{
v26 = 0xFFFFFFFFLL;
v22 = 0xFFFFFFFFLL;
ImPlot::GetPlotMousePos((ImPlot *)0xFFFFFFFFLL, (const char *)0xFFFFFFFFLL, (__m128)0xBF800000, v24, v25);
*(double *)a2 = v24;
LOBYTE(v27) = 1;
}
}
else
{
v27 = 0;
}
ImPlot::PushPlotClipRect((ImPlot *)v26, (__m128)0LL, (const char *)v22);
WindowDrawList = (ImDrawList *)ImGui::GetWindowDrawList((ImGui *)v26);
if ( !(((unsigned __int8)(a4 & 8) >> 3) | (unsigned __int8)v27 ^ 1) )
{
v29 = ImPlot::PlotToPixels(
(ImPlot *)0xFFFFFFFFLL,
(__m128d)0LL,
(__m128d)*(unsigned long long *)a2,
(const char *)0xFFFFFFFFLL);
v30 = _mm_shuffle_ps(v29, v29, 85);
v30.m128_f32[0] = v30.m128_f32[0] + 0.5;
v38 = _mm_cvtepi32_ps(_mm_cvttps_epi32(v30));
}
v41 = v36;
v42 = v38.m128_i32[0];
v39 = v37;
v40 = v38.m128_i32[0];
ImDrawList::AddLine(WindowDrawList);
v41 = v36;
v42 = v38.m128_i32[0];
v39 = v36 + v35;
v40 = v38.m128_i32[0];
v34 = v34 * 3.0;
ImDrawList::AddLine(WindowDrawList);
v41 = v37;
v42 = v38.m128_i32[0];
v39 = v37 - v35;
v40 = v38.m128_i32[0];
ImDrawList::AddLine(WindowDrawList);
ImPlot::PopPlotClipRect(WindowDrawList, (const char *)&v41);
ImGui::PopID(WindowDrawList);
return v27;
}
|
DragLineY:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV EBP,ECX
MOVSS dword ptr [RSP + 0x10],XMM0
MOV R14,RDX
MOV RBX,RSI
MOV R15D,EDI
LEA RDI,[0x39ac67]
CALL 0x0032a4d4
MOV R12,qword ptr [0x00436ca0]
CMP qword ptr [R12 + 0x50],0x0
JNZ 0x001c1a21
LEA RDI,[0x39ac7b]
CALL 0x003161f4
LAB_001c1a21:
MOV R13,qword ptr [0x00436ca0]
MOV RAX,qword ptr [R13 + 0x50]
CMP byte ptr [RAX + 0x9de],0x0
JNZ 0x001c1a3a
CALL 0x001b930f
LAB_001c1a3a:
MOV RAX,qword ptr [R13 + 0x50]
MOV byte ptr [RAX + 0x9de],0x1
TEST BPL,0x2
JNZ 0x001c1adf
MOV RAX,qword ptr [0x00436ca0]
MOV RAX,qword ptr [RAX + 0x50]
CMP byte ptr [RAX + 0x9df],0x1
JNZ 0x001c1adf
MOVSD XMM0,qword ptr [RBX]
UCOMISD XMM0,XMM0
JP 0x001c1adf
MOVAPD XMM1,xmmword ptr [0x00394550]
ANDPD XMM1,XMM0
MOVSD XMM2,qword ptr [0x0039a3e8]
UCOMISD XMM2,XMM1
JC 0x001c1adf
MOVSXD RCX,dword ptr [RAX + 0x97c]
IMUL RCX,RCX,0x178
UCOMISD XMM0,qword ptr [RAX + RCX*0x1 + 0x58]
JC 0x001c1adf
MOVSD XMM1,qword ptr [RAX + RCX*0x1 + 0x60]
UCOMISD XMM1,XMM0
JC 0x001c1adf
ADD RAX,RCX
ADD RAX,0x18
MOVUPD XMM1,xmmword ptr [RAX + 0x28]
MOVAPD XMM2,XMM1
UNPCKLPD XMM2,XMM0
MOVAPD XMM3,XMM1
MOVSD XMM3,XMM0
CMPLTPD XMM3,XMM2
UNPCKLPD XMM0,XMM0
ANDPD XMM0,XMM3
ANDNPD XMM3,XMM1
ORPD XMM3,XMM0
MOVUPD xmmword ptr [RAX + 0x28],XMM3
LAB_001c1adf:
MOVSS XMM0,dword ptr [RSP + 0x10]
MULSS XMM0,dword ptr [0x0038f020]
MOVSS XMM1,dword ptr [0x00399b6c]
MAXSS XMM1,XMM0
MOVSS dword ptr [RSP + 0x14],XMM1
MOV RAX,qword ptr [R12 + 0x50]
MOVSS XMM0,dword ptr [RAX + 0x9a0]
MOVSS dword ptr [RSP + 0x18],XMM0
MOVSS XMM0,dword ptr [RAX + 0x9a8]
MOVSS dword ptr [RSP + 0x1c],XMM0
MOVSD XMM1,qword ptr [RBX]
XORPS XMM0,XMM0
MOV EDI,0xffffffff
MOV ESI,0xffffffff
CALL 0x001c0360
SHUFPS XMM0,XMM0,0x55
ADDSS XMM0,dword ptr [0x0038f020]
CVTTPS2DQ XMM0,XMM0
CVTDQ2PS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LEA RAX,[0x437030]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x1368]
MOV byte ptr [RDI + 0xcc],0x1
MOV ESI,R15D
CALL 0x0032a414
MOV R15D,EAX
MOVAPS XMM2,xmmword ptr [RSP + 0x20]
MOVAPS XMM0,XMM2
MOVSS XMM1,dword ptr [RSP + 0x14]
SUBSS XMM0,XMM1
ADDSS XMM1,XMM2
MOVSS XMM2,dword ptr [RSP + 0x18]
MOVSS dword ptr [RSP + 0x40],XMM2
MOVSS dword ptr [RSP + 0x44],XMM0
MOVSS XMM0,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RSP + 0x48],XMM0
MOVSS dword ptr [RSP + 0x4c],XMM1
XOR EAX,EAX
MOV byte ptr [RSP + 0xf],AL
MOV byte ptr [RSP + 0xe],AL
MOV EDI,R15D
CALL 0x0031b118
TEST BPL,0x4
JNZ 0x001c1bdd
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0xf]
LEA RCX,[RSP + 0xe]
MOV ESI,R15D
XOR R8D,R8D
CALL 0x00356fee
LAB_001c1bdd:
CMP byte ptr [RSP + 0xf],0x0
JZ 0x001c1bec
TEST BPL,0x1
JZ 0x001c1bf9
JMP 0x001c1c03
LAB_001c1bec:
TEST BPL,0x1
JNZ 0x001c1c03
CMP byte ptr [RSP + 0xe],0x0
JZ 0x001c1c03
LAB_001c1bf9:
MOV EDI,0x3
CALL 0x0032b68a
LAB_001c1c03:
MOVSS XMM0,dword ptr [R12 + 0x134]
MOVSS dword ptr [RSP + 0x14],XMM0
MOVSS XMM0,dword ptr [R14 + 0xc]
UCOMISS XMM0,dword ptr [0x0038f004]
JNZ 0x001c1c2e
JP 0x001c1c2e
XOR EDI,EDI
CALL 0x00315eee
MOV R14,RAX
LAB_001c1c2e:
MOVUPS XMM0,xmmword ptr [R14]
LEA RDI,[RSP + 0x50]
MOVAPS xmmword ptr [RDI],XMM0
CALL 0x00313cfe
MOV R14D,EAX
CMP byte ptr [RSP + 0xe],0x1
JNZ 0x001c1c77
XOR R15D,R15D
MOVSS XMM0,dword ptr [0x0038f004]
XOR EDI,EDI
CALL 0x0032b4f9
TEST AL,AL
JZ 0x001c1c7a
MOV EDI,0xffffffff
MOV ESI,0xffffffff
CALL 0x001c062e
MOVSD qword ptr [RBX],XMM1
MOV R15B,0x1
JMP 0x001c1c7a
LAB_001c1c77:
XOR R15D,R15D
LAB_001c1c7a:
AND EBP,0x8
SHR EBP,0x3
XORPS XMM0,XMM0
CALL 0x001bd878
CALL 0x0032983c
MOV R12,RAX
MOV EAX,R15D
XOR AL,0x1
OR AL,BPL
JNZ 0x001c1cc8
MOVSD XMM1,qword ptr [RBX]
XORPS XMM0,XMM0
MOV EDI,0xffffffff
MOV ESI,0xffffffff
CALL 0x001c0360
SHUFPS XMM0,XMM0,0x55
ADDSS XMM0,dword ptr [0x0038f020]
CVTTPS2DQ XMM0,XMM0
CVTDQ2PS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LAB_001c1cc8:
LEA RBX,[RSP + 0x38]
MOVSS XMM0,dword ptr [RSP + 0x18]
MOVSS dword ptr [RBX],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVSS dword ptr [RBX + 0x4],XMM0
LEA R13,[RSP + 0x30]
MOVSS XMM1,dword ptr [RSP + 0x1c]
MOVSS dword ptr [R13],XMM1
MOVSS dword ptr [R13 + 0x4],XMM0
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R13
MOV ECX,R14D
MOVSS XMM0,dword ptr [RSP + 0x10]
CALL 0x0033d9c0
MOVSS XMM2,dword ptr [RSP + 0x18]
MOVSS dword ptr [RBX],XMM2
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVSS dword ptr [RBX + 0x4],XMM0
ADDSS XMM2,dword ptr [RSP + 0x14]
MOVSS dword ptr [R13],XMM2
MOVSS dword ptr [R13 + 0x4],XMM0
MOVSS XMM0,dword ptr [RSP + 0x10]
MULSS XMM0,dword ptr [0x003943d0]
MOVSS dword ptr [RSP + 0x10],XMM0
LEA RBX,[RSP + 0x38]
LEA R13,[RSP + 0x30]
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R13
MOV ECX,R14D
CALL 0x0033d9c0
MOVSS XMM0,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RBX],XMM0
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MOVSS dword ptr [RBX + 0x4],XMM1
SUBSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [R13],XMM0
MOVSS dword ptr [R13 + 0x4],XMM1
LEA RSI,[RSP + 0x38]
LEA RDX,[RSP + 0x30]
MOV RDI,R12
MOV ECX,R14D
MOVSS XMM0,dword ptr [RSP + 0x10]
CALL 0x0033d9c0
CALL 0x001bd912
CALL 0x0032a94d
MOV EAX,R15D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ImPlot::DragLineY(int, double*, ImVec4 const&, float, int) */
char ImPlot::DragLineY(int param_1,double *param_2,ImVec4 *param_3,float param_4,int param_5)
{
ImGuiWindow *this;
int1 auVar1 [16];
ulong uVar2;
long lVar3;
char cVar4;
uint uVar5;
long lVar6;
ImDrawList *this_00;
long lVar7;
char cVar8;
ulong uVar9;
ulong uVar10;
float extraout_XMM0_Db;
float extraout_XMM0_Db_00;
double dVar11;
int1 auVar12 [16];
bool local_8a;
bool local_89;
float local_88;
float local_84;
float local_80;
float local_7c;
float local_78;
float fStack_74;
float fStack_70;
float fStack_6c;
float local_68;
float local_64;
float local_60;
float local_5c;
float local_58;
float local_54;
float local_50;
float local_4c;
int8 local_48;
int8 uStack_40;
local_88 = param_4;
ImGui::PushID("#IMPLOT_DRAG_LINE_Y");
lVar3 = GImPlot;
if (*(long *)(GImPlot + 0x50) == 0) {
ImGui::ErrorLog("DragLineY() needs to be called between BeginPlot() and EndPlot()!");
}
lVar6 = GImPlot;
if (*(char *)(*(long *)(GImPlot + 0x50) + 0x9de) == '\0') {
SetupFinish();
}
*(int1 *)(*(long *)(lVar6 + 0x50) + 0x9de) = 1;
if ((((((param_5 & 2U) == 0) &&
(lVar6 = *(long *)(GImPlot + 0x50), *(char *)(lVar6 + 0x9df) == '\x01')) &&
(dVar11 = *param_2, !NAN(dVar11))) &&
(((double)(_DAT_00394550 & (ulong)dVar11) <= DAT_0039a3e8 &&
(lVar7 = (long)*(int *)(lVar6 + 0x97c) * 0x178, *(double *)(lVar6 + 0x58 + lVar7) <= dVar11))
)) && (dVar11 <= *(double *)(lVar6 + 0x60 + lVar7))) {
lVar6 = lVar6 + lVar7;
uVar9 = -(ulong)(dVar11 < *(double *)(lVar6 + 0x40));
uVar10 = -(ulong)(*(double *)(lVar6 + 0x48) < dVar11);
uVar2 = (ulong)dVar11 & uVar10;
auVar12._0_8_ = ~uVar9 & (ulong)*(double *)(lVar6 + 0x40);
auVar12._8_8_ = ~uVar10 & (ulong)*(double *)(lVar6 + 0x48);
auVar1._8_4_ = (int)uVar2;
auVar1._0_8_ = (ulong)dVar11 & uVar9;
auVar1._12_4_ = (int)(uVar2 >> 0x20);
*(int1 (*) [16])(lVar6 + 0x40) = auVar12 | auVar1;
}
local_84 = DAT_00399b6c;
if (DAT_00399b6c <= local_88 * DAT_0038f020) {
local_84 = local_88 * DAT_0038f020;
}
lVar6 = *(long *)(lVar3 + 0x50);
local_80 = *(float *)(lVar6 + 0x9a0);
local_7c = *(float *)(lVar6 + 0x9a8);
PlotToPixels(0.0,*param_2,-1,-1);
local_78 = (float)(int)(extraout_XMM0_Db + DAT_0038f020);
fStack_74 = (float)(int)extraout_XMM0_Db;
fStack_70 = (float)(int)extraout_XMM0_Db;
fStack_6c = (float)(int)extraout_XMM0_Db;
this = *(ImGuiWindow **)(GImGui + 0x1368);
this[0xcc] = (ImGuiWindow)0x1;
uVar5 = ImGuiWindow::GetID(this,param_1);
local_54 = local_78 - local_84;
local_4c = local_84 + local_78;
dVar11 = (double)(ulong)(uint)local_4c;
local_58 = local_80;
local_50 = local_7c;
local_89 = false;
local_8a = false;
ImGui::KeepAliveID(uVar5);
if ((param_5 & 4U) == 0) {
ImGui::ButtonBehavior((ImRect *)&local_58,uVar5,&local_89,&local_8a,0);
}
if (local_89 == false) {
if (((param_5 & 1U) != 0) || (local_8a == false)) goto LAB_001c1c03;
}
else if ((param_5 & 1U) != 0) goto LAB_001c1c03;
ImGui::SetMouseCursor(3);
LAB_001c1c03:
local_84 = *(float *)(lVar3 + 0x134);
if ((*(float *)(param_3 + 0xc) == DAT_0038f004) &&
(!NAN(*(float *)(param_3 + 0xc)) && !NAN(DAT_0038f004))) {
param_3 = (ImVec4 *)ImGui::GetStyleColorVec4(0);
}
local_48 = *(int8 *)param_3;
uStack_40 = *(int8 *)(param_3 + 8);
uVar5 = ImGui::ColorConvertFloat4ToU32((ImVec4 *)&local_48);
if (local_8a == true) {
cVar8 = '\0';
cVar4 = ImGui::IsMouseDragging(0,DAT_0038f004);
if (cVar4 != '\0') {
GetPlotMousePos(-1,-1);
*param_2 = dVar11;
cVar8 = '\x01';
}
}
else {
cVar8 = '\0';
}
PushPlotClipRect(0.0);
this_00 = (ImDrawList *)ImGui::GetWindowDrawList();
if (cVar8 == '\x01' && (char)((param_5 & 8U) >> 3) == '\0') {
PlotToPixels(0.0,*param_2,-1,-1);
local_78 = (float)(int)(extraout_XMM0_Db_00 + DAT_0038f020);
fStack_74 = (float)(int)extraout_XMM0_Db_00;
fStack_70 = (float)(int)extraout_XMM0_Db_00;
fStack_6c = (float)(int)extraout_XMM0_Db_00;
}
local_60 = local_80;
local_5c = local_78;
local_68 = local_7c;
local_64 = local_78;
ImDrawList::AddLine(this_00,(ImVec2 *)&local_60,(ImVec2 *)&local_68,uVar5,local_88);
local_60 = local_80;
local_5c = local_78;
local_68 = local_80 + local_84;
local_64 = local_78;
local_88 = local_88 * DAT_003943d0;
ImDrawList::AddLine(this_00,(ImVec2 *)&local_60,(ImVec2 *)&local_68,uVar5,local_88);
local_60 = local_7c;
local_5c = local_78;
local_68 = local_7c - local_84;
local_64 = local_78;
ImDrawList::AddLine(this_00,(ImVec2 *)&local_60,(ImVec2 *)&local_68,uVar5,local_88);
PopPlotClipRect();
ImGui::PopID();
return cVar8;
}
|
|
13,922
|
minja::split(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&)
|
llama.cpp/common/minja/minja.hpp
|
static std::vector<std::string> split(const std::string & s, const std::string & sep) {
std::vector<std::string> result;
size_t start = 0;
size_t end = s.find(sep);
while (end != std::string::npos) {
result.push_back(s.substr(start, end - start));
start = end + sep.length();
end = s.find(sep, start);
}
result.push_back(s.substr(start));
return result;
}
|
O3
|
cpp
|
minja::split(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 $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x205c0
cmpq $-0x1, %rax
je 0xaf5f0
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x210c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x28998
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xaf5cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x205c0
movq %rax, %r12
cmpq $-0x1, %rax
jne 0xaf594
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x210c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28998
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf62f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0xaf660
jmp 0xaf64e
movq %rax, %r14
jmp 0xaf672
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xaf672
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
movq %rbx, %rdi
callq 0x278c6
movq %r14, %rdi
callq 0x20ae0
|
_ZN5minjaL5splitERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebp, ebp
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_AF5F0
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_AF594:
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_AF5CF
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF5CF:
mov rsi, [r15]
mov rcx, [r15+8]
mov rbp, r12
add rbp, rcx
mov rdi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r12, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_AF594
loc_AF5F0:
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, rbp
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AF62F
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF62F:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
jmp short loc_AF660
jmp short $+2
loc_AF64E:
mov r14, rax
jmp short loc_AF672
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_AF660:
cmp rdi, rax
jz short loc_AF672
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF672:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
|
void minja::split(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // r12
long long v7; // rcx
void *v8[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v9[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
v5 = std::string::find(a2, *a3, 0LL, a3[1]);
if ( v5 != -1 )
{
v6 = v5;
v4 = 0LL;
do
{
std::string::substr(v8, a2, v4, v6 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
v7 = a3[1];
v4 = v7 + v6;
v6 = std::string::find(a2, *a3, v7 + v6, v7);
}
while ( v6 != -1 );
}
std::string::substr(v8, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
}
|
split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBP,EBP
MOV RDI,R14
XOR EDX,EDX
CALL 0x001205c0
CMP RAX,-0x1
JZ 0x001af5f0
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_001af594:
MOV RCX,R12
SUB RCX,RBP
LAB_001af59a:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x001210c0
LAB_001af5a8:
MOV RDI,RBX
MOV RSI,R13
CALL 0x00128998
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001af5cf
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
LAB_001af5cf:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x001205c0
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x001af594
LAB_001af5f0:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x001210c0
LAB_001af607:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00128998
LAB_001af614:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001af62f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
LAB_001af62f:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::split(std::__cxx11::string const&, std::__cxx11::string const&) */
void __thiscall minja::split(minja *this,string *param_1,string *param_2)
{
long lVar1;
long *local_50 [2];
long local_40 [2];
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
lVar1 = std::__cxx11::string::find((char *)param_1,*(ulong *)param_2,0);
if (lVar1 != -1) {
do {
/* try { // try from 001af59a to 001af5a7 has its CatchHandler @ 001af64e */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 001af5a8 to 001af5b2 has its CatchHandler @ 001af653 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = std::__cxx11::string::find
((char *)param_1,*(ulong *)param_2,lVar1 + *(long *)(param_2 + 8));
} while (lVar1 != -1);
}
/* try { // try from 001af5f0 to 001af606 has its CatchHandler @ 001af64c */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 001af607 to 001af613 has its CatchHandler @ 001af63e */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return;
}
|
|
13,923
|
inline_mysql_file_pread
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, 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_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_pread:
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 0x2717ac(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x6, %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 0x4fabf
leaq 0x271762(%rip), %rax # 0x2c1158
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 0xf59e0
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x4fa6a
cmpq $0x0, -0x38(%rbp)
jne 0x4fa4f
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x4fa5a
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x4fa5a
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x4fa97
cmpq $-0x1, -0x38(%rbp)
je 0x4fa7e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x4fa89
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x4fa89
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x2716ba(%rip), %rax # 0x2c1158
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 0x4fae3
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xf59e0
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_pread_2:
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, 6
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_4FABF
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_pread
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_4FA6A
cmp [rbp+var_38], 0
jnz short loc_4FA4F
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_4FA5A
loc_4FA4F:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_4FA5A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_4FA97
loc_4FA6A:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_4FA7E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_4FA89
loc_4FA7E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_4FA89:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_4FA97:
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_4FAE3
loc_4FABF:
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_pread
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_4FAE3:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long inline_mysql_file_pread_2(
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, 6LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pread(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_pread(v16, v15, v14, v13, a7);
}
}
|
inline_mysql_file_pread:
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,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x6
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 0x0014fabf
LEA RAX,[0x3c1158]
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 0x001f59e0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x0014fa6a
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0014fa4f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0014fa5a
LAB_0014fa4f:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0014fa5a
LAB_0014fa5a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0014fa97
LAB_0014fa6a:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x0014fa7e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0014fa89
LAB_0014fa7e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0014fa89
LAB_0014fa89:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_0014fa97:
LEA RAX,[0x3c1158]
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 0x0014fae3
LAB_0014fabf:
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 0x001f59e0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_0014fae3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pread
(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,6);
if (local_48 == 0) {
local_10 = my_pread(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_pread(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;
}
|
|
13,924
|
inline_mysql_file_pread
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, 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_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
}
|
O3
|
c
|
inline_mysql_file_pread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %r13d
leaq 0x333031(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x550d1
movl $0x4, %r8d
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xa158c
movq %rax, %r14
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x332fe5(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq 0x86c7f(%rip), %rdx # 0xdbd64
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %ecx
callq *0x210(%rax)
xorl %r13d, %r13d
movl $0x4, %r8d
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xa158c
movq %rax, %r14
testq %rax, %rax
cmoveq %rbx, %r13
leaq 0x332fa2(%rip), %rax # 0x3880c0
movq (%rax), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x218(%rax)
jmp 0x550bf
|
inline_mysql_file_pread_1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rcx
mov r14, rdx
mov r15d, esi
mov r13d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_70]
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz short loc_550D1
mov r8d, 4
mov edi, r15d
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call my_pread
mov r14, rax
loc_550BF:
mov rax, r14
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_550D1:
mov r12, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r12
mov rsi, rbx
mov ecx, r13d
call qword ptr [rax+210h]
xor r13d, r13d
mov r8d, 4
mov edi, r15d
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call my_pread
mov r14, rax
test rax, rax
cmovz r13, rbx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r12
mov rsi, r13
call qword ptr [rax+218h]
jmp short loc_550BF
|
long long inline_mysql_file_pread_1(unsigned int a1, long long a2, long long a3, long long a4)
{
long long v6; // rax
long long v7; // r14
long long v9; // r12
long long v10; // r13
_BYTE v11[112]; // [rsp+0h] [rbp-70h] BYREF
v6 = ((long long ( *)(_BYTE *, long long, long long))PSI_server[43])(v11, a2, 6LL);
if ( !v6 )
return my_pread((unsigned int)a2, a3, a4, 0LL, 4LL);
v9 = v6;
((void ( *)(long long, long long, const char *, _QWORD))PSI_server[66])(
v6,
a4,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
a1);
v10 = 0LL;
v7 = my_pread((unsigned int)a2, a3, a4, 0LL, 4LL);
if ( !v7 )
v10 = a4;
((void ( *)(long long, long long))PSI_server[67])(v9, v10);
return v7;
}
|
inline_mysql_file_pread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RCX
MOV R14,RDX
MOV R15D,ESI
MOV R13D,EDI
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x70]
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001550d1
MOV R8D,0x4
MOV EDI,R15D
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x001a158c
MOV R14,RAX
LAB_001550bf:
MOV RAX,R14
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001550d1:
MOV R12,RAX
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dbd64]
MOV RDI,R12
MOV RSI,RBX
MOV ECX,R13D
CALL qword ptr [RAX + 0x210]
XOR R13D,R13D
MOV R8D,0x4
MOV EDI,R15D
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x001a158c
MOV R14,RAX
TEST RAX,RAX
CMOVZ R13,RBX
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
MOV RDI,R12
MOV RSI,R13
CALL qword ptr [RAX + 0x218]
JMP 0x001550bf
|
long inline_mysql_file_pread(int4 param_1,ulong param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
int8 uVar3;
int1 local_78 [72];
lVar1 = (**(code **)(PSI_server + 0x158))(local_78,param_2,6);
if (lVar1 == 0) {
lVar2 = my_pread(param_2 & 0xffffffff,param_3,param_4,0,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,param_4,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
param_1);
lVar2 = my_pread(param_2 & 0xffffffff,param_3,param_4,0,4);
uVar3 = 0;
if (lVar2 == 0) {
uVar3 = param_4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar3);
}
return lVar2;
}
|
|
13,925
|
parse_icmp_port_unreachable
|
xtate/src/templ/templ-icmp.c
|
bool parse_icmp_port_unreachable(const unsigned char *transport_px,
unsigned length, ipaddress *r_ip_them,
unsigned *r_port_them, ipaddress *r_ip_me,
unsigned *r_port_me, unsigned *r_icmp_proto) {
const unsigned char *icmp_ip_px = transport_px + 8;
unsigned icmp_payload_len = length - (icmp_ip_px - transport_px);
unsigned char *trans_header;
unsigned trans_len;
unsigned ipv4_header_len;
if (icmp_ip_px[0] >> 4 == 4) {
/*ipv4*/
r_ip_them->version = 4;
r_ip_me->version = 4;
r_ip_me->ipv4 = BE_TO_U32(icmp_ip_px + 12);
r_ip_them->ipv4 = BE_TO_U32(icmp_ip_px + 16);
*r_icmp_proto = icmp_ip_px[9];
if (*r_icmp_proto != IP_PROTO_TCP && *r_icmp_proto != IP_PROTO_UDP)
return false;
ipv4_header_len = (icmp_ip_px[0] & 0xF) << 2;
trans_len = icmp_payload_len - ipv4_header_len;
trans_header = (unsigned char *)icmp_ip_px + ipv4_header_len;
} else if (icmp_ip_px[0] >> 4 == 6) {
/*ipv6*/
r_ip_them->version = 6;
r_ip_me->version = 6;
r_ip_me->ipv6.hi = BE_TO_U64(icmp_ip_px + 8);
r_ip_me->ipv6.lo = BE_TO_U64(icmp_ip_px + 16);
r_ip_them->ipv6.hi = BE_TO_U64(icmp_ip_px + 24);
r_ip_them->ipv6.lo = BE_TO_U64(icmp_ip_px + 32);
*r_icmp_proto = icmp_ip_px[6];
if (*r_icmp_proto != IP_PROTO_TCP && *r_icmp_proto != IP_PROTO_UDP)
return false;
/*length of ipv6 header is fixed*/
trans_header = (unsigned char *)icmp_ip_px + 40;
trans_len = icmp_payload_len - 40;
} else {
/*invalid ip version*/
return false;
}
if (trans_len < 4)
return false;
*r_port_me = BE_TO_U16(trans_header);
*r_port_them = BE_TO_U16(trans_header + 2);
return true;
}
|
O3
|
c
|
parse_icmp_port_unreachable:
movq 0x8(%rsp), %rax
movzbl 0x8(%rdi), %r10d
shrl $0x4, %r10d
cmpl $0x6, %r10d
je 0x49caf
cmpl $0x4, %r10d
jne 0x49d00
movb $0x4, %r10b
movb %r10b, 0x10(%rdx)
movb %r10b, 0x10(%r8)
movl 0x14(%rdi), %r10d
bswapl %r10d
movl %r10d, (%r8)
movl 0x18(%rdi), %r8d
bswapl %r8d
movl %r8d, (%rdx)
movzbl 0x11(%rdi), %edx
movl %edx, (%rax)
cmpl $0x11, %edx
je 0x49c98
cmpl $0x6, %edx
jne 0x49d00
addq $0x8, %rdi
addl $-0x8, %esi
movzbl (%rdi), %eax
shll $0x2, %eax
andl $0x3c, %eax
subl %eax, %esi
addq %rax, %rdi
jmp 0x49cfb
movb $0x6, %r10b
movb %r10b, 0x10(%rdx)
movb %r10b, 0x10(%r8)
movq 0x10(%rdi), %r10
bswapq %r10
movq %r10, (%r8)
movq 0x18(%rdi), %r10
bswapq %r10
movq %r10, 0x8(%r8)
movq 0x20(%rdi), %r8
bswapq %r8
movq %r8, (%rdx)
movq 0x28(%rdi), %r8
bswapq %r8
movq %r8, 0x8(%rdx)
movzbl 0xe(%rdi), %edx
movl %edx, (%rax)
cmpl $0x11, %edx
je 0x49cf4
cmpl $0x6, %edx
jne 0x49d00
addq $0x30, %rdi
addl $-0x30, %esi
cmpl $0x4, %esi
jae 0x49d03
xorl %eax, %eax
retq
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%r9)
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%rcx)
movb $0x1, %al
retq
|
parse_icmp_port_unreachable:
mov rax, [rsp+arg_0]
movzx r10d, byte ptr [rdi+8]
shr r10d, 4
cmp r10d, 6
jz short loc_49CAF
cmp r10d, 4
jnz loc_49D00
mov r10b, 4
mov [rdx+10h], r10b
mov [r8+10h], r10b
mov r10d, [rdi+14h]
bswap r10d
mov [r8], r10d
mov r8d, [rdi+18h]
bswap r8d
mov [rdx], r8d
movzx edx, byte ptr [rdi+11h]
mov [rax], edx
cmp edx, 11h
jz short loc_49C98
cmp edx, 6
jnz short loc_49D00
loc_49C98:
add rdi, 8
add esi, 0FFFFFFF8h
movzx eax, byte ptr [rdi]
shl eax, 2
and eax, 3Ch
sub esi, eax
add rdi, rax
jmp short loc_49CFB
loc_49CAF:
mov r10b, 6
mov [rdx+10h], r10b
mov [r8+10h], r10b
mov r10, [rdi+10h]
bswap r10
mov [r8], r10
mov r10, [rdi+18h]
bswap r10
mov [r8+8], r10
mov r8, [rdi+20h]
bswap r8
mov [rdx], r8
mov r8, [rdi+28h]
bswap r8
mov [rdx+8], r8
movzx edx, byte ptr [rdi+0Eh]
mov [rax], edx
cmp edx, 11h
jz short loc_49CF4
cmp edx, 6
jnz short loc_49D00
loc_49CF4:
add rdi, 30h ; '0'
add esi, 0FFFFFFD0h
loc_49CFB:
cmp esi, 4
jnb short loc_49D03
loc_49D00:
xor eax, eax
retn
loc_49D03:
movzx eax, word ptr [rdi]
rol ax, 8
movzx eax, ax
mov [r9], eax
movzx eax, word ptr [rdi+2]
rol ax, 8
movzx eax, ax
mov [rcx], eax
mov al, 1
retn
|
char parse_icmp_port_unreachable(
long long a1,
int a2,
long long a3,
_DWORD *a4,
long long a5,
_DWORD *a6,
_DWORD *a7)
{
int v7; // r10d
int v8; // edx
_BYTE *v9; // rdi
long long v10; // rax
unsigned int v11; // esi
_WORD *v12; // rdi
int v13; // edx
v7 = *(unsigned __int8 *)(a1 + 8) >> 4;
if ( v7 == 6 )
{
*(_BYTE *)(a3 + 16) = 6;
*(_BYTE *)(a5 + 16) = 6;
*(_QWORD *)a5 = _byteswap_uint64(*(_QWORD *)(a1 + 16));
*(_QWORD *)(a5 + 8) = _byteswap_uint64(*(_QWORD *)(a1 + 24));
*(_QWORD *)a3 = _byteswap_uint64(*(_QWORD *)(a1 + 32));
*(_QWORD *)(a3 + 8) = _byteswap_uint64(*(_QWORD *)(a1 + 40));
v13 = *(unsigned __int8 *)(a1 + 14);
*a7 = v13;
if ( v13 != 17 && v13 != 6 )
return 0;
v12 = (_WORD *)(a1 + 48);
v11 = a2 - 48;
}
else
{
if ( v7 != 4 )
return 0;
*(_BYTE *)(a3 + 16) = 4;
*(_BYTE *)(a5 + 16) = 4;
*(_DWORD *)a5 = _byteswap_ulong(*(_DWORD *)(a1 + 20));
*(_DWORD *)a3 = _byteswap_ulong(*(_DWORD *)(a1 + 24));
v8 = *(unsigned __int8 *)(a1 + 17);
*a7 = v8;
if ( v8 != 17 && v8 != 6 )
return 0;
v9 = (_BYTE *)(a1 + 8);
v10 = (4 * *v9) & 0x3C;
v11 = a2 - 8 - v10;
v12 = &v9[v10];
}
if ( v11 < 4 )
return 0;
*a6 = (unsigned __int16)__ROL2__(*v12, 8);
*a4 = (unsigned __int16)__ROL2__(v12[1], 8);
return 1;
}
|
parse_icmp_port_unreachable:
MOV RAX,qword ptr [RSP + 0x8]
MOVZX R10D,byte ptr [RDI + 0x8]
SHR R10D,0x4
CMP R10D,0x6
JZ 0x00149caf
CMP R10D,0x4
JNZ 0x00149d00
MOV R10B,0x4
MOV byte ptr [RDX + 0x10],R10B
MOV byte ptr [R8 + 0x10],R10B
MOV R10D,dword ptr [RDI + 0x14]
BSWAP R10D
MOV dword ptr [R8],R10D
MOV R8D,dword ptr [RDI + 0x18]
BSWAP R8D
MOV dword ptr [RDX],R8D
MOVZX EDX,byte ptr [RDI + 0x11]
MOV dword ptr [RAX],EDX
CMP EDX,0x11
JZ 0x00149c98
CMP EDX,0x6
JNZ 0x00149d00
LAB_00149c98:
ADD RDI,0x8
ADD ESI,-0x8
MOVZX EAX,byte ptr [RDI]
SHL EAX,0x2
AND EAX,0x3c
SUB ESI,EAX
ADD RDI,RAX
JMP 0x00149cfb
LAB_00149caf:
MOV R10B,0x6
MOV byte ptr [RDX + 0x10],R10B
MOV byte ptr [R8 + 0x10],R10B
MOV R10,qword ptr [RDI + 0x10]
BSWAP R10
MOV qword ptr [R8],R10
MOV R10,qword ptr [RDI + 0x18]
BSWAP R10
MOV qword ptr [R8 + 0x8],R10
MOV R8,qword ptr [RDI + 0x20]
BSWAP R8
MOV qword ptr [RDX],R8
MOV R8,qword ptr [RDI + 0x28]
BSWAP R8
MOV qword ptr [RDX + 0x8],R8
MOVZX EDX,byte ptr [RDI + 0xe]
MOV dword ptr [RAX],EDX
CMP EDX,0x11
JZ 0x00149cf4
CMP EDX,0x6
JNZ 0x00149d00
LAB_00149cf4:
ADD RDI,0x30
ADD ESI,-0x30
LAB_00149cfb:
CMP ESI,0x4
JNC 0x00149d03
LAB_00149d00:
XOR EAX,EAX
RET
LAB_00149d03:
MOVZX EAX,word ptr [RDI]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [R9],EAX
MOVZX EAX,word ptr [RDI + 0x2]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RCX],EAX
MOV AL,0x1
RET
|
int8
parse_icmp_port_unreachable
(long param_1,int param_2,ulong *param_3,uint *param_4,ulong *param_5,uint *param_6,
uint *param_7)
{
byte bVar1;
ushort uVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
ushort *puVar6;
bVar1 = *(byte *)(param_1 + 8) >> 4;
if (bVar1 == 6) {
*(int1 *)(param_3 + 2) = 6;
*(int1 *)(param_5 + 2) = 6;
uVar3 = *(ulong *)(param_1 + 0x10);
*param_5 = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 | (uVar3 & 0xff0000000000) >> 0x18
| (uVar3 & 0xff00000000) >> 8 | (uVar3 & 0xff000000) << 8 |
(uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 | uVar3 << 0x38;
uVar3 = *(ulong *)(param_1 + 0x18);
param_5[1] = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
uVar3 = *(ulong *)(param_1 + 0x20);
*param_3 = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 | (uVar3 & 0xff0000000000) >> 0x18
| (uVar3 & 0xff00000000) >> 8 | (uVar3 & 0xff000000) << 8 |
(uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 | uVar3 << 0x38;
uVar3 = *(ulong *)(param_1 + 0x28);
param_3[1] = uVar3 >> 0x38 | (uVar3 & 0xff000000000000) >> 0x28 |
(uVar3 & 0xff0000000000) >> 0x18 | (uVar3 & 0xff00000000) >> 8 |
(uVar3 & 0xff000000) << 8 | (uVar3 & 0xff0000) << 0x18 | (uVar3 & 0xff00) << 0x28 |
uVar3 << 0x38;
bVar1 = *(byte *)(param_1 + 0xe);
*param_7 = (uint)bVar1;
if ((bVar1 != 0x11) && (bVar1 != 6)) {
return 0;
}
puVar6 = (ushort *)(param_1 + 0x30);
uVar5 = param_2 - 0x30;
}
else {
if (bVar1 != 4) {
return 0;
}
*(int1 *)(param_3 + 2) = 4;
*(int1 *)(param_5 + 2) = 4;
uVar5 = *(uint *)(param_1 + 0x14);
*(uint *)param_5 =
uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18;
uVar5 = *(uint *)(param_1 + 0x18);
*(uint *)param_3 =
uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18;
bVar1 = *(byte *)(param_1 + 0x11);
*param_7 = (uint)bVar1;
if ((bVar1 != 0x11) && (bVar1 != 6)) {
return 0;
}
uVar4 = *(byte *)(param_1 + 8) & 0xf;
uVar5 = param_2 + -8 + uVar4 * -4;
puVar6 = (ushort *)((byte *)(param_1 + 8) + uVar4 * 4);
}
if (uVar5 < 4) {
return 0;
}
*param_6 = (uint)(ushort)(*puVar6 << 8 | *puVar6 >> 8);
uVar2 = puVar6[1];
*param_4 = (uint)(ushort)(uVar2 << 8 | uVar2 >> 8);
return CONCAT71((uint7)(byte)uVar2,1);
}
|
|
13,926
|
resize_queue
|
eloqsql/mysys/queues.c
|
int resize_queue(QUEUE *queue, uint max_elements)
{
uchar **new_root;
DBUG_ENTER("resize_queue");
if (queue->max_elements == max_elements)
DBUG_RETURN(0);
if ((new_root= (uchar **) my_realloc(key_memory_QUEUE, (void *)queue->root,
(max_elements + 1)* sizeof(void*),
MYF(MY_WME))) == 0)
DBUG_RETURN(1);
set_if_smaller(queue->elements, max_elements);
queue->max_elements= max_elements;
queue->root= new_root;
DBUG_RETURN(0);
}
|
O0
|
c
|
resize_queue:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xf7136
jmp 0xf712d
movl $0x0, -0x4(%rbp)
jmp 0xf71a9
leaq 0xb8c193(%rip), %rax # 0xc832d0
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
movl $0x10, %ecx
callq 0xf3a30
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xf7173
jmp 0xf716a
movl $0x1, -0x4(%rbp)
jmp 0xf71a9
jmp 0xf7175
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0xf718b
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0xf718d
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
resize_queue:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov eax, [rax+14h]
cmp eax, [rbp+var_14]
jnz short loc_F7136
jmp short $+2
loc_F712D:
mov [rbp+var_4], 0
jmp short loc_F71A9
loc_F7136:
lea rax, key_memory_QUEUE
mov edi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_14]
add eax, 1
mov eax, eax
mov edx, eax
shl rdx, 3
mov ecx, 10h
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_F7173
jmp short $+2
loc_F716A:
mov [rbp+var_4], 1
jmp short loc_F71A9
loc_F7173:
jmp short $+2
loc_F7175:
mov rax, [rbp+var_10]
mov eax, [rax+10h]
cmp eax, [rbp+var_14]
jbe short loc_F718B
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
loc_F718B:
jmp short $+2
loc_F718D:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 0
loc_F71A9:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long resize_queue(long long a1, unsigned int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
if ( *(_DWORD *)(a1 + 20) == a2 )
{
return 0;
}
else
{
v3 = my_realloc(key_memory_QUEUE, *(_QWORD *)a1, (const char *)(8LL * (a2 + 1)), 16);
if ( v3 )
{
if ( *(_DWORD *)(a1 + 16) > a2 )
*(_DWORD *)(a1 + 16) = a2;
*(_DWORD *)(a1 + 20) = a2;
*(_QWORD *)a1 = v3;
return 0;
}
else
{
return 1;
}
}
}
|
resize_queue:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x001f7136
JMP 0x001f712d
LAB_001f712d:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001f71a9
LAB_001f7136:
LEA RAX,[0xd832d0]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV EAX,EAX
MOV EDX,EAX
SHL RDX,0x3
MOV ECX,0x10
CALL 0x001f3a30
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001f7173
JMP 0x001f716a
LAB_001f716a:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001f71a9
LAB_001f7173:
JMP 0x001f7175
LAB_001f7175:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RBP + -0x14]
JBE 0x001f718b
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],ECX
LAB_001f718b:
JMP 0x001f718d
LAB_001f718d:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_001f71a9:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 resize_queue(long *param_1,uint param_2)
{
long lVar1;
int4 local_c;
if (*(uint *)((long)param_1 + 0x14) == param_2) {
local_c = 0;
}
else {
lVar1 = my_realloc(key_memory_QUEUE,*param_1,(ulong)(param_2 + 1) << 3,0x10);
if (lVar1 == 0) {
local_c = 1;
}
else {
if (param_2 < *(uint *)(param_1 + 2)) {
*(uint *)(param_1 + 2) = param_2;
}
*(uint *)((long)param_1 + 0x14) = param_2;
*param_1 = lVar1;
local_c = 0;
}
}
return local_c;
}
|
|
13,927
|
AimRTCodeGenerator::ProtoFileBaseName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
aimrt_mujoco_sim/_deps/aimrt-src/src/tools/protoc_plugin_cpp_gen_aimrt_cpp_rpc/main.cc
|
static std::string ProtoFileBaseName(const std::string& full_name) {
return full_name.substr(0, full_name.rfind('.'));
}
|
O3
|
cpp
|
AimRTCodeGenerator::ProtoFileBaseName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x12887
movq (%rsi), %rdx
movq %rax, %rcx
subq $0x1, %rcx
jb 0x12887
cmpb $0x2e, -0x1(%rdx,%rax)
movq %rcx, %rax
jne 0x12875
jmp 0x1288e
movq $-0x1, %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11d9c
movq %rbx, %rax
popq %rbx
retq
nop
|
_ZN18AimRTCodeGenerator17ProtoFileBaseNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbx
mov rbx, rdi
mov rax, [rsi+8]
test rax, rax
jz short loc_12887
mov rdx, [rsi]
mov rcx, rax
loc_12875:
sub rcx, 1
jb short loc_12887
cmp byte ptr [rdx+rax-1], 2Eh ; '.'
mov rax, rcx
jnz short loc_12875
jmp short loc_1288E
loc_12887:
mov rcx, 0FFFFFFFFFFFFFFFFh
loc_1288E:
mov rdi, rbx
xor edx, edx
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, rbx
pop rbx
retn
|
long long AimRTCodeGenerator::ProtoFileBaseName(long long a1, _QWORD *a2)
{
long long v2; // rax
long long v3; // rcx
bool v5; // zf
v2 = a2[1];
if ( v2 )
{
v3 = a2[1];
do
{
if ( v3-- == 0 )
break;
v5 = *(_BYTE *)(*a2 + v2 - 1) == 46;
v2 = v3;
}
while ( !v5 );
}
std::string::substr(a1, (long long)a2, 0LL);
return a1;
}
|
ProtoFileBaseName:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x8]
TEST RAX,RAX
JZ 0x00112887
MOV RDX,qword ptr [RSI]
MOV RCX,RAX
LAB_00112875:
SUB RCX,0x1
JC 0x00112887
CMP byte ptr [RDX + RAX*0x1 + -0x1],0x2e
MOV RAX,RCX
JNZ 0x00112875
JMP 0x0011288e
LAB_00112887:
MOV RCX,-0x1
LAB_0011288e:
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00111d9c
MOV RAX,RBX
POP RBX
RET
|
/* AimRTCodeGenerator::ProtoFileBaseName(std::__cxx11::string const&) */
AimRTCodeGenerator * __thiscall
AimRTCodeGenerator::ProtoFileBaseName(AimRTCodeGenerator *this,string *param_1)
{
char *pcVar1;
long lVar2;
if (*(long *)(param_1 + 8) != 0) {
lVar2 = *(long *)(param_1 + 8);
do {
if (lVar2 == 0) break;
pcVar1 = (char *)(*(long *)param_1 + -1 + lVar2);
lVar2 = lVar2 + -1;
} while (*pcVar1 != '.');
}
std::__cxx11::string::substr((ulong)this,(ulong)param_1);
return this;
}
|
|
13,928
|
quantize_row_q4_1_ref
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c
|
void quantize_row_q4_1_ref(const float * restrict x, block_q4_1 * restrict y, int64_t k) {
const int qk = QK4_1;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
float min = FLT_MAX;
float max = -FLT_MAX;
for (int j = 0; j < qk; j++) {
const float v = x[i*qk + j];
if (v < min) min = v;
if (v > max) max = v;
}
const float d = (max - min) / ((1 << 4) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
y[i].m = GGML_FP32_TO_FP16(min);
for (int j = 0; j < qk/2; ++j) {
const float x0 = (x[i*qk + 0 + j] - min)*id;
const float x1 = (x[i*qk + qk/2 + j] - min)*id;
const uint8_t xi0 = MIN(15, (int8_t)(x0 + 0.5f));
const uint8_t xi1 = MIN(15, (int8_t)(x1 + 0.5f));
y[i].qs[j] = xi0;
y[i].qs[j] |= xi1 << 4;
}
}
}
|
O2
|
c
|
quantize_row_q4_1_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testb $0x1f, %dl
jne 0x31fd4
movq %rdi, %r12
shrq $0x5, %rdx
xorl %ebx, %ebx
testl %edx, %edx
cmovlel %ebx, %edx
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x4(%rsi), %rbp
pushq $0xf
popq %r15
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %r14
cmpq %rdx, %rbx
je 0x31fc5
movl %ebx, %eax
andl $0x7ffffff, %eax # imm = 0x7FFFFFF
shlq $0x7, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax), %r13
addq %r12, %rax
xorl %ecx, %ecx
movss 0x21166(%rip), %xmm0 # 0x53030
movss 0x2115a(%rip), %xmm3 # 0x5302c
cmpq $0x20, %rcx
je 0x31ef3
movss (%rax,%rcx,4), %xmm1
movaps %xmm1, %xmm2
minss %xmm3, %xmm2
maxss %xmm0, %xmm1
incq %rcx
movaps %xmm1, %xmm0
movaps %xmm2, %xmm3
jmp 0x31ed2
subss %xmm3, %xmm0
divss 0x21135(%rip), %xmm0 # 0x53034
movss 0x1c159(%rip), %xmm1 # 0x4e060
divss %xmm0, %xmm1
movaps %xmm0, %xmm2
cmpneqss 0x21111(%rip), %xmm2 # 0x53028
andps %xmm1, %xmm2
movaps %xmm2, 0x30(%rsp)
movss %xmm3, 0xc(%rsp)
callq 0x31de9
movq %rbx, 0x28(%rsp)
imulq $0x14, %rbx, %rbx
movw %ax, (%r14,%rbx)
movss 0xc(%rsp), %xmm0
callq 0x31de9
movw %ax, 0x2(%r14,%rbx)
xorl %eax, %eax
movss 0x1c119(%rip), %xmm1 # 0x4e06c
cmpq $0x10, %rax
je 0x31faf
movss -0x40(%r13,%rax,4), %xmm0
movss 0xc(%rsp), %xmm2
subss %xmm2, %xmm0
mulss 0x30(%rsp), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
cmpb $0xf, %cl
jl 0x31f80
movl %r15d, %ecx
movss (%r13,%rax,4), %xmm0
subss %xmm2, %xmm0
mulss 0x30(%rsp), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edx
cmpb $0xf, %dl
jl 0x31fa1
movl %r15d, %edx
shlb $0x4, %dl
orb %cl, %dl
movb %dl, (%rbp,%rax)
incq %rax
jmp 0x31f53
movq 0x28(%rsp), %rbx
incq %rbx
addq $0x14, %rbp
movq 0x18(%rsp), %rdx
jmp 0x31ea0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ba7d(%rip), %rdi # 0x5da58
leaq 0x2ba82(%rip), %rsi # 0x5da64
leaq 0x2bb25(%rip), %rcx # 0x5db0e
pushq $0x47
popq %rdx
callq 0x1dfb0
|
quantize_row_q4_1_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
test dl, 1Fh
jnz loc_31FD4
mov r12, rdi
shr rdx, 5
xor ebx, ebx
test edx, edx
cmovle edx, ebx
lea rax, [rdi+40h]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_58], rsi
lea rbp, [rsi+4]
push 0Fh
pop r15
mov [rsp+78h+var_60], rdx
mov r14, [rsp+78h+var_58]
loc_31EA0:
cmp rbx, rdx
jz loc_31FC5
mov eax, ebx
and eax, 7FFFFFFh
shl rax, 7
mov rcx, [rsp+78h+var_68]
lea r13, [rcx+rax]
add rax, r12
xor ecx, ecx
movss xmm0, cs:dword_53030
movss xmm3, cs:dword_5302C
loc_31ED2:
cmp rcx, 20h ; ' '
jz short loc_31EF3
movss xmm1, dword ptr [rax+rcx*4]
movaps xmm2, xmm1
minss xmm2, xmm3
maxss xmm1, xmm0
inc rcx
movaps xmm0, xmm1
movaps xmm3, xmm2
jmp short loc_31ED2
loc_31EF3:
subss xmm0, xmm3
divss xmm0, cs:dword_53034
movss xmm1, cs:dword_4E060
divss xmm1, xmm0
movaps xmm2, xmm0
cmpneqss xmm2, cs:dword_53028
andps xmm2, xmm1
movaps [rsp+78h+var_48], xmm2
movss [rsp+78h+var_6C], xmm3
call ggml_compute_fp32_to_fp16_0
mov [rsp+78h+var_50], rbx
imul rbx, 14h
mov [r14+rbx], ax
movss xmm0, [rsp+78h+var_6C]
call ggml_compute_fp32_to_fp16_0
mov [r14+rbx+2], ax
xor eax, eax
movss xmm1, cs:dword_4E06C
loc_31F53:
cmp rax, 10h
jz short loc_31FAF
movss xmm0, dword ptr [r13+rax*4-40h]
movss xmm2, [rsp+78h+var_6C]
subss xmm0, xmm2
mulss xmm0, dword ptr [rsp+78h+var_48]
addss xmm0, xmm1
cvttss2si ecx, xmm0
cmp cl, 0Fh
jl short loc_31F80
mov ecx, r15d
loc_31F80:
movss xmm0, dword ptr [r13+rax*4+0]
subss xmm0, xmm2
mulss xmm0, dword ptr [rsp+78h+var_48]
addss xmm0, xmm1
cvttss2si edx, xmm0
cmp dl, 0Fh
jl short loc_31FA1
mov edx, r15d
loc_31FA1:
shl dl, 4
or dl, cl
mov [rbp+rax+0], dl
inc rax
jmp short loc_31F53
loc_31FAF:
mov rbx, [rsp+78h+var_50]
inc rbx
add rbp, 14h
mov rdx, [rsp+78h+var_60]
jmp loc_31EA0
loc_31FC5:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_31FD4:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo_0; "void quantize_row_q4_1_ref(const float "...
push 47h ; 'G'
pop rdx
call ___assert_fail
|
long long quantize_row_q4_1_ref(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rbx
long long result; // rax
long long v6; // rbp
unsigned long long v7; // rax
unsigned long long v8; // r13
long long v9; // rax
long long v10; // rcx
__m128 v11; // xmm0
float v12; // xmm3_4
__m128 v13; // xmm1
float v14; // xmm2_4
__m128 v15; // rt1
long long v16; // rbx
int v17; // ecx
int v18; // edx
unsigned long long v19; // [rsp+18h] [rbp-60h]
long long v20; // [rsp+28h] [rbp-50h]
float v21; // [rsp+30h] [rbp-48h]
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
71LL,
"void quantize_row_q4_1_ref(const float *restrict, block_q4_1 *restrict, int64_t)");
v3 = a3 >> 5;
v4 = 0LL;
if ( (int)v3 <= 0 )
v3 = 0LL;
result = a1 + 64;
v6 = a2 + 4;
v19 = v3;
while ( v4 != v3 )
{
v7 = (unsigned long long)(v4 & 0x7FFFFFF) << 7;
v8 = a1 + 64 + v7;
v9 = a1 + v7;
v10 = 0LL;
v11 = (__m128)0xFF7FFFFF;
v12 = 3.4028235e38;
while ( v10 != 32 )
{
v13 = (__m128)*(unsigned int *)(v9 + 4 * v10);
v14 = fminf(*(float *)(v9 + 4 * v10), v12);
v13.m128_f32[0] = fmaxf(v13.m128_f32[0], v11.m128_f32[0]);
++v10;
v11 = v13;
v12 = v14;
}
v11.m128_f32[0] = (float)(v11.m128_f32[0] - v12) / 15.0;
v15.m128_i32[0] = 0;
LODWORD(v21) = _mm_cmpneq_ss(v11, v15).m128_u32[0] & COERCE_UNSIGNED_INT(1.0 / v11.m128_f32[0]);
v20 = v4;
v16 = 20 * v4;
*(_WORD *)(a2 + v16) = ggml_compute_fp32_to_fp16_0((__m128i)v11);
*(_WORD *)(a2 + v16 + 2) = ggml_compute_fp32_to_fp16_0((__m128i)LODWORD(v12));
for ( result = 0LL; result != 16; ++result )
{
v17 = (int)(float)((float)((float)(*(float *)(v8 + 4 * result - 64) - v12) * v21) + 0.5);
if ( (char)v17 >= 15 )
LOBYTE(v17) = 15;
v18 = (int)(float)((float)((float)(*(float *)(v8 + 4 * result) - v12) * v21) + 0.5);
if ( (char)v18 >= 15 )
LOBYTE(v18) = 15;
*(_BYTE *)(v6 + result) = v17 | (16 * v18);
}
v4 = v20 + 1;
v6 += 20LL;
v3 = v19;
}
return result;
}
|
quantize_row_q4_1_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
TEST DL,0x1f
JNZ 0x00131fd4
MOV R12,RDI
SHR RDX,0x5
XOR EBX,EBX
TEST EDX,EDX
CMOVLE EDX,EBX
LEA RAX,[RDI + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x20],RSI
LEA RBP,[RSI + 0x4]
PUSH 0xf
POP R15
MOV qword ptr [RSP + 0x18],RDX
MOV R14,qword ptr [RSP + 0x20]
LAB_00131ea0:
CMP RBX,RDX
JZ 0x00131fc5
MOV EAX,EBX
AND EAX,0x7ffffff
SHL RAX,0x7
MOV RCX,qword ptr [RSP + 0x10]
LEA R13,[RCX + RAX*0x1]
ADD RAX,R12
XOR ECX,ECX
MOVSS XMM0,dword ptr [0x00153030]
MOVSS XMM3,dword ptr [0x0015302c]
LAB_00131ed2:
CMP RCX,0x20
JZ 0x00131ef3
MOVSS XMM1,dword ptr [RAX + RCX*0x4]
MOVAPS XMM2,XMM1
MINSS XMM2,XMM3
MAXSS XMM1,XMM0
INC RCX
MOVAPS XMM0,XMM1
MOVAPS XMM3,XMM2
JMP 0x00131ed2
LAB_00131ef3:
SUBSS XMM0,XMM3
DIVSS XMM0,dword ptr [0x00153034]
MOVSS XMM1,dword ptr [0x0014e060]
DIVSS XMM1,XMM0
MOVAPS XMM2,XMM0
CMPNEQSS XMM2,dword ptr [0x00153028]
ANDPS XMM2,XMM1
MOVAPS xmmword ptr [RSP + 0x30],XMM2
MOVSS dword ptr [RSP + 0xc],XMM3
CALL 0x00131de9
MOV qword ptr [RSP + 0x28],RBX
IMUL RBX,RBX,0x14
MOV word ptr [R14 + RBX*0x1],AX
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00131de9
MOV word ptr [R14 + RBX*0x1 + 0x2],AX
XOR EAX,EAX
MOVSS XMM1,dword ptr [0x0014e06c]
LAB_00131f53:
CMP RAX,0x10
JZ 0x00131faf
MOVSS XMM0,dword ptr [R13 + RAX*0x4 + -0x40]
MOVSS XMM2,dword ptr [RSP + 0xc]
SUBSS XMM0,XMM2
MULSS XMM0,dword ptr [RSP + 0x30]
ADDSS XMM0,XMM1
CVTTSS2SI ECX,XMM0
CMP CL,0xf
JL 0x00131f80
MOV ECX,R15D
LAB_00131f80:
MOVSS XMM0,dword ptr [R13 + RAX*0x4]
SUBSS XMM0,XMM2
MULSS XMM0,dword ptr [RSP + 0x30]
ADDSS XMM0,XMM1
CVTTSS2SI EDX,XMM0
CMP DL,0xf
JL 0x00131fa1
MOV EDX,R15D
LAB_00131fa1:
SHL DL,0x4
OR DL,CL
MOV byte ptr [RBP + RAX*0x1],DL
INC RAX
JMP 0x00131f53
LAB_00131faf:
MOV RBX,qword ptr [RSP + 0x28]
INC RBX
ADD RBP,0x14
MOV RDX,qword ptr [RSP + 0x18]
JMP 0x00131ea0
LAB_00131fc5:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00131fd4:
LEA RDI,[0x15da58]
LEA RSI,[0x15da64]
LEA RCX,[0x15db0e]
PUSH 0x47
POP RDX
CALL 0x0011dfb0
|
void quantize_row_q4_1_ref(long param_1,long param_2,ulong param_3)
{
long lVar1;
int2 uVar2;
long lVar3;
byte bVar4;
long lVar5;
byte bVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
float fVar10;
float fVar11;
float fVar12;
float fVar13;
if ((param_3 & 0x1f) == 0) {
uVar8 = 0;
uVar7 = param_3 >> 5 & 0xffffffff;
if ((int)(param_3 >> 5) < 1) {
uVar7 = uVar8;
}
lVar9 = param_2 + 4;
for (; uVar8 != uVar7; uVar8 = uVar8 + 1) {
lVar3 = (ulong)((uint)uVar8 & 0x7ffffff) * 0x80;
lVar1 = param_1 + 0x40 + lVar3;
fVar10 = DAT_00153030;
fVar13 = DAT_0015302c;
for (lVar5 = 0; lVar5 != 0x20; lVar5 = lVar5 + 1) {
fVar12 = *(float *)(lVar3 + param_1 + lVar5 * 4);
fVar11 = fVar12;
if (fVar13 <= fVar12) {
fVar11 = fVar13;
}
if (fVar12 <= fVar10) {
fVar12 = fVar10;
}
fVar10 = fVar12;
fVar13 = fVar11;
}
fVar10 = (fVar10 - fVar13) / DAT_00153034;
fVar12 = (float)(-(uint)(fVar10 != DAT_00153028) & (uint)(DAT_0014e060 / fVar10));
uVar2 = ggml_compute_fp32_to_fp16();
*(int2 *)(param_2 + uVar8 * 0x14) = uVar2;
uVar2 = ggml_compute_fp32_to_fp16(fVar13);
*(int2 *)(param_2 + 2 + uVar8 * 0x14) = uVar2;
fVar10 = DAT_0014e06c;
for (lVar3 = 0; lVar3 != 0x10; lVar3 = lVar3 + 1) {
bVar4 = (byte)(int)((*(float *)(lVar1 + -0x40 + lVar3 * 4) - fVar13) * fVar12 + fVar10);
if ('\x0e' < (char)bVar4) {
bVar4 = 0xf;
}
bVar6 = (byte)(int)((*(float *)(lVar1 + lVar3 * 4) - fVar13) * fVar12 + fVar10);
if ('\x0e' < (char)bVar6) {
bVar6 = 0xf;
}
*(byte *)(lVar9 + lVar3) = bVar6 << 4 | bVar4;
}
lVar9 = lVar9 + 0x14;
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x47,
"void quantize_row_q4_1_ref(const float *restrict, block_q4_1 *restrict, int64_t)");
}
|
|
13,929
|
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h
|
void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
}
|
O3
|
c
|
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %r15
movq %r15, %rdi
callq 0x1fef8
testb %al, %al
je 0x381cd
leaq 0xbc72(%rip), %rdx # 0x43e36
leaq 0xbc6a(%rip), %rsi # 0x43e35
jmp 0x381fb
movq %r15, %rdi
callq 0x1ff34
leaq 0xbc59(%rip), %rcx # 0x43e35
leaq 0xa160(%rip), %rsi # 0x42343
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xbc46(%rip), %rax # 0x43e36
leaq 0xa14d(%rip), %rdx # 0x42344
cmovneq %rax, %rdx
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x3911e
leaq 0xc336(%rip), %rcx # 0x44555
movl $0x15, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8590
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x38258
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x3825f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xc2e9(%rip), %rsi # 0x4456b
callq 0x8a50
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x382ae
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x382b6
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x108(%r14), %rax
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x3471e
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r13, %rcx
je 0x3830c
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x3832f
leaq 0x58(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x3832a
movq 0x58(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x3833b
leaq 0x28(%rsp), %rdi
callq 0x8170
jmp 0x38349
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8590
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x3836d
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x38373
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xc1e3(%rip), %rsi # 0x4457a
leaq 0x8(%rsp), %rdi
callq 0x8a50
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x383d1
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x383d8
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x3903c
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x3841d
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38438
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38453
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3846a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x38481
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3849e
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x84e0
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r14, %rdi
je 0x384d4
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x384d4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x384f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x384f4
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38514
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x38514
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x38530
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x38530
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x3854c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x3854c
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r12, %rdi
je 0x38569
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
nop
|
_ZN7testing8internal17StreamingListener9OnTestEndERKNS_8TestInfoE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D0h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+90h]
mov rdi, r15; this
call _ZNK7testing10TestResult7SkippedEv; testing::TestResult::Skipped(void)
test al, al
jz short loc_381CD
lea rdx, aStaticCastSize+78h; ""
lea rsi, aStaticCastSize+77h; "0"
jmp short loc_381FB
loc_381CD:
mov rdi, r15; this
call _ZNK7testing10TestResult6FailedEv; testing::TestResult::Failed(void)
lea rcx, aStaticCastSize+77h; "0"
lea rsi, aFcntlPipeFd1FS+22h; "1"
test al, al
cmovnz rsi, rcx
lea rax, aStaticCastSize+78h; ""
lea rdx, aFcntlPipeFd1FS+23h; ""
cmovnz rdx, rax
loc_381FB:
lea r12, [rsp+0F8h+var_40]
mov [r12-10h], r12
lea r15, [rsp+0F8h+var_50]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rcx, aEventTestendPa; "event=TestEnd&passed="
mov r8d, 15h
mov rdi, r15
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r15, [rsp+0F8h+var_80]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_38258
mov [rsp+0F8h+var_90], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_80], rdx
jmp short loc_3825F
loc_38258:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_3825F:
mov rdx, [rax+8]
lea rdi, [rsp+0F8h+var_90]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, aElapsedTime; "&elapsed_time="
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+0F8h+var_C0]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_382AE
mov [rsp+0F8h+var_D0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_C0], rdx
jmp short loc_382B6
loc_382AE:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_382B6:
mov rdx, [rax+8]
mov [rsp+0F8h+var_C8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rax, [r14+108h]
lea rsi, [rsp+0F8h+var_30]
mov [rsi], rax
lea rdi, [rsp+0F8h+var_B0]
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
mov rcx, [rsp+0F8h+var_D0]
mov r8, [rsp+0F8h+var_C8]
mov rdx, [rsp+0F8h+var_A8]
lea rax, [rdx+r8]
mov edi, 0Fh
cmp rcx, r13
jz short loc_3830C
mov rdi, [rsp+0F8h+var_C0]
loc_3830C:
mov rsi, [rsp+0F8h+var_B0]
cmp rax, rdi
jbe short loc_3832F
lea r9, [rsp+0F8h+var_A0]
mov edi, 0Fh
cmp rsi, r9
jz short loc_3832A
mov rdi, [rsp+0F8h+var_A0]
loc_3832A:
cmp rax, rdi
jbe short loc_3833B
loc_3832F:
lea rdi, [rsp+0F8h+var_D0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_38349
loc_3833B:
lea rdi, [rsp+0F8h+var_B0]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_38349:
lea rdx, [rsp+0F8h+var_E0]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_3836D
mov [rsp+0F8h+var_F0], rsi
mov rdx, [rcx]
mov [rsp+0F8h+var_E0], rdx
jmp short loc_38373
loc_3836D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_38373:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0F8h+var_E8], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, aMs; "ms"
lea rdi, [rsp+0F8h+var_F0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r14, [rsp+0F8h+var_60]
mov [r14-10h], r14
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_383D1
mov [rsp+0F8h+var_70], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_60], rdx
jmp short loc_383D8
loc_383D1:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r14], xmm0
loc_383D8:
mov rdx, [rax+8]
lea rsi, [rsp+0F8h+var_70]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rbx+8]
call _ZN7testing8internal17StreamingListener20AbstractSocketWriter6SendLnERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::string const&)
mov rdi, [rsp+0F8h+var_70]; void *
cmp rdi, r14
jz short loc_3841D
mov rsi, [rsp+0F8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3841D:
lea rax, [rsp+0F8h+var_E0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_38438
mov rsi, [rsp+0F8h+var_E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38438:
lea rax, [rsp+0F8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_38453
mov rsi, [rsp+0F8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38453:
mov rdi, [rsp+0F8h+var_D0]; void *
cmp rdi, r13
jz short loc_3846A
mov rsi, [rsp+0F8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3846A:
mov rdi, [rsp+0F8h+var_90]; void *
cmp rdi, r15
jz short loc_38481
mov rsi, [rsp+0F8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38481:
mov rdi, [rsp+0F8h+var_50]; void *
cmp rdi, r12
jz short loc_3849E
mov rsi, [rsp+0F8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3849E:
add rsp, 0D0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_80]; void *
cmp rdi, r14
jz short loc_384D4
mov rsi, [rsp+arg_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_384D4
mov rbx, rax
loc_384D4:
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_384F4
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_384F4
mov rbx, rax
loc_384F4:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_38514
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_38514
mov rbx, rax
loc_38514:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_38530
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_38530
mov rbx, rax
loc_38530:
mov rdi, [rsp+arg_60]; void *
cmp rdi, r15
jz short loc_3854C
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3854C
mov rbx, rax
loc_3854C:
mov rdi, [rsp+arg_A0]; void *
cmp rdi, r12
jz short loc_38569
mov rsi, [rsp+arg_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38569:
mov rdi, rbx
call __Unwind_Resume
|
void testing::internal::StreamingListener::OnTestEnd(
testing::internal::StreamingListener *this,
const testing::TestInfo *a2)
{
char *v4; // rdx
char *v5; // rsi
bool v6; // al
long long v7; // rax
__int128 *v8; // rcx
long long v9; // rax
__int128 *v10; // rcx
char *v11; // rax
unsigned long long v12; // rdi
unsigned long long v13; // rdi
void **v14; // rax
__int128 *v15; // rcx
long long v16; // rax
int v17; // r8d
int v18; // r9d
__int128 *v19; // rcx
int v20; // edx
void *v21[2]; // [rsp+8h] [rbp-F0h] BYREF
__int128 v22; // [rsp+18h] [rbp-E0h] BYREF
void *v23; // [rsp+28h] [rbp-D0h] BYREF
long long v24; // [rsp+30h] [rbp-C8h]
__int128 v25; // [rsp+38h] [rbp-C0h] BYREF
void *v26[2]; // [rsp+48h] [rbp-B0h] BYREF
_QWORD v27[2]; // [rsp+58h] [rbp-A0h] BYREF
void *v28[2]; // [rsp+68h] [rbp-90h] BYREF
__int128 v29; // [rsp+78h] [rbp-80h] BYREF
void *v30; // [rsp+88h] [rbp-70h] BYREF
long long v31; // [rsp+90h] [rbp-68h]
__int128 v32; // [rsp+98h] [rbp-60h] BYREF
void *v33[2]; // [rsp+A8h] [rbp-50h] BYREF
_QWORD v34[2]; // [rsp+B8h] [rbp-40h] BYREF
_QWORD v35[6]; // [rsp+C8h] [rbp-30h] BYREF
if ( testing::TestResult::Skipped((const testing::TestInfo *)((char *)a2 + 144)) )
{
v4 = "";
v5 = "0";
}
else
{
v6 = testing::TestResult::Failed((const testing::TestInfo *)((char *)a2 + 144));
v5 = "1";
if ( v6 )
v5 = "0";
v4 = "";
if ( v6 )
v4 = "";
}
v33[0] = v34;
std::string::_M_construct<char const*>(v33, v5, v4);
v7 = std::string::replace(v33, 0LL, 0LL);
v28[0] = &v29;
v8 = (__int128 *)(v7 + 16);
if ( *(_QWORD *)v7 == v7 + 16 )
{
v29 = *v8;
}
else
{
v28[0] = *(void **)v7;
*(_QWORD *)&v29 = *(_QWORD *)v8;
}
v28[1] = *(void **)(v7 + 8);
*(_QWORD *)v7 = v8;
*(_QWORD *)(v7 + 8) = 0LL;
*(_BYTE *)(v7 + 16) = 0;
v9 = std::string::append(v28, "&elapsed_time=");
v23 = &v25;
v10 = (__int128 *)(v9 + 16);
if ( *(_QWORD *)v9 == v9 + 16 )
{
v25 = *v10;
}
else
{
v23 = *(void **)v9;
*(_QWORD *)&v25 = *(_QWORD *)v10;
}
v24 = *(_QWORD *)(v9 + 8);
*(_QWORD *)v9 = v10;
*(_QWORD *)(v9 + 8) = 0LL;
*(_BYTE *)(v9 + 16) = 0;
v35[0] = *((_QWORD *)a2 + 33);
testing::internal::StreamableToString<long>((long long)v26, v35);
v11 = (char *)v26[1] + v24;
v12 = 15LL;
if ( v23 != &v25 )
v12 = v25;
if ( (unsigned long long)v11 <= v12 )
goto LABEL_19;
v13 = 15LL;
if ( v26[0] != v27 )
v13 = v27[0];
if ( (unsigned long long)v11 <= v13 )
v14 = (void **)std::string::replace(v26, 0LL, 0LL);
else
LABEL_19:
v14 = (void **)std::string::_M_append(&v23, v26[0]);
v21[0] = &v22;
v15 = (__int128 *)(v14 + 2);
if ( *v14 == v14 + 2 )
{
v22 = *v15;
}
else
{
v21[0] = *v14;
*(_QWORD *)&v22 = *(_QWORD *)v15;
}
v21[1] = v14[1];
*v14 = v15;
v14[1] = 0LL;
*(_BYTE *)v15 = 0;
v16 = std::string::append(v21, "ms");
v30 = &v32;
v19 = (__int128 *)(v16 + 16);
if ( *(_QWORD *)v16 == v16 + 16 )
{
v32 = *v19;
}
else
{
v30 = *(void **)v16;
*(_QWORD *)&v32 = *(_QWORD *)v19;
}
v31 = *(_QWORD *)(v16 + 8);
v20 = v31;
*(_QWORD *)v16 = v19;
*(_QWORD *)(v16 + 8) = 0LL;
*(_BYTE *)(v16 + 16) = 0;
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(
*((_QWORD *)this + 1),
(unsigned int)&v30,
v20,
(_DWORD)v19,
v17,
v18);
if ( v30 != &v32 )
operator delete(v30, v32 + 1);
if ( v21[0] != &v22 )
operator delete(v21[0], v22 + 1);
if ( v26[0] != v27 )
operator delete(v26[0], v27[0] + 1LL);
if ( v23 != &v25 )
operator delete(v23, v25 + 1);
if ( v28[0] != &v29 )
operator delete(v28[0], v29 + 1);
if ( v33[0] != v34 )
operator delete(v33[0], v34[0] + 1LL);
}
|
OnTestEnd:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd0
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x90]
MOV RDI,R15
CALL 0x0011fef8
TEST AL,AL
JZ 0x001381cd
LEA RDX,[0x143e36]
LEA RSI,[0x143e35]
JMP 0x001381fb
LAB_001381cd:
MOV RDI,R15
CALL 0x0011ff34
LEA RCX,[0x143e35]
LEA RSI,[0x142343]
TEST AL,AL
CMOVNZ RSI,RCX
LEA RAX,[0x143e36]
LEA RDX,[0x142344]
CMOVNZ RDX,RAX
LAB_001381fb:
LEA R12,[RSP + 0xb8]
MOV qword ptr [R12 + -0x10],R12
LEA R15,[RSP + 0xa8]
MOV RDI,R15
CALL 0x0013911e
LAB_00138218:
LEA RCX,[0x144555]
MOV R8D,0x15
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00108590
LEA R15,[RSP + 0x78]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00138258
MOV qword ptr [RSP + 0x68],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x78],RDX
JMP 0x0013825f
LAB_00138258:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_0013825f:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x68]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0013827b:
LEA RSI,[0x14456b]
CALL 0x00108a50
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001382ae
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x001382b6
LAB_001382ae:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_001382b6:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [R14 + 0x108]
LEA RSI,[RSP + 0xc8]
MOV qword ptr [RSI],RAX
LAB_001382e0:
LEA RDI,[RSP + 0x48]
CALL 0x0013471e
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x50]
LEA RAX,[RDX + R8*0x1]
MOV EDI,0xf
CMP RCX,R13
JZ 0x0013830c
MOV RDI,qword ptr [RSP + 0x38]
LAB_0013830c:
MOV RSI,qword ptr [RSP + 0x48]
CMP RAX,RDI
JBE 0x0013832f
LEA R9,[RSP + 0x58]
MOV EDI,0xf
CMP RSI,R9
JZ 0x0013832a
MOV RDI,qword ptr [RSP + 0x58]
LAB_0013832a:
CMP RAX,RDI
JBE 0x0013833b
LAB_0013832f:
LEA RDI,[RSP + 0x28]
CALL 0x00108170
JMP 0x00138349
LAB_0013833b:
LEA RDI,[RSP + 0x48]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00108590
LAB_00138349:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x0013836d
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00138373
LAB_0013836d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_00138373:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_00138390:
LEA RSI,[0x14457a]
LEA RDI,[RSP + 0x8]
CALL 0x00108a50
LEA R14,[RSP + 0x98]
MOV qword ptr [R14 + -0x10],R14
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001383d1
MOV qword ptr [RSP + 0x88],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x98],RDX
JMP 0x001383d8
LAB_001383d1:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R14],XMM0
LAB_001383d8:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x88]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RBX + 0x8]
LAB_001383fb:
CALL 0x0013903c
LAB_00138400:
MOV RDI,qword ptr [RSP + 0x88]
CMP RDI,R14
JZ 0x0013841d
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x001084e0
LAB_0013841d:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00138438
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_00138438:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00138453
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001084e0
LAB_00138453:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0013846a
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001084e0
LAB_0013846a:
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R15
JZ 0x00138481
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001084e0
LAB_00138481:
MOV RDI,qword ptr [RSP + 0xa8]
CMP RDI,R12
JZ 0x0013849e
MOV RSI,qword ptr [RSP + 0xb8]
INC RSI
CALL 0x001084e0
LAB_0013849e:
ADD RSP,0xd0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) */
void __thiscall
testing::internal::StreamingListener::OnTestEnd(StreamingListener *this,TestInfo *param_1)
{
char cVar1;
long *plVar2;
int8 *puVar3;
long *plVar4;
ulong *puVar5;
char *pcVar6;
char *pcVar7;
ulong uVar8;
long *local_f0;
int8 local_e8;
long local_e0;
int8 uStack_d8;
ulong *local_d0;
long local_c8;
ulong local_c0;
long lStack_b8;
ulong *local_b0;
long local_a8;
ulong local_a0 [2];
long *local_90;
long local_88;
long local_80;
long lStack_78;
long *local_70;
long local_68;
long local_60;
long lStack_58;
long *local_50 [2];
long local_40 [2];
int8 local_30;
cVar1 = TestResult::Skipped((TestResult *)(param_1 + 0x90));
if (cVar1 == '\0') {
cVar1 = TestResult::Failed((TestResult *)(param_1 + 0x90));
pcVar7 = "1";
if (cVar1 != '\0') {
pcVar7 = "0";
}
pcVar6 = "";
if (cVar1 != '\0') {
pcVar6 = "";
}
}
else {
pcVar6 = "";
pcVar7 = "0";
}
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char_const*>(local_50,pcVar7,pcVar6);
/* try { // try from 00138218 to 00138230 has its CatchHandler @ 00138549 */
plVar2 = (long *)std::__cxx11::string::replace((ulong)local_50,0,(char *)0x0,0x144555);
plVar4 = plVar2 + 2;
if ((long *)*plVar2 == plVar4) {
local_80 = *plVar4;
lStack_78 = plVar2[3];
local_90 = &local_80;
}
else {
local_80 = *plVar4;
local_90 = (long *)*plVar2;
}
local_88 = plVar2[1];
*plVar2 = (long)plVar4;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 0013827b to 00138286 has its CatchHandler @ 0013852d */
plVar2 = (long *)std::__cxx11::string::append((char *)&local_90);
puVar5 = (ulong *)(plVar2 + 2);
if ((ulong *)*plVar2 == puVar5) {
local_c0 = *puVar5;
lStack_b8 = plVar2[3];
local_d0 = &local_c0;
}
else {
local_c0 = *puVar5;
local_d0 = (ulong *)*plVar2;
}
local_c8 = plVar2[1];
*plVar2 = (long)puVar5;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
local_30 = *(int8 *)(param_1 + 0x108);
/* try { // try from 001382e0 to 001382e9 has its CatchHandler @ 00138511 */
StreamableToString<long>((long *)&local_b0);
uVar8 = 0xf;
if (local_d0 != &local_c0) {
uVar8 = local_c0;
}
if (uVar8 < (ulong)(local_a8 + local_c8)) {
uVar8 = 0xf;
if (local_b0 != local_a0) {
uVar8 = local_a0[0];
}
if ((ulong)(local_a8 + local_c8) <= uVar8) {
puVar3 = (int8 *)
std::__cxx11::string::replace((ulong)&local_b0,0,(char *)0x0,(ulong)local_d0);
goto LAB_00138349;
}
}
/* try { // try from 0013832f to 00138348 has its CatchHandler @ 001384f1 */
puVar3 = (int8 *)std::__cxx11::string::_M_append((char *)&local_d0,(ulong)local_b0);
LAB_00138349:
local_f0 = &local_e0;
plVar2 = puVar3 + 2;
if ((long *)*puVar3 == plVar2) {
local_e0 = *plVar2;
uStack_d8 = puVar3[3];
}
else {
local_e0 = *plVar2;
local_f0 = (long *)*puVar3;
}
local_e8 = puVar3[1];
*puVar3 = plVar2;
puVar3[1] = 0;
*(int1 *)plVar2 = 0;
/* try { // try from 00138390 to 001383a0 has its CatchHandler @ 001384d1 */
plVar2 = (long *)std::__cxx11::string::append((char *)&local_f0);
plVar4 = plVar2 + 2;
if ((long *)*plVar2 == plVar4) {
local_60 = *plVar4;
lStack_58 = plVar2[3];
local_70 = &local_60;
}
else {
local_60 = *plVar4;
local_70 = (long *)*plVar2;
}
local_68 = plVar2[1];
*plVar2 = (long)plVar4;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
/* try { // try from 001383fb to 001383ff has its CatchHandler @ 001384af */
AbstractSocketWriter::SendLn(*(AbstractSocketWriter **)(this + 8),(string *)&local_70);
if (local_70 != &local_60) {
operator_delete(local_70,local_60 + 1);
}
if (local_f0 != &local_e0) {
operator_delete(local_f0,local_e0 + 1);
}
if (local_b0 != local_a0) {
operator_delete(local_b0,local_a0[0] + 1);
}
if (local_d0 != &local_c0) {
operator_delete(local_d0,local_c0 + 1);
}
if (local_90 != &local_80) {
operator_delete(local_90,local_80 + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return;
}
|
|
13,930
|
unreg_request
|
eloqsql/mysys/mf_keycache.c
|
static void unreg_request(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int at_end)
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
DBUG_ASSERT(block->requests);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
/*
Unregister the request, but do not link erroneous blocks into the
LRU ring.
*/
if (!--block->requests && !(block->status & BLOCK_ERROR))
{
my_bool hot;
if (block->hits_left)
block->hits_left--;
hot= !block->hits_left && at_end &&
keycache->warm_blocks > keycache->min_warm_blocks;
if (hot)
{
if (block->temperature == BLOCK_WARM)
keycache->warm_blocks--;
block->temperature= BLOCK_HOT;
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
link_block(keycache, block, hot, (my_bool)at_end);
block->last_hit_time= keycache->keycache_time;
keycache->keycache_time++;
/*
At this place, the block might be in the LRU ring or not. If an
evicter was waiting for a block, it was selected for eviction and
not linked in the LRU ring.
*/
/*
Check if we should link a hot block to the warm block sub-chain.
It is possible that we select the same block as above. But it can
also be another block. In any case a block from the LRU ring is
selected. In other words it works even if the above block was
selected for eviction and not linked in the LRU ring. Since this
happens only if the LRU ring is empty, the block selected below
would be NULL and the rest of the function skipped.
*/
block= keycache->used_ins;
if (block && keycache->keycache_time - block->last_hit_time >
keycache->age_threshold)
{
unlink_block(keycache, block);
link_block(keycache, block, 0, 0);
if (block->temperature != BLOCK_WARM)
{
keycache->warm_blocks++;
block->temperature= BLOCK_WARM;
}
KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
keycache->warm_blocks));
}
}
}
|
O0
|
c
|
unreg_request:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x71d85
jmp 0x71d87
jmp 0x71d89
jmp 0x71d8b
jmp 0x71d8d
jmp 0x71d8f
jmp 0x71d91
jmp 0x71d93
jmp 0x71d95
jmp 0x71d97
jmp 0x71d99
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rcx)
cmpl $0x0, %eax
jne 0x71ef7
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x71ef7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x71dd9
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x58(%rcx)
movb %al, -0x16(%rbp)
jne 0x71e09
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x16(%rbp)
je 0x71e09
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
seta %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x15(%rbp)
cmpb $0x0, -0x15(%rbp)
je 0x71e43
movq -0x10(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0x71e34
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x54(%rax)
jmp 0x71e41
jmp 0x71e43
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x15(%rbp), %cl
movl -0x14(%rbp), %eax
movsbl %cl, %edx
movsbl %al, %ecx
callq 0x73360
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x71ef5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x60(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x71ef5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x73230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x73360
movq -0x10(%rbp), %rax
cmpl $0x1, 0x54(%rax)
je 0x71eef
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x54(%rax)
jmp 0x71ef1
jmp 0x71ef3
jmp 0x71ef5
jmp 0x71ef7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
unreg_request:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
jmp short $+2
loc_71D85:
jmp short $+2
loc_71D87:
jmp short $+2
loc_71D89:
jmp short $+2
loc_71D8B:
jmp short $+2
loc_71D8D:
jmp short $+2
loc_71D8F:
jmp short $+2
loc_71D91:
jmp short $+2
loc_71D93:
jmp short $+2
loc_71D95:
jmp short $+2
loc_71D97:
jmp short $+2
loc_71D99:
mov rcx, [rbp+var_10]
mov eax, [rcx+38h]
add eax, 0FFFFFFFFh
mov [rcx+38h], eax
cmp eax, 0
jnz loc_71EF7
mov rax, [rbp+var_10]
mov eax, [rax+50h]
and eax, 1
cmp eax, 0
jnz loc_71EF7
mov rax, [rbp+var_10]
cmp dword ptr [rax+58h], 0
jz short loc_71DD9
mov rax, [rbp+var_10]
mov ecx, [rax+58h]
add ecx, 0FFFFFFFFh
mov [rax+58h], ecx
loc_71DD9:
mov rcx, [rbp+var_10]
xor eax, eax
cmp dword ptr [rcx+58h], 0
mov [rbp+var_16], al
jnz short loc_71E09
xor eax, eax
cmp [rbp+var_14], 0
mov [rbp+var_16], al
jz short loc_71E09
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+20h]
setnbe al
mov [rbp+var_16], al
loc_71E09:
mov al, [rbp+var_16]
and al, 1
movzx eax, al
mov [rbp+var_15], al
cmp [rbp+var_15], 0
jz short loc_71E43
mov rax, [rbp+var_10]
cmp dword ptr [rax+54h], 1
jnz short loc_71E34
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+68h], rcx
loc_71E34:
mov rax, [rbp+var_10]
mov dword ptr [rax+54h], 2
jmp short $+2
loc_71E41:
jmp short $+2
loc_71E43:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov cl, [rbp+var_15]
mov eax, [rbp+var_14]
movsx edx, cl
movsx ecx, al
call link_block
mov rax, [rbp+var_8]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+30h]
add rcx, 1
mov [rax+30h], rcx
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_71EF5
mov rax, [rbp+var_8]
mov rax, [rax+30h]
mov rcx, [rbp+var_10]
sub rax, [rcx+60h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+28h]
jbe short loc_71EF5
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call unlink_block
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
xor ecx, ecx
mov edx, ecx
call link_block
mov rax, [rbp+var_10]
cmp dword ptr [rax+54h], 1
jz short loc_71EEF
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
add rcx, 1
mov [rax+68h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+54h], 1
loc_71EEF:
jmp short $+2
loc_71EF1:
jmp short $+2
loc_71EF3:
jmp short $+2
loc_71EF5:
jmp short $+2
loc_71EF7:
add rsp, 20h
pop rbp
retn
|
unsigned long long unreg_request(_QWORD *a1, long long a2, int a3)
{
unsigned long long result; // rax
bool v4; // [rsp+Ah] [rbp-16h]
unsigned long long v5; // [rsp+10h] [rbp-10h]
result = (unsigned int)(*(_DWORD *)(a2 + 56) - 1);
*(_DWORD *)(a2 + 56) = result;
if ( !(_DWORD)result )
{
result = *(_DWORD *)(a2 + 80) & 1;
if ( !(_DWORD)result )
{
if ( *(_DWORD *)(a2 + 88) )
--*(_DWORD *)(a2 + 88);
v4 = 0;
if ( !*(_DWORD *)(a2 + 88) )
{
v4 = 0;
if ( a3 )
v4 = a1[13] > a1[4];
}
if ( v4 )
{
if ( *(_DWORD *)(a2 + 84) == 1 )
--a1[13];
*(_DWORD *)(a2 + 84) = 2;
}
link_block(a1, a2, v4, (unsigned int)(char)a3);
*(_QWORD *)(a2 + 96) = a1[6]++;
result = a1[23];
v5 = result;
if ( result )
{
result = a1[6] - *(_QWORD *)(result + 96);
if ( result > a1[5] )
{
unlink_block(a1, v5);
link_block(a1, v5, 0LL, 0LL);
result = v5;
if ( *(_DWORD *)(v5 + 84) != 1 )
{
++a1[13];
result = v5;
*(_DWORD *)(v5 + 84) = 1;
}
}
}
}
}
return result;
}
|
unreg_request:
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
JMP 0x00171d85
LAB_00171d85:
JMP 0x00171d87
LAB_00171d87:
JMP 0x00171d89
LAB_00171d89:
JMP 0x00171d8b
LAB_00171d8b:
JMP 0x00171d8d
LAB_00171d8d:
JMP 0x00171d8f
LAB_00171d8f:
JMP 0x00171d91
LAB_00171d91:
JMP 0x00171d93
LAB_00171d93:
JMP 0x00171d95
LAB_00171d95:
JMP 0x00171d97
LAB_00171d97:
JMP 0x00171d99
LAB_00171d99:
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0x38]
ADD EAX,-0x1
MOV dword ptr [RCX + 0x38],EAX
CMP EAX,0x0
JNZ 0x00171ef7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x00171ef7
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x58],0x0
JZ 0x00171dd9
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x58]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x58],ECX
LAB_00171dd9:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP dword ptr [RCX + 0x58],0x0
MOV byte ptr [RBP + -0x16],AL
JNZ 0x00171e09
XOR EAX,EAX
CMP dword ptr [RBP + -0x14],0x0
MOV byte ptr [RBP + -0x16],AL
JZ 0x00171e09
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x20]
SETA AL
MOV byte ptr [RBP + -0x16],AL
LAB_00171e09:
MOV AL,byte ptr [RBP + -0x16]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x15],AL
CMP byte ptr [RBP + -0x15],0x0
JZ 0x00171e43
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x54],0x1
JNZ 0x00171e34
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x68],RCX
LAB_00171e34:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x54],0x2
JMP 0x00171e41
LAB_00171e41:
JMP 0x00171e43
LAB_00171e43:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RBP + -0x15]
MOV EAX,dword ptr [RBP + -0x14]
MOVSX EDX,CL
MOVSX ECX,AL
CALL 0x00173360
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x30]
ADD RCX,0x1
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00171ef5
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RCX + 0x60]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x28]
JBE 0x00171ef5
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00173230
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
XOR ECX,ECX
MOV EDX,ECX
CALL 0x00173360
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x54],0x1
JZ 0x00171eef
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
ADD RCX,0x1
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x54],0x1
LAB_00171eef:
JMP 0x00171ef1
LAB_00171ef1:
JMP 0x00171ef3
LAB_00171ef3:
JMP 0x00171ef5
LAB_00171ef5:
JMP 0x00171ef7
LAB_00171ef7:
ADD RSP,0x20
POP RBP
RET
|
void unreg_request(long param_1,long param_2,int param_3)
{
long lVar1;
int iVar2;
bool local_1e;
iVar2 = *(int *)(param_2 + 0x38) + -1;
*(int *)(param_2 + 0x38) = iVar2;
if ((iVar2 == 0) && ((*(uint *)(param_2 + 0x50) & 1) == 0)) {
if (*(int *)(param_2 + 0x58) != 0) {
*(int *)(param_2 + 0x58) = *(int *)(param_2 + 0x58) + -1;
}
local_1e = false;
if ((*(int *)(param_2 + 0x58) == 0) && (local_1e = false, param_3 != 0)) {
local_1e = *(ulong *)(param_1 + 0x20) < *(ulong *)(param_1 + 0x68);
}
if (local_1e != false) {
if (*(int *)(param_2 + 0x54) == 1) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + -1;
}
*(int4 *)(param_2 + 0x54) = 2;
}
link_block(param_1,param_2,local_1e,(int)(char)param_3);
*(int8 *)(param_2 + 0x60) = *(int8 *)(param_1 + 0x30);
*(long *)(param_1 + 0x30) = *(long *)(param_1 + 0x30) + 1;
lVar1 = *(long *)(param_1 + 0xb8);
if ((lVar1 != 0) &&
(*(ulong *)(param_1 + 0x28) < (ulong)(*(long *)(param_1 + 0x30) - *(long *)(lVar1 + 0x60))))
{
unlink_block(param_1,lVar1);
link_block(param_1,lVar1,0);
if (*(int *)(lVar1 + 0x54) != 1) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
*(int4 *)(lVar1 + 0x54) = 1;
}
}
}
return;
}
|
|
13,931
|
(anonymous namespace)::msgpack23_StringNotEnoughDataTest_Test::~msgpack23_StringNotEnoughDataTest_Test()
|
msgpack23/tests/exception_tests.cpp
|
TEST(msgpack23, StringNotEnoughDataTest) {
std::vector<std::byte> const expected_data{
static_cast<std::byte>(0b10100000 | 4),
static_cast<std::byte>('t'),
static_cast<std::byte>('e')
};
msgpack23::Unpacker unpacker{expected_data};
std::string actual{};
EXPECT_THROW(unpacker(actual), std::out_of_range);
}
|
O0
|
cpp
|
(anonymous namespace)::msgpack23_StringNotEnoughDataTest_Test::~msgpack23_StringNotEnoughDataTest_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f3e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN12_GLOBAL__N_138msgpack23_StringNotEnoughDataTest_TestD2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
call _ZN7testing4TestD2Ev; testing::Test::~Test()
add rsp, 10h
pop rbp
retn
|
void `anonymous namespace'::msgpack23_StringNotEnoughDataTest_Test::~msgpack23_StringNotEnoughDataTest_Test(
_anonymous_namespace_::msgpack23_StringNotEnoughDataTest_Test *this)
{
testing::Test::~Test(this);
}
|
~msgpack23_StringNotEnoughDataTest_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0019f3e0
ADD RSP,0x10
POP RBP
RET
|
/* (anonymous
namespace)::msgpack23_StringNotEnoughDataTest_Test::~msgpack23_StringNotEnoughDataTest_Test() */
void __thiscall
(anonymous_namespace)::msgpack23_StringNotEnoughDataTest_Test::
~msgpack23_StringNotEnoughDataTest_Test(msgpack23_StringNotEnoughDataTest_Test *this)
{
testing::Test::~Test((Test *)this);
return;
}
|
|
13,932
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<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::allocator<std::pair<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, minja::Value>>>::at(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
|
T& at(const key_type& key)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it->second;
}
}
JSON_THROW(std::out_of_range("key not found"));
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<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::allocator<std::pair<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, minja::Value>>>::at(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&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x113de0
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x113e50
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x113e10
testb $0x1, %al
jne 0x135316
jmp 0x135367
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x113e80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0x127a30
testb $0x1, %al
jne 0x135346
jmp 0x135359
leaq 0x30(%rsp), %rdi
callq 0x113e80
addq $0x10, %rax
addq $0x48, %rsp
retq
jmp 0x13535b
leaq 0x30(%rsp), %rdi
callq 0x1141d0
jmp 0x1352f2
movl $0x10, %edi
callq 0x5a680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0xdeb0b(%rip), %rsi # 0x213e8d
callq 0x5a490
jmp 0x135389
movq (%rsp), %rdi
movq 0x16fb84(%rip), %rsi # 0x2a4f18
movq 0x16fbe5(%rip), %rdx # 0x2a4f80
callq 0x5aae0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x5af70
movq 0x20(%rsp), %rdi
callq 0x5aba0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_38], rdi
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+48h+var_18], rax
loc_1352F2:
mov rdi, [rsp+48h+var_38]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+48h+var_20], rax
lea rdi, [rsp+48h+var_18]
lea rsi, [rsp+48h+var_20]
call _ZN9__gnu_cxxneIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_135316
jmp short loc_135367
loc_135316:
mov rax, [rsp+48h+var_38]
add rax, 18h
mov [rsp+48h+var_40], rax
lea rdi, [rsp+48h+var_18]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, [rsp+48h+var_40]
mov rsi, rax
mov rdx, [rsp+48h+var_10]
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEESI_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSJ_OSK_
test al, 1
jnz short loc_135346
jmp short loc_135359
loc_135346:
lea rdi, [rsp+48h+var_18]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
add rax, 10h
add rsp, 48h
retn
loc_135359:
jmp short $+2
loc_13535B:
lea rdi, [rsp+48h+var_18]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator++(void)
jmp short loc_1352F2
loc_135367:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+48h+var_48], rax
lea rsi, aKeyNotFound; "key not found"
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
jmp short $+2
loc_135389:
mov rdi, [rsp+48h+var_48]; void *
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+48h+var_48]; void *
mov rcx, rax
mov eax, edx
mov [rsp+48h+var_28], rcx
mov [rsp+48h+var_2C], eax
call ___cxa_free_exception
mov rdi, [rsp+48h+var_28]
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::at(
long long a1,
long long a2)
{
long long v2; // rax
std::out_of_range *exception; // [rsp+0h] [rbp-48h]
long long v5; // [rsp+28h] [rbp-20h] BYREF
long long i; // [rsp+30h] [rbp-18h] BYREF
long long v7; // [rsp+38h] [rbp-10h]
long long v8; // [rsp+40h] [rbp-8h]
v8 = a1;
v7 = a2;
for ( i = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator++(&i) )
{
v5 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
(long long)&i,
(long long)&v5) )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "key not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
v2 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->((long long)&i);
if ( (std::equal_to<void>::operator()<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&>(
a1 + 24,
v2,
v7) & 1) != 0 )
break;
}
return __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->((long long)&i)
+ 16;
}
| |||
13,933
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<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::allocator<std::pair<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, minja::Value>>>::at(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
|
T& at(const key_type& key)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it->second;
}
}
JSON_THROW(std::out_of_range("key not found"));
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<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::allocator<std::pair<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, minja::Value>>>::at(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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
cmpq 0x8(%r15), %rbx
je 0x6e0d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6809c
testb %al, %al
jne 0x6e0c7
addq $0x60, %rbx
jmp 0x6e0ac
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %rbx
leaq 0x463b0(%rip), %rsi # 0xb4496
movq %rax, %rdi
callq 0x23100
movq 0x8fec3(%rip), %rsi # 0xfdfb8
movq 0x8fe9c(%rip), %rdx # 0xfdf98
movq %rbx, %rdi
callq 0x23f30
movq %rax, %r14
movq %rbx, %rdi
callq 0x236b0
movq %r14, %rdi
callq 0x23fd0
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_:
push r15
push r14
push rbx
mov r14, rsi
mov r15, rdi
mov rbx, [rdi]
loc_6E0AC:
cmp rbx, [r15+8]
jz short loc_6E0D4
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_6E0C7
add rbx, 60h ; '`'
jmp short loc_6E0AC
loc_6E0C7:
add rbx, 10h
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_6E0D4:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aKeyNotFound; "key not found"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
|
unsigned __int8 * nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::at(
unsigned __int8 **a1,
unsigned __int8 *a2,
__m128d a3)
{
unsigned __int8 *i; // rbx
std::out_of_range *exception; // rbx
for ( i = *a1; ; i += 96 )
{
if ( i == a1[1] )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "key not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
if ( nlohmann::json_abi_v3_11_3::operator==(i, a2, a3) )
break;
}
return i + 16;
}
|
at:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV R15,RDI
MOV RBX,qword ptr [RDI]
LAB_0016e0ac:
CMP RBX,qword ptr [R15 + 0x8]
JZ 0x0016e0d4
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016809c
TEST AL,AL
JNZ 0x0016e0c7
ADD RBX,0x60
JMP 0x0016e0ac
LAB_0016e0c7:
ADD RBX,0x10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0016e0d4:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV RBX,RAX
LAB_0016e0df:
LEA RSI,[0x1b4496]
MOV RDI,RAX
CALL 0x00123100
LAB_0016e0ee:
MOV RSI,qword ptr [0x001fdfb8]
MOV RDX,qword ptr [0x001fdf98]
MOV RDI,RBX
CALL 0x00123f30
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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, minja::Value> >
>::at(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,minja::Value>>>
::at(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,minja::Value>>>
*this,basic_json *param_1)
{
char cVar1;
out_of_range *this_00;
basic_json *pbVar2;
pbVar2 = *(basic_json **)this;
while( true ) {
if (pbVar2 == *(basic_json **)(this + 8)) {
this_00 = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 0016e0df to 0016e0ed has its CatchHandler @ 0016e104 */
std::out_of_range::out_of_range(this_00,"key not found");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fdfb8,PTR__out_of_range_001fdf98);
}
cVar1 = json_abi_v3_11_3::operator==(pbVar2,param_1);
if (cVar1 != '\0') break;
pbVar2 = pbVar2 + 0x60;
}
return pbVar2 + 0x10;
}
|
|
13,934
|
unicode_prop
|
bluesky950520[P]quickjs/libunicode.c
|
int unicode_prop(CharRange *cr, const char *prop_name)
{
int prop_idx, ret;
prop_idx = unicode_find_name(unicode_prop_name_table, prop_name);
if (prop_idx < 0)
return -2;
prop_idx += UNICODE_PROP_ASCII_Hex_Digit;
ret = 0;
switch(prop_idx) {
case UNICODE_PROP_ASCII:
if (cr_add_interval(cr, 0x00, 0x7f + 1))
return -1;
break;
case UNICODE_PROP_Any:
if (cr_add_interval(cr, 0x00000, 0x10ffff + 1))
return -1;
break;
case UNICODE_PROP_Assigned:
ret = unicode_prop_ops(cr,
POP_GC, M(Cn),
POP_INVERT,
POP_END);
break;
case UNICODE_PROP_Math:
ret = unicode_prop_ops(cr,
POP_GC, M(Sm),
POP_PROP, UNICODE_PROP_Other_Math,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Lowercase:
ret = unicode_prop_ops(cr,
POP_GC, M(Ll),
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Uppercase:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Cased:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Alphabetic:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Alphabetic,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Grapheme_Base:
ret = unicode_prop_ops(cr,
POP_GC, M(Cc) | M(Cf) | M(Cs) | M(Co) | M(Cn) | M(Zl) | M(Zp) | M(Me) | M(Mn),
POP_PROP, UNICODE_PROP_Other_Grapheme_Extend,
POP_UNION,
POP_INVERT,
POP_END);
break;
case UNICODE_PROP_Grapheme_Extend:
ret = unicode_prop_ops(cr,
POP_GC, M(Me) | M(Mn),
POP_PROP, UNICODE_PROP_Other_Grapheme_Extend,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_XID_Start:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl),
POP_PROP, UNICODE_PROP_Other_ID_Start,
POP_UNION,
POP_PROP, UNICODE_PROP_Pattern_Syntax,
POP_PROP, UNICODE_PROP_Pattern_White_Space,
POP_UNION,
POP_PROP, UNICODE_PROP_XID_Start1,
POP_UNION,
POP_INVERT,
POP_INTER,
POP_END);
break;
case UNICODE_PROP_XID_Continue:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl) |
M(Mn) | M(Mc) | M(Nd) | M(Pc),
POP_PROP, UNICODE_PROP_Other_ID_Start,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_ID_Continue,
POP_UNION,
POP_PROP, UNICODE_PROP_Pattern_Syntax,
POP_PROP, UNICODE_PROP_Pattern_White_Space,
POP_UNION,
POP_PROP, UNICODE_PROP_XID_Continue1,
POP_UNION,
POP_INVERT,
POP_INTER,
POP_END);
break;
case UNICODE_PROP_Changes_When_Uppercased:
ret = unicode_case1(cr, CASE_U);
break;
case UNICODE_PROP_Changes_When_Lowercased:
ret = unicode_case1(cr, CASE_L);
break;
case UNICODE_PROP_Changes_When_Casemapped:
ret = unicode_case1(cr, CASE_U | CASE_L | CASE_F);
break;
case UNICODE_PROP_Changes_When_Titlecased:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_U,
POP_PROP, UNICODE_PROP_Changes_When_Titlecased1,
POP_XOR,
POP_END);
break;
case UNICODE_PROP_Changes_When_Casefolded:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_F,
POP_PROP, UNICODE_PROP_Changes_When_Casefolded1,
POP_XOR,
POP_END);
break;
case UNICODE_PROP_Changes_When_NFKC_Casefolded:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_F,
POP_PROP, UNICODE_PROP_Changes_When_NFKC_Casefolded1,
POP_XOR,
POP_END);
break;
/* we use the existing tables */
case UNICODE_PROP_ID_Continue:
ret = unicode_prop_ops(cr,
POP_PROP, UNICODE_PROP_ID_Start,
POP_PROP, UNICODE_PROP_ID_Continue1,
POP_XOR,
POP_END);
break;
default:
if (prop_idx >= countof(unicode_prop_table))
return -2;
ret = unicode_prop1(cr, prop_idx);
break;
}
return ret;
}
|
O2
|
c
|
unicode_prop:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xceeb(%rip), %rdi # 0x8d5d0
callq 0x80005
pushq $-0x2
popq %rbp
testl %eax, %eax
js 0x8094c
leal -0x24(%rax), %ecx
cmpl $0x14, %ecx
ja 0x80955
leaq 0x9f4c(%rip), %rdx # 0x8a654
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x80, %edx
jmp 0x8085a
subq $0x8, %rsp
pushq $0x3
popq %r9
pushq $0x1
popq %rcx
pushq $0x7
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x43e, %edx # imm = 0x43E
xorl %eax, %eax
pushq $0x7
pushq $0x4
pushq $0x6
pushq %r9
pushq $0xb
pushq %rcx
pushq %r9
pushq $0x20
pushq %rcx
pushq $0x1f
pushq %rcx
callq 0x80969
addq $0x60, %rsp
jmp 0x8094a
subq $0x8, %rsp
pushq $0x32
popq %rdx
pushq $0x1
popq %rcx
pushq $0xa
popq %r8
pushq $0x5
popq %r9
movq %rbx, %rdi
movl %ecx, %esi
jmp 0x8093f
pushq $0x1
jmp 0x80875
pushq $0x3
popq %r9
pushq $0xe
popq %rdx
pushq $0x1
popq %rcx
pushq $0x4
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
pushq $0x7
pushq %r9
pushq %r9
pushq $0x1
callq 0x80969
addq $0x20, %rsp
jmp 0x8094a
subq $0x8, %rsp
pushq $0x1
popq %rcx
pushq $0x5
popq %r8
pushq $0x3
popq %r9
movq %rbx, %rdi
xorl %esi, %esi
movl $0x140, %edx # imm = 0x140
jmp 0x8093f
subq $0x8, %rsp
pushq $0x3
popq %r9
pushq $0x1
popq %rcx
pushq $0x4
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x43e, %edx # imm = 0x43E
xorl %eax, %eax
pushq $0x7
pushq %r9
pushq $0x2
pushq %rcx
pushq %r9
pushq %r9
pushq %rcx
callq 0x80969
addq $0x40, %rsp
jmp 0x8094a
subq $0x8, %rsp
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x1
popq %rcx
pushq $0xe
jmp 0x808e3
pushq $0x1
popq %rcx
pushq $0x5
popq %r8
pushq $0x3
popq %r9
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3f000141, %edx # imm = 0x3F000141
xorl %eax, %eax
pushq $0x7
pushq $0x6
jmp 0x80943
pushq $0x1
popq %rdx
pushq $0x6
popq %rcx
pushq $0x7
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x80969
jmp 0x8094a
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x110000, %edx # imm = 0x110000
callq 0x80099
testl %eax, %eax
je 0x8094c
pushq $-0x1
popq %rbp
jmp 0x8094c
pushq $0x7
jmp 0x80875
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x80441
jmp 0x8094a
subq $0x8, %rsp
pushq $0x4
popq %rdx
pushq $0x1
popq %rcx
pushq $0x3
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
movl %r8d, %r9d
jmp 0x8093f
subq $0x8, %rsp
pushq $0x1
popq %rcx
pushq $0x3
popq %r9
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
movl %ecx, %r8d
jmp 0x8093f
subq $0x8, %rsp
pushq $0x2
popq %rsi
pushq $0x1
popq %rcx
pushq $0xd
popq %r8
pushq $0x5
popq %r9
movq %rbx, %rdi
movl %ecx, %edx
jmp 0x8093f
subq $0x8, %rsp
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x1
popq %rcx
pushq $0xf
popq %r8
pushq $0x5
popq %r9
movq %rbx, %rdi
jmp 0x8093f
pushq $0x3
popq %r9
pushq $0x1
popq %rcx
pushq $0x7
popq %r8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x106fe, %edx # imm = 0x106FE
xorl %eax, %eax
pushq $0x7
pushq $0x4
pushq $0x6
pushq %r9
pushq $0xc
pushq %rcx
pushq %r9
pushq $0x20
pushq %rcx
pushq $0x1f
pushq %rcx
pushq %r9
pushq $0x8
pushq %rcx
callq 0x80969
addq $0x70, %rsp
jmp 0x8094a
subq $0x8, %rsp
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
pushq $0x4
popq %r8
pushq $0x3
popq %r9
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
pushq $0x7
callq 0x80969
popq %rcx
popq %rdx
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x23, %eax
ja 0x8094c
addl $0x10, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x80c7a
jmp 0x8094a
|
unicode_prop:
push rbp
push rbx
push rax
mov rbx, rdi
lea rdi, unicode_prop_name_table; "ASCII_Hex_Digit,AHex"
call unicode_find_name
push 0FFFFFFFFFFFFFFFEh
pop rbp
test eax, eax
js loc_8094C
lea ecx, [rax-24h]; switch 21 cases
cmp ecx, 14h
ja def_8070F; jumptable 000000000008070F default case, cases 50,51
lea rdx, jpt_8070F
movsxd rcx, ds:(jpt_8070F - 8A654h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_80711:
xor ebp, ebp; jumptable 000000000008070F case 36
mov rdi, rbx
xor esi, esi
mov edx, 80h
jmp loc_8085A
loc_80722:
sub rsp, 8; jumptable 000000000008070F case 56
push 3
pop r9
push 1
pop rcx
push 7
pop r8
mov rdi, rbx
xor esi, esi
mov edx, 43Eh
xor eax, eax
push 7
push 4
push 6
push r9
push 0Bh
push rcx
push r9
push 20h ; ' '
push rcx
push 1Fh
push rcx
call unicode_prop_ops
add rsp, 60h
jmp loc_8094A
loc_8075E:
sub rsp, 8; jumptable 000000000008070F case 49
push 32h ; '2'
pop rdx
push 1
pop rcx
push 0Ah
pop r8
push 5
pop r9
mov rdi, rbx
mov esi, ecx
jmp loc_8093F
loc_8077A:
push 1; jumptable 000000000008070F case 46
jmp loc_80875
loc_80781:
push 3; jumptable 000000000008070F case 40
pop r9
push 0Eh
pop rdx
push 1
pop rcx
push 4
pop r8
mov rdi, rbx
xor esi, esi
xor eax, eax
push 7
push r9
push r9
push 1
call unicode_prop_ops
add rsp, 20h
jmp loc_8094A
loc_807AC:
sub rsp, 8; jumptable 000000000008070F case 48
push 1
pop rcx
push 5
pop r8
push 3
pop r9
mov rdi, rbx
xor esi, esi
mov edx, 140h
jmp loc_8093F
loc_807CA:
sub rsp, 8; jumptable 000000000008070F case 37
push 3
pop r9
push 1
pop rcx
push 4
pop r8
mov rdi, rbx
xor esi, esi
mov edx, 43Eh
xor eax, eax
push 7
push r9
push 2
push rcx
push r9
push r9
push rcx
call unicode_prop_ops
add rsp, 40h
jmp loc_8094A
loc_807FF:
sub rsp, 8; jumptable 000000000008070F case 41
push 2
pop rsi
push 4
pop rdx
push 1
pop rcx
push 0Eh
jmp loc_808E3
loc_80813:
push 1; jumptable 000000000008070F case 47
pop rcx
push 5
pop r8
push 3
pop r9
mov rdi, rbx
xor esi, esi
mov edx, 3F000141h
xor eax, eax
push 7
push 6
jmp loc_80943
loc_80833:
push 1; jumptable 000000000008070F case 39
pop rdx
push 6
pop rcx
push 7
pop r8
mov rdi, rbx
xor esi, esi
xor eax, eax
call unicode_prop_ops
jmp loc_8094A
loc_8084E:
xor ebp, ebp; jumptable 000000000008070F case 38
mov rdi, rbx
xor esi, esi
mov edx, 110000h
loc_8085A:
call cr_add_interval
test eax, eax
jz loc_8094C
push 0FFFFFFFFFFFFFFFFh
pop rbp
jmp loc_8094C
loc_8086F:
push 7; jumptable 000000000008070F case 42
jmp short loc_80875
loc_80873:
push 2; jumptable 000000000008070F case 43
loc_80875:
pop rsi
mov rdi, rbx
call unicode_case1
jmp loc_8094A
loc_80883:
sub rsp, 8; jumptable 000000000008070F case 52
push 4
pop rdx
push 1
pop rcx
push 3
pop r8
mov rdi, rbx
xor esi, esi
mov r9d, r8d
jmp loc_8093F
loc_8089E:
sub rsp, 8; jumptable 000000000008070F case 53
push 1
pop rcx
push 3
pop r9
mov rdi, rbx
xor esi, esi
mov edx, 1000h
mov r8d, ecx
jmp loc_8093F
loc_808BB:
sub rsp, 8; jumptable 000000000008070F case 45
push 2
pop rsi
push 1
pop rcx
push 0Dh
pop r8
push 5
pop r9
mov rdi, rbx
mov edx, ecx
jmp short loc_8093F
loc_808D4:
sub rsp, 8; jumptable 000000000008070F case 44
push 2
pop rsi
push 4
pop rdx
push 1
pop rcx
push 0Fh
loc_808E3:
pop r8
push 5
pop r9
mov rdi, rbx
jmp short loc_8093F
loc_808EE:
push 3; jumptable 000000000008070F case 55
pop r9
push 1
pop rcx
push 7
pop r8
mov rdi, rbx
xor esi, esi
mov edx, 106FEh
xor eax, eax
push 7
push 4
push 6
push r9
push 0Ch
push rcx
push r9
push 20h ; ' '
push rcx
push 1Fh
push rcx
push r9
push 8
push rcx
call unicode_prop_ops
add rsp, 70h
jmp short loc_8094A
loc_80928:
sub rsp, 8; jumptable 000000000008070F case 54
push 2
pop rdx
push 1
pop rcx
push 4
pop r8
push 3
pop r9
mov rdi, rbx
xor esi, esi
loc_8093F:
xor eax, eax
push 7
loc_80943:
call unicode_prop_ops
pop rcx
pop rdx
loc_8094A:
mov ebp, eax
loc_8094C:
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
retn
def_8070F:
cmp eax, 23h ; '#'; jumptable 000000000008070F default case, cases 50,51
ja short loc_8094C
add eax, 10h
mov rdi, rbx
mov esi, eax
call unicode_prop1
jmp short loc_8094A
|
long long unicode_prop(int *a1, long long a2)
{
long long v2; // rax
int name; // eax
int v4; // r9d
unsigned int v5; // ebp
int v6; // edx
unsigned int v7; // eax
int v9; // [rsp-18h] [rbp-28h]
long long v10; // [rsp-8h] [rbp-18h]
v10 = v2;
name = unicode_find_name("ASCII_Hex_Digit,AHex", a2);
v5 = -2;
if ( name >= 0 )
{
switch ( name )
{
case '$':
v5 = 0;
v6 = 128;
goto LABEL_14;
case '%':
v7 = unicode_prop_ops((_DWORD)a1, 0, 1086, 1, 4, 3, 1LL, 3LL, 3LL, 1LL, 2LL, 3LL, 7LL);
goto LABEL_26;
case '&':
v5 = 0;
v6 = 1114112;
LABEL_14:
if ( (unsigned int)cr_add_interval(a1, 0, v6) )
return (unsigned int)-1;
return v5;
case '\'':
v7 = unicode_prop_ops((_DWORD)a1, 0, 1, 6, 7, v4, v10);
goto LABEL_26;
case '(':
v7 = unicode_prop_ops((_DWORD)a1, 0, 14, 1, 4, 3, 1LL, 3LL, 3LL, 7LL);
goto LABEL_26;
case ')':
v9 = 14;
goto LABEL_23;
case '*':
v7 = unicode_case1(a1, 7);
goto LABEL_26;
case '+':
v7 = unicode_case1(a1, 2);
goto LABEL_26;
case ',':
v9 = 15;
LABEL_23:
v7 = unicode_prop_ops((_DWORD)a1, 2, 4, 1, v9, 5, 7LL);
goto LABEL_26;
case '-':
v7 = unicode_prop_ops((_DWORD)a1, 2, 1, 1, 13, 5, 7LL);
goto LABEL_26;
case '.':
v7 = unicode_case1(a1, 1);
goto LABEL_26;
case '/':
v7 = unicode_prop_ops((_DWORD)a1, 0, 1056964929, 1, 5, 3, 6LL);
goto LABEL_26;
case '0':
v7 = unicode_prop_ops((_DWORD)a1, 0, 320, 1, 5, 3, 7LL);
goto LABEL_26;
case '1':
v7 = unicode_prop_ops((_DWORD)a1, 1, 50, 1, 10, 5, 7LL);
goto LABEL_26;
case '4':
v7 = unicode_prop_ops((_DWORD)a1, 0, 4, 1, 3, 3, 7LL);
goto LABEL_26;
case '5':
v7 = unicode_prop_ops((_DWORD)a1, 0, 4096, 1, 1, 3, 7LL);
goto LABEL_26;
case '6':
v7 = unicode_prop_ops((_DWORD)a1, 0, 2, 1, 4, 3, 7LL);
goto LABEL_26;
case '7':
v7 = unicode_prop_ops(
(_DWORD)a1,
0,
67326,
1,
7,
3,
1LL,
8LL,
3LL,
1LL,
31LL,
1LL,
32LL,
3LL,
1LL,
12LL,
3LL,
6LL,
4LL,
7LL);
goto LABEL_26;
case '8':
v7 = unicode_prop_ops((_DWORD)a1, 0, 1086, 1, 7, 3, 1LL, 31LL, 1LL, 32LL, 3LL, 1LL, 11LL, 3LL, 6LL, 4LL, 7LL);
goto LABEL_26;
default:
if ( (unsigned int)name > 0x23 )
return v5;
v7 = unicode_prop1(a1, (unsigned int)(name + 16));
LABEL_26:
v5 = v7;
break;
}
}
return v5;
}
|
unicode_prop:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RDI,[0x18d5d0]
CALL 0x00180005
PUSH -0x2
POP RBP
TEST EAX,EAX
JS 0x0018094c
LEA ECX,[RAX + -0x24]
CMP ECX,0x14
JA 0x00180955
LEA RDX,[0x18a654]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_24:
XOR EBP,EBP
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x80
JMP 0x0018085a
caseD_38:
SUB RSP,0x8
PUSH 0x3
POP R9
PUSH 0x1
POP RCX
PUSH 0x7
POP R8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x43e
XOR EAX,EAX
PUSH 0x7
PUSH 0x4
PUSH 0x6
PUSH R9
PUSH 0xb
PUSH RCX
PUSH R9
PUSH 0x20
PUSH RCX
PUSH 0x1f
PUSH RCX
CALL 0x00180969
ADD RSP,0x60
JMP 0x0018094a
caseD_31:
SUB RSP,0x8
PUSH 0x32
POP RDX
PUSH 0x1
POP RCX
PUSH 0xa
POP R8
PUSH 0x5
POP R9
MOV RDI,RBX
MOV ESI,ECX
JMP 0x0018093f
caseD_2e:
PUSH 0x1
JMP 0x00180875
caseD_28:
PUSH 0x3
POP R9
PUSH 0xe
POP RDX
PUSH 0x1
POP RCX
PUSH 0x4
POP R8
MOV RDI,RBX
XOR ESI,ESI
XOR EAX,EAX
PUSH 0x7
PUSH R9
PUSH R9
PUSH 0x1
CALL 0x00180969
ADD RSP,0x20
JMP 0x0018094a
caseD_30:
SUB RSP,0x8
PUSH 0x1
POP RCX
PUSH 0x5
POP R8
PUSH 0x3
POP R9
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x140
JMP 0x0018093f
caseD_25:
SUB RSP,0x8
PUSH 0x3
POP R9
PUSH 0x1
POP RCX
PUSH 0x4
POP R8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x43e
XOR EAX,EAX
PUSH 0x7
PUSH R9
PUSH 0x2
PUSH RCX
PUSH R9
PUSH R9
PUSH RCX
CALL 0x00180969
ADD RSP,0x40
JMP 0x0018094a
caseD_29:
SUB RSP,0x8
PUSH 0x2
POP RSI
PUSH 0x4
POP RDX
PUSH 0x1
POP RCX
PUSH 0xe
JMP 0x001808e3
caseD_2f:
PUSH 0x1
POP RCX
PUSH 0x5
POP R8
PUSH 0x3
POP R9
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x3f000141
XOR EAX,EAX
PUSH 0x7
PUSH 0x6
JMP 0x00180943
caseD_27:
PUSH 0x1
POP RDX
PUSH 0x6
POP RCX
PUSH 0x7
POP R8
MOV RDI,RBX
XOR ESI,ESI
XOR EAX,EAX
CALL 0x00180969
JMP 0x0018094a
caseD_26:
XOR EBP,EBP
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x110000
LAB_0018085a:
CALL 0x00180099
TEST EAX,EAX
JZ 0x0018094c
PUSH -0x1
POP RBP
JMP 0x0018094c
caseD_2a:
PUSH 0x7
JMP 0x00180875
caseD_2b:
PUSH 0x2
LAB_00180875:
POP RSI
MOV RDI,RBX
CALL 0x00180441
JMP 0x0018094a
caseD_34:
SUB RSP,0x8
PUSH 0x4
POP RDX
PUSH 0x1
POP RCX
PUSH 0x3
POP R8
MOV RDI,RBX
XOR ESI,ESI
MOV R9D,R8D
JMP 0x0018093f
caseD_35:
SUB RSP,0x8
PUSH 0x1
POP RCX
PUSH 0x3
POP R9
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x1000
MOV R8D,ECX
JMP 0x0018093f
caseD_2d:
SUB RSP,0x8
PUSH 0x2
POP RSI
PUSH 0x1
POP RCX
PUSH 0xd
POP R8
PUSH 0x5
POP R9
MOV RDI,RBX
MOV EDX,ECX
JMP 0x0018093f
caseD_2c:
SUB RSP,0x8
PUSH 0x2
POP RSI
PUSH 0x4
POP RDX
PUSH 0x1
POP RCX
PUSH 0xf
LAB_001808e3:
POP R8
PUSH 0x5
POP R9
MOV RDI,RBX
JMP 0x0018093f
caseD_37:
PUSH 0x3
POP R9
PUSH 0x1
POP RCX
PUSH 0x7
POP R8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x106fe
XOR EAX,EAX
PUSH 0x7
PUSH 0x4
PUSH 0x6
PUSH R9
PUSH 0xc
PUSH RCX
PUSH R9
PUSH 0x20
PUSH RCX
PUSH 0x1f
PUSH RCX
PUSH R9
PUSH 0x8
PUSH RCX
CALL 0x00180969
ADD RSP,0x70
JMP 0x0018094a
caseD_36:
SUB RSP,0x8
PUSH 0x2
POP RDX
PUSH 0x1
POP RCX
PUSH 0x4
POP R8
PUSH 0x3
POP R9
MOV RDI,RBX
XOR ESI,ESI
LAB_0018093f:
XOR EAX,EAX
PUSH 0x7
LAB_00180943:
CALL 0x00180969
POP RCX
POP RDX
LAB_0018094a:
MOV EBP,EAX
LAB_0018094c:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
RET
caseD_32:
CMP EAX,0x23
JA 0x0018094c
ADD EAX,0x10
MOV RDI,RBX
MOV ESI,EAX
CALL 0x00180c7a
JMP 0x0018094a
|
int4 unicode_prop(int8 param_1)
{
uint uVar1;
int iVar2;
int4 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
uVar1 = unicode_find_name("ASCII_Hex_Digit,AHex");
uVar9 = 0xfffffffffffffffe;
uVar3 = 0xfffffffe;
if ((int)uVar1 < 0) {
return 0xfffffffe;
}
switch(uVar1) {
case 0x24:
uVar9 = 0x80;
goto LAB_0018085a;
case 0x25:
uVar3 = unicode_prop_ops(param_1,0,0x43e,1,4,3,1,3,3,1,2,3,7);
break;
case 0x26:
uVar9 = 0x110000;
LAB_0018085a:
uVar3 = 0;
iVar2 = cr_add_interval(param_1,0,uVar9);
if (iVar2 != 0) {
uVar3 = 0xffffffff;
}
break;
case 0x27:
uVar3 = unicode_prop_ops(param_1,0,1,6,7);
break;
case 0x28:
uVar3 = unicode_prop_ops(param_1,0,0xe,1,4,3,1,3,3,7);
break;
case 0x29:
uVar7 = 0xe;
goto LAB_001808e3;
case 0x2a:
uVar9 = 7;
goto LAB_00180875;
case 0x2b:
uVar9 = 2;
goto LAB_00180875;
case 0x2c:
uVar7 = 0xf;
LAB_001808e3:
uVar5 = 2;
uVar4 = 4;
uVar6 = 5;
goto LAB_0018093f;
case 0x2d:
uVar5 = 2;
uVar7 = 0xd;
uVar6 = 5;
uVar4 = 1;
goto LAB_0018093f;
case 0x2e:
uVar9 = 1;
LAB_00180875:
uVar3 = unicode_case1(param_1,uVar9);
break;
case 0x2f:
uVar7 = 5;
uVar6 = 3;
uVar5 = 0;
uVar4 = 0x3f000141;
uVar9 = 7;
uVar8 = 6;
goto LAB_00180943;
case 0x30:
uVar7 = 5;
uVar6 = 3;
uVar5 = 0;
uVar4 = 0x140;
goto LAB_0018093f;
case 0x31:
uVar4 = 0x32;
uVar7 = 10;
uVar6 = 5;
uVar5 = 1;
goto LAB_0018093f;
default:
if (uVar1 < 0x24) {
uVar3 = unicode_prop1(param_1,uVar1 + 0x10);
}
break;
case 0x34:
uVar4 = 4;
uVar7 = 3;
uVar5 = 0;
uVar6 = 3;
goto LAB_0018093f;
case 0x35:
uVar6 = 3;
uVar5 = 0;
uVar4 = 0x1000;
uVar7 = 1;
goto LAB_0018093f;
case 0x36:
uVar4 = 2;
uVar7 = 4;
uVar6 = 3;
uVar5 = 0;
LAB_0018093f:
uVar8 = 7;
LAB_00180943:
uVar3 = unicode_prop_ops(param_1,uVar5,uVar4,1,uVar7,uVar6,uVar8,uVar9);
break;
case 0x37:
uVar3 = unicode_prop_ops(param_1,0,0x106fe,1,7,3,1,8,3,1,0x1f,1,0x20,3,1,0xc,3,6,4,7);
break;
case 0x38:
uVar3 = unicode_prop_ops(param_1,0,0x43e,1,7,3,1,0x1f,1,0x20,3,1,0xb,3,6,4,7);
}
return uVar3;
}
|
|
13,935
|
unicode_prop
|
bluesky950520[P]quickjs/libunicode.c
|
int unicode_prop(CharRange *cr, const char *prop_name)
{
int prop_idx, ret;
prop_idx = unicode_find_name(unicode_prop_name_table, prop_name);
if (prop_idx < 0)
return -2;
prop_idx += UNICODE_PROP_ASCII_Hex_Digit;
ret = 0;
switch(prop_idx) {
case UNICODE_PROP_ASCII:
if (cr_add_interval(cr, 0x00, 0x7f + 1))
return -1;
break;
case UNICODE_PROP_Any:
if (cr_add_interval(cr, 0x00000, 0x10ffff + 1))
return -1;
break;
case UNICODE_PROP_Assigned:
ret = unicode_prop_ops(cr,
POP_GC, M(Cn),
POP_INVERT,
POP_END);
break;
case UNICODE_PROP_Math:
ret = unicode_prop_ops(cr,
POP_GC, M(Sm),
POP_PROP, UNICODE_PROP_Other_Math,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Lowercase:
ret = unicode_prop_ops(cr,
POP_GC, M(Ll),
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Uppercase:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Cased:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Alphabetic:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl),
POP_PROP, UNICODE_PROP_Other_Uppercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Lowercase,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_Alphabetic,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_Grapheme_Base:
ret = unicode_prop_ops(cr,
POP_GC, M(Cc) | M(Cf) | M(Cs) | M(Co) | M(Cn) | M(Zl) | M(Zp) | M(Me) | M(Mn),
POP_PROP, UNICODE_PROP_Other_Grapheme_Extend,
POP_UNION,
POP_INVERT,
POP_END);
break;
case UNICODE_PROP_Grapheme_Extend:
ret = unicode_prop_ops(cr,
POP_GC, M(Me) | M(Mn),
POP_PROP, UNICODE_PROP_Other_Grapheme_Extend,
POP_UNION,
POP_END);
break;
case UNICODE_PROP_XID_Start:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl),
POP_PROP, UNICODE_PROP_Other_ID_Start,
POP_UNION,
POP_PROP, UNICODE_PROP_Pattern_Syntax,
POP_PROP, UNICODE_PROP_Pattern_White_Space,
POP_UNION,
POP_PROP, UNICODE_PROP_XID_Start1,
POP_UNION,
POP_INVERT,
POP_INTER,
POP_END);
break;
case UNICODE_PROP_XID_Continue:
ret = unicode_prop_ops(cr,
POP_GC, M(Lu) | M(Ll) | M(Lt) | M(Lm) | M(Lo) | M(Nl) |
M(Mn) | M(Mc) | M(Nd) | M(Pc),
POP_PROP, UNICODE_PROP_Other_ID_Start,
POP_UNION,
POP_PROP, UNICODE_PROP_Other_ID_Continue,
POP_UNION,
POP_PROP, UNICODE_PROP_Pattern_Syntax,
POP_PROP, UNICODE_PROP_Pattern_White_Space,
POP_UNION,
POP_PROP, UNICODE_PROP_XID_Continue1,
POP_UNION,
POP_INVERT,
POP_INTER,
POP_END);
break;
case UNICODE_PROP_Changes_When_Uppercased:
ret = unicode_case1(cr, CASE_U);
break;
case UNICODE_PROP_Changes_When_Lowercased:
ret = unicode_case1(cr, CASE_L);
break;
case UNICODE_PROP_Changes_When_Casemapped:
ret = unicode_case1(cr, CASE_U | CASE_L | CASE_F);
break;
case UNICODE_PROP_Changes_When_Titlecased:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_U,
POP_PROP, UNICODE_PROP_Changes_When_Titlecased1,
POP_XOR,
POP_END);
break;
case UNICODE_PROP_Changes_When_Casefolded:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_F,
POP_PROP, UNICODE_PROP_Changes_When_Casefolded1,
POP_XOR,
POP_END);
break;
case UNICODE_PROP_Changes_When_NFKC_Casefolded:
ret = unicode_prop_ops(cr,
POP_CASE, CASE_F,
POP_PROP, UNICODE_PROP_Changes_When_NFKC_Casefolded1,
POP_XOR,
POP_END);
break;
/* we use the existing tables */
case UNICODE_PROP_ID_Continue:
ret = unicode_prop_ops(cr,
POP_PROP, UNICODE_PROP_ID_Start,
POP_PROP, UNICODE_PROP_ID_Continue1,
POP_XOR,
POP_END);
break;
default:
if (prop_idx >= countof(unicode_prop_table))
return -2;
ret = unicode_prop1(cr, prop_idx);
break;
}
return ret;
}
|
O3
|
c
|
unicode_prop:
pushq %rbx
movq %rdi, %rbx
leaq 0xcfce(%rip), %rdi # 0xa9670
callq 0x9bd54
movl %eax, %esi
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testl %esi, %esi
js 0x9c9fb
leal -0x24(%rsi), %ecx
cmpl $0x14, %ecx
ja 0x9c9fd
leaq 0xa02b(%rip), %rdx # 0xa66f4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl (%rbx), %eax
leal 0x2(%rax), %esi
cmpl 0x4(%rbx), %esi
jle 0x9c6f5
movq %rbx, %rdi
callq 0x9af6f
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x9c9fb
movl (%rbx), %eax
movq 0x8(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, (%rbx)
cltq
movl $0x0, (%rcx,%rax,4)
movslq (%rbx), %rax
leal 0x1(%rax), %edx
movl %edx, (%rbx)
movl $0x80, (%rcx,%rax,4)
jmp 0x9c8e2
subq $0x8, %rsp
movl $0x3, %r11d
movl $0x1, %r10d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x43e, %edx # imm = 0x43E
movl $0x1, %ecx
movl $0x7, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
pushq $0x4
pushq $0x6
pushq %r11
pushq $0xb
pushq %r10
pushq %r11
pushq $0x20
pushq %r10
pushq $0x1f
pushq %r10
callq 0x9ca0e
addq $0x60, %rsp
jmp 0x9c9fb
subq $0x8, %rsp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x32, %edx
movl $0x1, %ecx
movl $0xa, %r8d
jmp 0x9c977
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x9c8fb
movl $0x3, %r10d
movq %rbx, %rdi
xorl %esi, %esi
movl $0xe, %edx
movl $0x1, %ecx
movl $0x4, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
pushq %r10
pushq %r10
pushq $0x1
callq 0x9ca0e
addq $0x20, %rsp
jmp 0x9c9fb
subq $0x8, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x140, %edx # imm = 0x140
movl $0x1, %ecx
movl $0x5, %r8d
jmp 0x9c9e8
subq $0x8, %rsp
movl $0x3, %r10d
movl $0x1, %r11d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x43e, %edx # imm = 0x43E
movl $0x1, %ecx
movl $0x4, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
pushq %r10
pushq $0x2
pushq %r11
pushq %r10
pushq %r10
pushq %r11
callq 0x9ca0e
addq $0x40, %rsp
jmp 0x9c9fb
subq $0x8, %rsp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x4, %edx
movl $0x1, %ecx
movl $0xe, %r8d
jmp 0x9c977
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3f000141, %edx # imm = 0x3F000141
movl $0x1, %ecx
movl $0x5, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
pushq $0x6
jmp 0x9c9f2
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
movl $0x6, %ecx
movl $0x7, %r8d
xorl %eax, %eax
popq %rbx
jmp 0x9ca0e
movl (%rbx), %eax
leal 0x2(%rax), %esi
cmpl 0x4(%rbx), %esi
jle 0x9c8c1
movq %rbx, %rdi
callq 0x9af6f
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x9c9fb
movl (%rbx), %eax
movq 0x8(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, (%rbx)
cltq
movl $0x0, (%rcx,%rax,4)
movslq (%rbx), %rax
leal 0x1(%rax), %edx
movl %edx, (%rbx)
movl $0x110000, (%rcx,%rax,4) # imm = 0x110000
xorl %eax, %eax
jmp 0x9c9fb
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x9c8fb
movq %rbx, %rdi
movl $0x2, %esi
popq %rbx
jmp 0x9c252
subq $0x8, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
movl $0x1, %ecx
movl $0x3, %r8d
jmp 0x9c9e8
subq $0x8, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
movl $0x1, %ecx
movl $0x1, %r8d
jmp 0x9c9e8
subq $0x8, %rsp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0xd, %r8d
jmp 0x9c977
subq $0x8, %rsp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x4, %edx
movl $0x1, %ecx
movl $0xf, %r8d
movl $0x5, %r9d
jmp 0x9c9ee
movl $0x3, %r11d
movl $0x1, %r10d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x106fe, %edx # imm = 0x106FE
movl $0x1, %ecx
movl $0x7, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
pushq $0x4
pushq $0x6
pushq %r11
pushq $0xc
pushq %r10
pushq %r11
pushq $0x20
pushq %r10
pushq $0x1f
pushq %r10
pushq %r11
pushq $0x8
pushq %r10
callq 0x9ca0e
addq $0x70, %rsp
jmp 0x9c9fb
subq $0x8, %rsp
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
movl $0x1, %ecx
movl $0x4, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $0x7
callq 0x9ca0e
addq $0x10, %rsp
popq %rbx
retq
cmpl $0x23, %esi
ja 0x9c9fb
addl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x9cd57
|
unicode_prop:
push rbx
mov rbx, rdi
lea rdi, unicode_prop_name_table; "ASCII_Hex_Digit,AHex"
call unicode_find_name
mov esi, eax
mov eax, 0FFFFFFFEh
test esi, esi
js loc_9C9FB
lea ecx, [rsi-24h]; switch 21 cases
cmp ecx, 14h
ja def_9C6D0; jumptable 000000000009C6D0 default case, cases 50,51
lea rdx, jpt_9C6D0
movsxd rcx, ds:(jpt_9C6D0 - 0A66F4h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_9C6D2:
mov eax, [rbx]; jumptable 000000000009C6D0 case 36
lea esi, [rax+2]
cmp esi, [rbx+4]
jle short loc_9C6F5
mov rdi, rbx
call cr_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz loc_9C9FB
mov eax, [rbx]
loc_9C6F5:
mov rcx, [rbx+8]
lea edx, [rax+1]
mov [rbx], edx
cdqe
mov dword ptr [rcx+rax*4], 0
movsxd rax, dword ptr [rbx]
lea edx, [rax+1]
mov [rbx], edx
mov dword ptr [rcx+rax*4], 80h
jmp loc_9C8E2
loc_9C71B:
sub rsp, 8; jumptable 000000000009C6D0 case 56
mov r11d, 3
mov r10d, 1
mov rdi, rbx
xor esi, esi
mov edx, 43Eh
mov ecx, 1
mov r8d, 7
mov r9d, 3
xor eax, eax
push 7
push 4
push 6
push r11
push 0Bh
push r10
push r11
push 20h ; ' '
push r10
push 1Fh
push r10
call unicode_prop_ops
add rsp, 60h
jmp loc_9C9FB
loc_9C76C:
sub rsp, 8; jumptable 000000000009C6D0 case 49
mov rdi, rbx
mov esi, 1
mov edx, 32h ; '2'
mov ecx, 1
mov r8d, 0Ah
jmp loc_9C977
loc_9C78D:
mov rdi, rbx; jumptable 000000000009C6D0 case 46
mov esi, 1
jmp loc_9C8FB
loc_9C79A:
mov r10d, 3; jumptable 000000000009C6D0 case 40
mov rdi, rbx
xor esi, esi
mov edx, 0Eh
mov ecx, 1
mov r8d, 4
mov r9d, 3
xor eax, eax
push 7
push r10
push r10
push 1
call unicode_prop_ops
add rsp, 20h
jmp loc_9C9FB
loc_9C7D3:
sub rsp, 8; jumptable 000000000009C6D0 case 48
mov rdi, rbx
xor esi, esi
mov edx, 140h
mov ecx, 1
mov r8d, 5
jmp loc_9C9E8
loc_9C7F1:
sub rsp, 8; jumptable 000000000009C6D0 case 37
mov r10d, 3
mov r11d, 1
mov rdi, rbx
xor esi, esi
mov edx, 43Eh
mov ecx, 1
mov r8d, 4
mov r9d, 3
xor eax, eax
push 7
push r10
push 2
push r11
push r10
push r10
push r11
call unicode_prop_ops
add rsp, 40h
jmp loc_9C9FB
loc_9C83A:
sub rsp, 8; jumptable 000000000009C6D0 case 41
mov rdi, rbx
mov esi, 2
mov edx, 4
mov ecx, 1
mov r8d, 0Eh
jmp loc_9C977
loc_9C85B:
mov rdi, rbx; jumptable 000000000009C6D0 case 47
xor esi, esi
mov edx, 3F000141h
mov ecx, 1
mov r8d, 5
mov r9d, 3
xor eax, eax
push 7
push 6
jmp loc_9C9F2
loc_9C881:
mov rdi, rbx; jumptable 000000000009C6D0 case 39
xor esi, esi
mov edx, 1
mov ecx, 6
mov r8d, 7
xor eax, eax
pop rbx
jmp unicode_prop_ops
loc_9C89E:
mov eax, [rbx]; jumptable 000000000009C6D0 case 38
lea esi, [rax+2]
cmp esi, [rbx+4]
jle short loc_9C8C1
mov rdi, rbx
call cr_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz loc_9C9FB
mov eax, [rbx]
loc_9C8C1:
mov rcx, [rbx+8]
lea edx, [rax+1]
mov [rbx], edx
cdqe
mov dword ptr [rcx+rax*4], 0
movsxd rax, dword ptr [rbx]
lea edx, [rax+1]
mov [rbx], edx
mov dword ptr [rcx+rax*4], 110000h
loc_9C8E2:
xor eax, eax
jmp loc_9C9FB
loc_9C8E9:
mov rdi, rbx; jumptable 000000000009C6D0 case 42
mov esi, 7
jmp short loc_9C8FB
loc_9C8F3:
mov rdi, rbx; jumptable 000000000009C6D0 case 43
mov esi, 2
loc_9C8FB:
pop rbx
jmp unicode_case1
loc_9C901:
sub rsp, 8; jumptable 000000000009C6D0 case 52
mov rdi, rbx
xor esi, esi
mov edx, 4
mov ecx, 1
mov r8d, 3
jmp loc_9C9E8
loc_9C91F:
sub rsp, 8; jumptable 000000000009C6D0 case 53
mov rdi, rbx
xor esi, esi
mov edx, 1000h
mov ecx, 1
mov r8d, 1
jmp loc_9C9E8
loc_9C93D:
sub rsp, 8; jumptable 000000000009C6D0 case 45
mov rdi, rbx
mov esi, 2
mov edx, 1
mov ecx, 1
mov r8d, 0Dh
jmp short loc_9C977
loc_9C95B:
sub rsp, 8; jumptable 000000000009C6D0 case 44
mov rdi, rbx
mov esi, 2
mov edx, 4
mov ecx, 1
mov r8d, 0Fh
loc_9C977:
mov r9d, 5
jmp short loc_9C9EE
loc_9C97F:
mov r11d, 3; jumptable 000000000009C6D0 case 55
mov r10d, 1
mov rdi, rbx
xor esi, esi
mov edx, 106FEh
mov ecx, 1
mov r8d, 7
mov r9d, 3
xor eax, eax
push 7
push 4
push 6
push r11
push 0Ch
push r10
push r11
push 20h ; ' '
push r10
push 1Fh
push r10
push r11
push 8
push r10
call unicode_prop_ops
add rsp, 70h
jmp short loc_9C9FB
loc_9C9CF:
sub rsp, 8; jumptable 000000000009C6D0 case 54
mov rdi, rbx
xor esi, esi
mov edx, 2
mov ecx, 1
mov r8d, 4
loc_9C9E8:
mov r9d, 3
loc_9C9EE:
xor eax, eax
push 7
loc_9C9F2:
call unicode_prop_ops
add rsp, 10h
loc_9C9FB:
pop rbx
retn
def_9C6D0:
cmp esi, 23h ; '#'; jumptable 000000000009C6D0 default case, cases 50,51
ja short loc_9C9FB
add esi, 10h
mov rdi, rbx
pop rbx
jmp unicode_prop1
|
long long unicode_prop(int *a1, long long a2)
{
int name; // esi
int v3; // r9d
long long result; // rax
int v5; // eax
int v6; // esi
int v7; // ecx
long long v8; // rcx
long long v9; // rax
int v10; // esi
int v11; // edx
int v12; // r8d
int v13; // eax
int v14; // esi
int v15; // ecx
long long v16; // rcx
long long v17; // rax
int v18; // r9d
name = unicode_find_name("ASCII_Hex_Digit,AHex", a2);
result = 4294967294LL;
if ( name >= 0 )
{
switch ( name )
{
case '$':
v5 = *a1;
v6 = *a1 + 2;
if ( v6 <= a1[1] )
goto LABEL_6;
v7 = cr_realloc((long long)a1, v6);
result = 0xFFFFFFFFLL;
if ( !v7 )
{
v5 = *a1;
LABEL_6:
v8 = *((_QWORD *)a1 + 1);
*a1 = v5 + 1;
*(_DWORD *)(v8 + 4LL * v5) = 0;
v9 = *a1;
*a1 = v9 + 1;
*(_DWORD *)(v8 + 4 * v9) = 128;
return 0LL;
}
return result;
case '%':
return unicode_prop_ops((_DWORD)a1, 0, 1086, 1, 4, 3, 1LL, 3LL, 3LL, 1LL, 2LL, 3LL, 7LL);
case '&':
v13 = *a1;
v14 = *a1 + 2;
if ( v14 <= a1[1] )
goto LABEL_19;
v15 = cr_realloc((long long)a1, v14);
result = 0xFFFFFFFFLL;
if ( !v15 )
{
v13 = *a1;
LABEL_19:
v16 = *((_QWORD *)a1 + 1);
*a1 = v13 + 1;
*(_DWORD *)(v16 + 4LL * v13) = 0;
v17 = *a1;
*a1 = v17 + 1;
*(_DWORD *)(v16 + 4 * v17) = 1114112;
return 0LL;
}
return result;
case '\'':
return unicode_prop_ops((_DWORD)a1, 0, 1, 6, 7, v3);
case '(':
return unicode_prop_ops((_DWORD)a1, 0, 14, 1, 4, 3, 1LL, 3LL, 3LL, 7LL);
case ')':
v10 = 2;
v11 = 4;
v12 = 14;
goto LABEL_28;
case '*':
return unicode_case1(a1, 7);
case '+':
return unicode_case1(a1, 2);
case ',':
v10 = 2;
v11 = 4;
v12 = 15;
goto LABEL_28;
case '-':
v10 = 2;
v11 = 1;
v12 = 13;
goto LABEL_28;
case '.':
return unicode_case1(a1, 1);
case '/':
return unicode_prop_ops((_DWORD)a1, 0, 1056964929, 1, 5, 3, 6LL, 7LL);
case '0':
v10 = 0;
v11 = 320;
v12 = 5;
goto LABEL_31;
case '1':
v10 = 1;
v11 = 50;
v12 = 10;
LABEL_28:
v18 = 5;
goto LABEL_32;
case '4':
v10 = 0;
v11 = 4;
v12 = 3;
goto LABEL_31;
case '5':
v10 = 0;
v11 = 4096;
v12 = 1;
goto LABEL_31;
case '6':
v10 = 0;
v11 = 2;
v12 = 4;
LABEL_31:
v18 = 3;
LABEL_32:
result = unicode_prop_ops((_DWORD)a1, v10, v11, 1, v12, v18, 7LL);
break;
case '7':
result = unicode_prop_ops(
(_DWORD)a1,
0,
67326,
1,
7,
3,
1LL,
8LL,
3LL,
1LL,
31LL,
1LL,
32LL,
3LL,
1LL,
12LL,
3LL,
6LL,
4LL,
7LL);
break;
case '8':
result = unicode_prop_ops(
(_DWORD)a1,
0,
1086,
1,
7,
3,
1LL,
31LL,
1LL,
32LL,
3LL,
1LL,
11LL,
3LL,
6LL,
4LL,
7LL);
break;
default:
if ( (unsigned int)name <= 0x23 )
result = unicode_prop1(a1, (unsigned int)(name + 16));
break;
}
}
return result;
}
|
unicode_prop:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x1a9670]
CALL 0x0019bd54
MOV ESI,EAX
MOV EAX,0xfffffffe
TEST ESI,ESI
JS 0x0019c9fb
LEA ECX,[RSI + -0x24]
CMP ECX,0x14
JA 0x0019c9fd
LEA RDX,[0x1a66f4]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_24:
MOV EAX,dword ptr [RBX]
LEA ESI,[RAX + 0x2]
CMP ESI,dword ptr [RBX + 0x4]
JLE 0x0019c6f5
MOV RDI,RBX
CALL 0x0019af6f
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0019c9fb
MOV EAX,dword ptr [RBX]
LAB_0019c6f5:
MOV RCX,qword ptr [RBX + 0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
CDQE
MOV dword ptr [RCX + RAX*0x4],0x0
MOVSXD RAX,dword ptr [RBX]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RCX + RAX*0x4],0x80
JMP 0x0019c8e2
caseD_38:
SUB RSP,0x8
MOV R11D,0x3
MOV R10D,0x1
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x43e
MOV ECX,0x1
MOV R8D,0x7
MOV R9D,0x3
XOR EAX,EAX
PUSH 0x7
PUSH 0x4
PUSH 0x6
PUSH R11
PUSH 0xb
PUSH R10
PUSH R11
PUSH 0x20
PUSH R10
PUSH 0x1f
PUSH R10
CALL 0x0019ca0e
ADD RSP,0x60
JMP 0x0019c9fb
caseD_31:
SUB RSP,0x8
MOV RDI,RBX
MOV ESI,0x1
MOV EDX,0x32
MOV ECX,0x1
MOV R8D,0xa
JMP 0x0019c977
caseD_2e:
MOV RDI,RBX
MOV ESI,0x1
JMP 0x0019c8fb
caseD_28:
MOV R10D,0x3
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0xe
MOV ECX,0x1
MOV R8D,0x4
MOV R9D,0x3
XOR EAX,EAX
PUSH 0x7
PUSH R10
PUSH R10
PUSH 0x1
CALL 0x0019ca0e
ADD RSP,0x20
JMP 0x0019c9fb
caseD_30:
SUB RSP,0x8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x140
MOV ECX,0x1
MOV R8D,0x5
JMP 0x0019c9e8
caseD_25:
SUB RSP,0x8
MOV R10D,0x3
MOV R11D,0x1
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x43e
MOV ECX,0x1
MOV R8D,0x4
MOV R9D,0x3
XOR EAX,EAX
PUSH 0x7
PUSH R10
PUSH 0x2
PUSH R11
PUSH R10
PUSH R10
PUSH R11
CALL 0x0019ca0e
ADD RSP,0x40
JMP 0x0019c9fb
caseD_29:
SUB RSP,0x8
MOV RDI,RBX
MOV ESI,0x2
MOV EDX,0x4
MOV ECX,0x1
MOV R8D,0xe
JMP 0x0019c977
caseD_2f:
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x3f000141
MOV ECX,0x1
MOV R8D,0x5
MOV R9D,0x3
XOR EAX,EAX
PUSH 0x7
PUSH 0x6
JMP 0x0019c9f2
caseD_27:
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x1
MOV ECX,0x6
MOV R8D,0x7
XOR EAX,EAX
POP RBX
JMP 0x0019ca0e
caseD_26:
MOV EAX,dword ptr [RBX]
LEA ESI,[RAX + 0x2]
CMP ESI,dword ptr [RBX + 0x4]
JLE 0x0019c8c1
MOV RDI,RBX
CALL 0x0019af6f
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0019c9fb
MOV EAX,dword ptr [RBX]
LAB_0019c8c1:
MOV RCX,qword ptr [RBX + 0x8]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
CDQE
MOV dword ptr [RCX + RAX*0x4],0x0
MOVSXD RAX,dword ptr [RBX]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RCX + RAX*0x4],0x110000
LAB_0019c8e2:
XOR EAX,EAX
JMP 0x0019c9fb
caseD_2a:
MOV RDI,RBX
MOV ESI,0x7
JMP 0x0019c8fb
caseD_2b:
MOV RDI,RBX
MOV ESI,0x2
LAB_0019c8fb:
POP RBX
JMP 0x0019c252
caseD_34:
SUB RSP,0x8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x4
MOV ECX,0x1
MOV R8D,0x3
JMP 0x0019c9e8
caseD_35:
SUB RSP,0x8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x1000
MOV ECX,0x1
MOV R8D,0x1
JMP 0x0019c9e8
caseD_2d:
SUB RSP,0x8
MOV RDI,RBX
MOV ESI,0x2
MOV EDX,0x1
MOV ECX,0x1
MOV R8D,0xd
JMP 0x0019c977
caseD_2c:
SUB RSP,0x8
MOV RDI,RBX
MOV ESI,0x2
MOV EDX,0x4
MOV ECX,0x1
MOV R8D,0xf
LAB_0019c977:
MOV R9D,0x5
JMP 0x0019c9ee
caseD_37:
MOV R11D,0x3
MOV R10D,0x1
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x106fe
MOV ECX,0x1
MOV R8D,0x7
MOV R9D,0x3
XOR EAX,EAX
PUSH 0x7
PUSH 0x4
PUSH 0x6
PUSH R11
PUSH 0xc
PUSH R10
PUSH R11
PUSH 0x20
PUSH R10
PUSH 0x1f
PUSH R10
PUSH R11
PUSH 0x8
PUSH R10
CALL 0x0019ca0e
ADD RSP,0x70
JMP 0x0019c9fb
caseD_36:
SUB RSP,0x8
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x2
MOV ECX,0x1
MOV R8D,0x4
LAB_0019c9e8:
MOV R9D,0x3
LAB_0019c9ee:
XOR EAX,EAX
PUSH 0x7
LAB_0019c9f2:
CALL 0x0019ca0e
ADD RSP,0x10
LAB_0019c9fb:
POP RBX
RET
caseD_32:
CMP ESI,0x23
JA 0x0019c9fb
ADD ESI,0x10
MOV RDI,RBX
POP RBX
JMP 0x0019cd57
|
int8 unicode_prop(int *param_1)
{
long lVar1;
uint uVar2;
int iVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
uVar2 = unicode_find_name("ASCII_Hex_Digit,AHex");
uVar4 = 0xfffffffe;
if ((int)uVar2 < 0) {
return 0xfffffffe;
}
switch(uVar2) {
case 0x24:
iVar3 = *param_1;
if (param_1[1] < iVar3 + 2) {
iVar3 = cr_realloc(param_1);
if (iVar3 != 0) {
return 0xffffffff;
}
iVar3 = *param_1;
}
lVar1 = *(long *)(param_1 + 2);
*param_1 = iVar3 + 1;
*(int4 *)(lVar1 + (long)iVar3 * 4) = 0;
iVar3 = *param_1;
*param_1 = iVar3 + 1;
*(int4 *)(lVar1 + (long)iVar3 * 4) = 0x80;
goto LAB_0019c8e2;
case 0x25:
uVar4 = unicode_prop_ops(param_1,0,0x43e,1,4,3,1,3,3,1,2,3,7);
break;
case 0x26:
iVar3 = *param_1;
if (param_1[1] < iVar3 + 2) {
iVar3 = cr_realloc(param_1);
if (iVar3 != 0) {
return 0xffffffff;
}
iVar3 = *param_1;
}
lVar1 = *(long *)(param_1 + 2);
*param_1 = iVar3 + 1;
*(int4 *)(lVar1 + (long)iVar3 * 4) = 0;
iVar3 = *param_1;
*param_1 = iVar3 + 1;
*(int4 *)(lVar1 + (long)iVar3 * 4) = 0x110000;
LAB_0019c8e2:
uVar4 = 0;
break;
case 0x27:
uVar4 = unicode_prop_ops(param_1,0,1,6,7);
return uVar4;
case 0x28:
uVar4 = unicode_prop_ops(param_1,0,0xe,1,4,3,1,3,3,7);
break;
case 0x29:
uVar5 = 2;
uVar4 = 4;
uVar6 = 0xe;
goto LAB_0019c977;
case 0x2a:
uVar4 = 7;
goto LAB_0019c8fb;
case 0x2b:
uVar4 = 2;
goto LAB_0019c8fb;
case 0x2c:
uVar5 = 2;
uVar4 = 4;
uVar6 = 0xf;
goto LAB_0019c977;
case 0x2d:
uVar5 = 2;
uVar4 = 1;
uVar6 = 0xd;
goto LAB_0019c977;
case 0x2e:
uVar4 = 1;
LAB_0019c8fb:
uVar4 = unicode_case1(param_1,uVar4);
return uVar4;
case 0x2f:
uVar5 = 0;
uVar4 = 0x3f000141;
uVar6 = 5;
uVar7 = 3;
uVar8 = 6;
goto LAB_0019c9f2;
case 0x30:
uVar4 = 0x140;
uVar6 = 5;
goto LAB_0019c9e8;
case 0x31:
uVar5 = 1;
uVar4 = 0x32;
uVar6 = 10;
LAB_0019c977:
uVar7 = 5;
LAB_0019c9ee:
uVar8 = 7;
LAB_0019c9f2:
uVar4 = unicode_prop_ops(param_1,uVar5,uVar4,1,uVar6,uVar7,uVar8);
break;
default:
if (uVar2 < 0x24) {
uVar4 = unicode_prop1(param_1,uVar2 + 0x10);
return uVar4;
}
break;
case 0x34:
uVar4 = 4;
uVar6 = 3;
goto LAB_0019c9e8;
case 0x35:
uVar4 = 0x1000;
uVar6 = 1;
goto LAB_0019c9e8;
case 0x36:
uVar4 = 2;
uVar6 = 4;
LAB_0019c9e8:
uVar5 = 0;
uVar7 = 3;
goto LAB_0019c9ee;
case 0x37:
uVar4 = unicode_prop_ops(param_1,0,0x106fe,1,7,3,1,8,3,1,0x1f,1,0x20,3,1,0xc,3,6,4,7);
break;
case 0x38:
uVar4 = unicode_prop_ops(param_1,0,0x43e,1,7,3,1,0x1f,1,0x20,3,1,0xb,3,6,4,7);
}
return uVar4;
}
|
|
13,936
|
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O1
|
cpp
|
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const:
cmpb $0x1, (%rdi)
jne 0xc718c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0xc7192
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b220
testl %eax, %eax
je 0xc718f
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
jne 0xc716d
jmp 0xc7192
xorl %eax, %eax
retq
movq %r15, %rax
movq 0x8(%rbx), %rcx
cmpq 0x8(%rcx), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C718C
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi+8]
mov r15, [r12]
mov rax, [r12+8]
cmp r15, rax
jz short loc_C7192
mov r14, rsi
loc_C716D:
mov rdi, r15
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C718F
add r15, 30h ; '0'
mov rax, [r12+8]
cmp r15, rax
jnz short loc_C716D
jmp short loc_C7192
loc_C718C:
xor eax, eax
retn
loc_C718F:
mov rax, r15
loc_C7192:
mov rcx, [rbx+8]
cmp rax, [rcx+8]
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // r15
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
v4 = v3;
}
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c718c
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV R15,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JZ 0x001c7192
MOV R14,RSI
LAB_001c716d:
MOV RDI,R15
MOV RSI,R14
CALL 0x0011b220
TEST EAX,EAX
JZ 0x001c718f
ADD R15,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JNZ 0x001c716d
JMP 0x001c7192
LAB_001c718c:
XOR EAX,EAX
RET
LAB_001c718f:
MOV RAX,R15
LAB_001c7192:
MOV RCX,qword ptr [RBX + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)plVar1[1];
pcVar4 = (char *)*plVar1;
if ((char *)*plVar1 != pcVar3) {
do {
pcVar3 = pcVar4;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar4 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar4 != pcVar3);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != *(char **)(*(long *)(param_1 + 8) + 8));
}
|
|
13,937
|
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O3
|
cpp
|
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const:
cmpb $0x1, (%rdi)
jne 0xc43a5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xc43a8
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a220
testl %eax, %eax
je 0xc4398
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xc437e
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xc43ab
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA21_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C43A5
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_C43A8
mov r15, rsi
loc_C437E:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C4398
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_C437E
loc_C4398:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_C43AB
loc_C43A5:
xor eax, eax
retn
loc_C43A8:
mov rax, rbx
loc_C43AB:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA21_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA21_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c43a5
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001c43a8
MOV R15,RSI
LAB_001c437e:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a220
TEST EAX,EAX
JZ 0x001c4398
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001c437e
LAB_001c4398:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001c43ab
LAB_001c43a5:
XOR EAX,EAX
RET
LAB_001c43a8:
MOV RAX,RBX
LAB_001c43ab:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA21_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
|
|
13,938
|
fmt::v11::detail::find_escape(char const*, char const*)
|
zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/format.h
|
inline auto find_escape(const char* begin, const char* end)
-> find_escape_result<char> {
if (const_check(!use_utf8)) return find_escape<char>(begin, end);
auto result = find_escape_result<char>{end, nullptr, 0};
for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
[&](uint32_t cp, string_view sv) {
if (needs_escape(cp)) {
result = {sv.begin(), sv.end(), cp};
return false;
}
return true;
});
return result;
}
|
O0
|
c
|
fmt::v11::detail::find_escape(char const*, char const*):
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
subq %rax, %rdi
callq 0xaae90
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x28(%rsp), %rdi
callq 0x753a0
movq 0x10(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xc4cd0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
|
_ZN3fmt3v116detail11find_escapeEPKcS3_:
sub rsp, 48h
mov [rsp+48h+var_38], rdi
mov rax, rdi
mov [rsp+48h+var_30], rax
mov [rsp+48h+var_8], rsi
mov [rsp+48h+var_10], rdx
mov rax, [rsp+48h+var_10]
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov dword ptr [rdi+10h], 0
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_40], rax
mov rdi, [rsp+48h+var_10]
mov rax, [rsp+48h+var_8]
sub rdi, rax
call _ZN3fmt3v116detail11to_unsignedIlEENSt13make_unsignedIT_E4typeES4_; fmt::v11::detail::to_unsigned<long>(long)
mov rsi, [rsp+48h+var_40]
mov rdx, rax
lea rdi, [rsp+48h+var_20]
call _ZN3fmt3v1117basic_string_viewIcEC2EPKcm; fmt::v11::basic_string_view<char>::basic_string_view(char const*,ulong)
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_28], rdi
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_28]
call _ZN3fmt3v116detail18for_each_codepointIZNS1_11find_escapeEPKcS4_EUljNS0_17basic_string_viewIcEEE_EEvS6_T_; fmt::v11::detail::for_each_codepoint<fmt::v11::detail::find_escape(char const*,char const*)::{lambda(uint,fmt::v11::basic_string_view<char>)#1}>(fmt::v11::basic_string_view<char>,fmt::v11::detail::find_escape(char const*,char const*)::{lambda(uint,fmt::v11::basic_string_view<char>)#1})
mov rax, [rsp+48h+var_30]
add rsp, 48h
retn
|
fmt::v11::detail * fmt::v11::detail::find_escape(fmt::v11::detail *this, const char *a2, const char *a3)
{
long long v3; // rax
_QWORD v5[2]; // [rsp+28h] [rbp-20h] BYREF
const char *v6; // [rsp+38h] [rbp-10h]
const char *v7; // [rsp+40h] [rbp-8h]
v7 = a2;
v6 = a3;
*(_QWORD *)this = a3;
*((_QWORD *)this + 1) = 0LL;
*((_DWORD *)this + 4) = 0;
v3 = fmt::v11::detail::to_unsigned<long>(v6 - v7);
fmt::v11::basic_string_view<char>::basic_string_view(v5, (long long)v7, v3);
fmt::v11::detail::for_each_codepoint<fmt::v11::detail::find_escape(char const*,char const*)::{lambda(unsigned int,fmt::v11::basic_string_view<char>)#1}>(
v5[0],
v5[1],
this);
return this;
}
|
find_escape:
SUB RSP,0x48
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x40]
SUB RDI,RAX
CALL 0x001aae90
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,RAX
LEA RDI,[RSP + 0x28]
CALL 0x001753a0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x001c4cd0
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x48
RET
|
/* fmt::v11::detail::find_escape(char const*, char const*) */
detail * __thiscall fmt::v11::detail::find_escape(detail *this,char *param_1,char *param_2)
{
ulong uVar1;
detail *local_20;
int8 local_18;
char *local_10;
char *local_8;
*(char **)this = param_2;
*(int8 *)(this + 8) = 0;
*(int4 *)(this + 0x10) = 0;
local_10 = param_2;
local_8 = param_1;
uVar1 = to_unsigned<long>((long)param_2 - (long)param_1);
basic_string_view<char>::basic_string_view((basic_string_view<char> *)&local_20,param_1,uVar1);
for_each_codepoint<fmt::v11::detail::find_escape(char_const*,char_const*)::_lambda(unsigned_int,fmt::v11::basic_string_view<char>)_1_>
(local_20,local_18,this);
return this;
}
|
|
13,939
|
mi_test_if_changed
|
eloqsql/storage/myisam/mi_locking.c
|
int _mi_test_if_changed(register MI_INFO *info)
{
MYISAM_SHARE *share=info->s;
if (share->state.process != share->last_process ||
share->state.unique != info->last_unique ||
share->state.update_count != info->last_loop)
{ /* Keyfile has changed */
DBUG_PRINT("info",("index file changed"));
if (share->state.process != share->this_process)
(void) flush_key_blocks(share->key_cache, share->kfile,
&share->dirty_part_map, FLUSH_RELEASE);
share->last_process=share->state.process;
info->last_unique= share->state.unique;
info->last_loop= share->state.update_count;
info->update|= HA_STATE_WRITTEN; /* Must use file on next */
info->data_changed= 1; /* For mi_is_changed */
return 1;
}
return (!(info->update & HA_STATE_AKTIV) ||
(info->update & (HA_STATE_WRITTEN | HA_STATE_DELETED |
HA_STATE_KEY_CHANGED)));
}
|
O3
|
c
|
mi_test_if_changed:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x68(%r14), %rax
cmpq 0x308(%r14), %rax
jne 0x7d593
movq 0x70(%r14), %rcx
cmpq 0x158(%rbx), %rcx
jne 0x7d593
movq 0x78(%r14), %rcx
cmpq 0x168(%rbx), %rcx
jne 0x7d593
movl $0x8e, %ecx
andl 0x1d0(%rbx), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
setne %al
jmp 0x7d5f2
cmpq 0x300(%r14), %rax
je 0x7d5bf
movq 0x278(%r14), %rdi
movl 0x350(%r14), %esi
leaq 0x280(%r14), %rdx
movl $0x1, %ecx
callq 0x99635
movq 0x68(%r14), %rax
movq %rax, 0x308(%r14)
movq 0x70(%r14), %rax
movq %rax, 0x158(%rbx)
movq 0x78(%r14), %rax
movq %rax, 0x168(%rbx)
orb $0x4, 0x1d0(%rbx)
movl $0x1, 0x1fc(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
_mi_test_if_changed:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov r14, [rdi]
mov rax, [r14+68h]
cmp rax, [r14+308h]
jnz short loc_7D593
mov rcx, [r14+70h]
cmp rcx, [rbx+158h]
jnz short loc_7D593
mov rcx, [r14+78h]
cmp rcx, [rbx+168h]
jnz short loc_7D593
mov ecx, 8Eh
and ecx, [rbx+1D0h]
xor eax, eax
cmp ecx, 2
setnz al
jmp short loc_7D5F2
loc_7D593:
cmp rax, [r14+300h]
jz short loc_7D5BF
mov rdi, [r14+278h]
mov esi, [r14+350h]
lea rdx, [r14+280h]
mov ecx, 1
call flush_key_blocks
mov rax, [r14+68h]
loc_7D5BF:
mov [r14+308h], rax
mov rax, [r14+70h]
mov [rbx+158h], rax
mov rax, [r14+78h]
mov [rbx+168h], rax
or byte ptr [rbx+1D0h], 4
mov dword ptr [rbx+1FCh], 1
mov eax, 1
loc_7D5F2:
pop rbx
pop r14
pop rbp
retn
|
_BOOL8 mi_test_if_changed(long long *a1)
{
long long v1; // r14
long long v2; // rax
v1 = *a1;
v2 = *(_QWORD *)(*a1 + 104);
if ( v2 == *(_QWORD *)(*a1 + 776) && *(_QWORD *)(v1 + 112) == a1[43] && *(_QWORD *)(v1 + 120) == a1[45] )
return (a1[58] & 0x8E) != 2;
if ( v2 != *(_QWORD *)(v1 + 768) )
{
flush_key_blocks(*(_QWORD *)(v1 + 632), *(unsigned int *)(v1 + 848), v1 + 640, 1LL);
v2 = *(_QWORD *)(v1 + 104);
}
*(_QWORD *)(v1 + 776) = v2;
a1[43] = *(_QWORD *)(v1 + 112);
a1[45] = *(_QWORD *)(v1 + 120);
*((_BYTE *)a1 + 464) |= 4u;
*((_DWORD *)a1 + 127) = 1;
return 1LL;
}
|
_mi_test_if_changed:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI]
MOV RAX,qword ptr [R14 + 0x68]
CMP RAX,qword ptr [R14 + 0x308]
JNZ 0x0017d593
MOV RCX,qword ptr [R14 + 0x70]
CMP RCX,qword ptr [RBX + 0x158]
JNZ 0x0017d593
MOV RCX,qword ptr [R14 + 0x78]
CMP RCX,qword ptr [RBX + 0x168]
JNZ 0x0017d593
MOV ECX,0x8e
AND ECX,dword ptr [RBX + 0x1d0]
XOR EAX,EAX
CMP ECX,0x2
SETNZ AL
JMP 0x0017d5f2
LAB_0017d593:
CMP RAX,qword ptr [R14 + 0x300]
JZ 0x0017d5bf
MOV RDI,qword ptr [R14 + 0x278]
MOV ESI,dword ptr [R14 + 0x350]
LEA RDX,[R14 + 0x280]
MOV ECX,0x1
CALL 0x00199635
MOV RAX,qword ptr [R14 + 0x68]
LAB_0017d5bf:
MOV qword ptr [R14 + 0x308],RAX
MOV RAX,qword ptr [R14 + 0x70]
MOV qword ptr [RBX + 0x158],RAX
MOV RAX,qword ptr [R14 + 0x78]
MOV qword ptr [RBX + 0x168],RAX
OR byte ptr [RBX + 0x1d0],0x4
MOV dword ptr [RBX + 0x1fc],0x1
MOV EAX,0x1
LAB_0017d5f2:
POP RBX
POP R14
POP RBP
RET
|
bool _mi_test_if_changed(long *param_1)
{
long lVar1;
long lVar2;
bool bVar3;
lVar1 = *param_1;
lVar2 = *(long *)(lVar1 + 0x68);
if (((lVar2 == *(long *)(lVar1 + 0x308)) && (*(long *)(lVar1 + 0x70) == param_1[0x2b])) &&
(*(long *)(lVar1 + 0x78) == param_1[0x2d])) {
bVar3 = (*(uint *)(param_1 + 0x3a) & 0x8e) != 2;
}
else {
if (lVar2 != *(long *)(lVar1 + 0x300)) {
flush_key_blocks(*(int8 *)(lVar1 + 0x278),*(int4 *)(lVar1 + 0x350),lVar1 + 0x280,1
);
lVar2 = *(long *)(lVar1 + 0x68);
}
*(long *)(lVar1 + 0x308) = lVar2;
param_1[0x2b] = *(long *)(lVar1 + 0x70);
param_1[0x2d] = *(long *)(lVar1 + 0x78);
*(byte *)(param_1 + 0x3a) = *(byte *)(param_1 + 0x3a) | 4;
*(int4 *)((long)param_1 + 0x1fc) = 1;
bVar3 = true;
}
return bVar3;
}
|
|
13,940
|
MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int)
|
eloqsql/mysys_ssl/my_crypt.cc
|
virtual int init(const EVP_CIPHER *cipher, int encrypt, const uchar *key,
uint klen, const uchar *iv, uint ivlen)
{
compile_time_assert(MY_AES_CTX_SIZE >= sizeof(MyCTX));
if (unlikely(!cipher))
return MY_AES_BAD_KEYSIZE;
if (EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, encrypt) != 1)
return MY_AES_OPENSSL_ERROR;
DBUG_ASSERT(EVP_CIPHER_CTX_key_length(ctx) == (int)klen);
DBUG_ASSERT(EVP_CIPHER_CTX_iv_length(ctx) <= (int)ivlen);
return MY_AES_OK;
}
|
O3
|
cpp
|
MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int):
testq %rsi, %rsi
je 0x2ff6f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
movq 0xc8(%rdi), %rdi
xorl %ebx, %ebx
xorl %edx, %edx
movq %r9, %r8
movl %eax, %r9d
callq 0x29730
cmpl $0x1, %eax
pushq $-0x65
popq %rax
cmovel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x66
popq %rax
retq
nop
|
_ZN5MyCTX4initEPK13evp_cipher_stiPKhjS4_j:
test rsi, rsi
jz short loc_2FF6F
push rbp
mov rbp, rsp
push rbx
push rax
mov eax, edx
mov rdi, [rdi+0C8h]
xor ebx, ebx
xor edx, edx
mov r8, r9
mov r9d, eax
call _EVP_CipherInit_ex
cmp eax, 1
push 0FFFFFFFFFFFFFF9Bh
pop rax
cmovz eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_2FF6F:
push 0FFFFFFFFFFFFFF9Ah
pop rax
retn
|
long long MyCTX::init(long long a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
long long v6; // rax
bool v7; // zf
long long result; // rax
if ( !a2 )
return -102LL;
v7 = (unsigned int)EVP_CipherInit_ex(*(_QWORD *)(a1 + 200), a2, 0LL, a4, a6, a3, v6) == 1;
result = -101LL;
if ( v7 )
return 0LL;
return result;
}
|
init:
TEST RSI,RSI
JZ 0x0012ff6f
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EAX,EDX
MOV RDI,qword ptr [RDI + 0xc8]
XOR EBX,EBX
XOR EDX,EDX
MOV R8,R9
MOV R9D,EAX
CALL 0x00129730
CMP EAX,0x1
PUSH -0x65
POP RAX
CMOVZ EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0012ff6f:
PUSH -0x66
POP RAX
RET
|
/* MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*,
unsigned int) */
int8
MyCTX::init(evp_cipher_st *param_1,int param_2,uchar *param_3,uint param_4,uchar *param_5,
uint param_6)
{
int iVar1;
int8 uVar2;
int4 in_register_0000000c;
int4 in_register_00000034;
int4 in_register_0000008c;
if (CONCAT44(in_register_00000034,param_2) != 0) {
iVar1 = EVP_CipherInit_ex((EVP_CIPHER_CTX *)param_1[2].init,
(EVP_CIPHER *)CONCAT44(in_register_00000034,param_2),(ENGINE *)0x0,
(uchar *)CONCAT44(in_register_0000000c,param_4),
(uchar *)CONCAT44(in_register_0000008c,param_6),(int)param_3);
uVar2 = 0xffffff9b;
if (iVar1 == 1) {
uVar2 = 0;
}
return uVar2;
}
return 0xffffffffffffff9a;
}
|
|
13,941
|
ma_search
|
eloqsql/storage/maria/ma_search.c
|
int _ma_search(register MARIA_HA *info, MARIA_KEY *key, uint32 nextflag,
my_off_t pos)
{
int error;
MARIA_PINNED_PAGE *page_link;
uchar *page_buff;
info->page_changed= 1; /* If page not saved */
if (!(error= _ma_search_no_save(info, key, nextflag, pos, &page_link,
&page_buff)))
{
if (nextflag & SEARCH_SAVE_BUFF)
{
memcpy(info->keyread_buff, page_buff, info->s->block_size);
/* Save position for a possible read next / previous */
info->int_keypos= info->keyread_buff + info->keypos_offset;
info->int_maxpos= info->keyread_buff + info->maxpos_offset;
info->int_keytree_version= key->keyinfo->version;
info->last_search_keypage= info->last_keypage;
info->page_changed= 0;
info->keyread_buff_used= 0;
}
}
_ma_unpin_all_pages(info, LSN_IMPOSSIBLE);
return (error);
}
|
O0
|
c
|
ma_search:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x684(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x93bb0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x93b98
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x93b96
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x7bc(%rax), %eax
movl %eax, %edx
callq 0x2a090
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x3c0(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b0(%rax)
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x3c4(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3d4(%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x448(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x684(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x685(%rax)
jmp 0x93b98
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x43ea0
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
_ma_search:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov byte ptr [rax+684h], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
lea r8, [rbp+var_30]
lea r9, [rbp+var_38]
call _ma_search_no_save
mov [rbp+var_24], eax
cmp eax, 0
jnz loc_93B98
mov eax, [rbp+var_14]
and eax, 20h
cmp eax, 0
jz loc_93B96
mov rax, [rbp+var_8]
mov rdi, [rax+380h]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+7BCh]
mov edx, eax
call _memcpy
mov rax, [rbp+var_8]
mov rcx, [rax+380h]
mov rax, [rbp+var_8]
mov eax, [rax+3C0h]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+3B0h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+380h]
mov rax, [rbp+var_8]
mov eax, [rax+3C4h]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+3B8h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rax+0B8h]
mov rax, [rbp+var_8]
mov [rax+3D4h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+440h]
mov rax, [rbp+var_8]
mov [rax+448h], rcx
mov rax, [rbp+var_8]
mov byte ptr [rax+684h], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+685h], 0
loc_93B96:
jmp short $+2
loc_93B98:
mov rdi, [rbp+var_8]
xor eax, eax
mov esi, eax
call _ma_unpin_all_pages
mov eax, [rbp+var_24]
add rsp, 40h
pop rbp
retn
|
long long ma_search(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // [rsp+8h] [rbp-38h] BYREF
_BYTE v6[12]; // [rsp+10h] [rbp-30h] BYREF
unsigned int v7; // [rsp+1Ch] [rbp-24h]
long long v8; // [rsp+20h] [rbp-20h]
unsigned int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
long long v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
*(_BYTE *)(a1 + 1668) = 1;
v7 = ma_search_no_save(v11, v10, v9, v8, v6, &v5);
if ( !v7 && (v9 & 0x20) != 0 )
{
memcpy(*(_QWORD *)(v11 + 896), v5, *(unsigned int *)(*(_QWORD *)v11 + 1980LL));
*(_QWORD *)(v11 + 944) = *(unsigned int *)(v11 + 960) + *(_QWORD *)(v11 + 896);
*(_QWORD *)(v11 + 952) = *(unsigned int *)(v11 + 964) + *(_QWORD *)(v11 + 896);
*(_DWORD *)(v11 + 980) = *(_DWORD *)(*(_QWORD *)(v10 + 8) + 184LL);
*(_QWORD *)(v11 + 1096) = *(_QWORD *)(v11 + 1088);
*(_BYTE *)(v11 + 1668) = 0;
*(_BYTE *)(v11 + 1669) = 0;
}
ma_unpin_all_pages(v11, 0LL);
return v7;
}
|
_ma_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x684],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
LEA R8,[RBP + -0x30]
LEA R9,[RBP + -0x38]
CALL 0x00193bb0
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JNZ 0x00193b98
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x20
CMP EAX,0x0
JZ 0x00193b96
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x380]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x3c0]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x3b0],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x3c4]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x3b8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x3d4],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x440]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x448],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x684],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x685],0x0
LAB_00193b96:
JMP 0x00193b98
LAB_00193b98:
MOV RDI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00143ea0
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x40
POP RBP
RET
|
int _ma_search(long *param_1,long param_2,uint param_3,int8 param_4)
{
void *local_40;
int1 local_38 [12];
int local_2c;
int8 local_28;
uint local_1c;
long local_18;
long *local_10;
*(int1 *)((long)param_1 + 0x684) = 1;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_2c = _ma_search_no_save(param_1,param_2,param_3,param_4,local_38,&local_40);
if ((local_2c == 0) && ((local_1c & 0x20) != 0)) {
memcpy((void *)local_10[0x70],local_40,(ulong)*(uint *)(*local_10 + 0x7bc));
local_10[0x76] = local_10[0x70] + (ulong)*(uint *)(local_10 + 0x78);
local_10[0x77] = local_10[0x70] + (ulong)*(uint *)((long)local_10 + 0x3c4);
*(int4 *)((long)local_10 + 0x3d4) = *(int4 *)(*(long *)(local_18 + 8) + 0xb8);
local_10[0x89] = local_10[0x88];
*(int1 *)((long)local_10 + 0x684) = 0;
*(int1 *)((long)local_10 + 0x685) = 0;
}
_ma_unpin_all_pages(local_10,0);
return local_2c;
}
|
|
13,942
|
free_full_pages
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
}
|
O0
|
c
|
free_full_pages:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x7826e
movq $0x0, -0x80(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0xa8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jbe 0x77fea
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x77fb6
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x77fea
movl $0x1000, %eax # imm = 0x1000
cmpq -0xa8(%rbp), %rax
ja 0x77fea
movb $0x0, -0x9a(%rbp)
movq -0x20(%rbp), %rax
movl 0xac(%rax), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
movl %eax, %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x98(%rbp)
jmp 0x78013
movb $0x1, -0x9a(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf4be0
movq %rax, -0x98(%rbp)
jmp 0x78015
cmpq $0x0, -0x98(%rbp)
jne 0x7802a
jmp 0x78021
movb $0x1, -0xd(%rbp)
jmp 0x7828e
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
movq -0x20(%rbp), %rcx
imull $0x7, 0xac(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jae 0x7810d
movq -0x78(%rbp), %rax
movzwl 0x5(%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x780ad
cmpl $0x0, -0xb4(%rbp)
je 0x780ad
cmpq $0x0, -0x80(%rbp)
jne 0x780ab
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x780fc
cmpq $0x0, -0x80(%rbp)
je 0x780fa
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x2a090
movq -0xc0(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x80(%rbp)
jmp 0x780fc
movq -0x78(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x78(%rbp)
jmp 0x78053
cmpq $0x0, -0x80(%rbp)
je 0x78152
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x2a090
movq -0xc8(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x78199
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x79ce0
movb $0x0, -0xd(%rbp)
jmp 0x7828e
movq -0x70(%rbp), %rax
movl $0x7, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0xa0(%rbp)
leaq -0xc(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xd0(%rbp)
movl -0xa0(%rbp), %eax
movw %ax, %cx
movq -0xd0(%rbp), %rax
movw %cx, (%rax)
leaq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x70(%rbp), %rax
addq $0x4, %rax
movl %eax, %r8d
leaq -0x60(%rbp), %r10
leaq -0xc(%rbp), %rax
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
movl $0x4, %r9d
xorl %r11d, %r11d
subq $0x20, %rsp
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x55370
addq $0x20, %rsp
movb %al, -0x99(%rbp)
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x79ce0
cmpb $0x0, -0x99(%rbp)
je 0x7826c
jmp 0x78266
movb $0x1, -0xd(%rbp)
jmp 0x7828e
jmp 0x7826e
jmp 0x78270
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0xac(%rax), %edx
callq 0x45260
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movb %al, -0xd1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x782b4
movb -0xd1(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
|
free_full_pages:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_78], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp byte ptr [rax+7E7h], 0
jz loc_7826E
mov [rbp+var_80], 0
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov [rbp+var_A8], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_A8]
sub rax, rcx
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
cmp rax, [rbp+var_A8]
jbe short loc_77FEA
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 10000h
cmp rax, rcx
jb short loc_77FB6
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 8000h
cmp rax, rcx
jnb short loc_77FEA
mov eax, 1000h
cmp rax, [rbp+var_A8]
ja short loc_77FEA
loc_77FB6:
mov [rbp+var_9A], 0
mov rax, [rbp+var_20]
mov ecx, [rax+0ACh]
mov eax, ecx
shl eax, 3
sub eax, ecx
mov ecx, eax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_98], rax
jmp short loc_78013
loc_77FEA:
mov [rbp+var_9A], 1
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov esi, eax
xor edi, edi
mov edx, offset stru_10010
call my_malloc
mov [rbp+var_98], rax
loc_78013:
jmp short $+2
loc_78015:
cmp [rbp+var_98], 0
jnz short loc_7802A
jmp short $+2
loc_78021:
mov [rbp+var_D], 1
jmp loc_7828E
loc_7802A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
mov rax, [rbp+var_78]
mov rcx, [rbp+var_20]
imul ecx, [rcx+0ACh], 7
mov ecx, ecx
add rax, rcx
mov [rbp+var_88], rax
loc_78053:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnb loc_7810D
mov rax, [rbp+var_78]
movzx eax, word ptr [rax+5]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 0FFFFBFFFh
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 8000h
cmp eax, 0
jnz short loc_780AD
cmp [rbp+var_B4], 0
jz short loc_780AD
cmp [rbp+var_80], 0
jnz short loc_780AB
mov rax, [rbp+var_78]
mov [rbp+var_80], rax
loc_780AB:
jmp short loc_780FC
loc_780AD:
cmp [rbp+var_80], 0
jz short loc_780FA
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C0], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C0]
call _memcpy
mov rax, [rbp+var_C0]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
mov [rbp+var_80], 0
loc_780FA:
jmp short $+2
loc_780FC:
mov rax, [rbp+var_78]
add rax, 7
mov [rbp+var_78], rax
jmp loc_78053
loc_7810D:
cmp [rbp+var_80], 0
jz short loc_78152
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C8], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C8]
call _memcpy
mov rax, [rbp+var_C8]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
loc_78152:
mov rax, [rbp+var_90]
mov rcx, [rbp+var_98]
sub rax, rcx
mov eax, eax
mov [rbp+var_70], rax
cmp rax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jnz short loc_78199
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_1
mov [rbp+var_D], 0
jmp loc_7828E
loc_78199:
mov rax, [rbp+var_70]
mov ecx, 7
xor edx, edx
div rcx
mov [rbp+var_A0], eax
lea rax, [rbp+var_C]
add rax, 2
mov [rbp+var_D0], rax
mov eax, [rbp+var_A0]
mov cx, ax
mov rax, [rbp+var_D0]
mov [rax], cx
lea rax, [rbp+var_C]
mov [rbp+var_40], rax
mov [rbp+var_38], 4
mov rax, [rbp+var_98]
mov [rbp+var_30], rax
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_18]
mov rax, [rbp+var_70]
add rax, 4
mov r8d, eax
lea r10, [rbp+var_60]
lea rax, [rbp+var_C]
lea rdi, [rbp+var_68]
mov esi, 8
mov r9d, 4
xor r11d, r11d
sub rsp, 20h
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 0
call translog_write_record
add rsp, 20h
mov [rbp+var_99], al
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_1
cmp [rbp+var_99], 0
jz short loc_7826C
jmp short $+2
loc_78266:
mov [rbp+var_D], 1
jmp short loc_7828E
loc_7826C:
jmp short $+2
loc_7826E:
jmp short $+2
loc_78270:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rsi, [rax+10h]
mov rax, [rbp+var_20]
mov edx, [rax+0ACh]
call _ma_bitmap_free_full_pages
mov [rbp+var_D], al
loc_7828E:
mov al, [rbp+var_D]
mov [rbp+var_D1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_782B4
mov al, [rbp+var_D1]
mov rsp, rbp
pop rbp
retn
loc_782B4:
call ___stack_chk_fail
|
char free_full_pages(long long *a1, long long a2)
{
_QWORD v3[3]; // [rsp+20h] [rbp-E0h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-C8h]
unsigned long long v5; // [rsp+40h] [rbp-C0h]
int v6; // [rsp+4Ch] [rbp-B4h]
unsigned long long v7; // [rsp+50h] [rbp-B0h]
unsigned long long v8; // [rsp+58h] [rbp-A8h] BYREF
int v9; // [rsp+60h] [rbp-A0h]
char v10; // [rsp+66h] [rbp-9Ah]
char v11; // [rsp+67h] [rbp-99h]
char *v12; // [rsp+68h] [rbp-98h]
char *v13; // [rsp+70h] [rbp-90h]
unsigned long long v14; // [rsp+78h] [rbp-88h]
unsigned long long v15; // [rsp+80h] [rbp-80h]
unsigned long long v16; // [rsp+88h] [rbp-78h]
unsigned long long v17; // [rsp+90h] [rbp-70h]
_BYTE v18[8]; // [rsp+98h] [rbp-68h] BYREF
_QWORD v19[8]; // [rsp+A0h] [rbp-60h] BYREF
long long v20; // [rsp+E0h] [rbp-20h]
long long *v21; // [rsp+E8h] [rbp-18h]
__int16 v23; // [rsp+F4h] [rbp-Ch] BYREF
__int16 v24; // [rsp+F6h] [rbp-Ah] BYREF
unsigned long long v25; // [rsp+F8h] [rbp-8h]
v25 = __readfsqword(0x28u);
v21 = a1;
v20 = a2;
v16 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*a1 + 2023) )
return ma_bitmap_free_full_pages(v21, *(_QWORD *)(v20 + 16), *(_DWORD *)(v20 + 172));
v15 = 0LL;
v8 = (unsigned int)(7 * *(_DWORD *)(v20 + 172));
v7 = *(_QWORD *)v21[15] - (_QWORD)&v8;
if ( v7 <= v8 || v7 - v8 <= 0x10000 && (v7 - v8 <= 0x8000 || v8 < 0x1000) )
{
v10 = 1;
v12 = (char *)my_malloc(0LL, (unsigned int)(7 * *(_DWORD *)(v20 + 172)), &stru_10010);
}
else
{
v10 = 0;
v12 = (char *)v3 - (((unsigned int)(7 * *(_DWORD *)(v20 + 172)) + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v12 )
{
v13 = v12;
v14 = (unsigned int)(7 * *(_DWORD *)(v20 + 172)) + v16;
while ( v16 < v14 )
{
v6 = *(unsigned __int16 *)(v16 + 5);
v6 &= ~0x4000u;
if ( (v6 & 0x8000) != 0 || !v6 )
{
if ( v15 )
{
v5 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v5;
v15 = 0LL;
}
}
else if ( !v15 )
{
v15 = v16;
}
v16 += 7LL;
}
if ( v15 )
{
v4 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v4;
}
v17 = (unsigned int)((_DWORD)v13 - (_DWORD)v12);
if ( (_DWORD)v13 == (_DWORD)v12 )
{
stack_alloc_free_1(v12, (unsigned int)v10);
return 0;
}
v9 = v17 / 7;
v3[2] = &v24;
v24 = v17 / 7;
v19[4] = &v23;
v19[5] = 4LL;
v19[6] = v12;
v19[7] = v17;
v11 = translog_write_record((long long)v18, 8u, v21[1], v21, v17 + 4, 4u, v19, &v23, 0LL);
stack_alloc_free_1(v12, (unsigned int)v10);
if ( v11 )
return 1;
return ma_bitmap_free_full_pages(v21, *(_QWORD *)(v20 + 16), *(_DWORD *)(v20 + 172));
}
return 1;
}
|
free_full_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0017826e
MOV qword ptr [RBP + -0x80],0x0
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0xa8]
SUB RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RBP + -0xa8]
JBE 0x00177fea
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x00177fb6
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x00177fea
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0xa8]
JA 0x00177fea
LAB_00177fb6:
MOV byte ptr [RBP + -0x9a],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0xac]
MOV EAX,ECX
SHL EAX,0x3
SUB EAX,ECX
MOV ECX,EAX
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00178013
LAB_00177fea:
MOV byte ptr [RBP + -0x9a],0x1
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f4be0
MOV qword ptr [RBP + -0x98],RAX
LAB_00178013:
JMP 0x00178015
LAB_00178015:
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x0017802a
JMP 0x00178021
LAB_00178021:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0017828e
LAB_0017802a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RCX + 0xac],0x7
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
LAB_00178053:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNC 0x0017810d
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,word ptr [RAX + 0x5]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x001780ad
CMP dword ptr [RBP + -0xb4],0x0
JZ 0x001780ad
CMP qword ptr [RBP + -0x80],0x0
JNZ 0x001780ab
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
LAB_001780ab:
JMP 0x001780fc
LAB_001780ad:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x001780fa
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc0],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc0]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0xc0]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
MOV qword ptr [RBP + -0x80],0x0
LAB_001780fa:
JMP 0x001780fc
LAB_001780fc:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x7
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00178053
LAB_0017810d:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x00178152
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc8],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc8]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0xc8]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
LAB_00178152:
MOV RAX,qword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x98]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JNZ 0x00178199
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x00179ce0
MOV byte ptr [RBP + -0xd],0x0
JMP 0x0017828e
LAB_00178199:
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x7
XOR EDX,EDX
DIV RCX
MOV dword ptr [RBP + -0xa0],EAX
LEA RAX,[RBP + -0xc]
ADD RAX,0x2
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0xa0]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xd0]
MOV word ptr [RAX],CX
LEA RAX,[RBP + -0xc]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],0x4
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x4
MOV R8D,EAX
LEA R10,[RBP + -0x60]
LEA RAX,[RBP + -0xc]
LEA RDI,[RBP + -0x68]
MOV ESI,0x8
MOV R9D,0x4
XOR R11D,R11D
SUB RSP,0x20
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00155370
ADD RSP,0x20
MOV byte ptr [RBP + -0x99],AL
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x00179ce0
CMP byte ptr [RBP + -0x99],0x0
JZ 0x0017826c
JMP 0x00178266
LAB_00178266:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0017828e
LAB_0017826c:
JMP 0x0017826e
LAB_0017826e:
JMP 0x00178270
LAB_00178270:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0xac]
CALL 0x00145260
MOV byte ptr [RBP + -0xd],AL
LAB_0017828e:
MOV AL,byte ptr [RBP + -0xd]
MOV byte ptr [RBP + -0xd1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001782b4
MOV AL,byte ptr [RBP + -0xd1]
MOV RSP,RBP
POP RBP
RET
LAB_001782b4:
CALL 0x0012a270
|
int8 free_full_pages(long *param_1,long param_2)
{
ushort uVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
int1 auVar5 [16];
int1 *puVar6;
void *__src;
long *plVar7;
uint uVar8;
size_t sVar9;
int1 *puVar10;
int iVar11;
long in_FS_OFFSET;
int1 auStack_e8 [15];
int1 local_d9;
int2 *local_d8;
size_t local_d0;
size_t local_c8;
uint local_bc;
ulong local_b8;
ulong local_b0;
int4 local_a8;
char local_a2;
char local_a1;
int1 *local_a0;
int1 *local_98;
void *local_90;
void *local_88;
void *local_80;
ulong local_78;
int1 local_70 [8];
int1 local_68 [32];
int1 *local_48;
int8 local_40;
int1 *local_38;
ulong local_30;
long local_28;
long *local_20;
int1 local_15;
int1 local_14 [2];
int2 local_12;
long local_10;
puVar10 = auStack_e8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(void **)(param_2 + 0x10);
local_28 = param_2;
local_20 = param_1;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
local_88 = (void *)0x0;
local_b0 = (ulong)(uint)(*(int *)(param_2 + 0xac) * 7);
local_b8 = *(long *)param_1[0xf] - (long)&local_b0;
if ((local_b0 < local_b8) &&
((0x10000 < local_b8 - local_b0 || ((0x8000 < local_b8 - local_b0 && (0xfff < local_b0))))))
{
local_a2 = '\0';
local_a0 = auStack_e8 +
-((ulong)(uint)(*(int *)(param_2 + 0xac) * 7) + 0xf & 0xfffffffffffffff0);
puVar10 = local_a0;
}
else {
local_a2 = '\x01';
local_a0 = (int1 *)my_malloc(0,*(int *)(param_2 + 0xac) * 7,0x10010);
puVar10 = auStack_e8;
}
if (local_a0 == (int1 *)0x0) {
local_15 = 1;
goto LAB_0017828e;
}
local_98 = local_a0;
local_90 = (void *)((long)local_80 + (ulong)(uint)(*(int *)(local_28 + 0xac) * 7));
for (; __src = local_88, puVar6 = local_98, local_80 < local_90;
local_80 = (void *)((long)local_80 + 7)) {
uVar1 = *(ushort *)((long)local_80 + 5);
local_bc = uVar1 & 0xffffbfff;
if (((uVar1 & 0x8000) == 0) && ((uVar1 & 0xbfff) != 0)) {
if (local_88 == (void *)0x0) {
local_88 = local_80;
}
}
else if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_c8 = sVar9;
*(int8 *)(puVar10 + -8) = 0x1780dd;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_c8;
local_88 = (void *)0x0;
}
}
if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_d0 = sVar9;
*(int8 *)(puVar10 + -8) = 0x17813d;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_d0;
}
plVar7 = local_20;
puVar6 = local_a0;
uVar8 = (int)local_98 - (int)local_a0;
local_78 = CONCAT44(0,uVar8);
if (local_78 == 0) {
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x178190;
stack_alloc_free(puVar6,iVar11);
local_15 = 0;
goto LAB_0017828e;
}
auVar5._8_8_ = 0;
auVar5._0_8_ = local_78;
local_a8 = SUB164(auVar5 / ZEXT816(7),0);
local_d8 = &local_12;
local_12 = SUB162(auVar5 / ZEXT816(7),0);
local_48 = local_14;
local_40 = 4;
local_38 = local_a0;
lVar3 = local_20[1];
local_30 = local_78;
*(int1 **)(puVar10 + -0x20) = local_68;
*(int1 **)(puVar10 + -0x18) = local_14;
*(int8 *)(puVar10 + -0x10) = 0;
*(int8 *)(puVar10 + -0x28) = 0x17823e;
local_a1 = translog_write_record(local_70,8,lVar3,plVar7,uVar8 + 4,4);
puVar6 = local_a0;
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x17825b;
stack_alloc_free(puVar6,iVar11);
if (local_a1 != '\0') {
local_15 = 1;
goto LAB_0017828e;
}
}
plVar7 = local_20;
uVar4 = *(int8 *)(local_28 + 0x10);
uVar2 = *(int4 *)(local_28 + 0xac);
*(int8 *)(puVar10 + -8) = 0x17828b;
local_15 = _ma_bitmap_free_full_pages(plVar7,uVar4,uVar2);
LAB_0017828e:
local_d9 = local_15;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar10 + -8) = 0x1782b9;
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_15);
}
|
|
13,943
|
free_full_pages
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
}
|
O3
|
c
|
free_full_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rsi), %r14
movq (%rdi), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x5e904
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
leaq -0xa0(%rbp), %r12
movq %r13, (%r12)
movq 0x78(%rbx), %rcx
movq (%rcx), %rcx
subq %r12, %rcx
subq %r13, %rcx
jbe 0x5e793
cmpq $0x10000, %rcx # imm = 0x10000
ja 0x5e776
cmpl $0x1000, %r13d # imm = 0x1000
jb 0x5e793
cmpq $0x8001, %rcx # imm = 0x8001
jb 0x5e793
movq %r15, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movq %rsp, %rdi
leaq 0xf(%r13), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, %rsp
movb $0x1, %bl
jmp 0x5e7ca
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
movq %r13, %rsi
callq 0xa0cdd
testq %rax, %rax
je 0x5e86c
movq %rax, %rdi
movq %rbx, -0x40(%rbp)
movq %r15, -0x48(%rbp)
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
xorl %ebx, %ebx
movq %rdi, %r15
testl %eax, %eax
je 0x5e84f
movl %ebx, -0x38(%rbp)
addq %r14, %r13
xorl %esi, %esi
movq %r14, %r12
movq %rdi, -0x50(%rbp)
movq %rdi, %r15
movzwl 0x5(%r14), %eax
testw %ax, %ax
sets %cl
testl $0xbfff, %eax # imm = 0xBFFF
sete %al
orb %cl, %al
jne 0x5e803
testq %rsi, %rsi
cmoveq %r14, %rsi
jmp 0x5e81e
testq %rsi, %rsi
je 0x5e81c
movq %r12, %rbx
subq %rsi, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r15
xorl %esi, %esi
addq $0x7, %r14
addq $0x7, %r12
cmpq %r13, %r14
jb 0x5e7e3
testq %rsi, %rsi
je 0x5e841
subq %rsi, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x29080
addq %r12, %r15
leaq -0xa0(%rbp), %r12
movq -0x50(%rbp), %rdi
movl -0x38(%rbp), %ebx
subq %rdi, %r15
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
andq %r15, %rax
jne 0x5e873
testb %bl, %bl
jne 0x5e865
callq 0xa0f0a
xorl %eax, %eax
jmp 0x5e916
movb $0x1, %al
jmp 0x5e916
movq %rdi, %r13
movl %r15d, %ecx
imulq $0x24924925, %rcx, %rcx # imm = 0x24924925
shrq $0x20, %rcx
movl %r15d, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x2, %edx
leaq -0x34(%rbp), %r10
movw %dx, 0x2(%r10)
movq %r10, -0x80(%rbp)
movq $0x4, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rdx
addl $0x4, %r15d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0x8, %esi
movq %rcx, -0x40(%rbp)
movl %r15d, %r8d
movl $0x4, %r9d
pushq $0x0
pushq %r10
pushq %r12
callq 0x2a8ac
addq $0x20, %rsp
movl %eax, %r14d
testb %bl, %bl
jne 0x5e8f1
movq %r13, %rdi
callq 0xa0f0a
movb $0x1, %al
testb %r14b, %r14b
jne 0x5e916
movq -0x48(%rbp), %r15
movq 0x10(%r15), %r14
movq -0x40(%rbp), %rbx
movl 0xac(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42a83
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x5e934
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
free_full_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rsi+10h]
mov rax, [rdi]
cmp byte ptr [rax+7E7h], 0
jz loc_5E904
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
lea r12, [rbp+var_A0]
mov [r12], r13
mov rcx, [rbx+78h]
mov rcx, [rcx]
sub rcx, r12
sub rcx, r13
jbe short loc_5E793
cmp rcx, offset stru_10000
ja short loc_5E776
cmp r13d, 1000h
jb short loc_5E793
cmp rcx, 8001h
jb short loc_5E793
loc_5E776:
mov [rbp+var_48], r15
mov [rbp+var_40], rbx
mov rdi, rsp
lea rcx, [r13+0Fh]
and rcx, 0FFFFFFFFFFFFFFF0h
sub rdi, rcx
mov rsp, rdi
mov bl, 1
jmp short loc_5E7CA
loc_5E793:
mov edx, 10010h
xor edi, edi
mov rsi, r13
call my_malloc
test rax, rax
jz loc_5E86C
mov rdi, rax
mov [rbp+var_40], rbx
mov [rbp+var_48], r15
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
xor ebx, ebx
loc_5E7CA:
mov r15, rdi
test eax, eax
jz short loc_5E84F
mov [rbp+var_38], ebx
add r13, r14
xor esi, esi
mov r12, r14
mov [rbp+var_50], rdi
mov r15, rdi
loc_5E7E3:
movzx eax, word ptr [r14+5]
test ax, ax
sets cl
test eax, 0BFFFh
setz al
or al, cl
jnz short loc_5E803
test rsi, rsi
cmovz rsi, r14
jmp short loc_5E81E
loc_5E803:
test rsi, rsi
jz short loc_5E81C
mov rbx, r12
sub rbx, rsi
mov rdi, r15
mov rdx, rbx
call _memcpy
add r15, rbx
loc_5E81C:
xor esi, esi
loc_5E81E:
add r14, 7
add r12, 7
cmp r14, r13
jb short loc_5E7E3
test rsi, rsi
jz short loc_5E841
sub r12, rsi
mov rdi, r15
mov rdx, r12
call _memcpy
add r15, r12
loc_5E841:
lea r12, [rbp+var_A0]
mov rdi, [rbp+var_50]
mov ebx, [rbp+var_38]
loc_5E84F:
sub r15, rdi
mov eax, 0FFFFFFFFh
and rax, r15
jnz short loc_5E873
test bl, bl
jnz short loc_5E865
call my_free
loc_5E865:
xor eax, eax
jmp loc_5E916
loc_5E86C:
mov al, 1
jmp loc_5E916
loc_5E873:
mov r13, rdi
mov ecx, r15d
imul rcx, 24924925h
shr rcx, 20h
mov edx, r15d
sub edx, ecx
shr edx, 1
add edx, ecx
shr edx, 2
lea r10, [rbp+var_34]
mov [r10+2], dx
mov [rbp+var_80], r10
mov [rbp+var_78], 4
mov [rbp+var_70], rdi
mov [rbp+var_68], rax
mov rcx, [rbp+var_40]
mov rdx, [rcx+8]
add r15d, 4
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 8
mov [rbp+var_40], rcx
mov r8d, r15d
mov r9d, 4
push 0
push r10
push r12
call translog_write_record
add rsp, 20h
mov r14d, eax
test bl, bl
jnz short loc_5E8F1
mov rdi, r13
call my_free
loc_5E8F1:
mov al, 1
test r14b, r14b
jnz short loc_5E916
mov r15, [rbp+var_48]
mov r14, [r15+10h]
mov rbx, [rbp+var_40]
loc_5E904:
mov edx, [r15+0ACh]
mov rdi, rbx
mov rsi, r14
call _ma_bitmap_free_full_pages
loc_5E916:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_5E934
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5E934:
call ___stack_chk_fail
|
char free_full_pages(long long *a1, long long a2)
{
long long v2; // r15
long long *v3; // rbx
unsigned long long v4; // r14
int v5; // eax
unsigned long long v6; // r13
unsigned long long v7; // rcx
bool v8; // cc
unsigned long long v9; // rcx
char *v10; // rdi
long long v11; // rax
char *v12; // r15
unsigned long long v13; // r13
unsigned long long v14; // rsi
unsigned long long v15; // r12
unsigned long long v16; // r12
unsigned int v17; // r15d
char result; // al
char v19; // r14
_OWORD v20[2]; // [rsp+0h] [rbp-A0h] BYREF
_WORD *v21; // [rsp+20h] [rbp-80h]
long long v22; // [rsp+28h] [rbp-78h]
char *v23; // [rsp+30h] [rbp-70h]
long long v24; // [rsp+38h] [rbp-68h]
char v25[8]; // [rsp+48h] [rbp-58h] BYREF
char *v26; // [rsp+50h] [rbp-50h]
long long v27; // [rsp+58h] [rbp-48h]
long long *v28; // [rsp+60h] [rbp-40h]
int v29; // [rsp+68h] [rbp-38h]
_WORD v30[2]; // [rsp+6Ch] [rbp-34h] BYREF
unsigned long long v31; // [rsp+70h] [rbp-30h]
v2 = a2;
v3 = a1;
v31 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*a1 + 2023) )
return ma_bitmap_free_full_pages(v3, (unsigned int *)v4, *(_DWORD *)(v2 + 172));
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
*(_QWORD *)&v20[0] = v6;
v7 = *(_QWORD *)a1[15] - (_QWORD)v20;
v8 = v7 <= v6;
v9 = v7 - v6;
if ( v8 || v9 <= (unsigned long long)&stru_10000 && ((unsigned int)v6 < 0x1000 || v9 < 0x8001) )
{
v11 = my_malloc(0LL, (unsigned int)(7 * v5), 65552LL);
if ( !v11 )
return 1;
v10 = (char *)v11;
v28 = v3;
v27 = a2;
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
LODWORD(v3) = 0;
}
else
{
v27 = a2;
v28 = a1;
v10 = (char *)v20 - ((v6 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v3) = 1;
}
LODWORD(v12) = (_DWORD)v10;
if ( v5 )
{
v29 = (int)v3;
v13 = v4 + v6;
v14 = 0LL;
v15 = v4;
v26 = v10;
v12 = v10;
do
{
if ( *(__int16 *)(v4 + 5) < 0 || (*(_WORD *)(v4 + 5) & 0xBFFF) == 0 )
{
if ( v14 )
{
memcpy(v12, v14, v15 - v14);
v12 += v15 - v14;
}
v14 = 0LL;
}
else if ( !v14 )
{
v14 = v4;
}
v4 += 7LL;
v15 += 7LL;
}
while ( v4 < v13 );
if ( v14 )
{
v16 = v15 - v14;
memcpy(v12, v14, v16);
LODWORD(v12) = v16 + (_DWORD)v12;
}
v10 = v26;
LOBYTE(v3) = v29;
}
v17 = (_DWORD)v12 - (_DWORD)v10;
if ( !v17 )
{
if ( !(_BYTE)v3 )
my_free(v10);
return 0;
}
v30[1] = v17 / 7;
v21 = v30;
v22 = 4LL;
v23 = v10;
v24 = v17;
v19 = translog_write_record((unsigned long long)v25, &byte_8, v28[1], v28, v17 + 4, 4, v20, v30, 0LL);
if ( !(_BYTE)v3 )
my_free(v10);
result = 1;
if ( !v19 )
{
v2 = v27;
v4 = *(_QWORD *)(v27 + 16);
v3 = v28;
return ma_bitmap_free_full_pages(v3, (unsigned int *)v4, *(_DWORD *)(v2 + 172));
}
return result;
}
|
free_full_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0015e904
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
LEA R12,[RBP + -0xa0]
MOV qword ptr [R12],R13
MOV RCX,qword ptr [RBX + 0x78]
MOV RCX,qword ptr [RCX]
SUB RCX,R12
SUB RCX,R13
JBE 0x0015e793
CMP RCX,0x10000
JA 0x0015e776
CMP R13D,0x1000
JC 0x0015e793
CMP RCX,0x8001
JC 0x0015e793
LAB_0015e776:
MOV qword ptr [RBP + -0x48],R15
MOV qword ptr [RBP + -0x40],RBX
MOV RDI,RSP
LEA RCX,[R13 + 0xf]
AND RCX,-0x10
SUB RDI,RCX
MOV RSP,RDI
MOV BL,0x1
JMP 0x0015e7ca
LAB_0015e793:
MOV EDX,0x10010
XOR EDI,EDI
MOV RSI,R13
CALL 0x001a0cdd
TEST RAX,RAX
JZ 0x0015e86c
MOV RDI,RAX
MOV qword ptr [RBP + -0x40],RBX
MOV qword ptr [RBP + -0x48],R15
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
XOR EBX,EBX
LAB_0015e7ca:
MOV R15,RDI
TEST EAX,EAX
JZ 0x0015e84f
MOV dword ptr [RBP + -0x38],EBX
ADD R13,R14
XOR ESI,ESI
MOV R12,R14
MOV qword ptr [RBP + -0x50],RDI
MOV R15,RDI
LAB_0015e7e3:
MOVZX EAX,word ptr [R14 + 0x5]
TEST AX,AX
SETS CL
TEST EAX,0xbfff
SETZ AL
OR AL,CL
JNZ 0x0015e803
TEST RSI,RSI
CMOVZ RSI,R14
JMP 0x0015e81e
LAB_0015e803:
TEST RSI,RSI
JZ 0x0015e81c
MOV RBX,R12
SUB RBX,RSI
MOV RDI,R15
MOV RDX,RBX
CALL 0x00129080
ADD R15,RBX
LAB_0015e81c:
XOR ESI,ESI
LAB_0015e81e:
ADD R14,0x7
ADD R12,0x7
CMP R14,R13
JC 0x0015e7e3
TEST RSI,RSI
JZ 0x0015e841
SUB R12,RSI
MOV RDI,R15
MOV RDX,R12
CALL 0x00129080
ADD R15,R12
LAB_0015e841:
LEA R12,[RBP + -0xa0]
MOV RDI,qword ptr [RBP + -0x50]
MOV EBX,dword ptr [RBP + -0x38]
LAB_0015e84f:
SUB R15,RDI
MOV EAX,0xffffffff
AND RAX,R15
JNZ 0x0015e873
TEST BL,BL
JNZ 0x0015e865
CALL 0x001a0f0a
LAB_0015e865:
XOR EAX,EAX
JMP 0x0015e916
LAB_0015e86c:
MOV AL,0x1
JMP 0x0015e916
LAB_0015e873:
MOV R13,RDI
MOV ECX,R15D
IMUL RCX,RCX,0x24924925
SHR RCX,0x20
MOV EDX,R15D
SUB EDX,ECX
SHR EDX,0x1
ADD EDX,ECX
SHR EDX,0x2
LEA R10,[RBP + -0x34]
MOV word ptr [R10 + 0x2],DX
MOV qword ptr [RBP + -0x80],R10
MOV qword ptr [RBP + -0x78],0x4
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RCX + 0x8]
ADD R15D,0x4
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0x8
MOV qword ptr [RBP + -0x40],RCX
MOV R8D,R15D
MOV R9D,0x4
PUSH 0x0
PUSH R10
PUSH R12
CALL 0x0012a8ac
ADD RSP,0x20
MOV R14D,EAX
TEST BL,BL
JNZ 0x0015e8f1
MOV RDI,R13
CALL 0x001a0f0a
LAB_0015e8f1:
MOV AL,0x1
TEST R14B,R14B
JNZ 0x0015e916
MOV R15,qword ptr [RBP + -0x48]
MOV R14,qword ptr [R15 + 0x10]
MOV RBX,qword ptr [RBP + -0x40]
LAB_0015e904:
MOV EDX,dword ptr [R15 + 0xac]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00142a83
LAB_0015e916:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0015e934
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015e934:
CALL 0x00129270
|
int8 free_full_pages(long *param_1,long param_2)
{
int4 uVar1;
long lVar2;
long *plVar3;
ulong *puVar4;
char cVar5;
int8 uVar6;
int iVar7;
ulong uVar8;
ulong *puVar9;
void *__src;
int1 *puVar10;
void *pvVar11;
void *pvVar12;
void *pvVar13;
int1 *__dest;
ulong uVar14;
long in_FS_OFFSET;
ulong local_a8 [4];
int1 *local_88;
int8 local_80;
int1 *local_78;
ulong local_70;
int1 local_60 [8];
int1 *local_58;
long local_50;
long *local_48;
uint local_40;
int1 local_3c [2];
int2 local_3a;
long local_38;
puVar9 = local_a8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pvVar11 = *(void **)(param_2 + 0x10);
puVar4 = local_a8;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = (*(long *)param_1[0xf] - (long)local_a8) - uVar14;
local_a8[0] = uVar14;
if ((uVar14 < (ulong)(*(long *)param_1[0xf] - (long)local_a8)) &&
((0x10000 < uVar8 || ((0xfff < (uint)(iVar7 * 7) && (0x8000 < uVar8)))))) {
__dest = (int1 *)((long)local_a8 - (uVar14 + 0xf & 0xfffffffffffffff0));
uVar8 = CONCAT71((int7)((ulong)param_1 >> 8),1);
puVar9 = (ulong *)__dest;
}
else {
__dest = (int1 *)my_malloc(0,uVar14,0x10010);
if (__dest == (int1 *)0x0) {
uVar6 = 1;
goto LAB_0015e916;
}
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = 0;
puVar9 = local_a8;
}
puVar10 = __dest;
local_50 = param_2;
local_48 = param_1;
if (iVar7 != 0) {
local_40 = (uint)uVar8;
pvVar12 = (void *)(uVar14 + (long)pvVar11);
__src = (void *)0x0;
pvVar13 = pvVar11;
local_58 = __dest;
do {
if ((*(ushort *)((long)pvVar13 + 5) & 0xbfff) == 0 ||
(short)*(ushort *)((long)pvVar13 + 5) < 0) {
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x15e819;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
__src = (void *)0x0;
}
else if (__src == (void *)0x0) {
__src = pvVar13;
}
pvVar13 = (void *)((long)pvVar13 + 7);
pvVar11 = (void *)((long)pvVar11 + 7);
} while (pvVar13 < pvVar12);
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x15e83e;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
uVar8 = (ulong)local_40;
puVar10 = local_58;
}
plVar3 = local_48;
uVar14 = (long)__dest - (long)puVar10;
if ((uVar14 & 0xffffffff) == 0) {
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x15e865;
my_free();
}
uVar6 = 0;
goto LAB_0015e916;
}
iVar7 = (int)((uVar14 & 0xffffffff) * 0x24924925 >> 0x20);
local_3a = (int2)(((uint)((int)uVar14 - iVar7) >> 1) + iVar7 >> 2);
local_80 = 4;
lVar2 = local_48[1];
local_88 = local_3c;
local_78 = puVar10;
local_70 = uVar14 & 0xffffffff;
*(int8 *)((long)puVar9 + -0x10) = 0;
*(int1 **)((long)puVar9 + -0x18) = local_3c;
*(ulong **)((long)puVar9 + -0x20) = local_a8;
*(int8 *)((long)puVar9 + -0x28) = 0x15e8de;
cVar5 = translog_write_record(local_60,8,lVar2,plVar3,(int)uVar14 + 4,4);
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x15e8f1;
my_free(puVar10);
}
uVar6 = 1;
if (cVar5 != '\0') goto LAB_0015e916;
pvVar11 = *(void **)(local_50 + 0x10);
param_1 = local_48;
puVar4 = puVar9;
param_2 = local_50;
}
puVar9 = puVar4;
uVar1 = *(int4 *)(param_2 + 0xac);
*(int8 *)((long)puVar9 + -8) = 0x15e916;
uVar6 = _ma_bitmap_free_full_pages(param_1,pvVar11,uVar1);
LAB_0015e916:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_read_block_record2;
__stack_chk_fail();
}
return uVar6;
}
|
|
13,944
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x1a1880(%rip), %rax # 0x1cc8e0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%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 0x2b0eb
leaq 0x1a183d(%rip), %rax # 0x1cc8e0
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x2ee20
movl %eax, -0x24(%rbp)
leaq 0x1a1810(%rip), %rax # 0x1cc8e0
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b100
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x2ee20
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_file_close:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2B0EB
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_2B100
loc_2B0EB:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_2B100:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_close(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server[0] + 43))(v5, a3, 4LL);
if ( v6 )
{
(*((void ( **)(long long, long long, _QWORD))PSI_server[0] + 68))(v6, v11, v10);
v7 = my_close(v9, v8);
(*((void ( **)(long long, _QWORD))PSI_server[0] + 69))(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x2cc8e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012b0eb
LEA RAX,[0x2cc8e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0012ee20
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x2cc8e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0012b100
LAB_0012b0eb:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0012ee20
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_0012b100:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
|
|
13,945
|
spdlog::details::os::localtime(long const&)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/os-inl.h
|
SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
#ifdef _WIN32
std::tm tm;
::localtime_s(&tm, &time_tt);
#else
std::tm tm;
::localtime_r(&time_tt, &tm);
#endif
return tm;
}
|
O0
|
c
|
spdlog::details::os::localtime(long const&):
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14360
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
_ZN6spdlog7details2os9localtimeERKl:
sub rsp, 18h
mov rax, rsi
mov rsi, rdi
mov rdi, rsi
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_8], rax
mov rdi, [rsp+18h+var_8]
call _localtime_r
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
|
spdlog::details::os * spdlog::details::os::localtime(spdlog::details::os *this, const long long *a2)
{
localtime_r(a2);
return this;
}
|
localtime:
SUB RSP,0x18
MOV RAX,RSI
MOV RSI,RDI
MOV RDI,RSI
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00114360
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
|
/* spdlog::details::os::localtime(long const&) */
os * __thiscall spdlog::details::os::localtime(os *this,long *param_1)
{
localtime_r(param_1,(tm *)this);
return this;
}
|
|
13,946
|
ftxui::Screen::Screen(int, int)
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/screen/screen.cpp
|
Screen::Screen(int dimx, int dimy)
: stencil{0, dimx - 1, 0, dimy - 1},
dimx_(dimx),
dimy_(dimy),
pixels_(dimy, std::vector<Pixel>(dimx)) {
#if defined(_WIN32)
// The placement of this call is a bit weird, however we can assume that
// anybody who instantiates a Screen object eventually wants to output
// something to the console.
// As we require UTF8 for all input/output operations we will just switch to
// UTF8 encoding here
SetConsoleOutputCP(CP_UTF8);
SetConsoleCP(CP_UTF8);
WindowsEmulateVT100Terminal();
#endif
}
|
O0
|
cpp
|
ftxui::Screen::Screen(int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
decl %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl -0x10(%rbp), %ecx
decl %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
addq $0x18, %rax
movq %rax, -0xa0(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x69de0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x69e00
jmp 0x87703
leaq -0x3d(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x69e70
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xb0(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x69e90
jmp 0x87733
leaq -0x3d(%rbp), %rdi
callq 0x22770
leaq -0x28(%rbp), %rdi
callq 0x22420
leaq -0x29(%rbp), %rdi
callq 0x22680
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
callq 0x8c290
movq -0xa8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xc8(%rbp)
movb $0x1, -0x7a(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xdaa0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
leaq 0x9552(%rip), %rsi # 0x90cfa
callq 0x16510
jmp 0x877af
movb $0x0, -0x7a(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
leaq -0x7b(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x161e0
movq -0xc8(%rbp), %rdi
movq -0xd0(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8c2b0
jmp 0x877f0
leaq -0x7b(%rbp), %rdi
callq 0x175d0
leaq -0x70(%rbp), %rax
movq %rax, -0xe0(%rbp)
addq $0x20, %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xe8(%rbp)
callq 0xdbc8
movq -0xe0(%rbp), %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xd8(%rbp)
jne 0x8780f
leaq -0x79(%rbp), %rdi
callq 0xd620
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8787e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x22770
leaq -0x28(%rbp), %rdi
callq 0x22420
leaq -0x29(%rbp), %rdi
callq 0x22680
jmp 0x87959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x878f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x7b(%rbp), %rdi
callq 0x175d0
leaq -0x70(%rbp), %rax
movq %rax, -0xf8(%rbp)
addq $0x20, %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x100(%rbp)
callq 0xdbc8
movq -0xf8(%rbp), %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xf0(%rbp)
jne 0x878c5
jmp 0x878f8
leaq -0x79(%rbp), %rdi
callq 0xd620
testb $0x1, -0x7a(%rbp)
jne 0x87909
jmp 0x8794d
movq -0x78(%rbp), %rax
leaq -0x70(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0x108(%rbp)
je 0x8794b
movq -0x108(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x110(%rbp)
callq 0xdbc8
movq -0x110(%rbp), %rax
leaq -0x70(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x108(%rbp)
jne 0x8791d
jmp 0x8794d
movq -0xa0(%rbp), %rdi
callq 0x222a0
movq -0x38(%rbp), %rdi
callq 0xda90
nopw %cs:(%rax,%rax)
|
_ZN5ftxui6ScreenC2Eii:
push rbp; Alternative name is 'ftxui::Screen::Screen(int, int)'
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
mov [rbp+var_A8], rax
mov dword ptr [rax], 0
mov ecx, [rbp+var_C]
dec ecx
mov [rax+4], ecx
mov dword ptr [rax+8], 0
mov ecx, [rbp+var_10]
dec ecx
mov [rax+0Ch], ecx
mov ecx, [rbp+var_C]
mov [rax+10h], ecx
mov ecx, [rbp+var_10]
mov [rax+14h], ecx
add rax, 18h
mov [rbp+var_A0], rax
movsxd rax, [rbp+var_10]
mov [rbp+var_98], rax
movsxd rax, [rbp+var_C]
mov [rbp+var_90], rax
lea rdi, [rbp+var_29]
mov [rbp+var_88], rdi
call _ZNSaIN5ftxui5PixelEEC2Ev; std::allocator<ftxui::Pixel>::allocator(void)
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_88]
lea rdi, [rbp+var_28]
call _ZNSt6vectorIN5ftxui5PixelESaIS1_EEC2EmRKS2_; std::vector<ftxui::Pixel>::vector(ulong,std::allocator<ftxui::Pixel> const&)
jmp short $+2
loc_87703:
lea rdi, [rbp+var_3D]
mov [rbp+var_B0], rdi
call _ZNSaISt6vectorIN5ftxui5PixelESaIS1_EEEC2Ev; std::allocator<std::vector<ftxui::Pixel>>::allocator(void)
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_98]
mov rcx, [rbp+var_B0]
lea rdx, [rbp+var_28]
call _ZNSt6vectorIS_IN5ftxui5PixelESaIS1_EESaIS3_EEC2EmRKS3_RKS4_; std::vector<std::vector<ftxui::Pixel>>::vector(ulong,std::vector<ftxui::Pixel> const&,std::allocator<std::vector<ftxui::Pixel>> const&)
jmp short $+2
loc_87733:
lea rdi, [rbp+var_3D]
call _ZNSaISt6vectorIN5ftxui5PixelESaIS1_EEED2Ev; std::allocator<std::vector<ftxui::Pixel>>::~allocator()
lea rdi, [rbp+var_28]
call _ZNSt6vectorIN5ftxui5PixelESaIS1_EED2Ev; std::vector<ftxui::Pixel>::~vector()
lea rdi, [rbp+var_29]
call _ZNSaIN5ftxui5PixelEED2Ev; std::allocator<ftxui::Pixel>::~allocator()
mov rdi, [rbp+var_A8]
add rdi, 30h ; '0'; this
call _ZN5ftxui6Screen6CursorC2Ev; ftxui::Screen::Cursor::Cursor(void)
mov rax, [rbp+var_A8]
add rax, 40h ; '@'
mov [rbp+var_C8], rax
mov [rbp+var_7A], 1
lea rax, [rbp+var_70]
mov [rbp+var_C0], rax
mov [rbp+var_78], rax
lea rdi, [rbp+var_79]
mov [rbp+var_B8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_C0]
mov rdx, [rbp+var_B8]
lea rsi, asc_90CF8+2; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_877AF:
mov [rbp+var_7A], 0
lea rax, [rbp+var_70]
mov [rbp+var_50], rax
mov [rbp+var_48], 1
lea rdi, [rbp+var_7B]
mov [rbp+var_D0], rdi
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2Ev; std::allocator<std::string>::allocator(void)
mov rdi, [rbp+var_C8]
mov rcx, [rbp+var_D0]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ESt16initializer_listIS5_ERKS6_; std::vector<std::string>::vector(std::initializer_list<std::string>,std::allocator<std::string> const&)
jmp short $+2
loc_877F0:
lea rdi, [rbp+var_7B]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
lea rax, [rbp+var_70]
mov [rbp+var_E0], rax
add rax, 20h ; ' '
mov [rbp+var_D8], rax
loc_8780F:
mov rdi, [rbp+var_D8]
add rdi, 0FFFFFFFFFFFFFFE0h; void *
mov [rbp+var_E8], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rcx, [rbp+var_E0]
mov rax, [rbp+var_E8]
cmp rax, rcx
mov [rbp+var_D8], rax
jnz short loc_8780F
lea rdi, [rbp+var_79]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
add rsp, 110h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
jmp short loc_8787E
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_3D]
call _ZNSaISt6vectorIN5ftxui5PixelESaIS1_EEED2Ev; std::allocator<std::vector<ftxui::Pixel>>::~allocator()
lea rdi, [rbp+var_28]
call _ZNSt6vectorIN5ftxui5PixelESaIS1_EED2Ev; std::vector<ftxui::Pixel>::~vector()
loc_8787E:
lea rdi, [rbp+var_29]
call _ZNSaIN5ftxui5PixelEED2Ev; std::allocator<ftxui::Pixel>::~allocator()
jmp loc_87959
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
jmp short loc_878F8
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_7B]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
lea rax, [rbp+var_70]
mov [rbp+var_F8], rax
add rax, 20h ; ' '
mov [rbp+var_F0], rax
loc_878C5:
mov rdi, [rbp+var_F0]
add rdi, 0FFFFFFFFFFFFFFE0h; void *
mov [rbp+var_100], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rcx, [rbp+var_F8]
mov rax, [rbp+var_100]
cmp rax, rcx
mov [rbp+var_F0], rax
jnz short loc_878C5
jmp short $+2
loc_878F8:
lea rdi, [rbp+var_79]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rbp+var_7A], 1
jnz short loc_87909
jmp short loc_8794D
loc_87909:
mov rax, [rbp+var_78]
lea rcx, [rbp+var_70]
cmp rcx, rax
mov [rbp+var_108], rax
jz short loc_8794B
loc_8791D:
mov rdi, [rbp+var_108]
add rdi, 0FFFFFFFFFFFFFFE0h; void *
mov [rbp+var_110], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rbp+var_110]
lea rcx, [rbp+var_70]
cmp rax, rcx
mov [rbp+var_108], rax
jnz short loc_8791D
loc_8794B:
jmp short $+2
loc_8794D:
mov rdi, [rbp+var_A0]
call _ZNSt6vectorIS_IN5ftxui5PixelESaIS1_EESaIS3_EED2Ev; std::vector<std::vector<ftxui::Pixel>>::~vector()
loc_87959:
mov rdi, [rbp+var_38]
call __Unwind_Resume
|
long long ftxui::Screen::Screen(ftxui::Screen *this, int a2, int a3)
{
_BYTE *v4; // [rsp+38h] [rbp-D8h]
long long v5; // [rsp+78h] [rbp-98h]
long long v6; // [rsp+80h] [rbp-90h]
_BYTE v7[2]; // [rsp+95h] [rbp-7Bh] BYREF
char v8; // [rsp+97h] [rbp-79h] BYREF
_BYTE *v9; // [rsp+98h] [rbp-78h]
_BYTE v10[32]; // [rsp+A0h] [rbp-70h] BYREF
_BYTE *v11; // [rsp+C0h] [rbp-50h] BYREF
long long v12; // [rsp+C8h] [rbp-48h]
char v13; // [rsp+D3h] [rbp-3Dh] BYREF
char v14; // [rsp+E7h] [rbp-29h] BYREF
long long v15[3]; // [rsp+E8h] [rbp-28h] BYREF
int v16; // [rsp+100h] [rbp-10h]
int v17; // [rsp+104h] [rbp-Ch]
ftxui::Screen *v18; // [rsp+108h] [rbp-8h]
v18 = this;
v17 = a2;
v16 = a3;
*(_DWORD *)this = 0;
*((_DWORD *)this + 1) = v17 - 1;
*((_DWORD *)this + 2) = 0;
*((_DWORD *)this + 3) = v16 - 1;
*((_DWORD *)this + 4) = v17;
*((_DWORD *)this + 5) = v16;
v5 = v16;
v6 = v17;
std::allocator<ftxui::Pixel>::allocator((long long)&v14);
std::vector<ftxui::Pixel>::vector((long long)v15, v6, (long long)&v14);
std::allocator<std::vector<ftxui::Pixel>>::allocator((long long)&v13);
std::vector<std::vector<ftxui::Pixel>>::vector((long long)this + 24, v5, (long long)v15, (long long)&v13);
std::allocator<std::vector<ftxui::Pixel>>::~allocator((long long)&v13);
std::vector<ftxui::Pixel>::~vector(v15);
std::allocator<ftxui::Pixel>::~allocator((long long)&v14);
ftxui::Screen::Cursor::Cursor((ftxui::Screen *)((char *)this + 48));
v9 = v10;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v10, (long long)"", (long long)&v8);
v7[1] = 0;
v11 = v10;
v12 = 1LL;
std::allocator<std::string>::allocator((long long)v7);
std::vector<std::string>::vector((char *)this + 64, v11, v12, v7);
std::allocator<std::string>::~allocator((long long)v7);
v4 = &v11;
do
{
std::string::~string(v4 - 32);
v4 -= 32;
}
while ( v4 != v10 );
return std::allocator<char>::~allocator(&v8);
}
|
Screen:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xa8],RAX
MOV dword ptr [RAX],0x0
MOV ECX,dword ptr [RBP + -0xc]
DEC ECX
MOV dword ptr [RAX + 0x4],ECX
MOV dword ptr [RAX + 0x8],0x0
MOV ECX,dword ptr [RBP + -0x10]
DEC ECX
MOV dword ptr [RAX + 0xc],ECX
MOV ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX + 0x10],ECX
MOV ECX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
ADD RAX,0x18
MOV qword ptr [RBP + -0xa0],RAX
MOVSXD RAX,dword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
MOVSXD RAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x29]
MOV qword ptr [RBP + -0x88],RDI
CALL 0x00169de0
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x88]
LAB_001876f8:
LEA RDI,[RBP + -0x28]
CALL 0x00169e00
JMP 0x00187703
LAB_00187703:
LEA RDI,[RBP + -0x3d]
MOV qword ptr [RBP + -0xb0],RDI
CALL 0x00169e70
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0xb0]
LAB_00187728:
LEA RDX,[RBP + -0x28]
CALL 0x00169e90
JMP 0x00187733
LAB_00187733:
LEA RDI,[RBP + -0x3d]
CALL 0x00122770
LEA RDI,[RBP + -0x28]
CALL 0x00122420
LEA RDI,[RBP + -0x29]
CALL 0x00122680
MOV RDI,qword ptr [RBP + -0xa8]
ADD RDI,0x30
CALL 0x0018c290
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,0x40
MOV qword ptr [RBP + -0xc8],RAX
MOV byte ptr [RBP + -0x7a],0x1
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0xc0],RAX
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x79]
MOV qword ptr [RBP + -0xb8],RDI
CALL 0x0010daa0
MOV RDI,qword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RBP + -0xb8]
LAB_001877a1:
LEA RSI,[0x190cfa]
CALL 0x00116510
JMP 0x001877af
LAB_001877af:
MOV byte ptr [RBP + -0x7a],0x0
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x48],0x1
LEA RDI,[RBP + -0x7b]
MOV qword ptr [RBP + -0xd0],RDI
CALL 0x001161e0
MOV RDI,qword ptr [RBP + -0xc8]
MOV RCX,qword ptr [RBP + -0xd0]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
LAB_001877e9:
CALL 0x0018c2b0
LAB_001877ee:
JMP 0x001877f0
LAB_001877f0:
LEA RDI,[RBP + -0x7b]
CALL 0x001175d0
LEA RAX,[RBP + -0x70]
MOV qword ptr [RBP + -0xe0],RAX
ADD RAX,0x20
MOV qword ptr [RBP + -0xd8],RAX
LAB_0018780f:
MOV RDI,qword ptr [RBP + -0xd8]
ADD RDI,-0x20
MOV qword ptr [RBP + -0xe8],RDI
CALL 0x0010dbc8
MOV RCX,qword ptr [RBP + -0xe0]
MOV RAX,qword ptr [RBP + -0xe8]
CMP RAX,RCX
MOV qword ptr [RBP + -0xd8],RAX
JNZ 0x0018780f
LEA RDI,[RBP + -0x79]
CALL 0x0010d620
ADD RSP,0x110
POP RBP
RET
|
/* ftxui::Screen::Screen(int, int) */
void __thiscall ftxui::Screen::Screen(Screen *this,int param_1,int param_2)
{
string *local_e0;
allocator<std::__cxx11::string> local_83;
int1 local_82;
allocator local_81;
string *local_80;
string local_78 [32];
string *local_58;
int8 local_50;
allocator local_45 [20];
allocator local_31;
vector<ftxui::Pixel,std::allocator<ftxui::Pixel>> local_30 [24];
int local_18;
int local_14;
Screen *local_10;
*(int4 *)this = 0;
*(int *)(this + 4) = param_1 + -1;
*(int4 *)(this + 8) = 0;
*(int *)(this + 0xc) = param_2 + -1;
*(int *)(this + 0x10) = param_1;
*(int *)(this + 0x14) = param_2;
local_18 = param_2;
local_14 = param_1;
local_10 = this;
std::allocator<ftxui::Pixel>::allocator();
/* try { // try from 001876f8 to 00187700 has its CatchHandler @ 00187852 */
std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>::vector(local_30,(long)param_1,&local_31);
std::allocator<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>>::allocator();
/* try { // try from 00187728 to 00187730 has its CatchHandler @ 00187860 */
std::
vector<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>,std::allocator<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>>>
::vector((vector<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>,std::allocator<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>>>
*)(this + 0x18),(long)param_2,(vector *)local_30,local_45);
std::allocator<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>>::~allocator
((allocator<std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>> *)local_45);
std::vector<ftxui::Pixel,std::allocator<ftxui::Pixel>>::~vector(local_30);
std::allocator<ftxui::Pixel>::~allocator((allocator<ftxui::Pixel> *)&local_31);
Cursor::Cursor((Cursor *)(this + 0x30));
local_82 = 1;
local_80 = local_78;
std::allocator<char>::allocator();
/* try { // try from 001877a1 to 001877ac has its CatchHandler @ 0018788c */
std::__cxx11::string::string<std::allocator<char>>(local_78,"",&local_81);
local_82 = 0;
local_58 = local_78;
local_50 = 1;
std::allocator<std::__cxx11::string>::allocator();
/* try { // try from 001877e9 to 001877ed has its CatchHandler @ 0018789a */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(this + 0x40,local_58,local_50,&local_83);
std::allocator<std::__cxx11::string>::~allocator(&local_83);
local_e0 = (string *)&local_58;
do {
local_e0 = local_e0 + -0x20;
std::__cxx11::string::~string(local_e0);
} while (local_e0 != local_78);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
return;
}
|
|
13,947
|
init_alloc_root
|
eloqsql/mysys/my_alloc.c
|
void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= (block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x2da9c
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0x2b4f5
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x2da9c
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_2DA9C
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_2DA9C
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_2DA9C:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long init_alloc_root(unsigned int a1, long long *a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (HIWORD(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24, a5);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
|
init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x0012da9c
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x0012b4f5
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0012da9c
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_0012da9c:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
|
|
13,948
|
minja::Value::Value(char const*)
|
monkey531[P]llama/common/minja.hpp
|
Value(const char * v) : primitive_(std::string(v)) {}
|
O3
|
cpp
|
minja::Value::Value(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x65cd2
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8563e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1df8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b910
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa1e23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0xa1e23
movq %rax, %r14
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xa1e31
callq 0x33c02
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xa1e3f
callq 0x33c02
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa1e4d
callq 0x33c02
movq %rbx, %rdi
callq 0x8d2ea
movq %r14, %rdi
callq 0x1bff0
nop
|
_ZN5minja5ValueC2EPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
lea rdi, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rbx+40h]
lea rsi, [rsp+38h+var_30]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A1DF8
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A1DF8:
add rsp, 28h
pop rbx
pop r14
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A1E23
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A1E23
mov r14, rax
loc_A1E23:
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_A1E31
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1E31:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_A1E3F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1E3F:
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_A1E4D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1E4D:
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
|
void minja::Value::Value(minja::Value *this, char *a2)
{
long long *v2; // [rsp+8h] [rbp-30h] BYREF
long long v3; // [rsp+18h] [rbp-20h] BYREF
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
std::string::basic_string<std::allocator<char>>(&v2, a2);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_((char *)this + 64);
if ( v2 != &v3 )
operator delete(v2, v3 + 1);
}
|
Value:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001a1dc0:
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x00165cd2
LEA RDI,[RBX + 0x40]
LAB_001a1dd3:
LEA RSI,[RSP + 0x8]
CALL 0x0018563e
LAB_001a1ddd:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a1df8
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b910
LAB_001a1df8:
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* minja::Value::Value(char const*) */
void __thiscall minja::Value::Value(Value *this,char *param_1)
{
allocator local_31;
long *local_30 [2];
long local_20 [2];
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 001a1dc0 to 001a1dce has its CatchHandler @ 001a1e20 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 001a1dd3 to 001a1ddc has its CatchHandler @ 001a1e00 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(this + 0x40,local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return;
}
|
|
13,949
|
sp_get_linestring_mbr
|
eloqsql/storage/maria/ma_sp_key.c
|
static int sp_get_linestring_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_points;
n_points = uint4korr(*wkb);
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
return 0;
}
|
O3
|
c
|
sp_get_linestring_mbr:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl (%rax), %ecx
addq $0x4, %rax
movq %rax, (%rdi)
testl %ecx, %ecx
je 0x70dba
addq $-0x8, %rsi
movb $0x1, %r8b
xorl %r9d, %r9d
movq (%rdi), %rax
cmpq %rsi, %rax
ja 0x70db3
movsd (%rax), %xmm0
addq $0x8, %rax
movq %rax, (%rdi)
movsd (%rdx,%r9), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x70d86
movsd %xmm0, (%rdx,%r9)
ucomisd 0x8(%rdx,%r9), %xmm0
jbe 0x70d99
orq $0x8, %r9
movsd %xmm0, (%rdx,%r9)
movl $0x10, %r9d
xorl %eax, %eax
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x70d61
decl %ecx
jne 0x70d5b
jmp 0x70dbc
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x70dbc
xorl %eax, %eax
popq %rbp
retq
|
sp_get_linestring_mbr:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov ecx, [rax]
add rax, 4
mov [rdi], rax
test ecx, ecx
jz short loc_70DBA
add rsi, 0FFFFFFFFFFFFFFF8h
loc_70D5B:
mov r8b, 1
xor r9d, r9d
loc_70D61:
mov rax, [rdi]
cmp rax, rsi
ja short loc_70DB3
movsd xmm0, qword ptr [rax]
add rax, 8
mov [rdi], rax
movsd xmm1, qword ptr [rdx+r9]
ucomisd xmm1, xmm0
jbe short loc_70D86
movsd qword ptr [rdx+r9], xmm0
loc_70D86:
ucomisd xmm0, qword ptr [rdx+r9+8]
jbe short loc_70D99
or r9, 8
movsd qword ptr [rdx+r9], xmm0
loc_70D99:
mov r9d, 10h
xor eax, eax
test r8b, 1
mov r8d, 0
jnz short loc_70D61
dec ecx
jnz short loc_70D5B
jmp short loc_70DBC
loc_70DB3:
mov eax, 0FFFFFFFFh
jmp short loc_70DBC
loc_70DBA:
xor eax, eax
loc_70DBC:
pop rbp
retn
|
long long sp_get_linestring_mbr(double **a1, long long a2, long long a3)
{
int v3; // ecx
unsigned long long v4; // rsi
char v5; // r8
long long v6; // r9
double *v7; // rax
double v8; // xmm0_8
long long result; // rax
bool v10; // zf
v3 = *(_DWORD *)*a1;
*a1 = (double *)((char *)*a1 + 4);
if ( !v3 )
return 0LL;
v4 = a2 - 8;
while ( 2 )
{
v5 = 1;
v6 = 0LL;
do
{
v7 = *a1;
if ( (unsigned long long)*a1 > v4 )
return 0xFFFFFFFFLL;
v8 = *v7;
*a1 = v7 + 1;
if ( *(double *)(a3 + v6) > v8 )
*(double *)(a3 + v6) = v8;
if ( v8 > *(double *)(a3 + v6 + 8) )
*(double *)(a3 + (v6 | 8)) = v8;
v6 = 16LL;
result = 0LL;
v10 = (v5 & 1) == 0;
v5 = 0;
}
while ( !v10 );
if ( --v3 )
continue;
break;
}
return result;
}
|
sp_get_linestring_mbr:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV ECX,dword ptr [RAX]
ADD RAX,0x4
MOV qword ptr [RDI],RAX
TEST ECX,ECX
JZ 0x00170dba
ADD RSI,-0x8
LAB_00170d5b:
MOV R8B,0x1
XOR R9D,R9D
LAB_00170d61:
MOV RAX,qword ptr [RDI]
CMP RAX,RSI
JA 0x00170db3
MOVSD XMM0,qword ptr [RAX]
ADD RAX,0x8
MOV qword ptr [RDI],RAX
MOVSD XMM1,qword ptr [RDX + R9*0x1]
UCOMISD XMM1,XMM0
JBE 0x00170d86
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00170d86:
UCOMISD XMM0,qword ptr [RDX + R9*0x1 + 0x8]
JBE 0x00170d99
OR R9,0x8
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00170d99:
MOV R9D,0x10
XOR EAX,EAX
TEST R8B,0x1
MOV R8D,0x0
JNZ 0x00170d61
DEC ECX
JNZ 0x00170d5b
JMP 0x00170dbc
LAB_00170db3:
MOV EAX,0xffffffff
JMP 0x00170dbc
LAB_00170dba:
XOR EAX,EAX
LAB_00170dbc:
POP RBP
RET
|
int8 sp_get_linestring_mbr(int8 *param_1,long param_2,long param_3)
{
double dVar1;
double *pdVar2;
bool bVar3;
int iVar4;
bool bVar5;
ulong uVar6;
iVar4 = *(int *)*param_1;
*param_1 = (int *)*param_1 + 1;
if (iVar4 != 0) {
do {
uVar6 = 0;
bVar3 = true;
do {
bVar5 = bVar3;
pdVar2 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar2) {
return 0xffffffff;
}
dVar1 = *pdVar2;
*param_1 = pdVar2 + 1;
if (dVar1 < *(double *)(param_3 + uVar6)) {
*(double *)(param_3 + uVar6) = dVar1;
}
pdVar2 = (double *)(param_3 + 8 + uVar6);
if (*pdVar2 <= dVar1 && dVar1 != *pdVar2) {
*(double *)(param_3 + (uVar6 | 8)) = dVar1;
}
uVar6 = 0x10;
bVar3 = false;
} while (bVar5);
iVar4 = iVar4 + -1;
} while (iVar4 != 0);
}
return 0;
}
|
|
13,950
|
quorem
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
static int quorem(Bigint *b, Bigint *S)
{
int n;
ULong *bx, *bxe, q, *sx, *sxe;
ULLong borrow, carry, y, ys;
n= S->wds;
if (b->wds < n)
return 0;
sx= S->p.x;
sxe= sx + --n;
bx= b->p.x;
bxe= bx + n;
q= *bxe / (*sxe + 1); /* ensure q <= true quotient */
if (q)
{
borrow= 0;
carry= 0;
do
{
ys= *sx++ * (ULLong)q + carry;
carry= ys >> 32;
y= *bx - (ys & FFFFFFFF) - borrow;
borrow= y >> 32 & (ULong)1;
*bx++= (ULong) (y & FFFFFFFF);
}
while (sx <= sxe);
if (!*bxe)
{
bx= b->p.x;
while (--bxe > bx && !*bxe)
--n;
b->wds= n;
}
}
if (cmp(b, S) >= 0)
{
q++;
borrow= 0;
carry= 0;
bx= b->p.x;
sx= S->p.x;
do
{
ys= *sx++ + carry;
carry= ys >> 32;
y= *bx - (ys & FFFFFFFF) - borrow;
borrow= y >> 32 & (ULong)1;
*bx++= (ULong) (y & FFFFFFFF);
}
while (sx <= sxe);
bx= b->p.x;
bxe= bx + n;
if (!*bxe)
{
while (--bxe > bx && !*bxe)
--n;
b->wds= n;
}
}
return q;
}
|
O0
|
c
|
quorem:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4f8d2
movl $0x0, -0x4(%rbp)
jmp 0x4fb63
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x4fa2a
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movl -0x34(%rbp), %ecx
imulq %rcx, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x4f946
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4fa28
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x69(%rbp)
jbe 0x4fa0a
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4fa13
jmp 0x4fa1e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f9e4
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x4fa2a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f580
cmpl $0x0, %eax
jl 0x4fb5d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x4fa6f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4fb5b
jmp 0x4fb17
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x6a(%rbp)
jbe 0x4fb3d
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x4fb46
jmp 0x4fb51
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fb17
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x4fb5d
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
quorem:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov eax, [rax+14h]
cmp eax, [rbp+var_1C]
jge short loc_4F8D2
mov [rbp+var_4], 0
jmp loc_4FB63
loc_4F8D2:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov ecx, [rbp+var_1C]
add ecx, 0FFFFFFFFh
mov [rbp+var_1C], ecx
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov eax, [rax]
mov rcx, [rbp+var_48]
mov ecx, [rcx]
add ecx, 1
xor edx, edx
div ecx
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jz loc_4FA2A
mov [rbp+var_50], 0
mov [rbp+var_58], 0
loc_4F946:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
mov ecx, [rbp+var_34]
imul rax, rcx
add rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
shr rax, 20h
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov rcx, 0FFFFFFFFh
and rcx, [rbp+var_68]
sub rax, rcx
sub rax, [rbp+var_50]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
shr rax, 20h
and rax, 1
mov [rbp+var_50], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_60]
mov ecx, eax
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 4
mov [rbp+var_28], rdx
mov [rax], ecx
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jbe loc_4F946
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_4FA28
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
loc_4F9E4:
mov rcx, [rbp+var_30]
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rcx
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_69], al
jbe short loc_4FA0A
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
setnz al
xor al, 0FFh
mov [rbp+var_69], al
loc_4FA0A:
mov al, [rbp+var_69]
test al, 1
jnz short loc_4FA13
jmp short loc_4FA1E
loc_4FA13:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_4F9E4
loc_4FA1E:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
loc_4FA28:
jmp short $+2
loc_4FA2A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cmp
cmp eax, 0
jl loc_4FB5D
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
mov [rbp+var_50], 0
mov [rbp+var_58], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_40], rax
loc_4FA6F:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
add rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
shr rax, 20h
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov rcx, 0FFFFFFFFh
and rcx, [rbp+var_68]
sub rax, rcx
sub rax, [rbp+var_50]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
shr rax, 20h
and rax, 1
mov [rbp+var_50], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_60]
mov ecx, eax
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 4
mov [rbp+var_28], rdx
mov [rax], ecx
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jbe short loc_4FA6F
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_4FB5B
jmp short $+2
loc_4FB17:
mov rcx, [rbp+var_30]
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rcx
xor eax, eax
cmp rcx, [rbp+var_28]
mov [rbp+var_6A], al
jbe short loc_4FB3D
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
setnz al
xor al, 0FFh
mov [rbp+var_6A], al
loc_4FB3D:
mov al, [rbp+var_6A]
test al, 1
jnz short loc_4FB46
jmp short loc_4FB51
loc_4FB46:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_4FB17
loc_4FB51:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
loc_4FB5B:
jmp short $+2
loc_4FB5D:
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_4FB63:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long quorem(long long a1, long long a2)
{
unsigned int *v2; // rax
unsigned int *v3; // rax
unsigned int *v4; // rax
unsigned int *v5; // rax
char v7; // [rsp+6h] [rbp-6Ah]
char v8; // [rsp+7h] [rbp-69h]
unsigned long long v9; // [rsp+8h] [rbp-68h]
unsigned long long v10; // [rsp+8h] [rbp-68h]
unsigned long long v11; // [rsp+10h] [rbp-60h]
unsigned long long v12; // [rsp+10h] [rbp-60h]
unsigned long long v13; // [rsp+18h] [rbp-58h]
unsigned long long v14; // [rsp+18h] [rbp-58h]
long long v15; // [rsp+20h] [rbp-50h]
long long v16; // [rsp+20h] [rbp-50h]
unsigned int *v17; // [rsp+28h] [rbp-48h]
unsigned int *v18; // [rsp+30h] [rbp-40h]
unsigned int *v19; // [rsp+30h] [rbp-40h]
unsigned int v20; // [rsp+3Ch] [rbp-34h]
_DWORD *v21; // [rsp+40h] [rbp-30h]
_DWORD *v22; // [rsp+40h] [rbp-30h]
unsigned int *v23; // [rsp+48h] [rbp-28h]
unsigned int *v24; // [rsp+48h] [rbp-28h]
int v25; // [rsp+54h] [rbp-1Ch]
int v26; // [rsp+54h] [rbp-1Ch]
v25 = *(_DWORD *)(a2 + 20);
if ( *(_DWORD *)(a1 + 20) >= v25 )
{
v18 = *(unsigned int **)a2;
v26 = v25 - 1;
v17 = (unsigned int *)(4LL * v26 + *(_QWORD *)a2);
v23 = *(unsigned int **)a1;
v21 = (_DWORD *)(4LL * v26 + *(_QWORD *)a1);
v20 = *v21 / (*v17 + 1);
if ( v20 )
{
v15 = 0LL;
v13 = 0LL;
do
{
v2 = v18++;
v9 = v13 + v20 * (unsigned long long)*v2;
v13 = HIDWORD(v9);
v11 = *v23 - (unsigned long long)(unsigned int)v9 - v15;
v15 = HIDWORD(v11) & 1;
v3 = v23++;
*v3 = v11;
}
while ( v18 <= v17 );
if ( !*v21 )
{
while ( 1 )
{
--v21;
v8 = 0;
if ( (unsigned long long)v21 > *(_QWORD *)a1 )
v8 = ~(*v21 != 0);
if ( (v8 & 1) == 0 )
break;
--v26;
}
*(_DWORD *)(a1 + 20) = v26;
}
}
if ( (int)cmp(a1, a2) >= 0 )
{
++v20;
v16 = 0LL;
v14 = 0LL;
v24 = *(unsigned int **)a1;
v19 = *(unsigned int **)a2;
do
{
v4 = v19++;
v10 = v14 + *v4;
v14 = HIDWORD(v10);
v12 = *v24 - (unsigned long long)(unsigned int)v10 - v16;
v16 = HIDWORD(v12) & 1;
v5 = v24++;
*v5 = v12;
}
while ( v19 <= v17 );
v22 = (_DWORD *)(4LL * v26 + *(_QWORD *)a1);
if ( !*v22 )
{
while ( 1 )
{
--v22;
v7 = 0;
if ( (unsigned long long)v22 > *(_QWORD *)a1 )
v7 = ~(*v22 != 0);
if ( (v7 & 1) == 0 )
break;
--v26;
}
*(_DWORD *)(a1 + 20) = v26;
}
}
return v20;
}
else
{
return 0;
}
}
|
quorem:
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 + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x0014f8d2
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fb63
LAB_0014f8d2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,-0x1
MOV dword ptr [RBP + -0x1c],ECX
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RCX]
ADD ECX,0x1
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JZ 0x0014fa2a
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_0014f946:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x34]
IMUL RAX,RCX
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
SHR RAX,0x20
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV RCX,0xffffffff
AND RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x0014f946
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x0014fa28
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LAB_0014f9e4:
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,-0x4
MOV qword ptr [RBP + -0x30],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x69],AL
JBE 0x0014fa0a
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x69],AL
LAB_0014fa0a:
MOV AL,byte ptr [RBP + -0x69]
TEST AL,0x1
JNZ 0x0014fa13
JMP 0x0014fa1e
LAB_0014fa13:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014f9e4
LAB_0014fa1e:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
LAB_0014fa28:
JMP 0x0014fa2a
LAB_0014fa2a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0014f580
CMP EAX,0x0
JL 0x0014fb5d
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_0014fa6f:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV EAX,dword ptr [RAX]
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
SHR RAX,0x20
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV RCX,0xffffffff
AND RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x20
AND RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x0014fa6f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x0014fb5b
JMP 0x0014fb17
LAB_0014fb17:
MOV RCX,qword ptr [RBP + -0x30]
ADD RCX,-0x4
MOV qword ptr [RBP + -0x30],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x6a],AL
JBE 0x0014fb3d
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x6a],AL
LAB_0014fb3d:
MOV AL,byte ptr [RBP + -0x6a]
TEST AL,0x1
JNZ 0x0014fb46
JMP 0x0014fb51
LAB_0014fb46:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014fb17
LAB_0014fb51:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
LAB_0014fb5b:
JMP 0x0014fb5d
LAB_0014fb5d:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014fb63:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
uint quorem(int8 *param_1,int8 *param_2)
{
int iVar1;
uint *puVar2;
ulong uVar3;
uint *puVar4;
bool bVar5;
ulong local_60;
ulong local_58;
uint *local_48;
uint local_3c;
uint *local_38;
uint *local_30;
int local_24;
uint local_c;
if (*(int *)((long)param_1 + 0x14) < *(int *)((long)param_2 + 0x14)) {
local_c = 0;
}
else {
local_24 = *(int *)((long)param_2 + 0x14) + -1;
puVar2 = (uint *)*param_2 + local_24;
local_38 = (uint *)*param_1 + local_24;
local_3c = *local_38 / (*puVar2 + 1);
if (local_3c != 0) {
local_58 = 0;
local_60 = 0;
local_48 = (uint *)*param_2;
local_30 = (uint *)*param_1;
do {
puVar4 = local_48 + 1;
uVar3 = (ulong)*local_48 * (ulong)local_3c + local_60;
local_60 = uVar3 >> 0x20;
uVar3 = ((ulong)*local_30 - (uVar3 & 0xffffffff)) - local_58;
local_58 = uVar3 >> 0x20 & 1;
*local_30 = (uint)uVar3;
local_48 = puVar4;
local_30 = local_30 + 1;
} while (puVar4 <= puVar2);
if (*local_38 == 0) {
while( true ) {
local_38 = local_38 + -1;
bVar5 = false;
if ((uint *)*param_1 < local_38) {
bVar5 = *local_38 == 0;
}
if (!bVar5) break;
local_24 = local_24 + -1;
}
*(int *)((long)param_1 + 0x14) = local_24;
}
}
iVar1 = cmp(param_1,param_2);
if (-1 < iVar1) {
local_3c = local_3c + 1;
local_58 = 0;
local_60 = 0;
local_48 = (uint *)*param_2;
local_30 = (uint *)*param_1;
do {
puVar4 = local_48 + 1;
uVar3 = *local_48 + local_60;
local_60 = uVar3 >> 0x20;
uVar3 = ((ulong)*local_30 - (uVar3 & 0xffffffff)) - local_58;
local_58 = uVar3 >> 0x20 & 1;
*local_30 = (uint)uVar3;
local_48 = puVar4;
local_30 = local_30 + 1;
} while (puVar4 <= puVar2);
local_38 = (uint *)((int *)*param_1 + local_24);
if (*local_38 == 0) {
while( true ) {
local_38 = local_38 + -1;
bVar5 = false;
if ((int *)*param_1 < local_38) {
bVar5 = *local_38 == 0;
}
if (!bVar5) break;
local_24 = local_24 + -1;
}
*(int *)((long)param_1 + 0x14) = local_24;
}
}
local_c = local_3c;
}
return local_c;
}
|
|
13,951
|
mysql_client_find_plugin@libmariadbclient_18
|
eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c
|
struct st_mysql_client_plugin * STDCALL
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
int plugin_nr= get_plugin_nr(type);
if (is_not_initialized(mysql, name))
return NULL;
if (plugin_nr == -1)
{
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, "invalid type");
}
if ((p= find_plugin(name, type)))
return p;
/* not found, load it */
return mysql_load_plugin(mysql, name, type, 0);
}
|
O0
|
c
|
mysql_client_find_plugin@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x45e70
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45800
cmpl $0x0, %eax
je 0x45dea
movq $0x0, -0x8(%rbp)
jmp 0x45e5b
cmpl $-0x1, -0x2c(%rbp)
jne 0x45e23
movq -0x10(%rbp), %rdi
leaq 0x1d2a5(%rip), %rax # 0x630a0
movq (%rax), %rdx
leaq 0x1d2ab(%rip), %rax # 0x630b0
movq 0x1d8(%rax), %rcx
movq -0x18(%rbp), %r8
movl $0x80b, %esi # imm = 0x80B
leaq 0xd458(%rip), %r9 # 0x53274
movb $0x0, %al
callq 0x20b60
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x45870
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x45e43
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45e5b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x17a40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_client_find_plugin@libmariadbclient_18:
push rbp; Alternative name is 'mysql_client_find_plugin'
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov edi, [rbp+var_1C]
call get_plugin_nr
mov [rbp+var_2C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call is_not_initialized
cmp eax, 0
jz short loc_45DEA
mov [rbp+var_8], 0
jmp short loc_45E5B
loc_45DEA:
cmp [rbp+var_2C], 0FFFFFFFFh
jnz short loc_45E23
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov r8, [rbp+var_18]
mov esi, 80Bh
lea r9, aInvalidType; "invalid type"
mov al, 0
call my_set_error
loc_45E23:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
call find_plugin
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_45E43
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_45E5B
loc_45E43:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
xor ecx, ecx
mov al, 0
call _mysql_load_plugin@libmariadbclient_18
mov [rbp+var_8], rax
loc_45E5B:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long mysql_client_find_plugin_libmariadbclient_18(long long a1, long long a2, unsigned int a3)
{
int v3; // r8d
int v4; // r9d
int plugin_nr; // [rsp+4h] [rbp-2Ch]
long long plugin; // [rsp+8h] [rbp-28h]
plugin_nr = get_plugin_nr(a3);
if ( (unsigned int)is_not_initialized(a1, a2) )
return 0LL;
if ( plugin_nr == -1 )
my_set_error(a1, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], a2, "invalid type");
plugin = find_plugin(a2, a3);
if ( plugin )
return plugin;
else
return mysql_load_plugin_libmariadbclient_18(a1, a2, a3, 0, v3, v4);
}
|
mysql_client_find_plugin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDI,dword ptr [RBP + -0x1c]
CALL 0x00145e70
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00145800
CMP EAX,0x0
JZ 0x00145dea
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00145e5b
LAB_00145dea:
CMP dword ptr [RBP + -0x2c],-0x1
JNZ 0x00145e23
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x1630a0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x1630b0]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV R8,qword ptr [RBP + -0x18]
MOV ESI,0x80b
LEA R9,[0x153274]
MOV AL,0x0
CALL 0x00120b60
LAB_00145e23:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00145870
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x00145e43
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00145e5b
LAB_00145e43:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
XOR ECX,ECX
MOV AL,0x0
CALL 0x00117a40
MOV qword ptr [RBP + -0x8],RAX
LAB_00145e5b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long mysql_client_find_plugin(int8 param_1,int8 param_2,int4 param_3)
{
int iVar1;
int iVar2;
long local_10;
iVar1 = get_plugin_nr(param_3);
iVar2 = is_not_initialized(param_1,param_2);
if (iVar2 == 0) {
if (iVar1 == -1) {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____00163288,
param_2,"invalid type");
}
local_10 = find_plugin(param_2,param_3);
if (local_10 == 0) {
local_10 = mysql_load_plugin(param_1,param_2,param_3,0);
}
}
else {
local_10 = 0;
}
return local_10;
}
|
|
13,952
|
set_date_field
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue set_date_field(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
// _field(obj, first_field, end_field, args, is_local)
double fields[9];
int res, first_field, end_field, is_local, i, n;
double d, a;
d = NAN;
first_field = (magic >> 8) & 0x0F;
end_field = (magic >> 4) & 0x0F;
is_local = magic & 0x0F;
res = get_date_fields(ctx, this_val, fields, is_local, first_field == 0);
if (res < 0)
return JS_EXCEPTION;
// Argument coercion is observable and must be done unconditionally.
n = min_int(argc, end_field - first_field);
for(i = 0; i < n; i++) {
if (JS_ToFloat64(ctx, &a, argv[i]))
return JS_EXCEPTION;
if (!isfinite(a))
res = FALSE;
fields[first_field + i] = trunc(a);
}
if (!res)
return JS_NAN;
if (argc > 0)
d = set_date_fields(fields, is_local);
return JS_SetThisTimeValue(ctx, this_val, d);
}
|
O0
|
c
|
set_date_field:
subq $0xb8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movq %r8, 0x80(%rsp)
movl %r9d, 0x7c(%rsp)
movsd 0x74de5(%rip), %xmm0 # 0x10c100
movsd %xmm0, 0x10(%rsp)
movl 0x7c(%rsp), %eax
sarl $0x8, %eax
andl $0xf, %eax
movl %eax, 0x28(%rsp)
movl 0x7c(%rsp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, 0x24(%rsp)
movl 0x7c(%rsp), %eax
andl $0xf, %eax
movl %eax, 0x20(%rsp)
movq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rcx
movl 0x20(%rsp), %r8d
cmpl $0x0, 0x28(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %r9d
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x97ab0
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0x973a4
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0x974f6
movl 0x8c(%rsp), %edi
movl 0x24(%rsp), %esi
subl 0x28(%rsp), %esi
callq 0x4fa40
movl %eax, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x9747f
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x8(%rsp), %rsi
callq 0x372c0
cmpl $0x0, %eax
je 0x97420
movl $0x0, 0xa8(%rsp)
movq $0x6, 0xb0(%rsp)
jmp 0x974f6
movsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x97454
movl $0x0, 0x2c(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xe140
movl 0x28(%rsp), %eax
addl 0x1c(%rsp), %eax
cltq
movsd %xmm0, 0x30(%rsp,%rax,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x973c4
cmpl $0x0, 0x2c(%rsp)
jne 0x974a5
movsd 0x74c72(%rip), %xmm0 # 0x10c100
movsd %xmm0, 0xa8(%rsp)
movq $0x7, 0xb0(%rsp)
jmp 0x974f6
cmpl $0x0, 0x8c(%rsp)
jle 0x974c3
leaq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x98160
movsd %xmm0, 0x10(%rsp)
movq 0x90(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x98080
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
movq 0xb0(%rsp), %rdx
addq $0xb8, %rsp
retq
nop
|
set_date_field:
sub rsp, 0B8h
mov [rsp+0B8h+var_20], rsi
mov [rsp+0B8h+var_18], rdx
mov [rsp+0B8h+var_28], rdi
mov [rsp+0B8h+var_2C], ecx
mov [rsp+0B8h+var_38], r8
mov [rsp+0B8h+var_3C], r9d
movsd xmm0, cs:qword_10C100
movsd [rsp+0B8h+var_A8], xmm0
mov eax, [rsp+0B8h+var_3C]
sar eax, 8
and eax, 0Fh
mov [rsp+0B8h+var_90], eax
mov eax, [rsp+0B8h+var_3C]
sar eax, 4
and eax, 0Fh
mov [rsp+0B8h+var_94], eax
mov eax, [rsp+0B8h+var_3C]
and eax, 0Fh
mov [rsp+0B8h+var_98], eax
mov rdi, [rsp+0B8h+var_28]
lea rcx, [rsp+0B8h+var_88]
mov r8d, [rsp+0B8h+var_98]
cmp [rsp+0B8h+var_90], 0
setz al
and al, 1
movzx r9d, al
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
call get_date_fields
mov [rsp+0B8h+var_8C], eax
cmp [rsp+0B8h+var_8C], 0
jge short loc_973A4
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_974F6
loc_973A4:
mov edi, [rsp+0B8h+var_2C]
mov esi, [rsp+0B8h+var_94]
sub esi, [rsp+0B8h+var_90]
call min_int_0
mov [rsp+0B8h+var_A0], eax
mov [rsp+0B8h+var_9C], 0
loc_973C4:
mov eax, [rsp+0B8h+var_9C]
cmp eax, [rsp+0B8h+var_A0]
jge loc_9747F
mov rdi, [rsp+0B8h+var_28]
mov rax, [rsp+0B8h+var_38]
movsxd rcx, [rsp+0B8h+var_9C]
shl rcx, 4
add rax, rcx
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0B8h+var_B0]
call JS_ToFloat64
cmp eax, 0
jz short loc_97420
mov dword ptr [rsp+0B8h+var_10], 0
mov [rsp+0B8h+var_8], 6
jmp loc_974F6
loc_97420:
movsd xmm0, [rsp+0B8h+var_B0]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_97454
mov [rsp+0B8h+var_8C], 0
loc_97454:
movsd xmm0, [rsp+0B8h+var_B0]
call _trunc
mov eax, [rsp+0B8h+var_90]
add eax, [rsp+0B8h+var_9C]
cdqe
movsd [rsp+rax*8+0B8h+var_88], xmm0
mov eax, [rsp+0B8h+var_9C]
add eax, 1
mov [rsp+0B8h+var_9C], eax
jmp loc_973C4
loc_9747F:
cmp [rsp+0B8h+var_8C], 0
jnz short loc_974A5
movsd xmm0, cs:qword_10C100
movsd [rsp+0B8h+var_10], xmm0
mov [rsp+0B8h+var_8], 7
jmp short loc_974F6
loc_974A5:
cmp [rsp+0B8h+var_2C], 0
jle short loc_974C3
lea rdi, [rsp+0B8h+var_88]
mov esi, [rsp+0B8h+var_98]
call set_date_fields
movsd [rsp+0B8h+var_A8], xmm0
loc_974C3:
mov rdi, [rsp+0B8h+var_28]
movsd xmm0, [rsp+0B8h+var_A8]
mov rsi, [rsp+0B8h+var_20]
mov rdx, [rsp+0B8h+var_18]
call JS_SetThisTimeValue
mov [rsp+0B8h+var_10], rax
mov [rsp+0B8h+var_8], rdx
loc_974F6:
mov rax, [rsp+0B8h+var_10]
mov rdx, [rsp+0B8h+var_8]
add rsp, 0B8h
retn
|
long long set_date_field(long long a1, long long a2, long long a3, signed int a4, long long a5, int a6)
{
double v6; // xmm0_8
long long v7; // rdx
double v9; // [rsp+8h] [rbp-B0h] BYREF
double v10; // [rsp+10h] [rbp-A8h]
int v11; // [rsp+18h] [rbp-A0h]
int i; // [rsp+1Ch] [rbp-9Ch]
unsigned int v13; // [rsp+20h] [rbp-98h]
int v14; // [rsp+24h] [rbp-94h]
int v15; // [rsp+28h] [rbp-90h]
int date_fields; // [rsp+2Ch] [rbp-8Ch]
double v17[9]; // [rsp+30h] [rbp-88h] BYREF
int v18; // [rsp+7Ch] [rbp-3Ch]
long long v19; // [rsp+80h] [rbp-38h]
signed int v20; // [rsp+8Ch] [rbp-2Ch]
long long v21; // [rsp+90h] [rbp-28h]
long long v22; // [rsp+98h] [rbp-20h]
long long v23; // [rsp+A0h] [rbp-18h]
long long v24; // [rsp+A8h] [rbp-10h]
long long v25; // [rsp+B0h] [rbp-8h]
v22 = a2;
v23 = a3;
v21 = a1;
v20 = a4;
v19 = a5;
v18 = a6;
v10 = NAN;
v15 = (a6 >> 8) & 0xF;
v14 = (a6 >> 4) & 0xF;
v13 = a6 & 0xF;
date_fields = get_date_fields(a1, a2, a3, v17, a6 & 0xF, v15 == 0);
if ( date_fields >= 0 )
{
v11 = min_int_0(v20, v14 - v15);
for ( i = 0; i < v11; ++i )
{
if ( (unsigned int)JS_ToFloat64(v21, (long long)&v9, *(_DWORD **)(16LL * i + v19), *(_QWORD *)(16LL * i + v19 + 8)) )
{
LODWORD(v24) = 0;
v25 = 6LL;
return v24;
}
if ( (*(_QWORD *)&v9 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
date_fields = 0;
v6 = trunc(v9);
v17[i + v15] = v6;
}
if ( date_fields )
{
if ( v20 > 0 )
v10 = set_date_fields(v17, v13);
v24 = JS_SetThisTimeValue(v21, v22, v23, v10);
v25 = v7;
}
else
{
v24 = 0x7FF8000000000000LL;
v25 = 7LL;
}
}
else
{
LODWORD(v24) = 0;
v25 = 6LL;
}
return v24;
}
|
set_date_field:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0xa0],RDX
MOV qword ptr [RSP + 0x90],RDI
MOV dword ptr [RSP + 0x8c],ECX
MOV qword ptr [RSP + 0x80],R8
MOV dword ptr [RSP + 0x7c],R9D
MOVSD XMM0,qword ptr [0x0020c100]
MOVSD qword ptr [RSP + 0x10],XMM0
MOV EAX,dword ptr [RSP + 0x7c]
SAR EAX,0x8
AND EAX,0xf
MOV dword ptr [RSP + 0x28],EAX
MOV EAX,dword ptr [RSP + 0x7c]
SAR EAX,0x4
AND EAX,0xf
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x7c]
AND EAX,0xf
MOV dword ptr [RSP + 0x20],EAX
MOV RDI,qword ptr [RSP + 0x90]
LEA RCX,[RSP + 0x30]
MOV R8D,dword ptr [RSP + 0x20]
CMP dword ptr [RSP + 0x28],0x0
SETZ AL
AND AL,0x1
MOVZX R9D,AL
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
CALL 0x00197ab0
MOV dword ptr [RSP + 0x2c],EAX
CMP dword ptr [RSP + 0x2c],0x0
JGE 0x001973a4
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001974f6
LAB_001973a4:
MOV EDI,dword ptr [RSP + 0x8c]
MOV ESI,dword ptr [RSP + 0x24]
SUB ESI,dword ptr [RSP + 0x28]
CALL 0x0014fa40
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0x1c],0x0
LAB_001973c4:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x18]
JGE 0x0019747f
MOV RDI,qword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x80]
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x001372c0
CMP EAX,0x0
JZ 0x00197420
MOV dword ptr [RSP + 0xa8],0x0
MOV qword ptr [RSP + 0xb0],0x6
JMP 0x001974f6
LAB_00197420:
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x00197454
MOV dword ptr [RSP + 0x2c],0x0
LAB_00197454:
MOVSD XMM0,qword ptr [RSP + 0x8]
CALL 0x0010e140
MOV EAX,dword ptr [RSP + 0x28]
ADD EAX,dword ptr [RSP + 0x1c]
CDQE
MOVSD qword ptr [RSP + RAX*0x8 + 0x30],XMM0
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001973c4
LAB_0019747f:
CMP dword ptr [RSP + 0x2c],0x0
JNZ 0x001974a5
MOVSD XMM0,qword ptr [0x0020c100]
MOVSD qword ptr [RSP + 0xa8],XMM0
MOV qword ptr [RSP + 0xb0],0x7
JMP 0x001974f6
LAB_001974a5:
CMP dword ptr [RSP + 0x8c],0x0
JLE 0x001974c3
LEA RDI,[RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x20]
CALL 0x00198160
MOVSD qword ptr [RSP + 0x10],XMM0
LAB_001974c3:
MOV RDI,qword ptr [RSP + 0x90]
MOVSD XMM0,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
CALL 0x00198080
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
LAB_001974f6:
MOV RAX,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
ADD RSP,0xb8
RET
|
int1 [16]
set_date_field(int8 param_1,int8 param_2,int8 param_3,int param_4,long param_5,
uint param_6)
{
int iVar1;
int8 *puVar2;
double dVar3;
int1 auVar4 [16];
double local_b0;
int8 local_a8;
int local_a0;
int local_9c;
uint local_98;
uint local_94;
uint local_90;
int local_8c;
double local_88 [9];
uint local_3c;
long local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_a8 = DAT_0020c100;
local_90 = (int)param_6 >> 8 & 0xf;
local_94 = (int)param_6 >> 4 & 0xf;
local_98 = param_6 & 0xf;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_8c = get_date_fields(param_1,param_2,param_3,local_88,local_98,local_90 == 0);
if (local_8c < 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_a0 = min_int(local_2c,local_94 - local_90);
for (local_9c = 0; local_9c < local_a0; local_9c = local_9c + 1) {
puVar2 = (int8 *)(local_38 + (long)local_9c * 0x10);
iVar1 = JS_ToFloat64(local_28,&local_b0,*puVar2,puVar2[1]);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001974f6;
}
if (0x7fefffffffffffff < (ulong)ABS(local_b0)) {
local_8c = 0;
}
dVar3 = trunc(local_b0);
local_88[(int)(local_90 + local_9c)] = dVar3;
}
if (local_8c == 0) {
local_10 = (int4)DAT_0020c100;
uStack_c = (int4)((ulong)DAT_0020c100 >> 0x20);
local_8 = 7;
}
else {
if (0 < local_2c) {
local_a8 = set_date_fields(local_88,local_98);
}
auVar4 = JS_SetThisTimeValue(local_a8,local_28,local_20,local_18);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
}
LAB_001974f6:
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
|
|
13,953
|
set_date_field
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue set_date_field(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
// _field(obj, first_field, end_field, args, is_local)
double fields[9];
int res, first_field, end_field, is_local, i, n;
double d, a;
d = NAN;
first_field = (magic >> 8) & 0x0F;
end_field = (magic >> 4) & 0x0F;
is_local = magic & 0x0F;
res = get_date_fields(ctx, this_val, fields, is_local, first_field == 0);
if (res < 0)
return JS_EXCEPTION;
// Argument coercion is observable and must be done unconditionally.
n = min_int(argc, end_field - first_field);
for(i = 0; i < n; i++) {
if (JS_ToFloat64(ctx, &a, argv[i]))
return JS_EXCEPTION;
if (!isfinite(a))
res = FALSE;
fields[first_field + i] = trunc(a);
}
if (!res)
return JS_NAN;
if (argc > 0)
d = set_date_fields(fields, is_local);
return JS_SetThisTimeValue(ctx, this_val, d);
}
|
O1
|
c
|
set_date_field:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %r12d
movq %r8, %r13
movl %ecx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %rbp
movl %r9d, %ebx
shrl $0x8, %ebx
movl %r9d, %r8d
andl $0xf, %r8d
xorl %r9d, %r9d
andl $0xf, %ebx
sete %r9b
leaq 0x30(%rsp), %rcx
movq %rdi, 0x20(%rsp)
movl %r8d, 0xc(%rsp)
callq 0x55e55
movl $0x6, %edx
testl %eax, %eax
js 0x55b10
movl %eax, %r14d
movq %rbp, 0x10(%rsp)
movq %r15, 0x18(%rsp)
shrl $0x4, %r12d
andl $0xf, %r12d
subl %ebx, %r12d
movl 0x8(%rsp), %eax
cmpl %r12d, %eax
cmovll %eax, %r12d
testl %r12d, %r12d
jle 0x55af4
movl %r12d, %ebp
movl %ebx, %eax
leaq (%rsp,%rax,8), %rbx
addq $0x30, %rbx
shlq $0x3, %rbp
xorl %r12d, %r12d
xorl %r15d, %r15d
movq (%r13,%r15,2), %rdx
movq 0x8(%r13,%r15,2), %rcx
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x26a6d
testl %eax, %eax
jne 0x55b15
movq 0x28(%rsp), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
cmovgel %r12d, %r14d
callq 0xe140
movq %xmm0, (%rbx,%r15)
addq $0x8, %r15
cmpq %r15, %rbp
jne 0x55aa2
testl %r14d, %r14d
je 0x55b1c
cmpl $0x0, 0x8(%rsp)
jle 0x55b2d
leaq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x563b1
jmp 0x55b35
xorl %r12d, %r12d
jmp 0x55b4c
movl $0x6, %edx
jmp 0x55b4c
movl $0x7, %edx
movabsq $0x7ff8000000000000, %r12 # imm = 0x7FF8000000000000
jmp 0x55b4c
movq 0x476ab(%rip), %xmm0 # 0x9d1e0
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x56328
movq %rax, %r12
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
set_date_field:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r12d, r9d
mov r13, r8
mov [rsp+0A8h+var_A0], ecx
mov r15, rdx
mov rbp, rsi
mov ebx, r9d
shr ebx, 8
mov r8d, r9d
and r8d, 0Fh
xor r9d, r9d
and ebx, 0Fh
setz r9b
lea rcx, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_88], rdi
mov [rsp+0A8h+var_9C], r8d
call get_date_fields
mov edx, 6
test eax, eax
js loc_55B10
mov r14d, eax
mov [rsp+0A8h+var_98], rbp
mov [rsp+0A8h+var_90], r15
shr r12d, 4
and r12d, 0Fh
sub r12d, ebx
mov eax, [rsp+0A8h+var_A0]
cmp eax, r12d
cmovl r12d, eax
test r12d, r12d
jle short loc_55AF4
mov ebp, r12d
mov eax, ebx
lea rbx, [rsp+rax*8+0A8h+var_A8]
add rbx, 30h ; '0'
shl rbp, 3
xor r12d, r12d
xor r15d, r15d
loc_55AA2:
mov rdx, [r13+r15*2+0]
mov rcx, [r13+r15*2+8]
mov rdi, [rsp+0A8h+var_88]
lea rsi, [rsp+0A8h+var_80]
call JS_ToFloat64
test eax, eax
jnz short loc_55B15
movq xmm0, [rsp+0A8h+var_80]
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
cmovge r14d, r12d
call _trunc
movq qword ptr [rbx+r15], xmm0
add r15, 8
cmp rbp, r15
jnz short loc_55AA2
loc_55AF4:
test r14d, r14d
jz short loc_55B1C
cmp [rsp+0A8h+var_A0], 0
jle short loc_55B2D
lea rdi, [rsp+0A8h+var_78]
mov esi, [rsp+0A8h+var_9C]
call set_date_fields
jmp short loc_55B35
loc_55B10:
xor r12d, r12d
jmp short loc_55B4C
loc_55B15:
mov edx, 6
jmp short loc_55B4C
loc_55B1C:
mov edx, 7
mov r12, 7FF8000000000000h
jmp short loc_55B4C
loc_55B2D:
movq xmm0, cs:qword_9D1E0
loc_55B35:
mov rdx, [rsp+0A8h+var_90]
mov rsi, [rsp+0A8h+var_98]
mov rdi, [rsp+0A8h+var_88]
call JS_SetThisTimeValue
mov r12, rax
loc_55B4C:
mov rax, r12
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long set_date_field(long long a1, long long a2, long long a3, int a4, long long a5, unsigned int a6, double a7)
{
unsigned __int8 v7; // r12
int v10; // ebx
int date_fields; // eax
int v12; // r14d
int v13; // r12d
_QWORD *v14; // rbx
long long v15; // rbp
long long v16; // r12
unsigned long long v17; // r15
long long v18; // rdx
unsigned int v21; // [rsp+Ch] [rbp-9Ch]
long long v22; // [rsp+18h] [rbp-90h]
long long v23; // [rsp+28h] [rbp-80h] BYREF
_QWORD v24[15]; // [rsp+30h] [rbp-78h] BYREF
v7 = a6;
v10 = (a6 >> 8) & 0xF;
v21 = a6 & 0xF;
date_fields = get_date_fields(a1, a2, a3, v24, a6 & 0xF, v10 == 0);
if ( date_fields < 0 )
return 0LL;
v12 = date_fields;
v22 = a3;
v13 = (v7 >> 4) - v10;
if ( a4 < v13 )
v13 = a4;
if ( v13 <= 0 )
{
LABEL_10:
if ( v12 )
{
if ( a4 <= 0 )
a7 = NAN;
else
set_date_fields(v24, v21);
return JS_SetThisTimeValue(a1, a2, v22, a7);
}
else
{
return 0x7FF8000000000000LL;
}
}
else
{
v14 = &v24[v10];
v15 = 8LL * (unsigned int)v13;
v16 = 0LL;
v17 = 0LL;
while ( !(unsigned int)JS_ToFloat64(a1, (double *)&v23, *(_DWORD **)(a5 + 2 * v17), *(_QWORD *)(a5 + 2 * v17 + 8)) )
{
if ( (v23 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
v12 = 0;
a7 = trunc(a1, &v23, v18);
*(double *)&v14[v17 / 8] = a7;
v17 += 8LL;
if ( v15 == v17 )
goto LABEL_10;
}
}
return v16;
}
|
set_date_field:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R12D,R9D
MOV R13,R8
MOV dword ptr [RSP + 0x8],ECX
MOV R15,RDX
MOV RBP,RSI
MOV EBX,R9D
SHR EBX,0x8
MOV R8D,R9D
AND R8D,0xf
XOR R9D,R9D
AND EBX,0xf
SETZ R9B
LEA RCX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0xc],R8D
CALL 0x00155e55
MOV EDX,0x6
TEST EAX,EAX
JS 0x00155b10
MOV R14D,EAX
MOV qword ptr [RSP + 0x10],RBP
MOV qword ptr [RSP + 0x18],R15
SHR R12D,0x4
AND R12D,0xf
SUB R12D,EBX
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,R12D
CMOVL R12D,EAX
TEST R12D,R12D
JLE 0x00155af4
MOV EBP,R12D
MOV EAX,EBX
LEA RBX,[RSP + RAX*0x8]
ADD RBX,0x30
SHL RBP,0x3
XOR R12D,R12D
XOR R15D,R15D
LAB_00155aa2:
MOV RDX,qword ptr [R13 + R15*0x2]
MOV RCX,qword ptr [R13 + R15*0x2 + 0x8]
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x28]
CALL 0x00126a6d
TEST EAX,EAX
JNZ 0x00155b15
MOVQ XMM0,qword ptr [RSP + 0x28]
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
CMOVGE R14D,R12D
CALL 0x0010e140
MOVQ qword ptr [RBX + R15*0x1],XMM0
ADD R15,0x8
CMP RBP,R15
JNZ 0x00155aa2
LAB_00155af4:
TEST R14D,R14D
JZ 0x00155b1c
CMP dword ptr [RSP + 0x8],0x0
JLE 0x00155b2d
LEA RDI,[RSP + 0x30]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x001563b1
JMP 0x00155b35
LAB_00155b10:
XOR R12D,R12D
JMP 0x00155b4c
LAB_00155b15:
MOV EDX,0x6
JMP 0x00155b4c
LAB_00155b1c:
MOV EDX,0x7
MOV R12,0x7ff8000000000000
JMP 0x00155b4c
LAB_00155b2d:
MOVQ XMM0,qword ptr [0x0019d1e0]
LAB_00155b35:
MOV RDX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00156328
MOV R12,RAX
LAB_00155b4c:
MOV RAX,R12
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
set_date_field(int8 param_1,int8 param_2,int8 param_3,uint param_4,long param_5,
uint param_6)
{
int iVar1;
int iVar2;
uint uVar3;
uint uVar4;
long lVar5;
double dVar6;
int8 uVar7;
double local_80;
double local_78 [9];
uVar3 = param_6 >> 8 & 0xf;
iVar1 = get_date_fields();
if (iVar1 < 0) {
uVar7 = 0;
}
else {
uVar4 = (param_6 >> 4 & 0xf) - uVar3;
if ((int)param_4 < (int)uVar4) {
uVar4 = param_4;
}
if (0 < (int)uVar4) {
lVar5 = 0;
do {
iVar2 = JS_ToFloat64(param_1,&local_80,*(int8 *)(param_5 + lVar5 * 2),
*(int8 *)(param_5 + 8 + lVar5 * 2));
if (iVar2 != 0) {
return 0;
}
if (0x7fefffffffffffff < (ulong)ABS(local_80)) {
iVar1 = 0;
}
dVar6 = trunc(local_80);
*(double *)((long)local_78 + lVar5 + (ulong)uVar3 * 8) = dVar6;
lVar5 = lVar5 + 8;
} while ((ulong)uVar4 << 3 != lVar5);
}
if (iVar1 == 0) {
uVar7 = 0x7ff8000000000000;
}
else {
uVar7 = DAT_0019d1e0;
if (0 < (int)param_4) {
uVar7 = set_date_fields(local_78,param_6 & 0xf);
}
uVar7 = JS_SetThisTimeValue(uVar7,param_1,param_2,param_3);
}
}
return uVar7;
}
|
|
13,954
|
my_wildcmp_bin_impl
|
eloqsql/strings/ctype-bin.c
|
static
int my_wildcmp_bin_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* match if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared through cmp */
cmp=likeconv(cs,cmp);
do
{
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1);
{
int tmp=my_wildcmp_bin_impl(cs,str,str_end,wildstr,wildend,escape,w_one,
w_many, recurse_level + 1);
if (tmp <= 0)
return(tmp);
}
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
}
|
O3
|
c
|
my_wildcmp_bin_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movl 0x18(%rbp), %r10d
leaq 0x33f00e(%rip), %rax # 0x36ea10
movq (%rax), %rax
testq %rax, %rax
je 0x2fa35
movl %r10d, %edi
movq %rsi, %r14
movl %r15d, -0x30(%rbp)
movl %r8d, %r15d
callq *%rax
movl 0x18(%rbp), %r10d
movl %r15d, %r8d
movl -0x30(%rbp), %r15d
movq %r14, %rsi
movl $0x1, %r14d
testl %eax, %eax
jne 0x2fb41
movl 0x10(%rbp), %r11d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r13, %rbx
je 0x2fb37
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %dil
cmpl %r15d, %ecx
sete %dl
orb %dl, %dil
je 0x2faa8
testb %dl, %dl
je 0x2fa9e
incq %rbx
movq %rbx, %rax
cmpq %rsi, %r12
je 0x2fb41
movq %r12, %rcx
movq %rax, %rbx
cmpq %r13, %rax
jae 0x2fa8d
leaq 0x1(%rcx), %r12
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rax
cmpl %r15d, %edx
je 0x2fa69
incq %rcx
cmpq %r13, %rbx
je 0x2fb34
movb (%rbx), %al
movq %rcx, %r12
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x2fa3f
jmp 0x2fafa
movl $0x1, %r14d
cmpq %rsi, %r12
je 0x2fb41
leaq 0x1(%rbx), %rax
cmpq %r13, %rax
cmoveq %rbx, %rax
cmpl %r8d, %ecx
cmoveq %rax, %rbx
movb (%rbx), %al
cmpb (%r12), %al
jne 0x2fb41
incq %r12
incq %rbx
cmpq %r13, %rbx
je 0x2fb37
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r15d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x2fa5f
cmpl %r15d, %ecx
jne 0x2faa8
jmp 0x2fa5f
leaq 0x1(%rbx), %rax
xorl %r14d, %r14d
cmpq %r13, %rax
je 0x2fb41
addq $0x2, %rbx
movb -0x1(%rbx), %cl
movsbl %cl, %eax
cmpl %r11d, %eax
je 0x2fb26
cmpl %r15d, %eax
jne 0x2fb53
cmpq %rsi, %r12
je 0x2fbd9
incq %r12
leaq 0x1(%rbx), %rax
cmpq %r13, %rbx
movq %rax, %rbx
jne 0x2fb0a
jmp 0x2fb41
movq %rcx, %r12
xorl %r14d, %r14d
cmpq %rsi, %r12
setne %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %rsi, %r12
je 0x2fb41
movzbl %cl, %eax
leaq -0x1(%rbx), %rdx
cmpl %r8d, %eax
jne 0x2fb74
cmpq %r13, %rbx
je 0x2fb74
movb (%rbx), %cl
movq %rbx, %rdx
incq %rdx
incl %r10d
cmpq %rsi, %r12
je 0x2fb41
cmpb %cl, (%r12)
je 0x2fb8a
incq %r12
jmp 0x2fb7a
movb %cl, -0x29(%rbp)
incq %r12
movq %r12, %rdi
movq %rdx, -0x38(%rbp)
movq %r13, %rcx
movq %rsi, %rbx
movl %r8d, -0x30(%rbp)
movl %r15d, %r9d
movq %r10, -0x40(%rbp)
pushq %r10
pushq %r11
callq 0x2f9da
addq $0x10, %rsp
testl %eax, %eax
jle 0x2fbe4
cmpq %rbx, %r12
movq %rbx, %rsi
movl -0x30(%rbp), %r8d
movq -0x40(%rbp), %r10
movl 0x10(%rbp), %r11d
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rdx
jne 0x2fb7a
jmp 0x2fb41
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x2fb41
movl %eax, %r14d
jmp 0x2fb41
|
my_wildcmp_bin_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, r9d
mov r13, rcx
mov rbx, rdx
mov r12, rdi
mov r10d, [rbp+arg_8]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_2FA35
mov edi, r10d
mov r14, rsi
mov [rbp+var_30], r15d
mov r15d, r8d
call rax
mov r10d, [rbp+arg_8]
mov r8d, r15d
mov r15d, [rbp+var_30]
mov rsi, r14
mov r14d, 1
test eax, eax
jnz loc_2FB41
loc_2FA35:
mov r11d, [rbp+arg_0]
mov r14d, 0FFFFFFFFh
loc_2FA3F:
cmp rbx, r13
jz loc_2FB37
mov al, [rbx]
movsx ecx, al
cmp ecx, r11d
setz dil
cmp ecx, r15d
setz dl
or dil, dl
jz short loc_2FAA8
loc_2FA5F:
test dl, dl
jz short loc_2FA9E
inc rbx
mov rax, rbx
loc_2FA69:
cmp r12, rsi
jz loc_2FB41
mov rcx, r12
mov rbx, rax
cmp rax, r13
jnb short loc_2FA8D
lea r12, [rcx+1]
movsx edx, byte ptr [rbx]
lea rax, [rbx+1]
cmp edx, r15d
jz short loc_2FA69
loc_2FA8D:
inc rcx
cmp rbx, r13
jz loc_2FB34
mov al, [rbx]
mov r12, rcx
loc_2FA9E:
movsx eax, al
cmp eax, r11d
jnz short loc_2FA3F
jmp short loc_2FAFA
loc_2FAA8:
mov r14d, 1
cmp r12, rsi
jz loc_2FB41
lea rax, [rbx+1]
cmp rax, r13
cmovz rax, rbx
cmp ecx, r8d
cmovz rbx, rax
mov al, [rbx]
cmp al, [r12]
jnz short loc_2FB41
inc r12
inc rbx
cmp rbx, r13
jz short loc_2FB37
mov al, [rbx]
movsx ecx, al
cmp ecx, r15d
setz dl
cmp ecx, r11d
jz loc_2FA5F
cmp ecx, r15d
jnz short loc_2FAA8
jmp loc_2FA5F
loc_2FAFA:
lea rax, [rbx+1]
xor r14d, r14d
cmp rax, r13
jz short loc_2FB41
add rbx, 2
loc_2FB0A:
mov cl, [rbx-1]
movsx eax, cl
cmp eax, r11d
jz short loc_2FB26
cmp eax, r15d
jnz short loc_2FB53
cmp r12, rsi
jz loc_2FBD9
inc r12
loc_2FB26:
lea rax, [rbx+1]
cmp rbx, r13
mov rbx, rax
jnz short loc_2FB0A
jmp short loc_2FB41
loc_2FB34:
mov r12, rcx
loc_2FB37:
xor r14d, r14d
cmp r12, rsi
setnz r14b
loc_2FB41:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2FB53:
mov r14d, 0FFFFFFFFh
cmp r12, rsi
jz short loc_2FB41
movzx eax, cl
lea rdx, [rbx-1]
cmp eax, r8d
jnz short loc_2FB74
cmp rbx, r13
jz short loc_2FB74
mov cl, [rbx]
mov rdx, rbx
loc_2FB74:
inc rdx
inc r10d
loc_2FB7A:
cmp r12, rsi
jz short loc_2FB41
cmp [r12], cl
jz short loc_2FB8A
inc r12
jmp short loc_2FB7A
loc_2FB8A:
mov [rbp+var_29], cl
inc r12
mov rdi, r12
mov [rbp+var_38], rdx
mov rcx, r13
mov rbx, rsi
mov [rbp+var_30], r8d
mov r9d, r15d
mov [rbp+var_40], r10
push r10
push r11
call my_wildcmp_bin_impl
add rsp, 10h
test eax, eax
jle short loc_2FBE4
cmp r12, rbx
mov rsi, rbx
mov r8d, [rbp+var_30]
mov r10, [rbp+var_40]
mov r11d, [rbp+arg_0]
mov cl, [rbp+var_29]
mov rdx, [rbp+var_38]
jnz short loc_2FB7A
jmp loc_2FB41
loc_2FBD9:
mov r14d, 0FFFFFFFFh
jmp loc_2FB41
loc_2FBE4:
mov r14d, eax
jmp loc_2FB41
|
long long my_wildcmp_bin_impl(
_BYTE *a1,
_BYTE *a2,
char *a3,
char *a4,
int a5,
int a6,
int a7,
unsigned int a8)
{
int v8; // r15d
unsigned int v12; // r10d
int v13; // r15d
int v14; // eax
unsigned int v15; // r14d
int v16; // r11d
char v17; // al
int v18; // ecx
bool v19; // dl
char *v20; // rax
_BYTE *v21; // rcx
int v22; // edx
_BYTE *v23; // rcx
char *v24; // rax
char *v25; // rbx
unsigned __int8 v26; // cl
char *v29; // rdx
_BYTE *v30; // rdx
long long v31; // r10
int v32; // eax
long long v33; // [rsp+0h] [rbp-40h]
_BYTE *v34; // [rsp+8h] [rbp-38h]
int v36; // [rsp+10h] [rbp-30h]
unsigned __int8 v37; // [rsp+17h] [rbp-29h]
v8 = a6;
v12 = a8;
if ( my_string_stack_guard )
{
v13 = a5;
v14 = my_string_stack_guard(a8);
v12 = a8;
a5 = v13;
v8 = a6;
v15 = 1;
if ( v14 )
return v15;
}
v16 = a7;
v15 = -1;
do
{
if ( a3 == a4 )
return a1 != a2;
v17 = *a3;
v18 = *a3;
v19 = v18 == v8;
if ( v18 != v8 && v18 != a7 )
{
do
{
v15 = 1;
if ( a1 == a2 )
return v15;
v24 = a3 + 1;
if ( a3 + 1 == a4 )
v24 = a3;
if ( v18 == a5 )
a3 = v24;
if ( *a3 != *a1 )
return v15;
++a1;
if ( ++a3 == a4 )
return a1 != a2;
v17 = *a3;
v18 = *a3;
v19 = v18 == v8;
}
while ( v18 != a7 && v18 != v8 );
}
if ( v19 )
{
v20 = a3 + 1;
do
{
if ( a1 == a2 )
return v15;
v21 = a1;
a3 = v20;
if ( v20 >= a4 )
break;
++a1;
v22 = *v20++;
}
while ( v22 == v8 );
v23 = v21 + 1;
if ( a3 == a4 )
{
a1 = v23;
return a1 != a2;
}
v17 = *a3;
a1 = v23;
}
}
while ( v17 != a7 );
v15 = 0;
if ( a3 + 1 == a4 )
return v15;
v25 = a3 + 2;
while ( 1 )
{
v26 = *(v25 - 1);
if ( (char)v26 == a7 )
goto LABEL_31;
if ( (char)v26 != v8 )
break;
if ( a1 == a2 )
return (unsigned int)-1;
++a1;
LABEL_31:
if ( v25++ == a4 )
return v15;
}
v15 = -1;
if ( a1 != a2 )
{
v29 = v25 - 1;
if ( v26 == a5 && v25 != a4 )
{
v26 = *v25;
v29 = v25;
}
v30 = v29 + 1;
v31 = v12 + 1;
while ( a1 != a2 )
{
if ( *a1 == v26 )
{
v37 = v26;
++a1;
v34 = v30;
v36 = a5;
v33 = v31;
v32 = my_wildcmp_bin_impl((_DWORD)a1, (_DWORD)a2, (_DWORD)v30, (_DWORD)a4, a5, v8, v16, v31);
if ( v32 <= 0 )
return (unsigned int)v32;
a5 = v36;
v31 = v33;
v16 = a7;
v26 = v37;
v30 = v34;
if ( a1 == a2 )
return v15;
}
else
{
++a1;
}
}
}
return v15;
}
|
my_wildcmp_bin_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,R9D
MOV R13,RCX
MOV RBX,RDX
MOV R12,RDI
MOV R10D,dword ptr [RBP + 0x18]
LEA RAX,[0x46ea10]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0012fa35
MOV EDI,R10D
MOV R14,RSI
MOV dword ptr [RBP + -0x30],R15D
MOV R15D,R8D
CALL RAX
MOV R10D,dword ptr [RBP + 0x18]
MOV R8D,R15D
MOV R15D,dword ptr [RBP + -0x30]
MOV RSI,R14
MOV R14D,0x1
TEST EAX,EAX
JNZ 0x0012fb41
LAB_0012fa35:
MOV R11D,dword ptr [RBP + 0x10]
MOV R14D,0xffffffff
LAB_0012fa3f:
CMP RBX,R13
JZ 0x0012fb37
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R11D
SETZ DIL
CMP ECX,R15D
SETZ DL
OR DIL,DL
JZ 0x0012faa8
LAB_0012fa5f:
TEST DL,DL
JZ 0x0012fa9e
INC RBX
MOV RAX,RBX
LAB_0012fa69:
CMP R12,RSI
JZ 0x0012fb41
MOV RCX,R12
MOV RBX,RAX
CMP RAX,R13
JNC 0x0012fa8d
LEA R12,[RCX + 0x1]
MOVSX EDX,byte ptr [RBX]
LEA RAX,[RBX + 0x1]
CMP EDX,R15D
JZ 0x0012fa69
LAB_0012fa8d:
INC RCX
CMP RBX,R13
JZ 0x0012fb34
MOV AL,byte ptr [RBX]
MOV R12,RCX
LAB_0012fa9e:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x0012fa3f
JMP 0x0012fafa
LAB_0012faa8:
MOV R14D,0x1
CMP R12,RSI
JZ 0x0012fb41
LEA RAX,[RBX + 0x1]
CMP RAX,R13
CMOVZ RAX,RBX
CMP ECX,R8D
CMOVZ RBX,RAX
MOV AL,byte ptr [RBX]
CMP AL,byte ptr [R12]
JNZ 0x0012fb41
INC R12
INC RBX
CMP RBX,R13
JZ 0x0012fb37
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R15D
SETZ DL
CMP ECX,R11D
JZ 0x0012fa5f
CMP ECX,R15D
JNZ 0x0012faa8
JMP 0x0012fa5f
LAB_0012fafa:
LEA RAX,[RBX + 0x1]
XOR R14D,R14D
CMP RAX,R13
JZ 0x0012fb41
ADD RBX,0x2
LAB_0012fb0a:
MOV CL,byte ptr [RBX + -0x1]
MOVSX EAX,CL
CMP EAX,R11D
JZ 0x0012fb26
CMP EAX,R15D
JNZ 0x0012fb53
CMP R12,RSI
JZ 0x0012fbd9
INC R12
LAB_0012fb26:
LEA RAX,[RBX + 0x1]
CMP RBX,R13
MOV RBX,RAX
JNZ 0x0012fb0a
JMP 0x0012fb41
LAB_0012fb34:
MOV R12,RCX
LAB_0012fb37:
XOR R14D,R14D
CMP R12,RSI
SETNZ R14B
LAB_0012fb41:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012fb53:
MOV R14D,0xffffffff
CMP R12,RSI
JZ 0x0012fb41
MOVZX EAX,CL
LEA RDX,[RBX + -0x1]
CMP EAX,R8D
JNZ 0x0012fb74
CMP RBX,R13
JZ 0x0012fb74
MOV CL,byte ptr [RBX]
MOV RDX,RBX
LAB_0012fb74:
INC RDX
INC R10D
LAB_0012fb7a:
CMP R12,RSI
JZ 0x0012fb41
CMP byte ptr [R12],CL
JZ 0x0012fb8a
INC R12
JMP 0x0012fb7a
LAB_0012fb8a:
MOV byte ptr [RBP + -0x29],CL
INC R12
MOV RDI,R12
MOV qword ptr [RBP + -0x38],RDX
MOV RCX,R13
MOV RBX,RSI
MOV dword ptr [RBP + -0x30],R8D
MOV R9D,R15D
MOV qword ptr [RBP + -0x40],R10
PUSH R10
PUSH R11
CALL 0x0012f9da
ADD RSP,0x10
TEST EAX,EAX
JLE 0x0012fbe4
CMP R12,RBX
MOV RSI,RBX
MOV R8D,dword ptr [RBP + -0x30]
MOV R10,qword ptr [RBP + -0x40]
MOV R11D,dword ptr [RBP + 0x10]
MOV CL,byte ptr [RBP + -0x29]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0012fb7a
JMP 0x0012fb41
LAB_0012fbd9:
MOV R14D,0xffffffff
JMP 0x0012fb41
LAB_0012fbe4:
MOV R14D,EAX
JMP 0x0012fb41
|
uint my_wildcmp_bin_impl(byte *param_1,byte *param_2,byte *param_3,byte *param_4,ulong param_5,
uint param_6,uint param_7,int param_8)
{
byte bVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
uint uVar5;
byte *pbVar6;
ulong uVar7;
bool bVar8;
if (my_string_stack_guard != (code *)0x0) {
param_5 = param_5 & 0xffffffff;
iVar2 = (*my_string_stack_guard)(param_8);
if (iVar2 != 0) {
return 1;
}
}
uVar3 = 0xffffffff;
while (param_3 != param_4) {
bVar1 = *param_3;
uVar5 = (uint)(char)bVar1;
bVar8 = uVar5 == param_6;
if (uVar5 != param_7 && !bVar8) {
do {
uVar3 = 1;
if (param_1 == param_2) {
return 1;
}
pbVar4 = param_3 + 1;
if (param_3 + 1 == param_4) {
pbVar4 = param_3;
}
if (uVar5 == (uint)param_5) {
param_3 = pbVar4;
}
if (*param_3 != *param_1) {
return 1;
}
param_1 = param_1 + 1;
param_3 = param_3 + 1;
if (param_3 == param_4) goto LAB_0012fb37;
bVar1 = *param_3;
uVar5 = (uint)(char)bVar1;
bVar8 = uVar5 == param_6;
} while ((uVar5 != param_7) && (uVar5 != param_6));
}
if (bVar8) {
do {
pbVar4 = param_1;
param_3 = param_3 + 1;
if (pbVar4 == param_2) {
return uVar3;
}
} while ((param_3 < param_4) && (param_1 = pbVar4 + 1, (int)(char)*param_3 == param_6));
param_1 = pbVar4 + 1;
if (param_3 == param_4) break;
bVar1 = *param_3;
}
if ((int)(char)bVar1 == param_7) {
if (param_3 + 1 != param_4) {
pbVar4 = param_3 + 2;
do {
bVar1 = pbVar4[-1];
if ((int)(char)bVar1 != param_7) {
if ((int)(char)bVar1 != param_6) {
if (param_1 == param_2) {
return 0xffffffff;
}
pbVar6 = pbVar4 + -1;
if (((uint)bVar1 == (uint)param_5) && (pbVar4 != param_4)) {
bVar1 = *pbVar4;
pbVar6 = pbVar4;
}
pbVar6 = pbVar6 + 1;
uVar7 = (ulong)(param_8 + 1);
while( true ) {
while( true ) {
if (param_1 == param_2) {
return 0xffffffff;
}
if (*param_1 == bVar1) break;
param_1 = param_1 + 1;
}
param_1 = param_1 + 1;
uVar5 = (uint)param_5;
uVar3 = my_wildcmp_bin_impl(param_1,param_2,pbVar6,param_4,param_5,param_6,param_7,
uVar7,uVar7,pbVar6,uVar5);
if ((int)uVar3 < 1) break;
param_5 = (ulong)uVar5;
if (param_1 == param_2) {
return 0xffffffff;
}
}
return uVar3;
}
if (param_1 == param_2) {
return 0xffffffff;
}
param_1 = param_1 + 1;
}
bVar8 = pbVar4 != param_4;
pbVar4 = pbVar4 + 1;
} while (bVar8);
}
return 0;
}
}
LAB_0012fb37:
return (uint)(param_1 != param_2);
}
|
|
13,955
|
ftxui::animation::easing::BounceOut(float)
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/animation.cpp
|
float BounceOut(float p) {
if (p < 4.f / 11.f) {
return (121.f * p * p) / 16.f;
}
if (p < 8.f / 11.f) {
return (363.f / 40.f * p * p) - (99.f / 10.f * p) + 17.f / 5.f;
}
if (p < 9.f / 10.f) {
return (4356.f / 361.f * p * p) - (35442.f / 1805.f * p) + 16061.f / 1805.f;
}
return (54.f / 5.f * p * p) - (513 / 25.f * p) + 268 / 25.f;
}
|
O0
|
cpp
|
ftxui::animation::easing::BounceOut(float):
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss 0x15d2b(%rip), %xmm0 # 0x9379c
ucomiss -0x8(%rbp), %xmm0
jbe 0x7da9f
movss 0x15d4d(%rip), %xmm0 # 0x937cc
mulss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss 0x15cdb(%rip), %xmm1 # 0x9376c
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x7db91
movss 0x15cf9(%rip), %xmm0 # 0x937a0
ucomiss -0x8(%rbp), %xmm0
jbe 0x7daf7
movss 0x15d13(%rip), %xmm0 # 0x937c8
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
movss 0x15cfd(%rip), %xmm1 # 0x937c4
mulss -0x8(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x15cd7(%rip), %xmm1 # 0x937c0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x7db91
movss 0x15ca5(%rip), %xmm0 # 0x937a4
ucomiss -0x8(%rbp), %xmm0
jbe 0x7db4c
movss 0x15caf(%rip), %xmm0 # 0x937bc
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
movss 0x15c99(%rip), %xmm1 # 0x937b8
mulss -0x8(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x15c73(%rip), %xmm1 # 0x937b4
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x7db91
movss 0x15c5c(%rip), %xmm0 # 0x937b0
mulss -0x8(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
movss 0x15c46(%rip), %xmm1 # 0x937ac
mulss -0x8(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x15c20(%rip), %xmm1 # 0x937a8
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN5ftxui9animation6easing9BounceOutEf:
push rbp
mov rbp, rsp
movss [rbp+var_8], xmm0
movss xmm0, cs:dword_9379C
ucomiss xmm0, [rbp+var_8]
jbe short loc_7DA9F
movss xmm0, cs:dword_937CC
mulss xmm0, [rbp+var_8]
mulss xmm0, [rbp+var_8]
movss xmm1, cs:dword_9376C
divss xmm0, xmm1
movss [rbp+var_4], xmm0
jmp loc_7DB91
loc_7DA9F:
movss xmm0, cs:dword_937A0
ucomiss xmm0, [rbp+var_8]
jbe short loc_7DAF7
movss xmm0, cs:dword_937C8
mulss xmm0, [rbp+var_8]
movss xmm2, [rbp+var_8]
movss xmm1, cs:dword_937C4
mulss xmm1, [rbp+var_8]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, cs:dword_937C0
addss xmm0, xmm1
movss [rbp+var_4], xmm0
jmp loc_7DB91
loc_7DAF7:
movss xmm0, cs:dword_937A4
ucomiss xmm0, [rbp+var_8]
jbe short loc_7DB4C
movss xmm0, cs:dword_937BC
mulss xmm0, [rbp+var_8]
movss xmm2, [rbp+var_8]
movss xmm1, cs:dword_937B8
mulss xmm1, [rbp+var_8]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, cs:dword_937B4
addss xmm0, xmm1
movss [rbp+var_4], xmm0
jmp short loc_7DB91
loc_7DB4C:
movss xmm0, cs:dword_937B0
mulss xmm0, [rbp+var_8]
movss xmm2, [rbp+var_8]
movss xmm1, cs:dword_937AC
mulss xmm1, [rbp+var_8]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss xmm1, cs:dword_937A8
addss xmm0, xmm1
movss [rbp+var_4], xmm0
loc_7DB91:
movss xmm0, [rbp+var_4]
pop rbp
retn
|
float ftxui::animation::easing::BounceOut(ftxui::animation::easing *this, float a2)
{
__m128i v2; // xmm1
__m128i v3; // xmm1
__m128i v4; // xmm1
if ( a2 < 0.36363637 )
return (float)((float)(121.0 * a2) * a2) / 16.0;
if ( a2 >= 0.72727275 )
{
if ( a2 >= 0.89999998 )
{
v4 = (__m128i)0x41A428F6u;
*(float *)v4.m128i_i32 = 20.52 * a2;
return (float)((float)((float)(10.8 * a2) * a2) + COERCE_FLOAT(_mm_cvtsi128_si32(v4) ^ 0x80000000)) + 10.72;
}
else
{
v3 = (__m128i)0x419D156Bu;
*(float *)v3.m128i_i32 = 19.635458 * a2;
return (float)((float)((float)(12.066482 * a2) * a2) + COERCE_FLOAT(_mm_cvtsi128_si32(v3) ^ 0x80000000))
+ 8.8980608;
}
}
else
{
v2 = (__m128i)0x411E6666u;
*(float *)v2.m128i_i32 = 9.8999996 * a2;
return (float)((float)((float)(9.0749998 * a2) * a2) + COERCE_FLOAT(_mm_cvtsi128_si32(v2) ^ 0x80000000)) + 3.4000001;
}
}
|
BounceOut:
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x8],XMM0
MOVSS XMM0,dword ptr [0x0019379c]
UCOMISS XMM0,dword ptr [RBP + -0x8]
JBE 0x0017da9f
MOVSS XMM0,dword ptr [0x001937cc]
MULSS XMM0,dword ptr [RBP + -0x8]
MULSS XMM0,dword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [0x0019376c]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x0017db91
LAB_0017da9f:
MOVSS XMM0,dword ptr [0x001937a0]
UCOMISS XMM0,dword ptr [RBP + -0x8]
JBE 0x0017daf7
MOVSS XMM0,dword ptr [0x001937c8]
MULSS XMM0,dword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [0x001937c4]
MULSS XMM1,dword ptr [RBP + -0x8]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001937c0]
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x0017db91
LAB_0017daf7:
MOVSS XMM0,dword ptr [0x001937a4]
UCOMISS XMM0,dword ptr [RBP + -0x8]
JBE 0x0017db4c
MOVSS XMM0,dword ptr [0x001937bc]
MULSS XMM0,dword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [0x001937b8]
MULSS XMM1,dword ptr [RBP + -0x8]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001937b4]
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x0017db91
LAB_0017db4c:
MOVSS XMM0,dword ptr [0x001937b0]
MULSS XMM0,dword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [0x001937ac]
MULSS XMM1,dword ptr [RBP + -0x8]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001937a8]
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_0017db91:
MOVSS XMM0,dword ptr [RBP + -0x4]
POP RBP
RET
|
/* ftxui::animation::easing::BounceOut(float) */
float ftxui::animation::easing::BounceOut(float param_1)
{
int4 local_c;
if (DAT_0019379c <= param_1) {
if (DAT_001937a0 <= param_1) {
if (DAT_001937a4 <= param_1) {
local_c = DAT_001937b0 * param_1 * param_1 + -(DAT_001937ac * param_1) + DAT_001937a8;
}
else {
local_c = DAT_001937bc * param_1 * param_1 + -(DAT_001937b8 * param_1) + DAT_001937b4;
}
}
else {
local_c = DAT_001937c8 * param_1 * param_1 + -(DAT_001937c4 * param_1) + DAT_001937c0;
}
}
else {
local_c = (DAT_001937cc * param_1 * param_1) / DAT_0019376c;
}
return local_c;
}
|
|
13,956
|
JS_ToInt64Clamp
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_ToInt64Clamp(JSContext *ctx, int64_t *pres, JSValue val,
int64_t min, int64_t max, int64_t neg_offset)
{
int res = JS_ToInt64SatFree(ctx, pres, js_dup(val));
if (res == 0) {
if (*pres < 0)
*pres += neg_offset;
if (*pres < min)
*pres = min;
else if (*pres > max)
*pres = max;
}
return res;
}
|
O1
|
c
|
JS_ToInt64Clamp:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %r15
movq %r8, %rbx
movq %rsi, %r14
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x2787b
movq 0x8(%rsp), %rax
incl (%rax)
movq %r14, %rsi
callq 0x277bc
testl %eax, %eax
jne 0x278aa
movq (%r14), %rcx
testq %rcx, %rcx
jns 0x27897
addq 0x30(%rsp), %rcx
movq %rcx, (%r14)
movq (%r14), %rcx
cmpq %rbx, %rcx
jl 0x278a7
movq %r15, %rbx
cmpq %r15, %rcx
jle 0x278aa
movq %rbx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
JS_ToInt64Clamp:
push r15
push r14
push rbx
sub rsp, 10h
mov r15, r9
mov rbx, r8
mov r14, rsi
mov [rsp+28h+var_20], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_2787B
mov rax, [rsp+28h+var_20]
inc dword ptr [rax]
loc_2787B:
mov rsi, r14
call JS_ToInt64SatFree
test eax, eax
jnz short loc_278AA
mov rcx, [r14]
test rcx, rcx
jns short loc_27897
add rcx, [rsp+28h+arg_0]
mov [r14], rcx
loc_27897:
mov rcx, [r14]
cmp rcx, rbx
jl short loc_278A7
mov rbx, r15
cmp rcx, r15
jle short loc_278AA
loc_278A7:
mov [r14], rbx
loc_278AA:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
long long JS_ToInt64Clamp(
long long a1,
unsigned long long *a2,
_DWORD *a3,
long long a4,
signed long long a5,
signed long long a6,
long long a7)
{
long long result; // rax
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
result = JS_ToInt64SatFree(a1, a2, (long long)a3, a4);
if ( !(_DWORD)result )
{
if ( (*a2 & 0x8000000000000000LL) != 0LL )
*a2 += a7;
if ( (long long)*a2 < a5 || (a5 = a6, (long long)*a2 > a6) )
*a2 = a5;
}
return result;
}
|
JS_ToInt64Clamp:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R15,R9
MOV RBX,R8
MOV R14,RSI
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x0012787b
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0012787b:
MOV RSI,R14
CALL 0x001277bc
TEST EAX,EAX
JNZ 0x001278aa
MOV RCX,qword ptr [R14]
TEST RCX,RCX
JNS 0x00127897
ADD RCX,qword ptr [RSP + 0x30]
MOV qword ptr [R14],RCX
LAB_00127897:
MOV RCX,qword ptr [R14]
CMP RCX,RBX
JL 0x001278a7
MOV RBX,R15
CMP RCX,R15
JLE 0x001278aa
LAB_001278a7:
MOV qword ptr [R14],RBX
LAB_001278aa:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
void JS_ToInt64Clamp(int8 param_1,long *param_2,int *param_3,uint param_4,long param_5,
long param_6,long param_7)
{
int iVar1;
if (0xfffffff6 < param_4) {
*param_3 = *param_3 + 1;
}
iVar1 = JS_ToInt64SatFree(param_1,param_2);
if (iVar1 == 0) {
if (*param_2 < 0) {
*param_2 = *param_2 + param_7;
}
if ((*param_2 < param_5) || (param_5 = param_6, param_6 < *param_2)) {
*param_2 = param_5;
}
}
return;
}
|
|
13,957
|
JS_ToInt64Clamp
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_ToInt64Clamp(JSContext *ctx, int64_t *pres, JSValue val,
int64_t min, int64_t max, int64_t neg_offset)
{
int res = JS_ToInt64SatFree(ctx, pres, js_dup(val));
if (res == 0) {
if (*pres < 0)
*pres += neg_offset;
if (*pres < min)
*pres = min;
else if (*pres > max)
*pres = max;
}
return res;
}
|
O2
|
c
|
JS_ToInt64Clamp:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %r15
movq %r8, %rbx
movq %rsi, %r14
cmpl $-0x9, %ecx
jb 0x214cc
incl (%rdx)
movq %r14, %rsi
callq 0x2141f
testl %eax, %eax
jne 0x214f8
movq (%r14), %rcx
testq %rcx, %rcx
jns 0x214e8
addq 0x20(%rsp), %rcx
movq %rcx, (%r14)
cmpq %rbx, %rcx
jl 0x214f5
movq %r15, %rbx
cmpq %r15, %rcx
jle 0x214f8
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
|
JS_ToInt64Clamp:
push r15
push r14
push rbx
mov r15, r9
mov rbx, r8
mov r14, rsi
cmp ecx, 0FFFFFFF7h
jb short loc_214CC
inc dword ptr [rdx]
loc_214CC:
mov rsi, r14
call JS_ToInt64SatFree
test eax, eax
jnz short loc_214F8
mov rcx, [r14]
test rcx, rcx
jns short loc_214E8
add rcx, [rsp+18h+arg_0]
mov [r14], rcx
loc_214E8:
cmp rcx, rbx
jl short loc_214F5
mov rbx, r15
cmp rcx, r15
jle short loc_214F8
loc_214F5:
mov [r14], rbx
loc_214F8:
pop rbx
pop r14
pop r15
retn
|
long long JS_ToInt64Clamp(
long long a1,
unsigned long long *a2,
_DWORD *a3,
long long a4,
signed long long a5,
signed long long a6,
long long a7)
{
long long result; // rax
signed long long v10; // rcx
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
result = JS_ToInt64SatFree(a1, a2, (long long)a3, a4);
if ( !(_DWORD)result )
{
v10 = *a2;
if ( (*a2 & 0x8000000000000000LL) != 0LL )
{
v10 += a7;
*a2 = v10;
}
if ( v10 < a5 || (a5 = a6, v10 > a6) )
*a2 = a5;
}
return result;
}
|
JS_ToInt64Clamp:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,R9
MOV RBX,R8
MOV R14,RSI
CMP ECX,-0x9
JC 0x001214cc
INC dword ptr [RDX]
LAB_001214cc:
MOV RSI,R14
CALL 0x0012141f
TEST EAX,EAX
JNZ 0x001214f8
MOV RCX,qword ptr [R14]
TEST RCX,RCX
JNS 0x001214e8
ADD RCX,qword ptr [RSP + 0x20]
MOV qword ptr [R14],RCX
LAB_001214e8:
CMP RCX,RBX
JL 0x001214f5
MOV RBX,R15
CMP RCX,R15
JLE 0x001214f8
LAB_001214f5:
MOV qword ptr [R14],RBX
LAB_001214f8:
POP RBX
POP R14
POP R15
RET
|
void JS_ToInt64Clamp(int8 param_1,long *param_2,int *param_3,uint param_4,long param_5,
long param_6,long param_7)
{
int iVar1;
long lVar2;
if (0xfffffff6 < param_4) {
*param_3 = *param_3 + 1;
}
iVar1 = JS_ToInt64SatFree(param_1,param_2);
if (iVar1 == 0) {
lVar2 = *param_2;
if (lVar2 < 0) {
lVar2 = lVar2 + param_7;
*param_2 = lVar2;
}
if ((lVar2 < param_5) || (param_5 = param_6, param_6 < lVar2)) {
*param_2 = param_5;
}
}
return;
}
|
|
13,958
|
my_wc_mb_big5
|
eloqsql/strings/ctype-big5.c
|
static int
my_wc_mb_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((int) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_big5_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
}
|
O0
|
c
|
my_wc_mb_big5:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x426fb
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x42774
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x4271b
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x42774
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x42a70
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x42737
movl $0x0, -0x4(%rbp)
jmp 0x42774
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x4274e
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x42774
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
my_wc_mb_big5:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_426FB
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_42774
loc_426FB:
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_4271B
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_42774
loc_4271B:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_big5_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_42737
mov [rbp+var_4], 0
jmp short loc_42774
loc_42737:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_4274E
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_42774
loc_4274E:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_42774:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long my_wc_mb_big5(long long a1, int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 128 )
{
v5 = func_uni_big5_onechar((unsigned int)a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_big5:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001426fb
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00142774
LAB_001426fb:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x0014271b
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00142774
LAB_0014271b:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x00142a70
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00142737
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00142774
LAB_00142737:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0014274e
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00142774
LAB_0014274e:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_00142774:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_big5(int8 param_1,int param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_big5_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9b;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
13,959
|
my_hash_reset
|
eloqsql/mysys/hash.c
|
void my_hash_reset(HASH *hash)
{
DBUG_ENTER("my_hash_reset");
DBUG_PRINT("enter",("hash:%p", hash));
my_hash_free_elements(hash);
reset_dynamic(&hash->array);
/* Set row pointers so that the hash can be reused at once */
hash->blength= 1;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_hash_reset:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2c2de
movq -0x8(%rbp), %rdi
callq 0x2c240
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x10(%rax)
jmp 0x2c300
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_reset:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_2C2DE:
mov rdi, [rbp+var_8]
call my_hash_free_elements
mov rax, [rbp+var_8]
mov dword ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 1
jmp short $+2
loc_2C300:
add rsp, 10h
pop rbp
retn
|
unsigned long long my_hash_reset(unsigned long long a1)
{
unsigned long long result; // rax
my_hash_free_elements(a1);
*(_DWORD *)(a1 + 48) = 0;
result = a1;
*(_QWORD *)(a1 + 16) = 1LL;
return result;
}
|
my_hash_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0012c2de
LAB_0012c2de:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012c240
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x1
JMP 0x0012c300
LAB_0012c300:
ADD RSP,0x10
POP RBP
RET
|
void my_hash_reset(long param_1)
{
my_hash_free_elements(param_1);
*(int4 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x10) = 1;
return;
}
|
|
13,960
|
my_hash_reset
|
eloqsql/mysys/hash.c
|
void my_hash_reset(HASH *hash)
{
DBUG_ENTER("my_hash_reset");
DBUG_PRINT("enter",("hash:%p", hash));
my_hash_free_elements(hash);
reset_dynamic(&hash->array);
/* Set row pointers so that the hash can be reused at once */
hash->blength= 1;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
my_hash_reset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r14d
testq %r14, %r14
je 0x29860
movq $0x0, 0x18(%rbx)
cmpq $0x0, 0x60(%rbx)
je 0x29860
movq 0x28(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq 0x8(%r15), %rdi
addq $0x10, %r15
callq *0x60(%rbx)
cmpq %r14, %r15
jb 0x29850
movl $0x0, 0x30(%rbx)
movq $0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_reset:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, [rdi+18h]
test r14, r14
jz short loc_29860
mov qword ptr [rbx+18h], 0
cmp qword ptr [rbx+60h], 0
jz short loc_29860
mov r15, [rbx+28h]
shl r14, 4
add r14, r15
loc_29850:
mov rdi, [r15+8]
add r15, 10h
call qword ptr [rbx+60h]
cmp r15, r14
jb short loc_29850
loc_29860:
mov dword ptr [rbx+30h], 0
mov qword ptr [rbx+10h], 1
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_hash_reset(long long a1)
{
long long v2; // r14
unsigned long long v3; // r15
unsigned long long v4; // r14
long long v5; // rdi
long long result; // rax
v2 = *(unsigned int *)(a1 + 24);
if ( *(_DWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 24) = 0LL;
if ( *(_QWORD *)(a1 + 96) )
{
v3 = *(_QWORD *)(a1 + 40);
v4 = v3 + 16 * v2;
do
{
v5 = *(_QWORD *)(v3 + 8);
v3 += 16LL;
result = (*(long long ( **)(long long))(a1 + 96))(v5);
}
while ( v3 < v4 );
}
}
*(_DWORD *)(a1 + 48) = 0;
*(_QWORD *)(a1 + 16) = 1LL;
return result;
}
|
my_hash_reset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x18]
TEST R14,R14
JZ 0x00129860
MOV qword ptr [RBX + 0x18],0x0
CMP qword ptr [RBX + 0x60],0x0
JZ 0x00129860
MOV R15,qword ptr [RBX + 0x28]
SHL R14,0x4
ADD R14,R15
LAB_00129850:
MOV RDI,qword ptr [R15 + 0x8]
ADD R15,0x10
CALL qword ptr [RBX + 0x60]
CMP R15,R14
JC 0x00129850
LAB_00129860:
MOV dword ptr [RBX + 0x30],0x0
MOV qword ptr [RBX + 0x10],0x1
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_reset(long param_1)
{
int8 *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
uVar2 = *(uint *)(param_1 + 0x18);
if (((ulong)uVar2 != 0) && (*(int8 *)(param_1 + 0x18) = 0, *(long *)(param_1 + 0x60) != 0))
{
uVar4 = *(ulong *)(param_1 + 0x28);
uVar3 = (ulong)uVar2 * 0x10 + uVar4;
do {
puVar1 = (int8 *)(uVar4 + 8);
uVar4 = uVar4 + 0x10;
(**(code **)(param_1 + 0x60))(*puVar1);
} while (uVar4 < uVar3);
}
*(int4 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x10) = 1;
return;
}
|
|
13,961
|
ma_kpos
|
eloqsql/storage/maria/ma_search.c
|
my_off_t _ma_kpos(uint nod_flag, const uchar *after_key)
{
after_key-=nod_flag;
switch (nod_flag) {
#if SIZEOF_OFF_T > 4
case 7:
return mi_uint7korr(after_key)*maria_block_size;
case 6:
return mi_uint6korr(after_key)*maria_block_size;
case 5:
return mi_uint5korr(after_key)*maria_block_size;
#else
case 7:
after_key++;
case 6:
after_key++;
case 5:
after_key++;
#endif
case 4:
return ((my_off_t) mi_uint4korr(after_key))*maria_block_size;
case 3:
return ((my_off_t) mi_uint3korr(after_key))*maria_block_size;
case 2:
return (my_off_t) (mi_uint2korr(after_key)*maria_block_size);
case 1:
return (uint) (*after_key)*maria_block_size;
case 0: /* At leaf page */
default: /* Impossible */
return(HA_OFFSET_ERROR);
}
}
|
O0
|
c
|
ma_kpos:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x9516d
movq -0x20(%rbp), %rax
leaq 0xcacf9(%rip), %rcx # 0x15fd44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x95180
leaq 0x22f4cc(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rdi
callq 0x951e0
leaq 0x22f4af(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rdi
callq 0x95230
leaq 0x22f492(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, %eax
leaq 0x22f44e(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
leaq 0x22f417(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
leaq 0x22f3e9(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %eax
leaq 0x22f3cf(%rip), %rcx # 0x2c4530
imulq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x95175
jmp 0x9516d
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
|
_ma_kpos:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov eax, [rbp+var_C]
mov ecx, eax
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
mov [rbp+var_20], rax
sub rax, 7; switch 8 cases
ja def_95052; jumptable 0000000000095052 default case
mov rax, [rbp+var_20]
lea rcx, jpt_95052
movsxd rax, ds:(jpt_95052 - 15FD44h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_95054:
mov rdi, [rbp+var_18]; jumptable 0000000000095052 case 7
call mi_uint7korr
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp loc_95175
loc_95071:
mov rdi, [rbp+var_18]; jumptable 0000000000095052 case 6
call mi_uint6korr
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp loc_95175
loc_9508E:
mov rdi, [rbp+var_18]; jumptable 0000000000095052 case 5
call mi_uint5korr
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp loc_95175
loc_950AB:
mov rax, [rbp+var_18]; jumptable 0000000000095052 case 4
movzx eax, byte ptr [rax+3]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 10h
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
shl ecx, 18h
or eax, ecx
mov eax, eax
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp loc_95175
loc_950EF:
mov rax, [rbp+var_18]; jumptable 0000000000095052 case 3
movzx eax, byte ptr [rax+2]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
shl ecx, 10h
or eax, ecx
mov eax, eax
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp short loc_95175
loc_95123:
mov rax, [rbp+var_18]; jumptable 0000000000095052 case 2
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp short loc_95175
loc_95151:
mov rax, [rbp+var_18]; jumptable 0000000000095052 case 1
movzx eax, byte ptr [rax]
mov eax, eax
lea rcx, maria_block_size
imul rax, [rcx]
mov [rbp+var_8], rax
jmp short loc_95175
loc_9516B:
jmp short $+2; jumptable 0000000000095052 case 0
def_95052:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh; jumptable 0000000000095052 default case
loc_95175:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long ma_kpos(unsigned int a1, long long a2)
{
unsigned __int8 *v3; // [rsp+8h] [rbp-18h]
long long v4; // [rsp+18h] [rbp-8h]
v3 = (unsigned __int8 *)(a2 - a1);
switch ( a1 )
{
case 1u:
v4 = *(_QWORD *)&maria_block_size * *v3;
break;
case 2u:
v4 = *(_QWORD *)&maria_block_size * _byteswap_ushort(*(_WORD *)v3);
break;
case 3u:
v4 = *(_QWORD *)&maria_block_size * ((*v3 << 16) | (v3[1] << 8) | (unsigned int)v3[2]);
break;
case 4u:
v4 = *(_QWORD *)&maria_block_size * _byteswap_ulong(*(_DWORD *)v3);
break;
case 5u:
v4 = *(_QWORD *)&maria_block_size * mi_uint5korr(v3);
break;
case 6u:
v4 = *(_QWORD *)&maria_block_size * mi_uint6korr(v3);
break;
case 7u:
v4 = *(_QWORD *)&maria_block_size * mi_uint7korr(v3);
break;
default:
v4 = -1LL;
break;
}
return v4;
}
|
_ma_kpos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x20],RAX
SUB RAX,0x7
JA 0x0019516d
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x25fd44]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00195180
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_6:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001951e0
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_5:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00195230
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x10
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
SHL ECX,0x18
OR EAX,ECX
MOV EAX,EAX
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV EAX,EAX
LEA RCX,[0x3c4530]
IMUL RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00195175
caseD_0:
JMP 0x0019516d
default:
MOV qword ptr [RBP + -0x8],-0x1
LAB_00195175:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long _ma_kpos(uint param_1,long param_2)
{
byte *pbVar1;
long local_10;
pbVar1 = (byte *)(param_2 - (ulong)param_1);
switch(param_1) {
case 0:
default:
local_10 = -1;
break;
case 1:
local_10 = (ulong)*pbVar1 * maria_block_size;
break;
case 2:
local_10 = (ulong)CONCAT11(*pbVar1,pbVar1[1]) * maria_block_size;
break;
case 3:
local_10 = (ulong)CONCAT12(*pbVar1,CONCAT11(pbVar1[1],pbVar1[2])) * maria_block_size;
break;
case 4:
local_10 = (ulong)CONCAT13(*pbVar1,CONCAT12(pbVar1[1],CONCAT11(pbVar1[2],pbVar1[3]))) *
maria_block_size;
break;
case 5:
local_10 = mi_uint5korr(pbVar1);
local_10 = local_10 * maria_block_size;
break;
case 6:
local_10 = mi_uint6korr(pbVar1);
local_10 = local_10 * maria_block_size;
break;
case 7:
local_10 = mi_uint7korr(pbVar1);
local_10 = local_10 * maria_block_size;
}
return local_10;
}
|
|
13,962
|
js_date_Symbol_toPrimitive
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// Symbol_toPrimitive(hint)
JSValue obj = this_val;
JSAtom hint = JS_ATOM_NULL;
int hint_num;
if (!JS_IsObject(obj))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (JS_IsString(argv[0])) {
hint = JS_ValueToAtom(ctx, argv[0]);
if (hint == JS_ATOM_NULL)
return JS_EXCEPTION;
JS_FreeAtom(ctx, hint);
}
switch (hint) {
case JS_ATOM_number:
case JS_ATOM_integer:
hint_num = HINT_NUMBER;
break;
case JS_ATOM_string:
case JS_ATOM_default:
hint_num = HINT_STRING;
break;
default:
return JS_ThrowTypeError(ctx, "invalid hint");
}
return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
}
|
O2
|
c
|
js_date_Symbol_toPrimitive:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x49ebc
movq 0x8(%r8), %rdx
cmpl $-0x7, %edx
jne 0x49ecc
movq %rsi, %r15
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x1e0bc
testl %eax, %eax
je 0x49ec4
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x1a995
cmpl $0x16, %ebp
je 0x49e99
pushq $0x11
popq %rcx
cmpl $0x47, %ebp
je 0x49e9c
cmpl $0x4c, %ebp
je 0x49e9c
cmpl $0x49, %ebp
jne 0x49ecc
pushq $0x10
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21846
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x49ee5
movq %rbx, %rdi
callq 0x1d5e1
pushq $0x6
popq %rdx
xorl %r14d, %r14d
jmp 0x49ee3
leaq 0x3d773(%rip), %rsi # 0x87646
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %rdx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
js_date_Symbol_toPrimitive:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz short loc_49EBC
mov rdx, [r8+8]
cmp edx, 0FFFFFFF9h
jnz short loc_49ECC
mov r15, rsi
mov rsi, [r8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_49EC4
mov ebp, eax
mov rdi, rbx
mov esi, eax
call JS_FreeAtom
cmp ebp, 16h
jz short loc_49E99
push 11h
pop rcx
cmp ebp, 47h ; 'G'
jz short loc_49E9C
cmp ebp, 4Ch ; 'L'
jz short loc_49E9C
cmp ebp, 49h ; 'I'
jnz short loc_49ECC
loc_49E99:
push 10h
pop rcx
loc_49E9C:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_ToPrimitive
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_49EE5
loc_49EBC:
mov rdi, rbx
call JS_ThrowTypeErrorNotAnObject
loc_49EC4:
push 6
pop rdx
xor r14d, r14d
jmp short loc_49EE3
loc_49ECC:
lea rsi, aInvalidHint; "invalid hint"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_49EE3:
xor ecx, ecx
loc_49EE5:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
unsigned long long js_date_Symbol_toPrimitive(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
long long v15; // rdx
int v16; // eax
int v17; // ebp
long long v18; // rax
unsigned long long v19; // rcx
long long v20; // r14
char v22; // [rsp-8h] [rbp-28h]
v22 = v14;
if ( (_DWORD)a3 != -1 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, (long long)a2, a3, a4, (long long)a5, a6, v14);
goto LABEL_10;
}
v15 = a5[1];
if ( (_DWORD)v15 != -7 )
{
LABEL_11:
v20 = 0LL;
JS_ThrowTypeError(a1, (long long)"invalid hint", v15, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v22);
goto LABEL_12;
}
v16 = JS_ValueToAtom(a1, *a5, -7);
if ( !v16 )
{
LABEL_10:
v20 = 0LL;
LABEL_12:
v19 = 0LL;
return v19 | v20;
}
v17 = v16;
JS_FreeAtom(a1, v16);
if ( v17 != 22 )
{
a4 = 17LL;
if ( v17 != 71 && v17 != 76 && v17 != 73 )
goto LABEL_11;
}
v18 = JS_ToPrimitive(a1, a2, 0xFFFFFFFF);
v19 = v18 & 0xFFFFFFFF00000000LL;
v20 = (unsigned int)v18;
return v19 | v20;
}
|
js_date_Symbol_toPrimitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
CMP R14D,-0x1
JNZ 0x00149ebc
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,-0x7
JNZ 0x00149ecc
MOV R15,RSI
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x0011e0bc
TEST EAX,EAX
JZ 0x00149ec4
MOV EBP,EAX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0011a995
CMP EBP,0x16
JZ 0x00149e99
PUSH 0x11
POP RCX
CMP EBP,0x47
JZ 0x00149e9c
CMP EBP,0x4c
JZ 0x00149e9c
CMP EBP,0x49
JNZ 0x00149ecc
LAB_00149e99:
PUSH 0x10
POP RCX
LAB_00149e9c:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00121846
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
JMP 0x00149ee5
LAB_00149ebc:
MOV RDI,RBX
CALL 0x0011d5e1
LAB_00149ec4:
PUSH 0x6
POP RDX
XOR R14D,R14D
JMP 0x00149ee3
LAB_00149ecc:
LEA RSI,[0x187646]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP RDX
LAB_00149ee3:
XOR ECX,ECX
LAB_00149ee5:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong js_date_Symbol_toPrimitive
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
ulong uVar3;
int8 extraout_RDX;
int8 uVar4;
if ((int)param_3 == -1) {
uVar4 = param_5[1];
if ((int)uVar4 == -7) {
iVar1 = JS_ValueToAtom(param_1,*param_5);
if (iVar1 != 0) {
JS_FreeAtom(param_1,iVar1);
if (iVar1 == 0x16) {
LAB_00149e99:
param_4 = 0x10;
}
else {
param_4 = 0x11;
if ((iVar1 != 0x47) && (iVar1 != 0x4c)) {
uVar4 = extraout_RDX;
if (iVar1 != 0x49) goto LAB_00149ecc;
goto LAB_00149e99;
}
}
uVar2 = JS_ToPrimitive(param_1,param_2,param_3,param_4);
uVar3 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
goto LAB_00149ee5;
}
}
else {
LAB_00149ecc:
JS_ThrowTypeError(param_1,"invalid hint",uVar4,param_4);
}
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
}
uVar2 = 0;
uVar3 = 0;
LAB_00149ee5:
return uVar2 | uVar3;
}
|
|
13,963
|
js_object_toString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, tag;
int is_array;
JSAtom atom;
JSObject *p;
if (JS_IsNull(this_val)) {
tag = js_new_string8(ctx, "Null");
} else if (JS_IsUndefined(this_val)) {
tag = js_new_string8(ctx, "Undefined");
} else {
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
return obj;
is_array = JS_IsArray(ctx, obj);
if (is_array < 0) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
if (is_array) {
atom = JS_ATOM_Array;
} else if (JS_IsFunction(ctx, obj)) {
atom = JS_ATOM_Function;
} else {
p = JS_VALUE_GET_OBJ(obj);
switch(p->class_id) {
case JS_CLASS_STRING:
case JS_CLASS_ARGUMENTS:
case JS_CLASS_MAPPED_ARGUMENTS:
case JS_CLASS_ERROR:
case JS_CLASS_BOOLEAN:
case JS_CLASS_NUMBER:
case JS_CLASS_DATE:
case JS_CLASS_REGEXP:
atom = ctx->rt->class_array[p->class_id].class_name;
break;
default:
atom = JS_ATOM_Object;
break;
}
}
tag = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_toStringTag);
JS_FreeValue(ctx, obj);
if (JS_IsException(tag))
return JS_EXCEPTION;
if (!JS_IsString(tag)) {
JS_FreeValue(ctx, tag);
tag = JS_AtomToString(ctx, atom);
}
}
return JS_ConcatString3(ctx, "[object ", tag, "]");
}
|
O1
|
c
|
js_object_toString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %edx
je 0x71329
cmpl $0x2, %edx
jne 0x7137a
leaq 0x3077d(%rip), %rsi # 0xa1a9c
movq %rbx, %rdi
movl $0x4, %edx
jmp 0x71338
leaq 0x30771(%rip), %rsi # 0xa1aa1
movq %rbx, %rdi
movl $0x9, %edx
callq 0x201dd
movq %rax, %r12
movq %rdx, %r13
leaq 0x30761(%rip), %rsi # 0xa1aab
leaq 0x2da67(%rip), %r8 # 0x9edb8
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x41f02
movq %rax, %r15
movq %rdx, %r14
movq %r15, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x26ddd
movq %rax, %r15
movq %rdx, %r14
movq %rax, (%rsp)
cmpl $0x6, %r14d
je 0x71365
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x282d2
testl %eax, %eax
js 0x71440
movl $0x94, %ebp
jne 0x713f5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22dbe
movl $0x9e, %ebp
testl %eax, %eax
jne 0x713f5
movq (%rsp), %rax
movzwl 0x6(%rax), %eax
movl $0x93, %ebp
cmpl $0x12, %eax
ja 0x713f5
movl $0x40778, %ecx # imm = 0x40778
btl %eax, %ecx
jae 0x713f5
movq 0x18(%rbx), %rcx
movq 0x80(%rcx), %rcx
leaq (%rax,%rax,4), %rax
movl 0x4(%rcx,%rax,8), %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xda, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rax, %r12
movq %rdx, %r13
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
cmpl $-0x7, %r13d
je 0x71343
cmpl $0x6, %r13d
jne 0x7145d
movl %r13d, %r14d
jmp 0x71455
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %r14d
xorl %r15d, %r15d
jmp 0x71365
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1d8c6
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x2075a
jmp 0x7133d
|
js_object_toString:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp edx, 3
jz short loc_71329
cmp edx, 2
jnz short loc_7137A
lea rsi, aNull_0; "Null"
mov rdi, rbx
mov edx, 4
jmp short loc_71338
loc_71329:
lea rsi, aUndefined; "Undefined"
mov rdi, rbx
mov edx, 9
loc_71338:
call js_new_string8_len
loc_7133D:
mov r12, rax
mov r13, rdx
loc_71343:
lea rsi, aObject_0; "[object "
lea r8, aUninitialized+0Eh; "]"
mov rdi, rbx
mov rdx, r12
mov rcx, r13
call JS_ConcatString3
mov r15, rax
mov r14, rdx
loc_71365:
mov rax, r15
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7137A:
mov rdi, rbx
call JS_ToObject
mov r15, rax
mov r14, rdx
mov [rsp+38h+var_38], rax
cmp r14d, 6
jz short loc_71365
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_IsArray
test eax, eax
js loc_71440
mov ebp, 94h
jnz short loc_713F5
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_IsFunction
mov ebp, 9Eh
test eax, eax
jnz short loc_713F5
mov rax, [rsp+38h+var_38]
movzx eax, word ptr [rax+6]
mov ebp, 93h
cmp eax, 12h
ja short loc_713F5
mov ecx, 40778h
bt ecx, eax
jnb short loc_713F5
mov rcx, [rbx+18h]
mov rcx, [rcx+80h]
lea rax, [rax+rax*4]
mov ebp, [rcx+rax*8+4]
loc_713F5:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 0DAh
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r12, rax
mov r13, rdx
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
cmp r13d, 0FFFFFFF9h
jz loc_71343
cmp r13d, 6
jnz short loc_7145D
mov r14d, r13d
jmp short loc_71455
loc_71440:
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
loc_71455:
xor r15d, r15d
jmp loc_71365
loc_7145D:
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, r13
call JS_FreeValueRT
mov rdi, rbx
mov esi, ebp
mov edx, 1
call __JS_AtomToValue
jmp loc_7133D
|
_DWORD * js_object_toString(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
const char *v14; // rsi
unsigned int v15; // edx
long long v16; // rax
long long v17; // rdx
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
_DWORD *PropertyInternal2; // r12
long long v22; // r13
_DWORD *v23; // r15
_DWORD *v25; // rax
long long v26; // rdx
long long v27; // r14
int IsArray; // eax
int v29; // ebp
long long v30; // rax
int v31; // ecx
long long v32; // rdx
_DWORD *v33; // [rsp+0h] [rbp-38h]
if ( (_DWORD)a3 == 3 )
{
v14 = "Undefined";
v15 = 9;
}
else
{
if ( (_DWORD)a3 != 2 )
{
v25 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v23 = v25;
v27 = v26;
v33 = v25;
if ( (_DWORD)v26 == 6 )
return v23;
IsArray = JS_IsArray(a1, (long long)v25, v26);
if ( IsArray < 0 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v23, v27);
}
else
{
v29 = 148;
if ( !IsArray )
{
v29 = 158;
if ( !(unsigned int)JS_IsFunction(a1, (long long)v23, v27) )
{
v30 = *((unsigned __int16 *)v33 + 3);
v29 = 147;
if ( (unsigned int)v30 <= 0x12 )
{
v31 = 264056;
if ( _bittest(&v31, v30) )
v29 = *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v30 + 4);
}
}
}
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, (long long)v23, v27, 0xDAu, (long long)v23, v27, 0LL, 0);
v22 = v32;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v23, v27);
if ( (_DWORD)v22 == -7 )
return JS_ConcatString3(
a1,
(long long)"[object ",
PropertyInternal2,
v22,
(long long)"]",
v18,
a7,
a8,
a9,
a10,
v19,
v20,
a13,
a14);
if ( (_DWORD)v22 != 6 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PropertyInternal2, v22);
v16 = _JS_AtomToValue(a1, v29, 1);
goto LABEL_6;
}
}
return 0LL;
}
v14 = "Null";
v15 = 4;
}
v16 = js_new_string8_len(a1, (long long)v14, v15);
LABEL_6:
PropertyInternal2 = (_DWORD *)v16;
v22 = v17;
return JS_ConcatString3(
a1,
(long long)"[object ",
PropertyInternal2,
v22,
(long long)"]",
v18,
a7,
a8,
a9,
a10,
v19,
v20,
a13,
a14);
}
| |||
13,964
|
js_object_toString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, tag;
int is_array;
JSAtom atom;
JSObject *p;
if (JS_IsNull(this_val)) {
tag = js_new_string8(ctx, "Null");
} else if (JS_IsUndefined(this_val)) {
tag = js_new_string8(ctx, "Undefined");
} else {
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj))
return obj;
is_array = JS_IsArray(ctx, obj);
if (is_array < 0) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
if (is_array) {
atom = JS_ATOM_Array;
} else if (JS_IsFunction(ctx, obj)) {
atom = JS_ATOM_Function;
} else {
p = JS_VALUE_GET_OBJ(obj);
switch(p->class_id) {
case JS_CLASS_STRING:
case JS_CLASS_ARGUMENTS:
case JS_CLASS_MAPPED_ARGUMENTS:
case JS_CLASS_ERROR:
case JS_CLASS_BOOLEAN:
case JS_CLASS_NUMBER:
case JS_CLASS_DATE:
case JS_CLASS_REGEXP:
atom = ctx->rt->class_array[p->class_id].class_name;
break;
default:
atom = JS_ATOM_Object;
break;
}
}
tag = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_toStringTag);
JS_FreeValue(ctx, obj);
if (JS_IsException(tag))
return JS_EXCEPTION;
if (!JS_IsString(tag)) {
JS_FreeValue(ctx, tag);
tag = JS_AtomToString(ctx, atom);
}
}
return JS_ConcatString3(ctx, "[object ", tag, "]");
}
|
O2
|
c
|
js_object_toString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %edx
je 0x5f431
cmpl $0x2, %edx
jne 0x5f47d
leaq 0x295a7(%rip), %rsi # 0x889d6
jmp 0x5f438
leaq 0x295a3(%rip), %rsi # 0x889db
movq %rbx, %rdi
callq 0x21856
movq %rax, %r12
movq %rdx, %r13
leaq 0x29598(%rip), %rsi # 0x889e5
leaq 0x268b4(%rip), %r8 # 0x85d08
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x39c30
movq %rax, %r15
movq %rdx, %r14
movq %r15, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x20b92
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x5f468
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21d01
testl %eax, %eax
js 0x5f52d
movl $0x94, %ebp
jne 0x5f4f1
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ce7d
movl $0x9e, %ebp
testl %eax, %eax
jne 0x5f4f1
movzwl 0x6(%r15), %eax
movl $0x93, %ebp
cmpl $0x12, %eax
ja 0x5f4f1
movl $0x40778, %ecx # imm = 0x40778
btl %eax, %ecx
jae 0x5f4f1
movq 0x18(%rbx), %rcx
movq 0x80(%rcx), %rcx
imulq $0x28, %rax, %rax
movl 0x4(%rcx,%rax), %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xda, %ecx
callq 0x1b043
movq %rax, %r12
movq %rdx, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
cmpl $-0x7, %r13d
je 0x5f446
cmpl $0x6, %r13d
jne 0x5f547
movl %r13d, %r14d
jmp 0x5f53f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
pushq $0x6
popq %r14
xorl %r15d, %r15d
jmp 0x5f468
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1801e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a990
jmp 0x5f440
|
js_object_toString:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp edx, 3
jz short loc_5F431
cmp edx, 2
jnz short loc_5F47D
lea rsi, aNull_0; "Null"
jmp short loc_5F438
loc_5F431:
lea rsi, aUndefined; "Undefined"
loc_5F438:
mov rdi, rbx
call js_new_string8
loc_5F440:
mov r12, rax
mov r13, rdx
loc_5F446:
lea rsi, aObject_0; "[object "
lea r8, aUninitialized+0Eh; "]"
mov rdi, rbx
mov rdx, r12
mov rcx, r13
call JS_ConcatString3
mov r15, rax
mov r14, rdx
loc_5F468:
mov rax, r15
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5F47D:
mov rdi, rbx
call JS_ToObject
mov r15, rax
mov r14, rdx
cmp r14d, 6
jz short loc_5F468
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_IsArray
test eax, eax
js loc_5F52D
mov ebp, 94h
jnz short loc_5F4F1
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_IsFunction
mov ebp, 9Eh
test eax, eax
jnz short loc_5F4F1
movzx eax, word ptr [r15+6]
mov ebp, 93h
cmp eax, 12h
ja short loc_5F4F1
mov ecx, 40778h
bt ecx, eax
jnb short loc_5F4F1
mov rcx, [rbx+18h]
mov rcx, [rcx+80h]
imul rax, 28h ; '('
mov ebp, [rcx+rax+4]
loc_5F4F1:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 0DAh
call JS_GetProperty
mov r12, rax
mov r13, rdx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
cmp r13d, 0FFFFFFF9h
jz loc_5F446
cmp r13d, 6
jnz short loc_5F547
mov r14d, r13d
jmp short loc_5F53F
loc_5F52D:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
push 6
pop r14
loc_5F53F:
xor r15d, r15d
jmp loc_5F468
loc_5F547:
mov rdi, rbx
mov rsi, r12
mov rdx, r13
call JS_FreeValue
mov rdi, rbx
mov esi, ebp
call JS_AtomToString
jmp loc_5F440
|
long long js_object_toString(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
const char *v14; // rsi
long long v15; // rax
long long v16; // rdx
long long Property; // r12
long long v18; // r13
long long v19; // r15
long long v21; // rax
long long v22; // rdx
long long v23; // r14
int IsArray; // eax
int v25; // ebp
long long v26; // rax
int v27; // ecx
long long v28; // rdx
if ( (_DWORD)a3 == 3 )
{
v14 = "Undefined";
}
else
{
if ( (_DWORD)a3 != 2 )
{
v21 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v21;
v23 = v22;
if ( (_DWORD)v22 == 6 )
return v19;
IsArray = JS_IsArray(a1, v21, v22);
if ( IsArray < 0 )
{
JS_FreeValue(a1, v19, v23);
}
else
{
v25 = 148;
if ( !IsArray )
{
v25 = 158;
if ( !(unsigned int)JS_IsFunction(a1, v19, v23) )
{
v26 = *(unsigned __int16 *)(v19 + 6);
v25 = 147;
if ( (unsigned int)v26 <= 0x12 )
{
v27 = 264056;
if ( _bittest(&v27, v26) )
v25 = *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v26 + 4);
}
}
}
Property = JS_GetProperty(a1, v19, v23, 218);
v18 = v28;
JS_FreeValue(a1, v19, v23);
if ( (_DWORD)v18 == -7 )
return JS_ConcatString3(a1, (long long)"[object ", Property, v18, (long long)"]");
if ( (_DWORD)v18 != 6 )
{
JS_FreeValue(a1, Property, v18);
v15 = JS_AtomToString(a1, v25);
goto LABEL_6;
}
}
return 0LL;
}
v14 = "Null";
}
v15 = js_new_string8(a1, (long long)v14);
LABEL_6:
Property = v15;
v18 = v16;
return JS_ConcatString3(a1, (long long)"[object ", Property, v18, (long long)"]");
}
|
js_object_toString:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP EDX,0x3
JZ 0x0015f431
CMP EDX,0x2
JNZ 0x0015f47d
LEA RSI,[0x1889d6]
JMP 0x0015f438
LAB_0015f431:
LEA RSI,[0x1889db]
LAB_0015f438:
MOV RDI,RBX
CALL 0x00121856
LAB_0015f440:
MOV R12,RAX
MOV R13,RDX
LAB_0015f446:
LEA RSI,[0x1889e5]
LEA R8,[0x185d08]
MOV RDI,RBX
MOV RDX,R12
MOV RCX,R13
CALL 0x00139c30
MOV R15,RAX
MOV R14,RDX
LAB_0015f468:
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015f47d:
MOV RDI,RBX
CALL 0x00120b92
MOV R15,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x0015f468
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00121d01
TEST EAX,EAX
JS 0x0015f52d
MOV EBP,0x94
JNZ 0x0015f4f1
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011ce7d
MOV EBP,0x9e
TEST EAX,EAX
JNZ 0x0015f4f1
MOVZX EAX,word ptr [R15 + 0x6]
MOV EBP,0x93
CMP EAX,0x12
JA 0x0015f4f1
MOV ECX,0x40778
BT ECX,EAX
JNC 0x0015f4f1
MOV RCX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
IMUL RAX,RAX,0x28
MOV EBP,dword ptr [RCX + RAX*0x1 + 0x4]
LAB_0015f4f1:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0xda
CALL 0x0011b043
MOV R12,RAX
MOV R13,RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
CMP R13D,-0x7
JZ 0x0015f446
CMP R13D,0x6
JNZ 0x0015f547
MOV R14D,R13D
JMP 0x0015f53f
LAB_0015f52d:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
PUSH 0x6
POP R14
LAB_0015f53f:
XOR R15D,R15D
JMP 0x0015f468
LAB_0015f547:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R13
CALL 0x0011801e
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0011a990
JMP 0x0015f440
|
int1 [16] js_object_toString(long param_1,int8 param_2,int param_3)
{
ushort uVar1;
int iVar2;
long lVar3;
int8 uVar4;
int4 uVar5;
char *pcVar6;
ulong uVar7;
int1 auVar8 [16];
if (param_3 == 3) {
pcVar6 = "Undefined";
}
else {
if (param_3 != 2) {
auVar8 = JS_ToObject(param_1);
uVar4 = auVar8._8_8_;
lVar3 = auVar8._0_8_;
if (auVar8._8_4_ == 6) {
return auVar8;
}
iVar2 = JS_IsArray(param_1,lVar3,uVar4);
if (iVar2 < 0) {
JS_FreeValue(param_1,lVar3,uVar4);
uVar7 = 6;
LAB_0015f53f:
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar7;
return auVar8 << 0x40;
}
uVar5 = 0x94;
if (iVar2 == 0) {
iVar2 = JS_IsFunction(param_1,lVar3,uVar4);
uVar5 = 0x9e;
if (iVar2 == 0) {
uVar1 = *(ushort *)(lVar3 + 6);
uVar5 = 0x93;
if ((uVar1 < 0x13) && ((0x40778U >> (uVar1 & 0x1f) & 1) != 0)) {
uVar5 = *(int4 *)
(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 4 + (ulong)uVar1 * 0x28);
}
}
}
auVar8 = JS_GetProperty(param_1,lVar3,uVar4,0xda);
JS_FreeValue(param_1,lVar3,uVar4);
if (auVar8._8_4_ != -7) {
if (auVar8._8_4_ == 6) {
uVar7 = auVar8._8_8_ & 0xffffffff;
goto LAB_0015f53f;
}
JS_FreeValue(param_1,auVar8._0_8_,auVar8._8_8_);
auVar8 = JS_AtomToString(param_1,uVar5);
}
goto LAB_0015f446;
}
pcVar6 = "Null";
}
auVar8 = js_new_string8(param_1,pcVar6);
LAB_0015f446:
auVar8 = JS_ConcatString3(param_1,"[object ",auVar8._0_8_,auVar8._8_8_,"]");
return auVar8;
}
|
|
13,965
|
extend_area_on_page
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool extend_area_on_page(MARIA_HA *info,
uchar *buff, uchar *dir,
uint rownr,
uint request_length,
uint *empty_space, uint *ret_offset,
uint *ret_length,
my_bool head_page)
{
uint rec_offset, length, org_rec_length;
uint max_entry= (uint) buff[DIR_COUNT_OFFSET];
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
DBUG_ENTER("extend_area_on_page");
/*
We can't check for min length here as we may have called
extend_directory() to create a new (empty) entry just before
*/
check_directory(share, buff, block_size, 0, *empty_space);
rec_offset= uint2korr(dir);
if (rec_offset)
{
/* Extending old row; Mark current space as 'free' */
length= org_rec_length= uint2korr(dir + 2);
DBUG_PRINT("info", ("rec_offset: %u length: %u request_length: %u "
"empty_space: %u",
rec_offset, org_rec_length, request_length,
*empty_space));
*empty_space+= org_rec_length;
}
else
{
/* Reusing free directory entry; Free it from the directory list */
if (dir[2] == END_OF_DIR_FREE_LIST)
buff[DIR_FREE_OFFSET]= dir[3];
else
{
uchar *prev_dir= dir_entry_pos(buff, block_size, (uint) dir[2]);
DBUG_ASSERT(uint2korr(prev_dir) == 0 && prev_dir[3] == (uchar) rownr);
prev_dir[3]= dir[3];
}
if (dir[3] != END_OF_DIR_FREE_LIST)
{
uchar *next_dir= dir_entry_pos(buff, block_size, (uint) dir[3]);
DBUG_ASSERT(uint2korr(next_dir) == 0 && next_dir[2] == (uchar) rownr);
next_dir[2]= dir[2];
}
rec_offset= start_of_next_entry(dir);
length= 0;
}
if (length < request_length)
{
uint old_rec_offset;
/*
New data did not fit in old position.
Find first possible position where to put new data.
*/
old_rec_offset= rec_offset;
rec_offset= end_of_previous_entry(share,
dir, buff + block_size -
PAGE_SUFFIX_SIZE);
length+= (uint) (old_rec_offset - rec_offset);
DBUG_ASSERT(old_rec_offset);
/*
'length' is 0 if we are doing an insert into a not allocated block.
This can only happen during "REDO of INSERT" or "UNDO of DELETE."
*/
if (length < request_length)
{
/*
Did not fit in current block + empty space. Extend with
empty space after block.
*/
if (rownr == max_entry - 1)
{
/* Last entry; Everything is free between this and directory */
length= ((block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE * max_entry) -
rec_offset);
}
else
length= start_of_next_entry(dir) - rec_offset;
DBUG_ASSERT((int) length >= 0);
if (length < request_length)
{
/* Not enough continuous space, compact page to get more */
int2store(dir, rec_offset);
/* Reset length, as this may be a deleted block */
int2store(dir+2, 0);
_ma_compact_block_page(share,
buff, rownr, 1,
head_page ? info->trn->min_read_from: 0,
head_page ? share->base.min_block_length : 0);
rec_offset= uint2korr(dir);
length= uint2korr(dir+2);
if (length < request_length)
{
DBUG_PRINT("error", ("Not enough space: "
"length: %u request_length: %u",
length, request_length));
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(1); /* Error in block */
}
*empty_space= length; /* All space is here */
}
}
}
int2store(dir, rec_offset);
int2store(dir + 2, length);
*ret_offset= rec_offset;
*ret_length= length;
check_directory(share,
buff, block_size,
head_page ? share->base.min_block_length : 0,
*empty_space - length);
DBUG_RETURN(0);
}
|
O3
|
c
|
extend_area_on_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %r12d
movq %rdx, %rbx
movq %rdi, %r15
movzbl 0x8(%rsi), %edx
movq (%rdi), %rdi
movl 0x7bc(%rdi), %eax
movzwl (%rbx), %r9d
testw %r9w, %r9w
je 0x605f9
movzwl 0x2(%rbx), %r8d
addl %r8d, (%r14)
jmp 0x60661
movzbl 0x2(%rbx), %r8d
cmpq $0xff, %r8
je 0x6061c
leaq (%rsi,%rax), %r9
shll $0x2, %r8d
subq %r8, %r9
movb 0x3(%rbx), %r8b
movb %r8b, -0x5(%r9)
jmp 0x60624
movb 0x3(%rbx), %r8b
movb %r8b, 0x9(%rsi)
cmpb $-0x1, %r8b
je 0x60641
leaq (%rsi,%rax), %r9
movzbl %r8b, %r8d
shll $0x2, %r8d
subq %r8, %r9
movb 0x2(%rbx), %r8b
movb %r8b, -0x6(%r9)
leaq -0x3(%rbx), %r9
movq %r9, %r8
cmpb $0x0, -0x1(%r9)
jne 0x60659
leaq -0x4(%r8), %r9
cmpb $0x0, (%r8)
je 0x60645
movzwl -0x1(%r8), %r9d
xorl %r8d, %r8d
movzwl %r9w, %r11d
cmpl %r12d, %r8d
jae 0x6070d
leaq (%rsi,%rax), %r13
addq $-0x4, %r13
leaq 0x4(%rbx), %r10
cmpq %r13, %r10
jae 0x60696
movzwl (%r10), %r9d
addq $0x4, %r10
testl %r9d, %r9d
je 0x6067a
movzwl -0x2(%r10), %r10d
addl %r9d, %r10d
jmp 0x606a1
movl 0xc18(%rdi), %r10d
addl $0xc, %r10d
subl %r10d, %r11d
addl %r11d, %r8d
cmpl %r12d, %r8d
jae 0x6070a
leal -0x1(%rdx), %r8d
cmpl %ecx, %r8d
jne 0x606c3
leal (%r10,%rdx,4), %edx
subl %edx, %eax
addl $-0x4, %eax
movl %eax, %r8d
jmp 0x606e1
leaq -0x3(%rbx), %rdx
movq %rdx, %rax
cmpb $0x0, -0x1(%rdx)
jne 0x606d9
leaq -0x4(%rax), %rdx
cmpb $0x0, (%rax)
je 0x606c7
movzwl -0x1(%rax), %r8d
subl %r10d, %r8d
cmpl %r12d, %r8d
jae 0x6070a
movw %r10w, (%rbx)
movw $0x0, 0x2(%rbx)
cmpb $0x0, 0x20(%rbp)
je 0x60735
movq 0x8(%r15), %rax
movq 0x80(%rax), %r8
movl 0x3b8(%rdi), %r9d
jmp 0x6073b
movl %r10d, %r11d
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rcx
movw %r11w, (%rbx)
movw %r8w, 0x2(%rbx)
movl %r11d, (%rcx)
movl %r8d, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %ecx, %edx
movl $0x1, %ecx
callq 0x5d050
movzwl 0x2(%rbx), %r8d
cmpl %r12d, %r8d
jae 0x60762
movq %r15, %rdi
movl $0x7f, %esi
callq 0x37978
movb $0x1, %al
jmp 0x60726
movzwl (%rbx), %r11d
movl %r8d, (%r14)
jmp 0x6070d
|
extend_area_on_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov r12d, r8d
mov rbx, rdx
mov r15, rdi
movzx edx, byte ptr [rsi+8]
mov rdi, [rdi]
mov eax, [rdi+7BCh]
movzx r9d, word ptr [rbx]
test r9w, r9w
jz short loc_605F9
movzx r8d, word ptr [rbx+2]
add [r14], r8d
jmp short loc_60661
loc_605F9:
movzx r8d, byte ptr [rbx+2]
cmp r8, 0FFh
jz short loc_6061C
lea r9, [rsi+rax]
shl r8d, 2
sub r9, r8
mov r8b, [rbx+3]
mov [r9-5], r8b
jmp short loc_60624
loc_6061C:
mov r8b, [rbx+3]
mov [rsi+9], r8b
loc_60624:
cmp r8b, 0FFh
jz short loc_60641
lea r9, [rsi+rax]
movzx r8d, r8b
shl r8d, 2
sub r9, r8
mov r8b, [rbx+2]
mov [r9-6], r8b
loc_60641:
lea r9, [rbx-3]
loc_60645:
mov r8, r9
cmp byte ptr [r9-1], 0
jnz short loc_60659
lea r9, [r8-4]
cmp byte ptr [r8], 0
jz short loc_60645
loc_60659:
movzx r9d, word ptr [r8-1]
xor r8d, r8d
loc_60661:
movzx r11d, r9w
cmp r8d, r12d
jnb loc_6070D
lea r13, [rsi+rax]
add r13, 0FFFFFFFFFFFFFFFCh
lea r10, [rbx+4]
loc_6067A:
cmp r10, r13
jnb short loc_60696
movzx r9d, word ptr [r10]
add r10, 4
test r9d, r9d
jz short loc_6067A
movzx r10d, word ptr [r10-2]
add r10d, r9d
jmp short loc_606A1
loc_60696:
mov r10d, [rdi+0C18h]
add r10d, 0Ch
loc_606A1:
sub r11d, r10d
add r8d, r11d
cmp r8d, r12d
jnb short loc_6070A
lea r8d, [rdx-1]
cmp r8d, ecx
jnz short loc_606C3
lea edx, [r10+rdx*4]
sub eax, edx
add eax, 0FFFFFFFCh
mov r8d, eax
jmp short loc_606E1
loc_606C3:
lea rdx, [rbx-3]
loc_606C7:
mov rax, rdx
cmp byte ptr [rdx-1], 0
jnz short loc_606D9
lea rdx, [rax-4]
cmp byte ptr [rax], 0
jz short loc_606C7
loc_606D9:
movzx r8d, word ptr [rax-1]
sub r8d, r10d
loc_606E1:
cmp r8d, r12d
jnb short loc_6070A
mov [rbx], r10w
mov word ptr [rbx+2], 0
cmp [rbp+arg_10], 0
jz short loc_60735
mov rax, [r15+8]
mov r8, [rax+80h]
mov r9d, [rdi+3B8h]
jmp short loc_6073B
loc_6070A:
mov r11d, r10d
loc_6070D:
mov rax, [rbp+arg_8]
mov rcx, [rbp+arg_0]
mov [rbx], r11w
mov [rbx+2], r8w
mov [rcx], r11d
mov [rax], r8d
xor eax, eax
loc_60726:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60735:
xor r8d, r8d
xor r9d, r9d
loc_6073B:
mov edx, ecx
mov ecx, 1
call _ma_compact_block_page
movzx r8d, word ptr [rbx+2]
cmp r8d, r12d
jnb short loc_60762
mov rdi, r15
mov esi, 7Fh
call _ma_set_fatal_error
mov al, 1
jmp short loc_60726
loc_60762:
movzx r11d, word ptr [rbx]
mov [r14], r8d
jmp short loc_6070D
|
char extend_area_on_page(
long long a1,
long long a2,
unsigned __int16 *a3,
int a4,
unsigned int a5,
_DWORD *a6,
_DWORD *a7,
_DWORD *a8,
char a9)
{
int v13; // edx
_DWORD *v14; // rdi
long long v15; // rax
unsigned __int16 v16; // r9
long long v17; // r8
long long v18; // r8
long long v19; // r9
unsigned __int8 v20; // r8
char *v21; // r9
int v22; // r11d
unsigned __int16 *v23; // r10
int v24; // r9d
int v25; // r10d
_BYTE *v26; // rdx
_BYTE *v27; // rax
unsigned long long v28; // r8
unsigned int v29; // r9d
long long v31; // rdx
long long v32; // rcx
int v33; // r9d
v13 = *(unsigned __int8 *)(a2 + 8);
v14 = *(_DWORD **)a1;
v15 = (unsigned int)v14[495];
v16 = *a3;
if ( *a3 )
{
LODWORD(v17) = a3[1];
*a6 += v17;
}
else
{
v18 = *((unsigned __int8 *)a3 + 2);
if ( v18 == 255 )
{
v20 = *((_BYTE *)a3 + 3);
*(_BYTE *)(a2 + 9) = v20;
}
else
{
v19 = a2 + v15 - (unsigned int)(4 * v18);
v20 = *((_BYTE *)a3 + 3);
*(_BYTE *)(v19 - 5) = v20;
}
if ( v20 != 0xFF )
*(_BYTE *)(a2 + v15 - 4 * (unsigned int)v20 - 6) = *((_BYTE *)a3 + 2);
v21 = (char *)a3 - 3;
do
{
v17 = (long long)v21;
if ( *(v21 - 1) )
break;
v21 -= 4;
}
while ( !*(_BYTE *)v17 );
v16 = *(_WORD *)(v17 - 1);
LODWORD(v17) = 0;
}
v22 = v16;
if ( (unsigned int)v17 < a5 )
{
v23 = a3 + 2;
while ( (unsigned long long)v23 < a2 + v15 - 4 )
{
v24 = *v23;
v23 += 2;
if ( v24 )
{
v25 = v24 + *(v23 - 1);
goto LABEL_18;
}
}
v25 = v14[774] + 12;
LABEL_18:
LODWORD(v17) = v22 - v25 + v17;
if ( (unsigned int)v17 >= a5 )
goto LABEL_28;
if ( v13 - 1 == a4 )
{
LODWORD(v17) = v15 - (v25 + 4 * v13) - 4;
}
else
{
v26 = (char *)a3 - 3;
do
{
v27 = v26;
if ( *(v26 - 1) )
break;
v26 -= 4;
}
while ( !*v27 );
LODWORD(v17) = *(unsigned __int16 *)(v27 - 1) - v25;
}
if ( (unsigned int)v17 >= a5 )
{
LABEL_28:
v22 = v25;
}
else
{
*a3 = v25;
a3[1] = 0;
if ( a9 )
{
v28 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 128LL);
v29 = v14[238];
}
else
{
v28 = 0LL;
v29 = 0;
}
ma_compact_block_page((long long)v14, a2, a4, 1, v28, v29);
v17 = a3[1];
if ( (unsigned int)v17 < a5 )
{
ma_set_fatal_error((_DWORD *)a1, 127LL, v31, v32, v17, v33);
return 1;
}
v22 = *a3;
*a6 = v17;
}
}
*a3 = v22;
a3[1] = v17;
*a7 = v22;
*a8 = v17;
return 0;
}
|
extend_area_on_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV R12D,R8D
MOV RBX,RDX
MOV R15,RDI
MOVZX EDX,byte ptr [RSI + 0x8]
MOV RDI,qword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x7bc]
MOVZX R9D,word ptr [RBX]
TEST R9W,R9W
JZ 0x001605f9
MOVZX R8D,word ptr [RBX + 0x2]
ADD dword ptr [R14],R8D
JMP 0x00160661
LAB_001605f9:
MOVZX R8D,byte ptr [RBX + 0x2]
CMP R8,0xff
JZ 0x0016061c
LEA R9,[RSI + RAX*0x1]
SHL R8D,0x2
SUB R9,R8
MOV R8B,byte ptr [RBX + 0x3]
MOV byte ptr [R9 + -0x5],R8B
JMP 0x00160624
LAB_0016061c:
MOV R8B,byte ptr [RBX + 0x3]
MOV byte ptr [RSI + 0x9],R8B
LAB_00160624:
CMP R8B,0xff
JZ 0x00160641
LEA R9,[RSI + RAX*0x1]
MOVZX R8D,R8B
SHL R8D,0x2
SUB R9,R8
MOV R8B,byte ptr [RBX + 0x2]
MOV byte ptr [R9 + -0x6],R8B
LAB_00160641:
LEA R9,[RBX + -0x3]
LAB_00160645:
MOV R8,R9
CMP byte ptr [R9 + -0x1],0x0
JNZ 0x00160659
LEA R9,[R8 + -0x4]
CMP byte ptr [R8],0x0
JZ 0x00160645
LAB_00160659:
MOVZX R9D,word ptr [R8 + -0x1]
XOR R8D,R8D
LAB_00160661:
MOVZX R11D,R9W
CMP R8D,R12D
JNC 0x0016070d
LEA R13,[RSI + RAX*0x1]
ADD R13,-0x4
LEA R10,[RBX + 0x4]
LAB_0016067a:
CMP R10,R13
JNC 0x00160696
MOVZX R9D,word ptr [R10]
ADD R10,0x4
TEST R9D,R9D
JZ 0x0016067a
MOVZX R10D,word ptr [R10 + -0x2]
ADD R10D,R9D
JMP 0x001606a1
LAB_00160696:
MOV R10D,dword ptr [RDI + 0xc18]
ADD R10D,0xc
LAB_001606a1:
SUB R11D,R10D
ADD R8D,R11D
CMP R8D,R12D
JNC 0x0016070a
LEA R8D,[RDX + -0x1]
CMP R8D,ECX
JNZ 0x001606c3
LEA EDX,[R10 + RDX*0x4]
SUB EAX,EDX
ADD EAX,-0x4
MOV R8D,EAX
JMP 0x001606e1
LAB_001606c3:
LEA RDX,[RBX + -0x3]
LAB_001606c7:
MOV RAX,RDX
CMP byte ptr [RDX + -0x1],0x0
JNZ 0x001606d9
LEA RDX,[RAX + -0x4]
CMP byte ptr [RAX],0x0
JZ 0x001606c7
LAB_001606d9:
MOVZX R8D,word ptr [RAX + -0x1]
SUB R8D,R10D
LAB_001606e1:
CMP R8D,R12D
JNC 0x0016070a
MOV word ptr [RBX],R10W
MOV word ptr [RBX + 0x2],0x0
CMP byte ptr [RBP + 0x20],0x0
JZ 0x00160735
MOV RAX,qword ptr [R15 + 0x8]
MOV R8,qword ptr [RAX + 0x80]
MOV R9D,dword ptr [RDI + 0x3b8]
JMP 0x0016073b
LAB_0016070a:
MOV R11D,R10D
LAB_0016070d:
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + 0x10]
MOV word ptr [RBX],R11W
MOV word ptr [RBX + 0x2],R8W
MOV dword ptr [RCX],R11D
MOV dword ptr [RAX],R8D
XOR EAX,EAX
LAB_00160726:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160735:
XOR R8D,R8D
XOR R9D,R9D
LAB_0016073b:
MOV EDX,ECX
MOV ECX,0x1
CALL 0x0015d050
MOVZX R8D,word ptr [RBX + 0x2]
CMP R8D,R12D
JNC 0x00160762
MOV RDI,R15
MOV ESI,0x7f
CALL 0x00137978
MOV AL,0x1
JMP 0x00160726
LAB_00160762:
MOVZX R11D,word ptr [RBX]
MOV dword ptr [R14],R8D
JMP 0x0016070d
|
int8
extend_area_on_page(long *param_1,long param_2,ushort *param_3,int param_4,uint param_5,
uint *param_6,uint *param_7,uint *param_8,char param_9)
{
byte bVar1;
ushort uVar2;
uint uVar3;
long lVar4;
char *pcVar5;
ushort *puVar6;
ulong uVar7;
char *pcVar8;
byte bVar9;
uint uVar10;
int8 uVar11;
int4 uVar12;
uint uVar13;
ushort *puVar14;
bVar1 = *(byte *)(param_2 + 8);
lVar4 = *param_1;
uVar3 = *(uint *)(lVar4 + 0x7bc);
uVar7 = (ulong)uVar3;
uVar2 = *param_3;
if (uVar2 == 0) {
if ((byte)param_3[1] == 0xff) {
bVar9 = *(byte *)((long)param_3 + 3);
*(byte *)(param_2 + 9) = bVar9;
}
else {
bVar9 = *(byte *)((long)param_3 + 3);
*(byte *)(param_2 + uVar7 + (ulong)(byte)param_3[1] * -4 + -5) = bVar9;
}
if (bVar9 != 0xff) {
*(char *)(param_2 + uVar7 + (ulong)bVar9 * -4 + -6) = (char)param_3[1];
}
pcVar5 = (char *)((long)param_3 + -3);
do {
pcVar8 = pcVar5;
if (pcVar8[-1] != '\0') break;
pcVar5 = pcVar8 + -4;
} while (*pcVar8 == '\0');
uVar2 = *(ushort *)(pcVar8 + -1);
uVar10 = 0;
}
else {
uVar10 = (uint)param_3[1];
*param_6 = *param_6 + (uint)param_3[1];
}
uVar13 = (uint)uVar2;
if (uVar10 < param_5) {
puVar6 = param_3 + 2;
do {
puVar14 = puVar6;
if ((ushort *)(param_2 + uVar7 + -4) <= puVar14) {
uVar13 = *(int *)(lVar4 + 0xc18) + 0xc;
goto LAB_001606a1;
}
puVar6 = puVar14 + 2;
} while (*puVar14 == 0);
uVar13 = (uint)puVar14[1] + (uint)*puVar14;
LAB_001606a1:
uVar10 = uVar10 + (uVar2 - uVar13);
if (uVar10 < param_5) {
if (bVar1 - 1 == param_4) {
uVar10 = (uVar3 - (uVar13 + (uint)bVar1 * 4)) - 4;
}
else {
pcVar5 = (char *)((long)param_3 + -3);
do {
pcVar8 = pcVar5;
if (pcVar8[-1] != '\0') break;
pcVar5 = pcVar8 + -4;
} while (*pcVar8 == '\0');
uVar10 = *(ushort *)(pcVar8 + -1) - uVar13;
}
if (uVar10 < param_5) {
*param_3 = (ushort)uVar13;
param_3[1] = 0;
if (param_9 == '\0') {
uVar11 = 0;
uVar12 = 0;
}
else {
uVar11 = *(int8 *)(param_1[1] + 0x80);
uVar12 = *(int4 *)(lVar4 + 0x3b8);
}
_ma_compact_block_page(lVar4,param_2,param_4,1,uVar11,uVar12);
uVar10 = (uint)param_3[1];
if (uVar10 < param_5) {
_ma_set_fatal_error(param_1,0x7f);
return 1;
}
uVar13 = (uint)*param_3;
*param_6 = uVar10;
}
}
}
*param_3 = (ushort)uVar13;
param_3[1] = (ushort)uVar10;
*param_7 = uVar13;
*param_8 = uVar10;
return 0;
}
|
|
13,966
|
spdlog::details::os::gmtime(long const&)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/os-inl.h
|
SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT {
#ifdef _WIN32
std::tm tm;
::gmtime_s(&tm, &time_tt);
#else
std::tm tm;
::gmtime_r(&time_tt, &tm);
#endif
return tm;
}
|
O0
|
c
|
spdlog::details::os::gmtime(long const&):
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x16e90
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
_ZN6spdlog7details2os6gmtimeERKl:
sub rsp, 18h
mov rax, rsi
mov rsi, rdi
mov rdi, rsi
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_8], rax
mov rdi, [rsp+18h+var_8]
call _gmtime_r
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
|
spdlog::details::os * spdlog::details::os::gmtime(spdlog::details::os *this, const long long *a2)
{
gmtime_r(a2);
return this;
}
|
gmtime:
SUB RSP,0x18
MOV RAX,RSI
MOV RSI,RDI
MOV RDI,RSI
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00116e90
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
|
/* spdlog::details::os::gmtime(long const&) */
os * __thiscall spdlog::details::os::gmtime(os *this,long *param_1)
{
gmtime_r(param_1,(tm *)this);
return this;
}
|
|
13,967
|
my_atoull
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static unsigned long long my_atoull(const char *str, const char *end_str, int *error)
{
const char *p = str;
const char *end;
unsigned long long ret;
while (p < end_str && isspace(*p))
p++;
ret = my_strtoull(p, end_str - p, &end, error);
while(end < end_str && isspace(*end))
end++;
if(end != end_str)
*error= 1;
return ret;
}
|
O0
|
c
|
my_atoull:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x559df
callq 0x36120
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x559e8
jmp 0x559f6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x559ac
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x54a50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x32(%rbp)
jae 0x55a49
callq 0x36120
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x55a52
jmp 0x55a60
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x55a16
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x55a74
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
|
my_atoull:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_559AC:
mov rcx, [rbp+var_20]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_31], al
jnb short loc_559DF
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
setnz al
mov [rbp+var_31], al
loc_559DF:
mov al, [rbp+var_31]
test al, 1
jnz short loc_559E8
jmp short loc_559F6
loc_559E8:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_559AC
loc_559F6:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_20]
sub rsi, rax
mov rcx, [rbp+var_18]
lea rdx, [rbp+var_28]
call my_strtoull
mov [rbp+var_30], rax
loc_55A16:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_32], al
jnb short loc_55A49
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_28]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
setnz al
mov [rbp+var_32], al
loc_55A49:
mov al, [rbp+var_32]
test al, 1
jnz short loc_55A52
jmp short loc_55A60
loc_55A52:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_55A16
loc_55A60:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_10]
jz short loc_55A74
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
loc_55A74:
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
|
unsigned long long my_atoull(char *a1, char *a2, _DWORD *a3)
{
bool v4; // [rsp+Eh] [rbp-32h]
bool v5; // [rsp+Fh] [rbp-31h]
unsigned long long v6; // [rsp+10h] [rbp-30h]
char *v7; // [rsp+18h] [rbp-28h] BYREF
char *i; // [rsp+20h] [rbp-20h]
_DWORD *v9; // [rsp+28h] [rbp-18h]
char *v10; // [rsp+30h] [rbp-10h]
char *v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
for ( i = a1; ; ++i )
{
v5 = 0;
if ( i < v10 )
v5 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *i) & 0x2000) != 0;
if ( !v5 )
break;
}
v6 = my_strtoull(i, v10 - i, &v7, v9);
while ( 1 )
{
v4 = 0;
if ( v7 < v10 )
v4 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *v7) & 0x2000) != 0;
if ( !v4 )
break;
++v7;
}
if ( v7 != v10 )
*v9 = 1;
return v6;
}
|
my_atoull:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001559ac:
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x31],AL
JNC 0x001559df
CALL 0x00136120
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_001559df:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x001559e8
JMP 0x001559f6
LAB_001559e8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001559ac
LAB_001559f6:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
SUB RSI,RAX
MOV RCX,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x28]
CALL 0x00154a50
MOV qword ptr [RBP + -0x30],RAX
LAB_00155a16:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x32],AL
JNC 0x00155a49
CALL 0x00136120
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x32],AL
LAB_00155a49:
MOV AL,byte ptr [RBP + -0x32]
TEST AL,0x1
JNZ 0x00155a52
JMP 0x00155a60
LAB_00155a52:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00155a16
LAB_00155a60:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x10]
JZ 0x00155a74
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
LAB_00155a74:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int8 my_atoull(char *param_1,char *param_2,int4 *param_3)
{
ushort **ppuVar1;
int8 uVar2;
bool bVar3;
char *local_30;
char *local_28;
int4 *local_20;
char *local_18;
char *local_10;
local_28 = param_1;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar3 = false;
if (local_28 < local_18) {
ppuVar1 = __ctype_b_loc();
bVar3 = ((*ppuVar1)[(int)*local_28] & 0x2000) != 0;
}
if (!bVar3) break;
local_28 = local_28 + 1;
}
uVar2 = my_strtoull(local_28,(long)local_18 - (long)local_28,&local_30,local_20);
while( true ) {
bVar3 = false;
if (local_30 < local_18) {
ppuVar1 = __ctype_b_loc();
bVar3 = ((*ppuVar1)[(int)*local_30] & 0x2000) != 0;
}
if (!bVar3) break;
local_30 = local_30 + 1;
}
if (local_30 != local_18) {
*local_20 = 1;
}
return uVar2;
}
|
|
13,968
|
my_coll_parser_exec
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_exec(MY_COLL_RULE_PARSER *p)
{
if (!my_coll_parser_scan_settings(p))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_RESET)
{
if (!my_coll_parser_scan_rule(p))
return 0;
}
/* Make sure no unparsed input data left */
return my_coll_parser_scan_term(p, MY_COLL_LEXEM_EOF);
}
|
O0
|
c
|
my_coll_parser_exec:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x551a0
cmpl $0x0, %eax
jne 0x54b73
movl $0x0, -0x4(%rbp)
jmp 0x54baa
jmp 0x54b75
movq -0x10(%rbp), %rdi
callq 0x54cd0
cmpl $0x4, (%rax)
jne 0x54b9c
movq -0x10(%rbp), %rdi
callq 0x551f0
cmpl $0x0, %eax
jne 0x54b9a
movl $0x0, -0x4(%rbp)
jmp 0x54baa
jmp 0x54b75
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x552a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_parser_exec:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call my_coll_parser_scan_settings
cmp eax, 0
jnz short loc_54B73
mov [rbp+var_4], 0
jmp short loc_54BAA
loc_54B73:
jmp short $+2
loc_54B75:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 4
jnz short loc_54B9C
mov rdi, [rbp+var_10]
call my_coll_parser_scan_rule
cmp eax, 0
jnz short loc_54B9A
mov [rbp+var_4], 0
jmp short loc_54BAA
loc_54B9A:
jmp short loc_54B75
loc_54B9C:
mov rdi, [rbp+var_10]
xor esi, esi
call my_coll_parser_scan_term
mov [rbp+var_4], eax
loc_54BAA:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
|
long long my_coll_parser_exec(long long a1)
{
if ( (unsigned int)my_coll_parser_scan_settings(a1) )
{
while ( *(_DWORD *)my_coll_parser_curr(a1) == 4 )
{
if ( !(unsigned int)my_coll_parser_scan_rule(a1) )
return 0;
}
return (unsigned int)my_coll_parser_scan_term(a1, 0LL);
}
else
{
return 0;
}
}
|
my_coll_parser_exec:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001551a0
CMP EAX,0x0
JNZ 0x00154b73
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00154baa
LAB_00154b73:
JMP 0x00154b75
LAB_00154b75:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00154cd0
CMP dword ptr [RAX],0x4
JNZ 0x00154b9c
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001551f0
CMP EAX,0x0
JNZ 0x00154b9a
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00154baa
LAB_00154b9a:
JMP 0x00154b75
LAB_00154b9c:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001552a0
MOV dword ptr [RBP + -0x4],EAX
LAB_00154baa:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 my_coll_parser_exec(int8 param_1)
{
int iVar1;
int4 uVar2;
int *piVar3;
iVar1 = my_coll_parser_scan_settings(param_1);
while( true ) {
if (iVar1 == 0) {
return 0;
}
piVar3 = (int *)my_coll_parser_curr(param_1);
if (*piVar3 != 4) break;
iVar1 = my_coll_parser_scan_rule(param_1);
}
uVar2 = my_coll_parser_scan_term(param_1,0);
return uVar2;
}
|
|
13,969
|
my_filename
|
eloqsql/mysys/my_div.c
|
char * my_filename(File fd)
{
DBUG_ENTER("my_filename");
if ((uint) fd >= (uint) my_file_limit || !my_file_info[fd].name)
DBUG_RETURN((char*) "UNKNOWN");
if (fd >= 0 && my_file_info[fd].type != UNOPEN)
{
DBUG_RETURN(my_file_info[fd].name);
}
else
DBUG_RETURN((char*) "UNOPENED"); /* Debug message */
}
|
O3
|
c
|
my_filename:
pushq %rbp
movq %rsp, %rbp
leaq 0x2d7619(%rip), %rcx # 0x33d990
leaq 0x343f1(%rip), %rax # 0x9a76f
cmpl %edi, (%rcx)
jbe 0x663b3
leaq 0x2d760f(%rip), %rcx # 0x33d998
movq (%rcx), %rcx
movslq %edi, %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rsi
testq %rsi, %rsi
je 0x663b3
testl %edi, %edi
js 0x663ac
addq %rdx, %rcx
cmpl $0x0, 0x8(%rcx)
movq %rsi, %rax
jne 0x663b3
leaq 0x343c4(%rip), %rax # 0x9a777
popq %rbp
retq
nopl (%rax)
|
my_filename:
push rbp
mov rbp, rsp
lea rcx, my_file_limit
lea rax, aUnknown_0; "UNKNOWN"
cmp [rcx], edi
jbe short loc_663B3
lea rcx, my_file_info
mov rcx, [rcx]
movsxd rdx, edi
shl rdx, 4
mov rsi, [rcx+rdx]
test rsi, rsi
jz short loc_663B3
test edi, edi
js short loc_663AC
add rcx, rdx
cmp dword ptr [rcx+8], 0
mov rax, rsi
jnz short loc_663B3
loc_663AC:
lea rax, aUnopened; "UNOPENED"
loc_663B3:
pop rbp
retn
|
const char * my_filename(int a1)
{
const char *result; // rax
long long v2; // rdx
result = "UNKNOWN";
if ( my_file_limit > (unsigned int)a1 )
{
v2 = 16LL * a1;
if ( *(_QWORD *)((char *)my_file_info + v2) )
{
if ( a1 < 0 )
return "UNOPENED";
result = (const char *)*((_QWORD *)my_file_info + 2 * a1);
if ( !*(_DWORD *)((char *)my_file_info + v2 + 8) )
return "UNOPENED";
}
}
return result;
}
|
my_filename:
PUSH RBP
MOV RBP,RSP
LEA RCX,[0x43d990]
LEA RAX,[0x19a76f]
CMP dword ptr [RCX],EDI
JBE 0x001663b3
LEA RCX,[0x43d998]
MOV RCX,qword ptr [RCX]
MOVSXD RDX,EDI
SHL RDX,0x4
MOV RSI,qword ptr [RCX + RDX*0x1]
TEST RSI,RSI
JZ 0x001663b3
TEST EDI,EDI
JS 0x001663ac
ADD RCX,RDX
CMP dword ptr [RCX + 0x8],0x0
MOV RAX,RSI
JNZ 0x001663b3
LAB_001663ac:
LEA RAX,[0x19a777]
LAB_001663b3:
POP RBP
RET
|
char * my_filename(uint param_1)
{
char *pcVar1;
pcVar1 = "UNKNOWN";
if (param_1 < my_file_limit) {
if ((*(char **)(my_file_info + (long)(int)param_1 * 0x10) != (char *)0x0) &&
(((int)param_1 < 0 ||
(pcVar1 = *(char **)(my_file_info + (long)(int)param_1 * 0x10),
*(int *)(my_file_info + (long)(int)param_1 * 0x10 + 8) == 0)))) {
pcVar1 = "UNOPENED";
}
}
return pcVar1;
}
|
|
13,970
|
my_uni_utf16le
|
eloqsql/strings/ctype-ucs2.c
|
static int
my_uni_utf16le(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
uint32 first, second, total;
if (wc < MY_UTF16_SURROGATE_HIGH_FIRST ||
(wc > MY_UTF16_SURROGATE_LOW_LAST &&
wc <= 0xFFFF))
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
int2store(s, wc);
return 2; /* [0000-D7FF,E000-FFFF] */
}
if (wc < 0xFFFF || wc > 0x10FFFF)
return MY_CS_ILUNI; /* [D800-DFFF,10FFFF+] */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
wc-= 0x10000;
first= (0xD800 | ((wc >> 10) & 0x3FF));
second= (0xDC00 | (wc & 0x3FF));
total= first | (second << 16);
int4store(s, total);
return 4; /* [010000-10FFFF] */
}
|
O0
|
c
|
my_uni_utf16le:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0xd800, -0x18(%rbp) # imm = 0xD800
jb 0x70192
cmpq $0xdfff, -0x18(%rbp) # imm = 0xDFFF
jbe 0x701d0
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x701d0
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x701ac
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x70262
jmp 0x701ae
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x40(%rbp), %rax
movw %cx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x70262
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jb 0x701e4
cmpq $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
jbe 0x701ed
movl $0x0, -0x4(%rbp)
jmp 0x70262
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x70204
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x70262
movq -0x18(%rbp), %rax
subq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
andq $0x3ff, %rax # imm = 0x3FF
orq $0xd800, %rax # imm = 0xD800
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
andq $0x3ff, %rax # imm = 0x3FF
orq $0xdc00, %rax # imm = 0xDC00
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_uni_utf16le:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
cmp [rbp+var_18], 0D800h
jb short loc_70192
cmp [rbp+var_18], 0DFFFh
jbe short loc_701D0
cmp [rbp+var_18], 0FFFFh
ja short loc_701D0
loc_70192:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_701AC
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_70262
loc_701AC:
jmp short $+2
loc_701AE:
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov cx, ax
mov rax, [rbp+var_40]
mov [rax], cx
mov [rbp+var_4], 2
jmp loc_70262
loc_701D0:
cmp [rbp+var_18], 0FFFFh
jb short loc_701E4
cmp [rbp+var_18], offset unk_10FFFF
jbe short loc_701ED
loc_701E4:
mov [rbp+var_4], 0
jmp short loc_70262
loc_701ED:
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_70204
mov [rbp+var_4], 0FFFFFF98h
jmp short loc_70262
loc_70204:
mov rax, [rbp+var_18]
sub rax, offset stru_10000
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
shr rax, 0Ah
and rax, 3FFh
or rax, 0D800h
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
and rax, 3FFh
or rax, 0DC00h
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
mov ecx, [rbp+var_30]
shl ecx, 10h
or eax, ecx
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_48]
mov [rax], ecx
mov [rbp+var_4], 4
loc_70262:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_utf16le(long long a1, unsigned long long a2, _DWORD *a3, unsigned long long a4)
{
if ( a2 >= 0xD800 && (a2 <= 0xDFFF || a2 > 0xFFFF) )
{
if ( a2 >= 0xFFFF && a2 <= (unsigned long long)&unk_10FFFF )
{
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = (((a2 - (_QWORD)&stru_10000) & 0x3FF | 0xDC00) << 16) | ((a2 - (unsigned long long)&stru_10000) >> 10) & 0x3FF | 0xD800;
return 4;
}
else
{
return (unsigned int)-104;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 + 2 <= a4 )
{
*(_WORD *)a3 = a2;
return 2;
}
else
{
return (unsigned int)-102;
}
}
|
my_uni_utf16le:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RBP + -0x18],0xd800
JC 0x00170192
CMP qword ptr [RBP + -0x18],0xdfff
JBE 0x001701d0
CMP qword ptr [RBP + -0x18],0xffff
JA 0x001701d0
LAB_00170192:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001701ac
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00170262
LAB_001701ac:
JMP 0x001701ae
LAB_001701ae:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x40]
MOV word ptr [RAX],CX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00170262
LAB_001701d0:
CMP qword ptr [RBP + -0x18],0xffff
JC 0x001701e4
CMP qword ptr [RBP + -0x18],0x10ffff
JBE 0x001701ed
LAB_001701e4:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00170262
LAB_001701ed:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00170204
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x00170262
LAB_00170204:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0xa
AND RAX,0x3ff
OR RAX,0xd800
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3ff
OR RAX,0xdc00
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + -0x30]
SHL ECX,0x10
OR EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x4
LAB_00170262:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf16le(int8 param_1,ulong param_2,uint *param_3,uint *param_4)
{
int4 local_c;
if ((param_2 < 0xd800) || ((0xdfff < param_2 && (param_2 < 0x10000)))) {
if (param_4 < (uint *)((long)param_3 + 2)) {
local_c = 0xffffff9a;
}
else {
*(short *)param_3 = (short)param_2;
local_c = 2;
}
}
else if ((param_2 < 0xffff) || (0x10ffff < param_2)) {
local_c = 0;
}
else if (param_4 < param_3 + 1) {
local_c = 0xffffff98;
}
else {
*param_3 = (uint)(param_2 - 0x10000 >> 10) & 0x3ff | 0xd800 |
((uint)(param_2 - 0x10000) & 0x3ff | 0xdc00) << 0x10;
local_c = 4;
}
return local_c;
}
|
|
13,971
|
coro::net::socket::blocking(coro::net::socket::blocking_t)
|
AlayaLite/build_O3/_deps/libcoro-src/src/net/socket.cpp
|
auto socket::blocking(blocking_t block) -> bool
{
if (m_fd < 0)
{
return false;
}
int flags = fcntl(m_fd, F_GETFL, 0);
if (flags == -1)
{
return false;
}
// Add or subtract non-blocking flag.
flags = (block == blocking_t::yes) ? flags & ~O_NONBLOCK : (flags | O_NONBLOCK);
return (fcntl(m_fd, F_SETFL, flags) == 0);
}
|
O3
|
cpp
|
coro::net::socket::blocking(coro::net::socket::blocking_t):
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
testl %edi, %edi
js 0x85c6
movl %esi, %ebp
xorl %r14d, %r14d
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31a0
cmpl $-0x1, %eax
je 0x85c9
xorl %edx, %edx
testl %ebp, %ebp
setne %dl
andl $0xfffff7ff, %eax # imm = 0xFFFFF7FF
shll $0xb, %edx
orl %eax, %edx
movl (%rbx), %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x31a0
testl %eax, %eax
sete %r14b
jmp 0x85c9
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
_ZN4coro3net6socket8blockingENS1_10blocking_tE:
push rbp
push r14
push rbx
mov rbx, rdi
mov edi, [rdi]
test edi, edi
js short loc_85C6
mov ebp, esi
xor r14d, r14d
mov esi, 3
xor edx, edx
xor eax, eax
call _fcntl
cmp eax, 0FFFFFFFFh
jz short loc_85C9
xor edx, edx
test ebp, ebp
setnz dl
and eax, 0FFFFF7FFh
shl edx, 0Bh
or edx, eax
mov edi, [rbx]
mov esi, 4
xor eax, eax
call _fcntl
test eax, eax
setz r14b
jmp short loc_85C9
loc_85C6:
xor r14d, r14d
loc_85C9:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long coro::net::socket::blocking(unsigned int *a1, int a2)
{
long long v3; // rdi
unsigned int v4; // r14d
int v5; // eax
v3 = *a1;
if ( (int)v3 < 0 )
{
return 0;
}
else
{
v4 = 0;
v5 = fcntl(v3, 3LL, 0LL);
if ( v5 != -1 )
LOBYTE(v4) = (unsigned int)fcntl(*a1, 4LL, v5 & 0xFFFFF7FF | ((a2 != 0) << 11)) == 0;
}
return v4;
}
|
blocking:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EDI,dword ptr [RDI]
TEST EDI,EDI
JS 0x001085c6
MOV EBP,ESI
XOR R14D,R14D
MOV ESI,0x3
XOR EDX,EDX
XOR EAX,EAX
CALL 0x001031a0
CMP EAX,-0x1
JZ 0x001085c9
XOR EDX,EDX
TEST EBP,EBP
SETNZ DL
AND EAX,0xfffff7ff
SHL EDX,0xb
OR EDX,EAX
MOV EDI,dword ptr [RBX]
MOV ESI,0x4
XOR EAX,EAX
CALL 0x001031a0
TEST EAX,EAX
SETZ R14B
JMP 0x001085c9
LAB_001085c6:
XOR R14D,R14D
LAB_001085c9:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
/* coro::net::socket::blocking(coro::net::socket::blocking_t) */
bool __thiscall coro::net::socket::blocking(socket *this,int param_2)
{
uint uVar1;
int iVar2;
bool bVar3;
if (*(int *)this < 0) {
bVar3 = false;
}
else {
bVar3 = false;
uVar1 = fcntl(*(int *)this,3,0);
if (uVar1 != 0xffffffff) {
iVar2 = fcntl(*(int *)this,4,(ulong)((uint)(param_2 != 0) << 0xb | uVar1 & 0xfffff7ff));
bVar3 = iVar2 == 0;
}
}
return bVar3;
}
|
|
13,972
|
js_cond_init
|
bluesky950520[P]quickjs/cutils.c
|
void js_cond_init(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
if (pthread_cond_init(cond, NULL))
abort();
#else
pthread_condattr_t attr;
if (pthread_condattr_init(&attr))
abort();
if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
abort();
if (pthread_cond_init(cond, &attr))
abort();
if (pthread_condattr_destroy(&attr))
abort();
#endif
}
|
O0
|
c
|
js_cond_init:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xc(%rsp), %rdi
callq 0xe6e0
cmpl $0x0, %eax
je 0x1fccd
callq 0xe090
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0xe4b0
cmpl $0x0, %eax
je 0x1fce6
callq 0xe090
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0xe600
cmpl $0x0, %eax
je 0x1fcff
callq 0xe090
leaq 0xc(%rsp), %rdi
callq 0xe350
cmpl $0x0, %eax
je 0x1fd13
callq 0xe090
addq $0x18, %rsp
retq
nopl (%rax,%rax)
|
js_cond_init:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_init
cmp eax, 0
jz short loc_1FCCD
call _abort
loc_1FCCD:
lea rdi, [rsp+18h+var_C]
mov esi, 1
call _pthread_condattr_setclock
cmp eax, 0
jz short loc_1FCE6
call _abort
loc_1FCE6:
mov rdi, [rsp+18h+var_8]
lea rsi, [rsp+18h+var_C]
call _pthread_cond_init
cmp eax, 0
jz short loc_1FCFF
call _abort
loc_1FCFF:
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_destroy
cmp eax, 0
jz short loc_1FD13
call _abort
loc_1FD13:
add rsp, 18h
retn
|
long long js_cond_init(long long a1)
{
long long result; // rax
_BYTE v2[4]; // [rsp+Ch] [rbp-Ch] BYREF
long long v3; // [rsp+10h] [rbp-8h]
v3 = a1;
if ( (unsigned int)pthread_condattr_init(v2) )
abort();
if ( (unsigned int)pthread_condattr_setclock(v2, 1LL) )
abort();
if ( (unsigned int)pthread_cond_init(v3, v2) )
abort();
result = pthread_condattr_destroy(v2);
if ( (_DWORD)result )
abort();
return result;
}
|
js_cond_init:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
LEA RDI,[RSP + 0xc]
CALL 0x0010e6e0
CMP EAX,0x0
JZ 0x0011fccd
CALL 0x0010e090
LAB_0011fccd:
LEA RDI,[RSP + 0xc]
MOV ESI,0x1
CALL 0x0010e4b0
CMP EAX,0x0
JZ 0x0011fce6
CALL 0x0010e090
LAB_0011fce6:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0xc]
CALL 0x0010e600
CMP EAX,0x0
JZ 0x0011fcff
CALL 0x0010e090
LAB_0011fcff:
LEA RDI,[RSP + 0xc]
CALL 0x0010e350
CMP EAX,0x0
JZ 0x0011fd13
CALL 0x0010e090
LAB_0011fd13:
ADD RSP,0x18
RET
|
void js_cond_init(pthread_cond_t *param_1)
{
int iVar1;
pthread_condattr_t local_c;
pthread_cond_t *local_8;
local_8 = param_1;
iVar1 = pthread_condattr_init(&local_c);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
iVar1 = pthread_condattr_setclock(&local_c,1);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
iVar1 = pthread_cond_init(local_8,&local_c);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
iVar1 = pthread_condattr_destroy(&local_c);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
return;
}
|
|
13,973
|
js_cond_init
|
bluesky950520[P]quickjs/cutils.c
|
void js_cond_init(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
if (pthread_cond_init(cond, NULL))
abort();
#else
pthread_condattr_t attr;
if (pthread_condattr_init(&attr))
abort();
if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
abort();
if (pthread_cond_init(cond, &attr))
abort();
if (pthread_condattr_destroy(&attr))
abort();
#endif
}
|
O1
|
c
|
js_cond_init:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
callq 0xe6f0
testl %eax, %eax
jne 0x1bbc3
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0xe4b0
testl %eax, %eax
jne 0x1bbc3
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xe600
testl %eax, %eax
jne 0x1bbc3
leaq 0xc(%rsp), %rdi
callq 0xe350
testl %eax, %eax
jne 0x1bbc3
addq $0x10, %rsp
popq %rbx
retq
callq 0xe090
|
js_cond_init:
push rbx
sub rsp, 10h
mov rbx, rdi
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_init
test eax, eax
jnz short loc_1BBC3
lea rdi, [rsp+18h+var_C]
mov esi, 1
call _pthread_condattr_setclock
test eax, eax
jnz short loc_1BBC3
lea rsi, [rsp+18h+var_C]
mov rdi, rbx
call _pthread_cond_init
test eax, eax
jnz short loc_1BBC3
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_destroy
test eax, eax
jnz short loc_1BBC3
add rsp, 10h
pop rbx
retn
loc_1BBC3:
call _abort
|
long long js_cond_init(long long a1)
{
long long result; // rax
_BYTE v2[12]; // [rsp+Ch] [rbp-Ch] BYREF
if ( (unsigned int)pthread_condattr_init(v2)
|| (unsigned int)pthread_condattr_setclock(v2, 1LL)
|| (unsigned int)pthread_cond_init(a1, v2)
|| (result = pthread_condattr_destroy(v2), (_DWORD)result) )
{
abort();
}
return result;
}
|
js_cond_init:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RDI,[RSP + 0xc]
CALL 0x0010e6f0
TEST EAX,EAX
JNZ 0x0011bbc3
LEA RDI,[RSP + 0xc]
MOV ESI,0x1
CALL 0x0010e4b0
TEST EAX,EAX
JNZ 0x0011bbc3
LEA RSI,[RSP + 0xc]
MOV RDI,RBX
CALL 0x0010e600
TEST EAX,EAX
JNZ 0x0011bbc3
LEA RDI,[RSP + 0xc]
CALL 0x0010e350
TEST EAX,EAX
JNZ 0x0011bbc3
ADD RSP,0x10
POP RBX
RET
LAB_0011bbc3:
CALL 0x0010e090
|
void js_cond_init(pthread_cond_t *param_1)
{
int iVar1;
pthread_condattr_t local_c;
iVar1 = pthread_condattr_init(&local_c);
if (iVar1 == 0) {
iVar1 = pthread_condattr_setclock(&local_c,1);
if (iVar1 == 0) {
iVar1 = pthread_cond_init(param_1,&local_c);
if (iVar1 == 0) {
iVar1 = pthread_condattr_destroy(&local_c);
if (iVar1 == 0) {
return;
}
}
}
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
13,974
|
js_cond_init
|
bluesky950520[P]quickjs/cutils.c
|
void js_cond_init(js_cond_t *cond) {
#if defined(__APPLE__) && defined(__MACH__)
if (pthread_cond_init(cond, NULL))
abort();
#else
pthread_condattr_t attr;
if (pthread_condattr_init(&attr))
abort();
if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
abort();
if (pthread_cond_init(cond, &attr))
abort();
if (pthread_condattr_destroy(&attr))
abort();
#endif
}
|
O3
|
c
|
js_cond_init:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
callq 0xe6f0
testl %eax, %eax
jne 0x1c499
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0xe4b0
testl %eax, %eax
jne 0x1c499
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xe600
testl %eax, %eax
jne 0x1c499
leaq 0xc(%rsp), %rdi
callq 0xe350
testl %eax, %eax
jne 0x1c499
addq $0x10, %rsp
popq %rbx
retq
callq 0xe090
|
js_cond_init:
push rbx
sub rsp, 10h
mov rbx, rdi
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_init
test eax, eax
jnz short loc_1C499
lea rdi, [rsp+18h+var_C]
mov esi, 1
call _pthread_condattr_setclock
test eax, eax
jnz short loc_1C499
lea rsi, [rsp+18h+var_C]
mov rdi, rbx
call _pthread_cond_init
test eax, eax
jnz short loc_1C499
lea rdi, [rsp+18h+var_C]
call _pthread_condattr_destroy
test eax, eax
jnz short loc_1C499
add rsp, 10h
pop rbx
retn
loc_1C499:
call _abort
|
long long js_cond_init(long long a1)
{
long long result; // rax
_BYTE v2[12]; // [rsp+Ch] [rbp-Ch] BYREF
if ( (unsigned int)pthread_condattr_init(v2)
|| (unsigned int)pthread_condattr_setclock(v2, 1LL)
|| (unsigned int)pthread_cond_init(a1, v2)
|| (result = pthread_condattr_destroy(v2), (_DWORD)result) )
{
abort();
}
return result;
}
|
js_cond_init:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RDI,[RSP + 0xc]
CALL 0x0010e6f0
TEST EAX,EAX
JNZ 0x0011c499
LEA RDI,[RSP + 0xc]
MOV ESI,0x1
CALL 0x0010e4b0
TEST EAX,EAX
JNZ 0x0011c499
LEA RSI,[RSP + 0xc]
MOV RDI,RBX
CALL 0x0010e600
TEST EAX,EAX
JNZ 0x0011c499
LEA RDI,[RSP + 0xc]
CALL 0x0010e350
TEST EAX,EAX
JNZ 0x0011c499
ADD RSP,0x10
POP RBX
RET
LAB_0011c499:
CALL 0x0010e090
|
void js_cond_init(pthread_cond_t *param_1)
{
int iVar1;
pthread_condattr_t local_c;
iVar1 = pthread_condattr_init(&local_c);
if (iVar1 == 0) {
iVar1 = pthread_condattr_setclock(&local_c,1);
if (iVar1 == 0) {
iVar1 = pthread_cond_init(param_1,&local_c);
if (iVar1 == 0) {
iVar1 = pthread_condattr_destroy(&local_c);
if (iVar1 == 0) {
return;
}
}
}
}
/* WARNING: Subroutine does not return */
abort();
}
|
|
13,975
|
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 0x6eeb7
movq 0x78(%rdi), %r15
movq %rbx, %r12
movq %rbx, %r14
leaq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x721fb
testl %eax, %eax
je 0x6eeb7
movl %eax, %r13d
movq -0x30(%rbp), %rdi
cmpq (%r15), %rdi
ja 0x6ee98
movq 0x8(%r15), %rax
movq %rdi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x6ee98
movzbl %dil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %edi
movq %rdi, -0x30(%rbp)
movq %r14, %rsi
callq 0x72317
testl %eax, %eax
je 0x6eeb7
movl %r13d, %ecx
movl %eax, %eax
addq %rax, %r14
cmpb $0x0, (%r12,%rcx)
leaq (%r12,%rcx), %r12
jne 0x6ee59
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_6EEB7
mov r15, [rdi+78h]
mov r12, rbx
mov r14, rbx
loc_6EE59:
lea rdi, [rbp+var_30]
mov rsi, r12
call my_mb_wc_utf8mb4_no_range
test eax, eax
jz short loc_6EEB7
mov r13d, eax
mov rdi, [rbp+var_30]
cmp rdi, [r15]
ja short loc_6EE98
mov rax, [r15+8]
mov rcx, rdi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_6EE98
movzx ecx, dil
lea rcx, [rcx+rcx*2]
mov edi, [rax+rcx*4]
mov [rbp+var_30], rdi
loc_6EE98:
mov rsi, r14
call my_wc_mb_utf8mb4_no_range
test eax, eax
jz short loc_6EEB7
mov ecx, r13d
mov eax, eax
add r14, rax
cmp byte ptr [r12+rcx], 0
lea r12, [r12+rcx]
jnz short loc_6EE59
loc_6EEB7:
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 0x0016eeb7
MOV R15,qword ptr [RDI + 0x78]
MOV R12,RBX
MOV R14,RBX
LAB_0016ee59:
LEA RDI,[RBP + -0x30]
MOV RSI,R12
CALL 0x001721fb
TEST EAX,EAX
JZ 0x0016eeb7
MOV R13D,EAX
MOV RDI,qword ptr [RBP + -0x30]
CMP RDI,qword ptr [R15]
JA 0x0016ee98
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,RDI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x0016ee98
MOVZX ECX,DIL
LEA RCX,[RCX + RCX*0x2]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x30],RDI
LAB_0016ee98:
MOV RSI,R14
CALL 0x00172317
TEST EAX,EAX
JZ 0x0016eeb7
MOV ECX,R13D
MOV EAX,EAX
ADD R14,RAX
CMP byte ptr [R12 + RCX*0x1],0x0
LEA R12,[R12 + RCX*0x1]
JNZ 0x0016ee59
LAB_0016eeb7:
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;
}
|
|
13,976
|
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>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>)
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
#if JSON_DIAGNOSTIC_POSITIONS
swap(start_position, other.start_position);
swap(end_position, other.end_position);
#endif
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
}
|
O2
|
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>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x1c730
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0x1c730
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push rbp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
push 1
pop rbp
mov rdi, rsi
mov esi, ebp
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+8], rax
mov rdi, r14
mov esi, ebp
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, r14
pop rbx
pop r14
pop rbp
retn
|
char * 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>::operator=(
char *a1,
char *a2)
{
char v2; // al
long long v3; // rax
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>::assert_invariant(
a2,
1LL);
v2 = *a1;
*a1 = *a2;
*a2 = v2;
v3 = *((_QWORD *)a1 + 1);
*((_QWORD *)a1 + 1) = *((_QWORD *)a2 + 1);
*((_QWORD *)a2 + 1) = v3;
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>::assert_invariant(
a1,
1LL);
return a1;
}
|
operator=:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
PUSH 0x1
POP RBP
MOV RDI,RSI
MOV ESI,EBP
CALL 0x0011c730
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,EBP
CALL 0x0011c730
MOV RAX,R14
POP RBX
POP R14
POP RBP
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>::TEMPNAMEPLACEHOLDERVALUE(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>
* __thiscall
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>
::operator=(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2)
{
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
|
|
13,977
|
stbi_load_16_from_memory
|
llama.cpp/examples/llava/../../common/stb_image.h
|
STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
}
|
O3
|
c
|
stbi_load_16_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x18a6e
addq $0xe8, %rsp
retq
|
stbi_load_16_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
mov qword ptr [rax+10h], 0
xor r10d, r10d
mov [rax+30h], r10d
mov [rax+0B8h], r10d
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rsi, esi
add rsi, rdi
mov [rax+0D8h], rsi
mov [rax+0C8h], rsi
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8d, r9d
call _ZL32stbi__load_and_postprocess_16bitP13stbi__contextPiS1_S1_i; stbi__load_and_postprocess_16bit(stbi__context *,int *,int *,int *,int)
add rsp, 0E8h
retn
|
_WORD * stbi_load_16_from_memory(long long a1, int a2, int *a3, int *a4, int *a5, unsigned int a6)
{
_BYTE v7[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v8; // [rsp+18h] [rbp-D0h]
int v9; // [rsp+38h] [rbp-B0h]
int v10; // [rsp+C0h] [rbp-28h]
long long v11; // [rsp+C8h] [rbp-20h]
long long v12; // [rsp+D0h] [rbp-18h]
long long v13; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v8 = 0LL;
v9 = 0;
v10 = 0;
v13 = a1;
v11 = a1;
v14 = a1 + a2;
v12 = v14;
return stbi__load_and_postprocess_16bit((long long)v7, a3, a4, a5, a6);
}
|
stbi_load_16_from_memory:
SUB RSP,0xe8
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x10],0x0
XOR R10D,R10D
MOV dword ptr [RAX + 0x30],R10D
MOV dword ptr [RAX + 0xb8],R10D
MOV qword ptr [RAX + 0xd0],RDI
MOV qword ptr [RAX + 0xc0],RDI
MOVSXD RSI,ESI
ADD RSI,RDI
MOV qword ptr [RAX + 0xd8],RSI
MOV qword ptr [RAX + 0xc8],RSI
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8D,R9D
CALL 0x00118a6e
ADD RSP,0xe8
RET
|
void stbi_load_16_from_memory
(long param_1,int param_2,int *param_3,int *param_4,int *param_5,int param_6)
{
stbi__context local_e0 [16];
int8 local_d0;
int4 local_b0;
int4 local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_d0 = 0;
local_b0 = 0;
local_28 = 0;
local_18 = param_2 + param_1;
local_20 = param_1;
local_10 = param_1;
local_8 = local_18;
stbi__load_and_postprocess_16bit(local_e0,param_3,param_4,param_5,param_6);
return;
}
|
|
13,978
|
maria_page_crc_set_normal
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= share->block_size - CRC_SIZE;
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_normal");
DBUG_PRINT("info", ("Page %lu crc: %lu", (ulong) page_no, (ulong)crc));
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + data_length, crc);
DBUG_RETURN(0);
}
|
O0
|
c
|
maria_page_crc_set_normal:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x7bc(%rax), %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x5d520
movl %eax, -0x28(%rbp)
jmp 0x5d5b6
jmp 0x5d5b8
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x5d5d2
jmp 0x5d5d4
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
maria_page_crc_set_normal:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+7BCh]
sub eax, 4
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov edi, eax
mov rsi, [rbp+var_10]
mov edx, [rbp+var_24]
call maria_page_crc
mov [rbp+var_28], eax
jmp short $+2
loc_5D5B6:
jmp short $+2
loc_5D5B8:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_24]
add rax, rcx
mov [rbp+var_30], rax
mov ecx, [rbp+var_28]
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_5D5D2:
jmp short $+2
loc_5D5D4:
xor eax, eax
add rsp, 30h
pop rbp
retn
|
long long maria_page_crc_set_normal(long long *a1)
{
_DWORD *v2; // [rsp+0h] [rbp-30h]
long long v3; // [rsp+10h] [rbp-20h]
v3 = a1[2];
v2 = (_DWORD *)(*(_DWORD *)(v3 + 1980) - 4 + *a1);
*v2 = maria_page_crc(a1[1], *a1, *(_DWORD *)(v3 + 1980) - 4);
return 0LL;
}
|
maria_page_crc_set_normal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x7bc]
SUB EAX,0x4
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
CALL 0x0015d520
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0015d5b6
LAB_0015d5b6:
JMP 0x0015d5b8
LAB_0015d5b8:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
JMP 0x0015d5d2
LAB_0015d5d2:
JMP 0x0015d5d4
LAB_0015d5d4:
XOR EAX,EAX
ADD RSP,0x30
POP RBP
RET
|
int8 maria_page_crc_set_normal(long *param_1)
{
long lVar1;
int iVar2;
int4 uVar3;
lVar1 = *param_1;
iVar2 = *(int *)(param_1[2] + 0x7bc) + -4;
uVar3 = maria_page_crc(param_1[1] & 0xffffffff,lVar1,iVar2);
*(int4 *)(lVar1 + iVar2) = uVar3;
return 0;
}
|
|
13,979
|
delete_setup_actor(String const*, String const*, String const*)
|
eloqsql/storage/perfschema/pfs_setup_actor.cc
|
int delete_setup_actor(const String *user, const String *host, const String *role)
{
PFS_thread *thread= PFS_thread::get_current_thread();
if (unlikely(thread == NULL))
return HA_ERR_OUT_OF_MEM;
LF_PINS* pins= get_setup_actor_hash_pins(thread);
if (unlikely(pins == NULL))
return HA_ERR_OUT_OF_MEM;
PFS_setup_actor_key key;
set_setup_actor_key(&key,
user->ptr(), user->length(),
host->ptr(), host->length(),
role->ptr(), role->length());
PFS_setup_actor **entry;
entry= reinterpret_cast<PFS_setup_actor**>
(lf_hash_search(&setup_actor_hash, pins, key.m_hash_key, key.m_key_length));
if (entry && (entry != MY_ERRPTR))
{
PFS_setup_actor *pfs= *entry;
lf_hash_delete(&setup_actor_hash, pins, key.m_hash_key, key.m_key_length);
global_setup_actor_container.deallocate(pfs);
}
lf_hash_search_unpin(pins);
update_setup_actors_derived_flags();
return 0;
}
|
O0
|
cpp
|
delete_setup_actor(String const*, String const*, String const*):
pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x2e0(%rbp)
movq %rsi, -0x2e8(%rbp)
movq %rdx, -0x2f0(%rbp)
callq 0x2ee20
movq %rax, -0x2f8(%rbp)
cmpq $0x0, -0x2f8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3fc6d
movl $0x80, -0x2d4(%rbp)
jmp 0x3fe05
movq -0x2f8(%rbp), %rdi
callq 0x3fa60
movq %rax, -0x300(%rbp)
cmpq $0x0, -0x300(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3fca4
movl $0x80, -0x2d4(%rbp)
jmp 0x3fe05
movq -0x2e0(%rbp), %rdi
addq $0x8, %rdi
callq 0x407b0
movq %rax, -0x340(%rbp)
movq -0x2e0(%rbp), %rdi
addq $0x8, %rdi
callq 0x407d0
movl %eax, -0x334(%rbp)
movq -0x2e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x407b0
movq %rax, -0x330(%rbp)
movq -0x2e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x407d0
movl %eax, -0x324(%rbp)
movq -0x2f0(%rbp), %rdi
addq $0x8, %rdi
callq 0x407b0
movq %rax, -0x320(%rbp)
movq -0x2f0(%rbp), %rdi
addq $0x8, %rdi
callq 0x407d0
movq -0x340(%rbp), %rsi
movl -0x334(%rbp), %edx
movq -0x330(%rbp), %rcx
movl -0x324(%rbp), %r8d
movq -0x320(%rbp), %r9
leaq -0x2d0(%rbp), %rdi
movl %eax, (%rsp)
callq 0x3fad0
movq -0x300(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x3cd1d2(%rip), %rdi # 0x40cf40
callq 0x5d8b0
movq %rax, -0x308(%rbp)
cmpq $0x0, -0x308(%rbp)
je 0x3fdd3
movl $0x1, %eax
cmpq %rax, -0x308(%rbp)
je 0x3fdd3
movq -0x308(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x310(%rbp)
movq -0x300(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x3cd185(%rip), %rdi # 0x40cf40
callq 0x5ce90
movq -0x310(%rbp), %rsi
leaq 0x3989da(%rip), %rdi # 0x3d87a8
callq 0x407f0
jmp 0x3fdd5
jmp 0x3fdd7
jmp 0x3fdd9
movq -0x300(%rbp), %rcx
movq $0x0, -0x318(%rbp)
movq -0x318(%rbp), %rax
xchgq %rax, 0x10(%rcx)
callq 0x3fbc0
movl $0x0, -0x2d4(%rbp)
movl -0x2d4(%rbp), %eax
movl %eax, -0x344(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3fe32
movl -0x344(%rbp), %eax
addq $0x350, %rsp # imm = 0x350
popq %rbp
retq
callq 0x26360
nopw (%rax,%rax)
|
_Z18delete_setup_actorPK6StringS1_S1_:
push rbp
mov rbp, rsp
sub rsp, 350h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2E0], rdi
mov [rbp+var_2E8], rsi
mov [rbp+var_2F0], rdx
call _ZN10PFS_thread18get_current_threadEv; PFS_thread::get_current_thread(void)
mov [rbp+var_2F8], rax
cmp [rbp+var_2F8], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_3FC6D
mov [rbp+var_2D4], 80h
jmp loc_3FE05
loc_3FC6D:
mov rdi, [rbp+var_2F8]; PFS_thread *
call _ZL25get_setup_actor_hash_pinsP10PFS_thread; get_setup_actor_hash_pins(PFS_thread *)
mov [rbp+var_300], rax
cmp [rbp+var_300], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_3FCA4
mov [rbp+var_2D4], 80h
jmp loc_3FE05
loc_3FCA4:
mov rdi, [rbp+var_2E0]
add rdi, 8; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_340], rax
mov rdi, [rbp+var_2E0]
add rdi, 8; this
call _ZNK13Binary_string6lengthEv; Binary_string::length(void)
mov [rbp+var_334], eax
mov rdi, [rbp+var_2E8]
add rdi, 8; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_330], rax
mov rdi, [rbp+var_2E8]
add rdi, 8; this
call _ZNK13Binary_string6lengthEv; Binary_string::length(void)
mov [rbp+var_324], eax
mov rdi, [rbp+var_2F0]
add rdi, 8; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_320], rax
mov rdi, [rbp+var_2F0]
add rdi, 8; this
call _ZNK13Binary_string6lengthEv; Binary_string::length(void)
mov rsi, [rbp+var_340]
mov edx, [rbp+var_334]
mov rcx, [rbp+var_330]
mov r8d, [rbp+var_324]
mov r9, [rbp+var_320]
lea rdi, [rbp+var_2D0]
mov [rsp+350h+var_350], eax
call _ZL19set_setup_actor_keyP19PFS_setup_actor_keyPKcjS2_jS2_j; set_setup_actor_key(PFS_setup_actor_key *,char const*,uint,char const*,uint,char const*,uint)
mov rsi, [rbp+var_300]
lea rdx, [rbp+var_2D0]
mov ecx, [rbp+var_C]
lea rdi, setup_actor_hash
call lf_hash_search
mov [rbp+var_308], rax
cmp [rbp+var_308], 0
jz short loc_3FDD3
mov eax, 1
cmp [rbp+var_308], rax
jz short loc_3FDD3
mov rax, [rbp+var_308]
mov rax, [rax]
mov [rbp+var_310], rax
mov rsi, [rbp+var_300]
lea rdx, [rbp+var_2D0]
mov ecx, [rbp+var_C]
lea rdi, setup_actor_hash
call lf_hash_delete
mov rsi, [rbp+var_310]
lea rdi, global_setup_actor_container
call _ZN29PFS_buffer_scalable_containerI15PFS_setup_actorLi128ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE10deallocateEPS0_; PFS_buffer_scalable_container<PFS_setup_actor,128,1024,PFS_buffer_default_array<PFS_setup_actor>,PFS_buffer_default_allocator<PFS_setup_actor>>::deallocate(PFS_setup_actor*)
loc_3FDD3:
jmp short $+2
loc_3FDD5:
jmp short $+2
loc_3FDD7:
jmp short $+2
loc_3FDD9:
mov rcx, [rbp+var_300]
mov [rbp+var_318], 0
mov rax, [rbp+var_318]
xchg rax, [rcx+10h]
call _Z33update_setup_actors_derived_flagsv; update_setup_actors_derived_flags(void)
mov [rbp+var_2D4], 0
loc_3FE05:
mov eax, [rbp+var_2D4]
mov [rbp+var_344], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3FE32
mov eax, [rbp+var_344]
add rsp, 350h
pop rbp
retn
loc_3FE32:
call ___stack_chk_fail
|
long long delete_setup_actor(const String *a1, const String *a2, const String *a3)
{
unsigned int v3; // eax
PFS_thread *v4; // rdi
long long v6; // [rsp+10h] [rbp-340h]
unsigned int v7; // [rsp+1Ch] [rbp-334h]
long long v8; // [rsp+20h] [rbp-330h]
unsigned int v9; // [rsp+2Ch] [rbp-324h]
long long v10; // [rsp+30h] [rbp-320h]
long long v11; // [rsp+40h] [rbp-310h]
long long *v12; // [rsp+48h] [rbp-308h]
long long setup_actor_hash_pins; // [rsp+50h] [rbp-300h]
PFS_thread *current_thread; // [rsp+58h] [rbp-2F8h]
_BYTE v17[708]; // [rsp+80h] [rbp-2D0h] BYREF
unsigned int v18; // [rsp+344h] [rbp-Ch]
unsigned long long v19; // [rsp+348h] [rbp-8h]
v19 = __readfsqword(0x28u);
current_thread = (PFS_thread *)PFS_thread::get_current_thread(a1);
if ( current_thread )
{
setup_actor_hash_pins = get_setup_actor_hash_pins(current_thread);
if ( setup_actor_hash_pins )
{
v6 = Binary_string::ptr((const String *)((char *)a1 + 8));
v7 = Binary_string::length((const String *)((char *)a1 + 8));
v8 = Binary_string::ptr((const String *)((char *)a2 + 8));
v9 = Binary_string::length((const String *)((char *)a2 + 8));
v10 = Binary_string::ptr((const String *)((char *)a3 + 8));
v3 = Binary_string::length((const String *)((char *)a3 + 8));
set_setup_actor_key((long long)v17, v6, v7, v8, v9, v10, v3);
v4 = (PFS_thread *)&setup_actor_hash;
v12 = (long long *)lf_hash_search(&setup_actor_hash, setup_actor_hash_pins, v17, v18);
if ( (unsigned long long)v12 >= 2 )
{
v11 = *v12;
lf_hash_delete(&setup_actor_hash, setup_actor_hash_pins, v17, v18);
v4 = (PFS_thread *)&global_setup_actor_container;
PFS_buffer_scalable_container<PFS_setup_actor,128,1024,PFS_buffer_default_array<PFS_setup_actor>,PFS_buffer_default_allocator<PFS_setup_actor>>::deallocate(
&global_setup_actor_container,
v11);
}
_InterlockedExchange64((volatile long long *)(setup_actor_hash_pins + 16), 0LL);
update_setup_actors_derived_flags(v4);
return 0;
}
else
{
return 128;
}
}
else
{
return 128;
}
}
|
delete_setup_actor:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x350
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x2e0],RDI
MOV qword ptr [RBP + -0x2e8],RSI
MOV qword ptr [RBP + -0x2f0],RDX
CALL 0x0012ee20
MOV qword ptr [RBP + -0x2f8],RAX
CMP qword ptr [RBP + -0x2f8],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013fc6d
MOV dword ptr [RBP + -0x2d4],0x80
JMP 0x0013fe05
LAB_0013fc6d:
MOV RDI,qword ptr [RBP + -0x2f8]
CALL 0x0013fa60
MOV qword ptr [RBP + -0x300],RAX
CMP qword ptr [RBP + -0x300],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013fca4
MOV dword ptr [RBP + -0x2d4],0x80
JMP 0x0013fe05
LAB_0013fca4:
MOV RDI,qword ptr [RBP + -0x2e0]
ADD RDI,0x8
CALL 0x001407b0
MOV qword ptr [RBP + -0x340],RAX
MOV RDI,qword ptr [RBP + -0x2e0]
ADD RDI,0x8
CALL 0x001407d0
MOV dword ptr [RBP + -0x334],EAX
MOV RDI,qword ptr [RBP + -0x2e8]
ADD RDI,0x8
CALL 0x001407b0
MOV qword ptr [RBP + -0x330],RAX
MOV RDI,qword ptr [RBP + -0x2e8]
ADD RDI,0x8
CALL 0x001407d0
MOV dword ptr [RBP + -0x324],EAX
MOV RDI,qword ptr [RBP + -0x2f0]
ADD RDI,0x8
CALL 0x001407b0
MOV qword ptr [RBP + -0x320],RAX
MOV RDI,qword ptr [RBP + -0x2f0]
ADD RDI,0x8
CALL 0x001407d0
MOV RSI,qword ptr [RBP + -0x340]
MOV EDX,dword ptr [RBP + -0x334]
MOV RCX,qword ptr [RBP + -0x330]
MOV R8D,dword ptr [RBP + -0x324]
MOV R9,qword ptr [RBP + -0x320]
LEA RDI,[RBP + -0x2d0]
MOV dword ptr [RSP],EAX
CALL 0x0013fad0
MOV RSI,qword ptr [RBP + -0x300]
LEA RDX,[RBP + -0x2d0]
MOV ECX,dword ptr [RBP + -0xc]
LEA RDI,[0x50cf40]
CALL 0x0015d8b0
MOV qword ptr [RBP + -0x308],RAX
CMP qword ptr [RBP + -0x308],0x0
JZ 0x0013fdd3
MOV EAX,0x1
CMP qword ptr [RBP + -0x308],RAX
JZ 0x0013fdd3
MOV RAX,qword ptr [RBP + -0x308]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x310],RAX
MOV RSI,qword ptr [RBP + -0x300]
LEA RDX,[RBP + -0x2d0]
MOV ECX,dword ptr [RBP + -0xc]
LEA RDI,[0x50cf40]
CALL 0x0015ce90
MOV RSI,qword ptr [RBP + -0x310]
LEA RDI,[0x4d87a8]
CALL 0x001407f0
LAB_0013fdd3:
JMP 0x0013fdd5
LAB_0013fdd5:
JMP 0x0013fdd7
LAB_0013fdd7:
JMP 0x0013fdd9
LAB_0013fdd9:
MOV RCX,qword ptr [RBP + -0x300]
MOV qword ptr [RBP + -0x318],0x0
MOV RAX,qword ptr [RBP + -0x318]
XCHG qword ptr [RCX + 0x10],RAX
CALL 0x0013fbc0
MOV dword ptr [RBP + -0x2d4],0x0
LAB_0013fe05:
MOV EAX,dword ptr [RBP + -0x2d4]
MOV dword ptr [RBP + -0x344],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013fe32
MOV EAX,dword ptr [RBP + -0x344]
ADD RSP,0x350
POP RBP
RET
LAB_0013fe32:
CALL 0x00126360
|
/* delete_setup_actor(String const*, String const*, String const*) */
int4 delete_setup_actor(String *param_1,String *param_2,String *param_3)
{
PFS_setup_actor *pPVar1;
uint uVar2;
uint uVar3;
uint uVar4;
PFS_thread *pPVar5;
long lVar6;
char *pcVar7;
char *pcVar8;
char *pcVar9;
int8 *puVar10;
long in_FS_OFFSET;
int4 local_2dc;
PFS_setup_actor_key local_2d8 [708];
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pPVar5 = (PFS_thread *)PFS_thread::get_current_thread();
if (pPVar5 == (PFS_thread *)0x0) {
local_2dc = 0x80;
}
else {
lVar6 = get_setup_actor_hash_pins(pPVar5);
if (lVar6 == 0) {
local_2dc = 0x80;
}
else {
pcVar7 = (char *)Binary_string::ptr((Binary_string *)(param_1 + 8));
uVar2 = Binary_string::length((Binary_string *)(param_1 + 8));
pcVar8 = (char *)Binary_string::ptr((Binary_string *)(param_2 + 8));
uVar3 = Binary_string::length((Binary_string *)(param_2 + 8));
pcVar9 = (char *)Binary_string::ptr((Binary_string *)(param_3 + 8));
uVar4 = Binary_string::length((Binary_string *)(param_3 + 8));
set_setup_actor_key(local_2d8,pcVar7,uVar2,pcVar8,uVar3,pcVar9,uVar4);
puVar10 = (int8 *)lf_hash_search(setup_actor_hash,lVar6,local_2d8,local_14);
if ((puVar10 != (int8 *)0x0) && (puVar10 != (int8 *)0x1)) {
pPVar1 = (PFS_setup_actor *)*puVar10;
lf_hash_delete(setup_actor_hash,lVar6,local_2d8,local_14);
PFS_buffer_scalable_container<PFS_setup_actor,128,1024,PFS_buffer_default_array<PFS_setup_actor>,PFS_buffer_default_allocator<PFS_setup_actor>>
::deallocate((PFS_buffer_scalable_container<PFS_setup_actor,128,1024,PFS_buffer_default_array<PFS_setup_actor>,PFS_buffer_default_allocator<PFS_setup_actor>>
*)global_setup_actor_container,pPVar1);
}
LOCK();
*(int8 *)(lVar6 + 0x10) = 0;
UNLOCK();
update_setup_actors_derived_flags();
local_2dc = 0;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_2dc;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
13,980
|
minja::Value::operator<(minja::Value const&) const
|
monkey531[P]llama/common/minja.hpp
|
bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " < " + other.dump());
}
|
O3
|
cpp
|
minja::Value::operator<(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xbb4c9
cmpq $0x0, 0x10(%r15)
jne 0xbb4c9
testb %al, %al
jne 0xbb4c9
cmpq $0x0, 0x30(%r15)
je 0xbb5cc
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0xbb503
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0xbb5fe
movq %r15, %rdi
callq 0xaa530
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
callq 0xaa530
ucomisd 0x48(%rsp), %xmm0
seta %bl
jmp 0xbb5ba
cmpb $0x3, %al
jne 0xbb5fe
cmpb $0x3, 0x40(%r14)
jne 0xbb5fe
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xab4ca
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xab4ca
movq 0x30(%rsp), %r15
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
testq %rdx, %rdx
je 0xbb561
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1d530
movl %eax, %ebx
testl %eax, %eax
jne 0xbb582
subq %r12, %r15
cmpq $-0x7fffffff, %r15 # imm = 0x80000001
movq $-0x80000000, %rbx # imm = 0x80000000
cmovgeq %r15, %rbx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %rbx
cmovgeq %rax, %rbx
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0xbb59c
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1dc50
shrl $0x1f, %ebx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb5ba
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x59d06(%rip), %rsi # 0x1152e6
movq %rax, %rdi
callq 0x1d410
movq 0x9a9f9(%rip), %rsi # 0x155fe8
movq 0x9a962(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa67c
leaq 0x5a8b0(%rip), %rsi # 0x115ed6
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x9cdd5
leaq 0x5a8af(%rip), %rsi # 0x115eee
leaq 0x90(%rsp), %rdi
callq 0x1e870
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbb66d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xbb67a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xaa67c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x9ce45
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e430
xorl %ebp, %ebp
movq 0x9a915(%rip), %rsi # 0x155fe8
movq 0x9a87e(%rip), %rdx # 0x155f58
movq %rbx, %rdi
callq 0x1e5b0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb708
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb708
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb731
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb731
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xbb750
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb750
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb771
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb78c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
testb %bpl, %bpl
jne 0xbb7d8
jmp 0xbb7e0
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb7d8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb7d8
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb7e0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbb7e0
jmp 0xbb7d5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8c0
movq %r14, %rdi
callq 0x1e660
|
_ZNK5minja5ValueltERKS0_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0B0h
mov r14, rsi
mov r15, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_BB4C9
cmp qword ptr [r15+10h], 0
jnz short loc_BB4C9
test al, al
jnz short loc_BB4C9
cmp qword ptr [r15+30h], 0
jz loc_BB5CC
loc_BB4C9:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_BB503
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_BB5FE
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0D8h+var_90], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
ucomisd xmm0, [rsp+0D8h+var_90]
setnbe bl
jmp loc_BB5BA
loc_BB503:
cmp al, 3
jnz loc_BB5FE
cmp byte ptr [r14+40h], 3
jnz loc_BB5FE
lea rdi, [rsp+0D8h+var_B0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0D8h+var_D0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r15, [rsp+0D8h+var_A8]
mov r14, [rsp+0D8h+var_D0]
mov r12, [rsp+0D8h+var_C8]
cmp r12, r15
mov rdx, r15
cmovb rdx, r12
test rdx, rdx
jz short loc_BB561
mov rdi, [rsp+0D8h+var_B0]
mov rsi, r14
call _memcmp
mov ebx, eax
test eax, eax
jnz short loc_BB582
loc_BB561:
sub r15, r12
cmp r15, 0FFFFFFFF80000001h
mov rbx, 0FFFFFFFF80000000h
cmovge rbx, r15
mov eax, 7FFFFFFFh
cmp rbx, rax
cmovge rbx, rax
loc_BB582:
lea rax, [rsp+0D8h+var_C0]
cmp r14, rax
jz short loc_BB59C
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_BB59C:
shr ebx, 1Fh
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB5BA
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB5BA:
mov eax, ebx
add rsp, 0B0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BB5CC:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_BB5FE:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0D8h+var_88]
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0D8h+var_48]
lea rdx, [rsp+0D8h+var_88]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rsi, asc_115EEE; " < "
lea rdi, [rsp+0D8h+var_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+0D8h+var_C0]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_BB66D
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
jmp short loc_BB67A
loc_BB66D:
mov [rsp+0D8h+var_D0], rdx
mov rdx, [rcx]
mov [rsp+0D8h+var_C0], rdx
loc_BB67A:
mov rdx, [rax+8]
mov [rsp+0D8h+var_C8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0D8h+var_68]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_D0]
lea rdx, [rsp+0D8h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0D8h+var_B0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB708
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB708
mov r14, rax
mov bpl, 1
loc_BB708:
lea rax, [rsp+0D8h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB731
mov rsi, [rsp+0D8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB731
mov r14, rax
mov bpl, 1
loc_BB731:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r15
jz short loc_BB750
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB750
mov r14, rax
mov bpl, 1
loc_BB750:
lea rax, [rsp+0D8h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB771
mov rsi, [rsp+0D8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB771:
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB78C
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BB78C:
test bpl, bpl
jnz short loc_BB7D8
jmp short loc_BB7E0
mov r14, rax
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB7D8
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB7D8
mov r14, rax
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BB7E0
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BB7E0
jmp short $+2
loc_BB7D5:
mov r14, rax
loc_BB7D8:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_BB7E0:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::operator<(long long a1, long long a2)
{
unsigned int v2; // ebx
char v3; // al
unsigned long long v4; // r15
__int128 *v5; // r14
unsigned long long v6; // r12
unsigned long long v7; // rdx
long long v8; // rbx
long long v9; // r15
std::runtime_error *exception; // rbx
void *v12; // rbx
long long v13; // rax
__int128 *v14; // rcx
void *v15; // [rsp+8h] [rbp-D0h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-C8h]
__int128 v17; // [rsp+18h] [rbp-C0h] BYREF
long long *v18; // [rsp+28h] [rbp-B0h] BYREF
unsigned long long v19; // [rsp+30h] [rbp-A8h]
long long v20; // [rsp+38h] [rbp-A0h] BYREF
double v21; // [rsp+48h] [rbp-90h]
_BYTE v22[16]; // [rsp+50h] [rbp-88h] BYREF
_QWORD v23[2]; // [rsp+70h] [rbp-68h] BYREF
_BYTE v24[16]; // [rsp+90h] [rbp-48h] BYREF
v3 = *(_BYTE *)(a1 + 64);
if ( !*(_QWORD *)(a1 + 32) && !*(_QWORD *)(a1 + 16) && !v3 && !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(v3 - 5) <= 2u )
{
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) <= 2u )
{
v21 = minja::Value::get<double>(a1);
LOBYTE(v2) = minja::Value::get<double>(a2) > v21;
return v2;
}
LABEL_24:
v12 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v22, a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v24, (long long)"Cannot compare values: ", (long long)v22);
v13 = std::string::append(v24, " < ");
v15 = &v17;
v14 = (__int128 *)(v13 + 16);
if ( *(_QWORD *)v13 == v13 + 16 )
{
v17 = *v14;
}
else
{
v15 = *(void **)v13;
*(_QWORD *)&v17 = *(_QWORD *)v14;
}
v16 = *(_QWORD *)(v13 + 8);
*(_QWORD *)v13 = v14;
*(_QWORD *)(v13 + 8) = 0LL;
*(_BYTE *)(v13 + 16) = 0;
minja::Value::dump[abi:cxx11]((long long)v23, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v18, &v15, v23);
std::runtime_error::runtime_error(v12, &v18);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 != 3 || *(_BYTE *)(a2 + 64) != 3 )
goto LABEL_24;
minja::Value::get<std::string>((long long)&v18, (_QWORD *)a1);
minja::Value::get<std::string>((long long)&v15, (_QWORD *)a2);
v4 = v19;
v5 = (__int128 *)v15;
v6 = v16;
v7 = v19;
if ( v16 < v19 )
v7 = v16;
if ( !v7 || (LODWORD(v8) = memcmp(v18, v15), !(_DWORD)v8) )
{
v9 = v4 - v6;
v8 = 0xFFFFFFFF80000000LL;
if ( v9 >= -2147483647 )
v8 = v9;
if ( v8 >= 0x7FFFFFFF )
LODWORD(v8) = 0x7FFFFFFF;
}
if ( v5 != &v17 )
operator delete(v5, v17 + 1);
v2 = (unsigned int)v8 >> 31;
if ( v18 != &v20 )
operator delete(v18, v20 + 1);
return v2;
}
|
operator<:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV R14,RSI
MOV R15,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x001bb4c9
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x001bb4c9
TEST AL,AL
JNZ 0x001bb4c9
CMP qword ptr [R15 + 0x30],0x0
JZ 0x001bb5cc
LAB_001bb4c9:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x001bb503
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x001bb5fe
MOV RDI,R15
CALL 0x001aa530
MOVSD qword ptr [RSP + 0x48],XMM0
MOV RDI,R14
CALL 0x001aa530
UCOMISD XMM0,qword ptr [RSP + 0x48]
SETA BL
JMP 0x001bb5ba
LAB_001bb503:
CMP AL,0x3
JNZ 0x001bb5fe
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x001bb5fe
LEA RDI,[RSP + 0x28]
MOV RSI,R15
CALL 0x001ab4ca
LAB_001bb523:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x001ab4ca
LAB_001bb530:
MOV R15,qword ptr [RSP + 0x30]
MOV R14,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RSP + 0x10]
CMP R12,R15
MOV RDX,R15
CMOVC RDX,R12
TEST RDX,RDX
JZ 0x001bb561
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,R14
CALL 0x0011d530
MOV EBX,EAX
TEST EAX,EAX
JNZ 0x001bb582
LAB_001bb561:
SUB R15,R12
CMP R15,-0x7fffffff
MOV RBX,-0x80000000
CMOVGE RBX,R15
MOV EAX,0x7fffffff
CMP RBX,RAX
CMOVGE RBX,RAX
LAB_001bb582:
LEA RAX,[RSP + 0x18]
CMP R14,RAX
JZ 0x001bb59c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV RDI,R14
CALL 0x0011dc50
LAB_001bb59c:
SHR EBX,0x1f
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001bb5ba
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011dc50
LAB_001bb5ba:
MOV EAX,EBX
ADD RSP,0xb0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001bb5cc:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001bb5d9:
LEA RSI,[0x2152e6]
MOV RDI,RAX
CALL 0x0011d410
LAB_001bb5e8:
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
LAB_001bb5fe:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001bb60b:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa67c
LAB_001bb61f:
LEA RSI,[0x215ed6]
LEA RDI,[RSP + 0x90]
LEA RDX,[RSP + 0x50]
CALL 0x0019cdd5
LAB_001bb638:
LEA RSI,[0x215eee]
LEA RDI,[RSP + 0x90]
CALL 0x0011e870
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JNZ 0x001bb66d
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
JMP 0x001bb67a
LAB_001bb66d:
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
LAB_001bb67a:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001bb692:
LEA RDI,[RSP + 0x70]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001aa67c
LAB_001bb6a6:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x70]
CALL 0x0019ce45
MOV BPL,0x1
LAB_001bb6bd:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011e430
XOR EBP,EBP
MOV RSI,qword ptr [0x00255fe8]
MOV RDX,qword ptr [0x00255f58]
MOV RDI,RBX
CALL 0x0011e5b0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator<(Value *this,Value *param_1)
{
Value VVar1;
double dVar2;
uint uVar3;
runtime_error *prVar4;
long *plVar5;
long *plVar6;
ulong uVar7;
int8 unaff_RBX;
long *local_d0;
ulong local_c8;
long local_c0;
long lStack_b8;
long *local_b0;
ulong local_a8;
long local_a0 [2];
double local_90;
int1 local_88 [32];
int1 local_68 [32];
char local_48 [32];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001bb5d9 to 001bb5e7 has its CatchHandler @ 001bb7d5 */
std::runtime_error::runtime_error(prVar4,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
if ((byte)((char)VVar1 - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_001bb5fe:
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001bb60b to 001bb61e has its CatchHandler @ 001bb7d3 */
dump_abi_cxx11_((int)local_88,SUB81(this,0));
/* try { // try from 001bb61f to 001bb637 has its CatchHandler @ 001bb793 */
std::operator+(local_48,(string *)"Cannot compare values: ");
/* try { // try from 001bb638 to 001bb64b has its CatchHandler @ 001bb74a */
plVar5 = (long *)std::__cxx11::string::append(local_48);
local_d0 = (long *)*plVar5;
plVar6 = plVar5 + 2;
if (local_d0 == plVar6) {
local_c0 = *plVar6;
lStack_b8 = plVar5[3];
local_d0 = &local_c0;
}
else {
local_c0 = *plVar6;
}
local_c8 = plVar5[1];
*plVar5 = (long)plVar6;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
/* try { // try from 001bb692 to 001bb6a5 has its CatchHandler @ 001bb72b */
dump_abi_cxx11_((int)local_68,SUB81(param_1,0));
/* try { // try from 001bb6a6 to 001bb6b9 has its CatchHandler @ 001bb702 */
std::operator+((string *)&local_b0,(string *)&local_d0);
/* try { // try from 001bb6bd to 001bb6e1 has its CatchHandler @ 001bb6e2 */
std::runtime_error::runtime_error(prVar4,(string *)&local_b0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00255fe8,PTR__runtime_error_00255f58);
}
local_90 = get<double>(this);
dVar2 = get<double>(param_1);
uVar7 = CONCAT71((int7)((ulong)unaff_RBX >> 8),local_90 < dVar2);
goto LAB_001bb5ba;
}
if ((VVar1 != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_001bb5fe;
get<std::__cxx11::string>();
/* try { // try from 001bb523 to 001bb52f has its CatchHandler @ 001bb7b3 */
get<std::__cxx11::string>();
uVar7 = local_a8;
if (local_c8 < local_a8) {
uVar7 = local_c8;
}
if (uVar7 == 0) {
LAB_001bb561:
uVar7 = 0xffffffff80000000;
if (-0x80000000 < (long)(local_a8 - local_c8)) {
uVar7 = local_a8 - local_c8;
}
if (0x7ffffffe < (long)uVar7) {
uVar7 = 0;
}
}
else {
uVar3 = memcmp(local_b0,local_d0,uVar7);
uVar7 = (ulong)uVar3;
if (uVar3 == 0) goto LAB_001bb561;
}
if (local_d0 != &local_c0) {
operator_delete(local_d0,local_c0 + 1);
}
uVar7 = uVar7 >> 0x1f & 1;
if (local_b0 != local_a0) {
operator_delete(local_b0,local_a0[0] + 1);
}
LAB_001bb5ba:
return uVar7 & 0xffffffff;
}
|
|
13,981
|
Type_handler_string_result::make_in_vector(THD*, Item_func_in const*, unsigned int) const
|
eloqsql/sql/sql_type.cc
|
in_vector *Type_handler_string_result::make_in_vector(THD *thd,
const Item_func_in *func,
uint nargs) const
{
return new (thd->mem_root) in_string(thd, nargs, (qsort2_cmp) srtcmp_in,
func->compare_collation());
}
|
O0
|
cpp
|
Type_handler_string_result::make_in_vector(THD*, Item_func_in const*, unsigned int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x48(%rbp)
movl $0xa0, %edi
callq 0x4a34d0
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, -0x1d(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x38(%rbp)
je 0x7b9c83
movb $0x1, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x650(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x7b9c5c
movq -0x50(%rbp), %r8
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
leaq 0x4e(%rip), %rcx # 0x7b9cc0
callq 0x923610
jmp 0x7b9c79
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x7b9c83
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x7b9ca1
jmp 0x7b9cae
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x4a3510
jmp 0x7b9cb0
movq -0x28(%rbp), %rdi
callq 0x433ff0
nopl (%rax)
|
_ZNK26Type_handler_string_result14make_in_vectorEP3THDPK12Item_func_inj:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov [rbp+var_48], rsi
mov edi, 0A0h
call _ZN9Sql_allocnwEmP11st_mem_root; Sql_alloc::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_40], rcx
mov [rbp+var_1D], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_38], rax
jz short loc_7B9C83
mov [rbp+var_1D], 1
mov rax, [rbp+var_10]
mov [rbp+var_60], rax
mov eax, [rbp+var_1C]
mov [rbp+var_54], eax
mov rdi, [rbp+var_18]
mov rax, [rdi]
mov rax, [rax+650h]
call rax
mov [rbp+var_50], rax
jmp short $+2
loc_7B9C5C:
mov r8, [rbp+var_50]; charset_info_st *
mov edx, [rbp+var_54]; unsigned int
mov rsi, [rbp+var_60]; THD *
mov rdi, [rbp+var_40]; this
lea rcx, _ZL9srtcmp_inPKvS0_S0_; int (*)(const void *, const void *, const void *)
call _ZN9in_stringC2EP3THDjPFiPKvS3_S3_EPK15charset_info_st; in_string::in_string(THD *,uint,int (*)(void const*,void const*,void const*),charset_info_st const*)
jmp short $+2
loc_7B9C79:
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
jmp short $+2
loc_7B9C83:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
test [rbp+var_1D], 1
jnz short loc_7B9CA1
jmp short loc_7B9CAE
loc_7B9CA1:
mov rsi, [rbp+var_48]
mov rdi, [rbp+var_40]
call _ZN9Sql_allocdlEPvP11st_mem_root; Sql_alloc::operator delete(void *,st_mem_root *)
loc_7B9CAE:
jmp short $+2
loc_7B9CB0:
mov rdi, [rbp+var_28]
call __Unwind_Resume
|
in_string * Type_handler_string_result::make_in_vector(
Type_handler_string_result *this,
THD *a2,
const Item_func_in *a3,
unsigned int a4)
{
charset_info_st *v5; // [rsp+10h] [rbp-50h]
in_string *v6; // [rsp+20h] [rbp-40h]
long long v7; // [rsp+28h] [rbp-38h]
v6 = (in_string *)Sql_alloc::operator new(160LL, *((_QWORD *)a2 + 5));
v7 = 0LL;
if ( v6 )
{
v5 = (charset_info_st *)(*(long long ( **)(const Item_func_in *))(*(_QWORD *)a3 + 1616LL))(a3);
in_string::in_string(v6, a2, a4, (int (*)(const void *, const void *, const void *))srtcmp_in, v5);
return v6;
}
return (in_string *)v7;
}
|
get_table_map:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x28]
CALL 0x005b3720
MOV qword ptr [RBP + -0x38],0x0
LAB_007b9c11:
LEA RDI,[RBP + -0x28]
XOR ESI,ESI
CALL 0x005b37f0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JZ 0x007b9c3d
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x1b0]
OR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x007b9c11
LAB_007b9c3d:
JMP 0x007b9c3f
LAB_007b9c3f:
JMP 0x007b9c41
LAB_007b9c41:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
|
/* get_table_map(List<Item>*) */
ulong get_table_map(List *param_1)
{
long *plVar1;
ulong uVar2;
ulong local_40;
List_iterator_fast<Item> local_30 [32];
List *local_10;
local_10 = param_1;
List_iterator_fast<Item>::List_iterator_fast(local_30,param_1);
local_40 = 0;
while( true ) {
plVar1 = (long *)List_iterator_fast<Item>::operator++(local_30,0);
if (plVar1 == (long *)0x0) break;
uVar2 = (**(code **)(*plVar1 + 0x1b0))();
local_40 = uVar2 | local_40;
}
return local_40;
}
|
|
13,982
|
wt_thd_destroy
|
eloqsql/mysys/waiting_threads.c
|
void wt_thd_destroy(WT_THD *thd)
{
DBUG_ENTER("wt_thd_destroy");
DBUG_ASSERT(thd->my_resources.elements == 0);
DBUG_ASSERT(thd->waiting_for == 0);
if (thd->pins != 0)
lf_hash_put_pins(thd->pins);
delete_dynamic(&thd->my_resources);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
wt_thd_destroy:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xa67c3
callq 0xa50df
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x919ec
|
wt_thd_destroy:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+30h]
test rdi, rdi
jz short loc_A67C3
call lf_pinbox_put_pins
loc_A67C3:
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp delete_dynamic
|
long long wt_thd_destroy(long long *a1)
{
long long v2; // rdi
v2 = a1[6];
if ( v2 )
lf_pinbox_put_pins(v2);
return delete_dynamic(a1);
}
|
wt_thd_destroy:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x30]
TEST RDI,RDI
JZ 0x001a67c3
CALL 0x001a50df
LAB_001a67c3:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001919ec
|
void wt_thd_destroy(long param_1)
{
if (*(long *)(param_1 + 0x30) != 0) {
lf_pinbox_put_pins();
}
delete_dynamic(param_1);
return;
}
|
|
13,983
|
aimrt::runtime::core::logger::LoggerProxy::Log(aimrt_log_level_t, unsigned int, char const*, char const*, char const*, unsigned long) const
|
aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/../core/logger/logger_proxy.h
|
void Log(aimrt_log_level_t lvl,
uint32_t line,
const char* file_name,
const char* function_name,
const char* log_data,
size_t log_data_size) const {
if (lvl >= lvl_) {
#if defined(_WIN32)
thread_local size_t tid(std::hash<std::thread::id>{}(std::this_thread::get_id()));
#else
thread_local size_t tid(gettid());
#endif
LogDataWrapper log_data_wrapper{
.module_name = module_name_,
.thread_id = tid,
.t = std::chrono::system_clock::now(),
.lvl = lvl,
.line = line,
.file_name = file_name,
.function_name = function_name,
.log_data = log_data,
.log_data_size = log_data_size};
for (const auto& logger_backend_ptr : logger_backend_vec_) {
logger_backend_ptr->Log(log_data_wrapper);
}
}
}
|
O3
|
c
|
aimrt::runtime::core::logger::LoggerProxy::Log(aimrt_log_level_t, unsigned int, char const*, char const*, char const*, unsigned long) const:
cmpl %esi, 0x20(%rdi)
jg 0x5b1d0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r15
movq %r9, 0x8(%rsp)
leaq 0x54bc1(%rip), %rdi # 0xafcf0
callq 0x1fe40
movq %rax, %rbx
cmpb $0x0, 0x30(%rax)
je 0x5b1d1
leaq 0x28(%rbx), %rcx
movq (%r15), %rax
movq 0x8(%r15), %rdx
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
callq 0x1e0d0
movq %rax, 0x28(%rsp)
movl %r13d, 0x30(%rsp)
movl %ebp, 0x34(%rsp)
movq %r12, 0x38(%rsp)
movq %r14, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x28(%r15), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x5b1c2
leaq 0x10(%rsp), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x5b1ad
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f010
movslq %eax, %rdx
leaq 0x28(%rbx), %rcx
movq %rdx, (%rcx)
movb $0x1, 0x30(%rbx)
jmp 0x5b14b
nop
|
_ZNK5aimrt7runtime4core6logger11LoggerProxy3LogE17aimrt_log_level_tjPKcS6_S6_m:
cmp [rdi+20h], esi
jg locret_5B1D0
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, r8
mov r12, rcx
mov ebp, edx
mov r13d, esi
mov r15, rdi
mov [rsp+88h+var_80], r9
lea rdi, _ZZN5aimrt6common4util12SimpleLogger3LogEjjPKcS4_S4_mE3tid_tlsind; this
call ___tls_get_addr
mov rbx, rax
cmp byte ptr [rax+30h], 0
jz loc_5B1D1
lea rcx, [rbx+28h]
loc_5B14B:
mov rax, [r15]
mov rdx, [r15+8]
mov [rsp+88h+var_78], rdx
mov [rsp+88h+var_70], rax
mov rax, [rcx]
mov [rsp+88h+var_68], rax
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rsp+88h+var_60], rax
mov [rsp+88h+var_58], r13d
mov [rsp+88h+var_54], ebp
mov [rsp+88h+var_50], r12
mov [rsp+88h+var_48], r14
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_40], rax
mov rax, [rsp+88h+arg_0]
mov [rsp+88h+var_38], rax
mov rax, [r15+28h]
mov r14, [rax]
mov r15, [rax+8]
cmp r14, r15
jz short loc_5B1C2
lea rbx, [rsp+88h+var_78]
loc_5B1AD:
mov rdi, [r14]
mov rax, [rdi]
mov rsi, rbx
call qword ptr [rax+40h]
add r14, 8
cmp r14, r15
jnz short loc_5B1AD
loc_5B1C2:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_5B1D0:
retn
loc_5B1D1:
call _gettid
movsxd rdx, eax
lea rcx, [rbx+28h]
mov [rcx], rdx
mov byte ptr [rbx+30h], 1
jmp loc_5B14B
|
void aimrt::runtime::core::logger::LoggerProxy::Log(
long long *a1,
int a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long addr; // rax
long long v11; // rbx
_QWORD *v12; // rcx
long long v13; // rax
long long v14; // rax
_QWORD *v15; // r14
_QWORD *v16; // r15
int v17; // eax
_QWORD v19[4]; // [rsp+8h] [rbp-78h] BYREF
int v20; // [rsp+28h] [rbp-58h]
int v21; // [rsp+2Ch] [rbp-54h]
long long v22; // [rsp+30h] [rbp-50h]
long long v23; // [rsp+38h] [rbp-48h]
long long v24; // [rsp+40h] [rbp-40h]
long long v25; // [rsp+48h] [rbp-38h]
if ( *((_DWORD *)a1 + 8) <= a2 )
{
addr = __tls_get_addr(&ZZN5aimrt6common4util12SimpleLogger3LogEjjPKcS4_S4_mE3tid_tlsind);
v11 = addr;
if ( *(_BYTE *)(addr + 48) )
{
v12 = (_QWORD *)(addr + 40);
}
else
{
v17 = gettid();
v12 = (_QWORD *)(v11 + 40);
*(_QWORD *)(v11 + 40) = v17;
*(_BYTE *)(v11 + 48) = 1;
}
v13 = *a1;
v19[0] = a1[1];
v19[1] = v13;
v19[2] = *v12;
v19[3] = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)&ZZN5aimrt6common4util12SimpleLogger3LogEjjPKcS4_S4_mE3tid_tlsind);
v20 = a2;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v25 = a7;
v14 = a1[5];
v15 = *(_QWORD **)v14;
v16 = *(_QWORD **)(v14 + 8);
if ( *(_QWORD **)v14 != v16 )
{
do
{
(*(void ( **)(_QWORD, _QWORD *))(*(_QWORD *)*v15 + 64LL))(*v15, v19);
++v15;
}
while ( v15 != v16 );
}
}
}
|
Log:
CMP dword ptr [RDI + 0x20],ESI
JG 0x0015b1d0
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,R8
MOV R12,RCX
MOV EBP,EDX
MOV R13D,ESI
MOV R15,RDI
MOV qword ptr [RSP + 0x8],R9
LEA RDI,[0x1afcf0]
CALL 0x0011fe40
MOV RBX,RAX
CMP byte ptr [RAX + 0x30],0x0
JZ 0x0015b1d1
LEA RCX,[RBX + 0x28]
LAB_0015b14b:
MOV RAX,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x0011e0d0
MOV qword ptr [RSP + 0x28],RAX
MOV dword ptr [RSP + 0x30],R13D
MOV dword ptr [RSP + 0x34],EBP
MOV qword ptr [RSP + 0x38],R12
MOV qword ptr [RSP + 0x40],R14
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [R15 + 0x28]
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
CMP R14,R15
JZ 0x0015b1c2
LEA RBX,[RSP + 0x10]
LAB_0015b1ad:
MOV RDI,qword ptr [R14]
MOV RAX,qword ptr [RDI]
MOV RSI,RBX
CALL qword ptr [RAX + 0x40]
ADD R14,0x8
CMP R14,R15
JNZ 0x0015b1ad
LAB_0015b1c2:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0015b1d0:
RET
LAB_0015b1d1:
CALL 0x0011f010
MOVSXD RDX,EAX
LEA RCX,[RBX + 0x28]
MOV qword ptr [RCX],RDX
MOV byte ptr [RBX + 0x30],0x1
JMP 0x0015b14b
|
/* aimrt::runtime::core::logger::LoggerProxy::Log(aimrt_log_level_t, unsigned int, char const*, char
const*, char const*, unsigned long) const */
void __thiscall
aimrt::runtime::core::logger::LoggerProxy::Log
(LoggerProxy *this,int param_2,int4 param_3,int8 param_4,int8 param_5,
int8 param_6,int8 param_7)
{
int8 *puVar1;
int iVar2;
long lVar3;
int8 *puVar4;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int local_58;
int4 local_54;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
if (*(int *)(this + 0x20) <= param_2) {
lVar3 = __tls_get_addr(&PTR_001afcf0);
if (*(char *)(lVar3 + 0x30) == '\0') {
iVar2 = gettid();
*(long *)(lVar3 + 0x28) = (long)iVar2;
*(int1 *)(lVar3 + 0x30) = 1;
}
local_70 = *(int8 *)this;
local_78 = *(int8 *)(this + 8);
local_68 = *(int8 *)(lVar3 + 0x28);
local_60 = std::chrono::_V2::system_clock::now();
local_38 = param_7;
puVar4 = (int8 *)**(long **)(this + 0x28);
puVar1 = (int8 *)(*(long **)(this + 0x28))[1];
if (puVar4 != puVar1) {
local_58 = param_2;
local_54 = param_3;
local_50 = param_4;
local_48 = param_5;
local_40 = param_6;
do {
(**(code **)(*(long *)*puVar4 + 0x40))((long *)*puVar4,&local_78);
puVar4 = puVar4 + 1;
} while (puVar4 != puVar1);
}
}
return;
}
|
|
13,984
|
bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(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&, bool)
|
monkey531[P]llama/common/json.hpp
|
bool operator!=(const_reference lhs, ScalarType rhs) noexcept
{
return lhs != basic_json(rhs);
}
|
O3
|
cpp
|
bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(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&, bool):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x3eeee
movq %r14, %rdi
movl $0x1, %esi
callq 0x3ce3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e62b
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r14, %rdi
callq 0x49a2a
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3neERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator!=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov ebx, eax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
unsigned __int8 a2)
{
long long result; // rax
_OWORD v3[2]; // [rsp+0h] [rbp-28h] BYREF
v3[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)v3,
a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
LOBYTE(result) = nlohmann::json_abi_v3_11_3::operator!=(a1, (unsigned __int8 *)v3, (__m128d)0LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)v3);
return (unsigned int)result;
}
|
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
CALL 0x0013eeee
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013ce3c
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016e62b
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R14
CALL 0x00149a2a
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(basic_json *param_1)
{
int4 uVar1;
int8 local_28;
int8 uStack_20;
local_28 = 0;
uStack_20 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
uVar1 = nlohmann::json_abi_v3_11_3::operator!=(param_1,(basic_json *)&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_28);
return uVar1;
}
|
|
13,985
|
my_rw_unlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_unlock(my_rw_lock_t *rwp)
{
DBUG_PRINT("rw_unlock",
("state: %d waiters: %d", rwp->state, rwp->waiters));
pthread_mutex_lock(&rwp->lock);
DBUG_ASSERT(rwp->state != 0);
if (rwp->state == -1) /* writer releasing */
{
my_rw_lock_assert_write_owner(rwp);
rwp->state= 0; /* mark as available */
#ifdef SAFE_MUTEX
rwp->write_thread= 0;
#endif
if ( rwp->waiters ) /* writers queued */
pthread_cond_signal( &rwp->writers );
else
pthread_cond_broadcast( &rwp->readers );
}
else
{
if ( --rwp->state == 0 && /* no more readers */
rwp->waiters)
pthread_cond_signal( &rwp->writers );
}
pthread_mutex_unlock( &rwp->lock );
return(0);
}
|
O3
|
c
|
my_rw_unlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24510
movl 0x88(%rbx), %eax
cmpl $-0x1, %eax
je 0x320b4
decl %eax
movl %eax, 0x88(%rbx)
jne 0x320db
cmpl $0x0, 0x8c(%rbx)
jne 0x320c7
jmp 0x320db
movl $0x0, 0x88(%rbx)
cmpl $0x0, 0x8c(%rbx)
je 0x320d2
leaq 0x58(%rbx), %rdi
callq 0x24040
jmp 0x320db
leaq 0x28(%rbx), %rdi
callq 0x24110
movq %rbx, %rdi
callq 0x24260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
my_rw_unlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
mov eax, [rbx+88h]
cmp eax, 0FFFFFFFFh
jz short loc_320B4
dec eax
mov [rbx+88h], eax
jnz short loc_320DB
cmp dword ptr [rbx+8Ch], 0
jnz short loc_320C7
jmp short loc_320DB
loc_320B4:
mov dword ptr [rbx+88h], 0
cmp dword ptr [rbx+8Ch], 0
jz short loc_320D2
loc_320C7:
lea rdi, [rbx+58h]
call _pthread_cond_signal
jmp short loc_320DB
loc_320D2:
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
loc_320DB:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long my_rw_unlock(long long a1)
{
int v1; // eax
int v2; // eax
pthread_mutex_lock(a1);
v1 = *(_DWORD *)(a1 + 136);
if ( v1 == -1 )
{
*(_DWORD *)(a1 + 136) = 0;
if ( !*(_DWORD *)(a1 + 140) )
{
pthread_cond_broadcast(a1 + 40);
goto LABEL_8;
}
goto LABEL_6;
}
v2 = v1 - 1;
*(_DWORD *)(a1 + 136) = v2;
if ( !v2 && *(_DWORD *)(a1 + 140) )
LABEL_6:
pthread_cond_signal(a1 + 88);
LABEL_8:
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_unlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00124510
MOV EAX,dword ptr [RBX + 0x88]
CMP EAX,-0x1
JZ 0x001320b4
DEC EAX
MOV dword ptr [RBX + 0x88],EAX
JNZ 0x001320db
CMP dword ptr [RBX + 0x8c],0x0
JNZ 0x001320c7
JMP 0x001320db
LAB_001320b4:
MOV dword ptr [RBX + 0x88],0x0
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x001320d2
LAB_001320c7:
LEA RDI,[RBX + 0x58]
CALL 0x00124040
JMP 0x001320db
LAB_001320d2:
LEA RDI,[RBX + 0x28]
CALL 0x00124110
LAB_001320db:
MOV RDI,RBX
CALL 0x00124260
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 my_rw_unlock(pthread_mutex_t *param_1)
{
int iVar1;
pthread_mutex_lock(param_1);
if (*(int *)((long)param_1 + 0x88) == -1) {
*(int4 *)((long)param_1 + 0x88) = 0;
if (*(int *)((long)param_1 + 0x8c) == 0) {
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 1));
goto LAB_001320db;
}
}
else {
iVar1 = *(int *)((long)param_1 + 0x88) + -1;
*(int *)((long)param_1 + 0x88) = iVar1;
if ((iVar1 != 0) || (*(int *)((long)param_1 + 0x8c) == 0)) goto LAB_001320db;
}
pthread_cond_signal((pthread_cond_t *)((long)param_1 + 0x58));
LAB_001320db:
pthread_mutex_unlock(param_1);
return 0;
}
|
|
13,986
|
READ_INFO::getbyte(char*)
|
eloqsql/sql/sql_load.cc
|
bool getbyte(char *to)
{
int chr= GET;
if (chr == my_b_EOF)
return (eof= true);
*to= chr;
return false;
}
|
O0
|
cpp
|
READ_INFO::getbyte(char*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x78(%rcx), %rax
cmpq 0x70(%rcx), %rax
je 0x5af9cd
movq -0x28(%rbp), %rcx
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, 0x78(%rcx)
movl -0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x5af9e0
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5ad8f0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x80000000, -0x1c(%rbp) # imm = 0x80000000
jne 0x5afa00
movq -0x28(%rbp), %rax
movb $0x1, 0x82(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5afa0f
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN9READ_INFO7getbyteEPc:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rcx, [rbp+var_10]
mov [rbp+var_28], rcx
mov rax, [rcx+78h]
cmp rax, [rcx+70h]
jz short loc_5AF9CD
mov rcx, [rbp+var_28]
mov rax, [rcx+78h]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFCh
mov [rcx+78h], rdx
mov eax, [rax-4]
mov [rbp+var_2C], eax
jmp short loc_5AF9E0
loc_5AF9CD:
mov rdi, [rbp+var_28]
add rdi, 0A0h
call _ZL8my_b_getP11st_io_cache_0; my_b_get(st_io_cache *)
mov [rbp+var_2C], eax
loc_5AF9E0:
mov eax, [rbp+var_2C]
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 80000000h
jnz short loc_5AFA00
mov rax, [rbp+var_28]
mov byte ptr [rax+82h], 1
mov [rbp+var_1], 1
jmp short loc_5AFA0F
loc_5AFA00:
mov eax, [rbp+var_1C]
mov cl, al
mov rax, [rbp+var_18]
mov [rax], cl
mov [rbp+var_1], 0
loc_5AFA0F:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
|
char READ_INFO::getbyte(READ_INFO *this, char *a2)
{
long long v2; // rax
int v4; // [rsp+4h] [rbp-2Ch]
if ( *((_QWORD *)this + 15) == *((_QWORD *)this + 14) )
{
v4 = my_b_get((long long)this + 160);
}
else
{
v2 = *((_QWORD *)this + 15);
*((_QWORD *)this + 15) = v2 - 4;
v4 = *(_DWORD *)(v2 - 4);
}
if ( v4 == 0x80000000 )
{
*((_BYTE *)this + 130) = 1;
return 1;
}
else
{
*a2 = v4;
return 0;
}
}
|
get_tmp_table_field:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
XOR EAX,EAX
POP RBP
RET
|
/* Item::get_tmp_table_field() */
int8 Item::get_tmp_table_field(void)
{
return 0;
}
|
|
13,987
|
mysql_list_fields_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_list_fields_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_fields,
(parms->mysql, parms->table, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
}
|
O3
|
c
|
mysql_list_fields_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x201bb
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_list_fields_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_list_fields
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_list_fields_start_internal(long long a1)
{
long long v1; // rbx
long long result; // rax
v1 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
result = mysql_list_fields(*(_QWORD *)a1, *(const char **)(a1 + 8), *(const char **)(a1 + 16));
*(_QWORD *)(v1 + 8) = result;
*(_DWORD *)v1 = 0;
return result;
}
|
mysql_list_fields_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x001201bb
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_list_fields_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_fields(*param_1,param_1[1],param_1[2]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
13,988
|
ggml_vec_dot_iq3_s_q8_K
|
monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu-quants.c
|
void ggml_vec_dot_iq3_s_q8_K (int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_iq3_s * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#if defined(__ARM_NEON)
typedef union {
uint16x8_t vec_index;
uint16_t index[8];
} vec_index_t;
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
static const int16_t k_shift[8] = {8, 7, 6, 5, 4, 3, 2, 1};
const ggml_uint8x16x2_t mask1 = ggml_vld1q_u8_x2(k_mask1);
const uint8x16_t mask2 = vld1q_u8(k_mask2);
const int16x8_t hshift = vld1q_s16(k_shift);
const uint16x8_t m256 = vdupq_n_u16(256);
const uint8x16_t m1 = vdupq_n_u8(1);
uint8x16x2_t vs;
ggml_int8x16x4_t q3s;
ggml_int8x16x4_t q8b;
vec_index_t idx;
uint32_t scales32[2];
const uint8_t * scales8 = (const uint8_t *)scales32;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)x[i].signs;
const int8_t * restrict q8 = y[i].qs;
memcpy(scales32, x[i].scales, 4);
scales32[1] = (((scales32[0] >> 4) & 0x0f0f0f0f) << 1) | 0x01010101;
scales32[0] = ((scales32[0] & 0x0f0f0f0f) << 1) | 0x01010101;
int sumi1 = 0, sumi2 = 0;
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
q8b = ggml_vld1q_s8_x4(q8); q8 += 64;
const uint8x16_t idx_l = vld1q_u8(qs); qs += 16;
idx.vec_index = vorrq_u16(vmovl_u8(vget_low_u8 (idx_l)), vandq_u16(vshlq_u16(vdupq_n_u16(qh[ib32+0]), hshift), m256));
const uint32x4_t aux32x4_0 = ggml_vld1q_u32(iq3s_grid[idx.index[0]], iq3s_grid[idx.index[1]],
iq3s_grid[idx.index[2]], iq3s_grid[idx.index[3]]);
const uint32x4_t aux32x4_1 = ggml_vld1q_u32(iq3s_grid[idx.index[4]], iq3s_grid[idx.index[5]],
iq3s_grid[idx.index[6]], iq3s_grid[idx.index[7]]);
idx.vec_index = vorrq_u16(vmovl_u8(vget_high_u8(idx_l)), vandq_u16(vshlq_u16(vdupq_n_u16(qh[ib32+1]), hshift), m256));
const uint32x4_t aux32x4_2 = ggml_vld1q_u32(iq3s_grid[idx.index[0]], iq3s_grid[idx.index[1]],
iq3s_grid[idx.index[2]], iq3s_grid[idx.index[3]]);
const uint32x4_t aux32x4_3 = ggml_vld1q_u32(iq3s_grid[idx.index[4]], iq3s_grid[idx.index[5]],
iq3s_grid[idx.index[6]], iq3s_grid[idx.index[7]]);
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[0] | ((uint32_t) signs[1] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vorrq_u8(vceqq_u8(vs.val[0], mask2), m1);
vs.val[1] = vorrq_u8(vceqq_u8(vs.val[1], mask2), m1);
q3s.val[0] = vmulq_s8(vreinterpretq_s8_u8(vs.val[0]), vreinterpretq_s8_u32(aux32x4_0));
q3s.val[1] = vmulq_s8(vreinterpretq_s8_u8(vs.val[1]), vreinterpretq_s8_u32(aux32x4_1));
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[2] | ((uint32_t) signs[3] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vorrq_u8(vceqq_u8(vs.val[0], mask2), m1);
vs.val[1] = vorrq_u8(vceqq_u8(vs.val[1], mask2), m1);
signs += 4;
q3s.val[2] = vmulq_s8(vreinterpretq_s8_u8(vs.val[0]), vreinterpretq_s8_u32(aux32x4_2));
q3s.val[3] = vmulq_s8(vreinterpretq_s8_u8(vs.val[1]), vreinterpretq_s8_u32(aux32x4_3));
const int32x4_t p1 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), q3s.val[0], q8b.val[0]), q3s.val[1], q8b.val[1]);
const int32x4_t p2 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), q3s.val[2], q8b.val[2]), q3s.val[3], q8b.val[3]);
sumi1 += vaddvq_s32(p1) * scales8[ib32/2+0];
sumi2 += vaddvq_s32(p2) * scales8[ib32/2+4];
}
sumf += d*(sumi1 + sumi2);
}
*s = sumf;
#elif defined(__AVX2__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m256i mask1 = _mm256_loadu_si256((const __m256i*)k_mask1);
const __m256i mask2 = _mm256_loadu_si256((const __m256i*)k_mask2);
const __m256i idx_shift = _mm256_set_epi32(1, 2, 3, 4, 5, 6, 7, 8);
const __m256i idx_mask = _mm256_set1_epi32(256);
typedef union {
__m256i vec[2];
uint32_t index[16];
} index_t;
index_t idx;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)x[i].signs;
const int8_t * restrict q8 = y[i].qs;
__m256i sumi1 = _mm256_setzero_si256();
__m256i sumi2 = _mm256_setzero_si256();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i idx_l = _mm256_cvtepu8_epi16(_mm_loadu_si128((const __m128i *)qs)); qs += 16;
idx.vec[0] = _mm256_set1_epi32(qh[ib32+0]);
idx.vec[1] = _mm256_set1_epi32(qh[ib32+1]);
idx.vec[0] = _mm256_and_si256(_mm256_sllv_epi32(idx.vec[0], idx_shift), idx_mask);
idx.vec[1] = _mm256_and_si256(_mm256_sllv_epi32(idx.vec[1], idx_shift), idx_mask);
idx.vec[0] = _mm256_or_si256(idx.vec[0], _mm256_cvtepi16_epi32(_mm256_castsi256_si128(idx_l)));
idx.vec[1] = _mm256_or_si256(idx.vec[1], _mm256_cvtepi16_epi32(_mm256_extractf128_si256(idx_l, 1)));
// At leat on my CPU (Ryzen 7950X), using _mm256_i32gather_epi32 is slower than _mm256_set_epi32. Strange.
//const __m256i q2_1 = _mm256_i32gather_epi32((const int *)iq3s_grid, idx.vec[0], 4);
//const __m256i q2_2 = _mm256_i32gather_epi32((const int *)iq3s_grid, idx.vec[1], 4);
const __m256i q2_1 = _mm256_set_epi32(
iq3s_grid[idx.index[7]], iq3s_grid[idx.index[6]], iq3s_grid[idx.index[5]], iq3s_grid[idx.index[4]],
iq3s_grid[idx.index[3]], iq3s_grid[idx.index[2]], iq3s_grid[idx.index[1]], iq3s_grid[idx.index[0]]
);
const __m256i q2_2 = _mm256_set_epi32(
iq3s_grid[idx.index[15]], iq3s_grid[idx.index[14]], iq3s_grid[idx.index[13]], iq3s_grid[idx.index[12]],
iq3s_grid[idx.index[11]], iq3s_grid[idx.index[10]], iq3s_grid[idx.index[ 9]], iq3s_grid[idx.index[ 8]]
);
__m256i aux256 = _mm256_set1_epi32(signs[0] | (signs[1] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_1 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_1 = _mm256_sub_epi8(_mm256_xor_si256(s2_1, q8_1), s2_1);
aux256 = _mm256_set1_epi32(signs[2] | (signs[3] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_2 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_2 = _mm256_sub_epi8(_mm256_xor_si256(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = _mm256_maddubs_epi16(q2_1, q8s_1);
const __m256i dot2 = _mm256_maddubs_epi16(q2_2, q8s_2);
const uint16_t ls1 = x[i].scales[ib32/2] & 0xf;
const uint16_t ls2 = x[i].scales[ib32/2] >> 4;
const __m256i p1 = _mm256_madd_epi16(dot1, _mm256_set1_epi16(2*ls1+1));
const __m256i p2 = _mm256_madd_epi16(dot2, _mm256_set1_epi16(2*ls2+1));
sumi1 = _mm256_add_epi32(sumi1, p1);
sumi2 = _mm256_add_epi32(sumi2, p2);
}
accumf = _mm256_fmadd_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(_mm256_add_epi32(sumi1, sumi2)), accumf);
}
*s = hsum_float_8(accumf);
#elif defined(__AVX__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i mask1_0 = _mm_loadu_si128((const __m128i*)k_mask1);
const __m128i mask1_1 = _mm_loadu_si128((const __m128i*)k_mask1 + 1);
const __m128i mask2_0 = _mm_loadu_si128((const __m128i*)k_mask2);
const __m128i mask2_1 = _mm_loadu_si128((const __m128i*)k_mask2 + 1);
const __m128i idx_mul_0 = _mm_set_epi32(32, 64, 128, 256);
const __m128i idx_mul_1 = _mm_set_epi32(2, 4, 8, 16);
const __m128i idx_mask = _mm_set1_epi32(256);
typedef union {
__m128i vec[4];
uint32_t index[16];
} index_t;
index_t idx;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)x[i].signs;
const int8_t * restrict q8 = y[i].qs;
__m128i sumi1_0 = _mm_setzero_si128();
__m128i sumi1_1 = _mm_setzero_si128();
__m128i sumi2_0 = _mm_setzero_si128();
__m128i sumi2_1 = _mm_setzero_si128();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m128i q8_1_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_1_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i qs_tmp = _mm_loadu_si128((const __m128i *)qs);
const __m128i idx_l_0 = _mm_cvtepu8_epi16(qs_tmp);
const __m128i idx_l_1 = _mm_cvtepu8_epi16(_mm_srli_si128(qs_tmp, 8)); qs += 16;
idx.vec[0] = _mm_set1_epi32(qh[ib32+0]);
idx.vec[1] = idx.vec[0];
idx.vec[2] = _mm_set1_epi32(qh[ib32+1]);
idx.vec[3] = idx.vec[2];
idx.vec[0] = _mm_and_si128(_mm_mullo_epi32(idx.vec[0], idx_mul_0), idx_mask);
idx.vec[1] = _mm_and_si128(_mm_mullo_epi32(idx.vec[1], idx_mul_1), idx_mask);
idx.vec[2] = _mm_and_si128(_mm_mullo_epi32(idx.vec[2], idx_mul_0), idx_mask);
idx.vec[3] = _mm_and_si128(_mm_mullo_epi32(idx.vec[3], idx_mul_1), idx_mask);
idx.vec[0] = _mm_or_si128(idx.vec[0], _mm_cvtepi16_epi32(idx_l_0));
idx.vec[1] = _mm_or_si128(idx.vec[1], _mm_cvtepi16_epi32(_mm_srli_si128(idx_l_0, 8)));
idx.vec[2] = _mm_or_si128(idx.vec[2], _mm_cvtepi16_epi32(idx_l_1));
idx.vec[3] = _mm_or_si128(idx.vec[3], _mm_cvtepi16_epi32(_mm_srli_si128(idx_l_1, 8)));
const __m128i q2_1_0 = _mm_set_epi32(iq3s_grid[idx.index[3]], iq3s_grid[idx.index[2]], iq3s_grid[idx.index[1]], iq3s_grid[idx.index[0]]);
const __m128i q2_1_1 = _mm_set_epi32(iq3s_grid[idx.index[7]], iq3s_grid[idx.index[6]], iq3s_grid[idx.index[5]], iq3s_grid[idx.index[4]]);
const __m128i q2_2_0 = _mm_set_epi32(iq3s_grid[idx.index[11]], iq3s_grid[idx.index[10]], iq3s_grid[idx.index[9]], iq3s_grid[idx.index[8]]);
const __m128i q2_2_1 = _mm_set_epi32(iq3s_grid[idx.index[15]], iq3s_grid[idx.index[14]], iq3s_grid[idx.index[13]], iq3s_grid[idx.index[12]]);
__m128i aux128_0 = _mm_set1_epi32(signs[0] | (signs[1] << 16));
__m128i aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_1_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_1_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_1_0 = _mm_sub_epi8(_mm_xor_si128(s2_1_0, q8_1_0), s2_1_0);
const __m128i q8s_1_1 = _mm_sub_epi8(_mm_xor_si128(s2_1_1, q8_1_1), s2_1_1);
aux128_0 = _mm_set1_epi32(signs[2] | (signs[3] << 16));
aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_2_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_2_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_2_0 = _mm_sub_epi8(_mm_xor_si128(s2_2_0, q8_2_0), s2_2_0);
const __m128i q8s_2_1 = _mm_sub_epi8(_mm_xor_si128(s2_2_1, q8_2_1), s2_2_1);
signs += 4;
const __m128i dot1_0 = _mm_maddubs_epi16(q2_1_0, q8s_1_0);
const __m128i dot1_1 = _mm_maddubs_epi16(q2_1_1, q8s_1_1);
const __m128i dot2_0 = _mm_maddubs_epi16(q2_2_0, q8s_2_0);
const __m128i dot2_1 = _mm_maddubs_epi16(q2_2_1, q8s_2_1);
const uint16_t ls1 = x[i].scales[ib32/2] & 0xf;
const uint16_t ls2 = x[i].scales[ib32/2] >> 4;
const __m128i p1_0 = _mm_madd_epi16(dot1_0, _mm_set1_epi16(2*ls1+1));
const __m128i p1_1 = _mm_madd_epi16(dot1_1, _mm_set1_epi16(2*ls1+1));
const __m128i p2_0 = _mm_madd_epi16(dot2_0, _mm_set1_epi16(2*ls2+1));
const __m128i p2_1 = _mm_madd_epi16(dot2_1, _mm_set1_epi16(2*ls2+1));
sumi1_0 = _mm_add_epi32(sumi1_0, p1_0);
sumi1_1 = _mm_add_epi32(sumi1_1, p1_1);
sumi2_0 = _mm_add_epi32(sumi2_0, p2_0);
sumi2_1 = _mm_add_epi32(sumi2_1, p2_1);
}
accumf = _mm256_add_ps(_mm256_mul_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(MM256_SET_M128I(_mm_add_epi32(sumi1_1, sumi2_1), _mm_add_epi32(sumi1_0, sumi2_0)))), accumf);
}
*s = hsum_float_8(accumf);
#elif defined(__POWER9_VECTOR__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
const vector int v0 = vec_splats((int32_t)0);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
const vector unsigned char mask0 = vec_xl( 0, k_mask1);
const vector unsigned char mask1 = vec_xl(16, k_mask1);
const vector signed char mask2 = (vector signed char)vec_xl( 0, k_mask2);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
const uint8_t * restrict q3 = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].signs);
const uint8_t * restrict sc = x[i].scales;
const int8_t * restrict q8 = y[i].qs;
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
for (int j = 0; j < QK_K/32; j += 2) {
__builtin_prefetch(q3, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector unsigned int aux32x4_0 = {iq3s_grid[q3[ 0] | ((qh[0] << 8) & 256)], iq3s_grid[q3[ 1] | ((qh[0] << 7) & 256)],
iq3s_grid[q3[ 2] | ((qh[0] << 6) & 256)], iq3s_grid[q3[ 3] | ((qh[0] << 5) & 256)]};
vector unsigned int aux32x4_1 = {iq3s_grid[q3[ 4] | ((qh[0] << 4) & 256)], iq3s_grid[q3[ 5] | ((qh[0] << 3) & 256)],
iq3s_grid[q3[ 6] | ((qh[0] << 2) & 256)], iq3s_grid[q3[ 7] | ((qh[0] << 1) & 256)]};
vector unsigned int aux32x4_2 = {iq3s_grid[q3[ 8] | ((qh[1] << 8) & 256)], iq3s_grid[q3[ 9] | ((qh[1] << 7) & 256)],
iq3s_grid[q3[10] | ((qh[1] << 6) & 256)], iq3s_grid[q3[11] | ((qh[1] << 5) & 256)]};
vector unsigned int aux32x4_3 = {iq3s_grid[q3[12] | ((qh[1] << 4) & 256)], iq3s_grid[q3[13] | ((qh[1] << 3) & 256)],
iq3s_grid[q3[14] | ((qh[1] << 2) & 256)], iq3s_grid[q3[15] | ((qh[1] << 1) & 256)]};
q3 += 16;
qh += 2;
vector signed char vsigns01 = (vector signed char)vec_splats(*(const uint32_t *)&signs[0]);
vector signed char vsigns02 = (vector signed char)vec_splats(*(const uint32_t *)&signs[2]);
signs += 4;
vector signed char vsigns0 = vec_perm(vsigns01, vsigns01, mask0);
vector signed char vsigns1 = vec_perm(vsigns01, vsigns01, mask1);
vector signed char vsigns2 = vec_perm(vsigns02, vsigns02, mask0);
vector signed char vsigns3 = vec_perm(vsigns02, vsigns02, mask1);
vsigns0 = (vector signed char)vec_cmpeq(vec_and(vsigns0, mask2), mask2);
vsigns1 = (vector signed char)vec_cmpeq(vec_and(vsigns1, mask2), mask2);
vsigns2 = (vector signed char)vec_cmpeq(vec_and(vsigns2, mask2), mask2);
vsigns3 = (vector signed char)vec_cmpeq(vec_and(vsigns3, mask2), mask2);
vector signed char q3x0 = vec_sub(vec_xor(vsigns0, (vector signed char)aux32x4_0), vsigns0);
vector signed char q3x1 = vec_sub(vec_xor(vsigns1, (vector signed char)aux32x4_1), vsigns1);
vector signed char q3x2 = vec_sub(vec_xor(vsigns2, (vector signed char)aux32x4_2), vsigns2);
vector signed char q3x3 = vec_sub(vec_xor(vsigns3, (vector signed char)aux32x4_3), vsigns3);
vector signed char q8y0 = vec_xl( 0, q8);
vector signed char q8y1 = vec_xl(16, q8);
vector signed char q8y2 = vec_xl(32, q8);
vector signed char q8y3 = vec_xl(48, q8);
q8 += 64;
vector signed short qv0 = vec_add(vec_mule(q3x0, q8y0), vec_mulo(q3x0, q8y0));
vector signed short qv1 = vec_add(vec_mule(q3x1, q8y1), vec_mulo(q3x1, q8y1));
vector signed short qv2 = vec_add(vec_mule(q3x2, q8y2), vec_mulo(q3x2, q8y2));
vector signed short qv3 = vec_add(vec_mule(q3x3, q8y3), vec_mulo(q3x3, q8y3));
const uint16_t ls0 = (uint16_t)(sc[0] & 0xf);
const uint16_t ls1 = (uint16_t)(sc[0] >> 4);
sc ++;
vector signed short vscales01 = (vector signed short)vec_splats((uint16_t)(2*ls0+1));
vector signed short vscales23 = (vector signed short)vec_splats((uint16_t)(2*ls1+1));
vsumi0 = vec_msum(qv0, vscales01, vsumi0);
vsumi1 = vec_msum(qv1, vscales01, vsumi1);
vsumi2 = vec_msum(qv2, vscales23, vsumi2);
vsumi3 = vec_msum(qv3, vscales23, vsumi3);
}
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m256i mask1 = __lasx_xvld((const __m256i*)k_mask1, 0);
const __m256i mask2 = __lasx_xvld((const __m256i*)k_mask2, 0);
__m256i idx_shift = lasx_set_w(1, 2, 3, 4, 5, 6, 7, 8);
const __m256i idx_mask = __lasx_xvreplgr2vr_w(256);
typedef union {
__m256i vec[2];
uint32_t index[16];
} index_t;
index_t idx;
__m256 accumf = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)x[i].signs;
const int8_t * restrict q8 = y[i].qs;
__m256i sumi1 = __lasx_xvldi(0);
__m256i sumi2 = __lasx_xvldi(0);
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i idx_l = lasx_extu8_16(__lsx_vld(qs, 0)); qs += 16;
idx.vec[0] = __lasx_xvreplgr2vr_w(qh[ib32+0]);
idx.vec[1] = __lasx_xvreplgr2vr_w(qh[ib32+1]);
idx.vec[0] = __lasx_xvand_v(__lasx_xvsll_w(idx.vec[0], idx_shift), idx_mask);
idx.vec[1] = __lasx_xvand_v(__lasx_xvsll_w(idx.vec[1], idx_shift), idx_mask);
idx.vec[0] = __lasx_xvor_v(idx.vec[0], lasx_ext16_32(lasx_extracti128(idx_l, 0)));
idx.vec[1] = __lasx_xvor_v(idx.vec[1], lasx_ext16_32(lasx_extracti128(idx_l, 1)));
// At leat on my CPU (Ryzen 7950X), using _mm256_i32gather_epi32 is slower than _mm256_set_epi32. Strange.
//const __m256i q2_1 = _mm256_i32gather_epi32((const int *)iq3s_grid, idx.vec[0], 4);
//const __m256i q2_2 = _mm256_i32gather_epi32((const int *)iq3s_grid, idx.vec[1], 4);
const __m256i q2_1 = lasx_set_w(
iq3s_grid[idx.index[7]], iq3s_grid[idx.index[6]], iq3s_grid[idx.index[5]], iq3s_grid[idx.index[4]],
iq3s_grid[idx.index[3]], iq3s_grid[idx.index[2]], iq3s_grid[idx.index[1]], iq3s_grid[idx.index[0]]
);
const __m256i q2_2 = lasx_set_w(
iq3s_grid[idx.index[15]], iq3s_grid[idx.index[14]], iq3s_grid[idx.index[13]], iq3s_grid[idx.index[12]],
iq3s_grid[idx.index[11]], iq3s_grid[idx.index[10]], iq3s_grid[idx.index[ 9]], iq3s_grid[idx.index[ 8]]
);
__m256i aux256 = __lasx_xvreplgr2vr_w(signs[0] | (signs[1] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_1 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_1 = __lasx_xvsub_b(__lasx_xvxor_v(s2_1, q8_1), s2_1);
aux256 = __lasx_xvreplgr2vr_w(signs[2] | (signs[3] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_2 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_2 = __lasx_xvsub_b(__lasx_xvxor_v(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = lasx_maddubs_h(q2_1, q8s_1);
const __m256i dot2 = lasx_maddubs_h(q2_2, q8s_2);
const uint16_t ls1 = x[i].scales[ib32/2] & 0xf;
const uint16_t ls2 = x[i].scales[ib32/2] >> 4;
const __m256i p1 = lasx_madd_h(dot1, __lasx_xvreplgr2vr_h(2*ls1+1));
const __m256i p2 = lasx_madd_h(dot2, __lasx_xvreplgr2vr_h(2*ls2+1));
sumi1 = __lasx_xvadd_w(sumi1, p1);
sumi2 = __lasx_xvadd_w(sumi2, p2);
}
accumf = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(__lasx_xvadd_w(sumi1, sumi2)), accumf);
}
*s = hsum_float_8(accumf);
#else
float sumf = 0.f;
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint8_t * restrict signs = x[i].signs;
const int8_t * restrict q8 = y[i].qs;
int32_t bsum = 0;
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const uint32_t ls1 = 2*(x[i].scales[ib32/2] & 0xf) + 1;
const uint32_t ls2 = 2*(x[i].scales[ib32/2] >> 4) + 1;
int32_t sumi = 0;
for (int l = 0; l < 4; ++l) {
const uint8_t * grid1 = (const uint8_t *)(iq3s_grid + (qs[2*l+0] | ((qh[ib32+0] << (8-2*l)) & 256)));
const uint8_t * grid2 = (const uint8_t *)(iq3s_grid + (qs[2*l+1] | ((qh[ib32+0] << (7-2*l)) & 256)));
for (int j = 0; j < 4; ++j) {
sumi += grid1[j] * q8[j+0] * (signs[l] & kmask_iq2xs[j+0] ? -1 : 1);
sumi += grid2[j] * q8[j+4] * (signs[l] & kmask_iq2xs[j+4] ? -1 : 1);
}
q8 += 8;
}
qs += 8;
signs += 4;
bsum += sumi * ls1;
sumi = 0;
for (int l = 0; l < 4; ++l) {
const uint8_t * grid1 = (const uint8_t *)(iq3s_grid + (qs[2*l+0] | ((qh[ib32+1] << (8-2*l)) & 256)));
const uint8_t * grid2 = (const uint8_t *)(iq3s_grid + (qs[2*l+1] | ((qh[ib32+1] << (7-2*l)) & 256)));
for (int j = 0; j < 4; ++j) {
sumi += grid1[j] * q8[j+0] * (signs[l] & kmask_iq2xs[j+0] ? -1 : 1);
sumi += grid2[j] * q8[j+4] * (signs[l] & kmask_iq2xs[j+4] ? -1 : 1);
}
q8 += 8;
}
qs += 8;
signs += 4;
bsum += sumi * ls2;
}
sumf += d * bsum;
}
*s = sumf;
#endif
}
|
O3
|
c
|
ggml_vec_dot_iq3_s_q8_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x8(%rsp)
movq %rcx, -0x18(%rsp)
movq %rsi, -0x10(%rsp)
vxorps %xmm6, %xmm6, %xmm6
cmpl $0x100, %edi # imm = 0x100
jl 0x32b02
shrl $0x8, %edi
vpxor %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
vpmovsxbd 0x22d3f(%rip), %ymm1 # 0x555d0
vpbroadcastd 0x22ad2(%rip), %ymm2 # 0x5536c
leaq 0x26d7f(%rip), %r8 # 0x59620
vmovdqa 0x22ad7(%rip), %ymm3 # 0x55380
vpbroadcastq 0x22d0e(%rip), %ymm4 # 0x555c0
movq -0x18(%rsp), %r10
vxorps %xmm5, %xmm5, %xmm5
imulq $0x6e, %rcx, %r11
movq -0x18(%rsp), %rax
movzwl (%rax,%r11), %r11d
movq 0x326a0(%rip), %rax # 0x64f70
vmovss (%rax,%r11,4), %xmm6
imulq $0x124, %rcx, %r11 # imm = 0x124
movq -0x8(%rsp), %rax
addq %rax, %r11
addq $0x4, %r11
vmovss -0x4(%r11), %xmm7
movq $-0x2, %rbx
movl $0x6a, %r14d
vpxor %xmm8, %xmm8, %xmm8
vpxor %xmm9, %xmm9, %xmm9
vmovdqu (%r11), %ymm11
vpmovzxbw 0x12(%r10,%rbx,8), %ymm12
vmovdqu 0x20(%r11), %ymm10
movzbl 0x44(%r10,%rbx), %ebp
vpbroadcastd %ebp, %ymm13
movzbl 0x45(%r10,%rbx), %ebp
vpbroadcastd %ebp, %ymm14
vpsllvd %ymm1, %ymm13, %ymm13
vpsllvd %ymm1, %ymm14, %ymm14
vpmovzxwd %xmm12, %ymm15 # ymm15 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero
vpternlogd $0xf8, %ymm2, %ymm13, %ymm15
vextracti128 $0x1, %ymm12, %xmm12
vpmovzxwd %xmm12, %ymm12 # ymm12 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero
vextracti128 $0x1, %ymm15, %xmm13
vpextrd $0x3, %xmm13, %r15d
vpextrd $0x3, %xmm15, %r12d
vpextrd $0x2, %xmm13, %r13d
vpextrd $0x2, %xmm15, %ebp
vpextrd $0x1, %xmm15, %edx
vpextrd $0x1, %xmm13, %esi
vmovd %xmm13, %eax
vmovd %xmm15, %r9d
vmovd (%r8,%r9,4), %xmm13
vmovd (%r8,%rax,4), %xmm15
vpinsrd $0x1, (%r8,%rdx,4), %xmm13, %xmm13
vpinsrd $0x2, (%r8,%rbp,4), %xmm13, %xmm13
vpinsrd $0x1, (%r8,%rsi,4), %xmm15, %xmm15
vpternlogd $0xf8, %ymm2, %ymm14, %ymm12
vpinsrd $0x3, (%r8,%r12,4), %xmm13, %xmm13
vextracti128 $0x1, %ymm12, %xmm14
vpextrd $0x3, %xmm14, %eax
vpextrd $0x2, %xmm14, %edx
vpextrd $0x1, %xmm14, %esi
vpinsrd $0x2, (%r8,%r13,4), %xmm15, %xmm15
vpextrd $0x3, %xmm12, %r9d
vpextrd $0x2, %xmm12, %r12d
vpinsrd $0x3, (%r8,%r15,4), %xmm15, %xmm15
vmovd %xmm14, %r15d
vpextrd $0x1, %xmm12, %r13d
vmovd %xmm12, %ebp
vmovd (%r8,%r15,4), %xmm12
vpinsrd $0x1, (%r8,%rsi,4), %xmm12, %xmm12
vmovd (%r8,%rbp,4), %xmm14
vpinsrd $0x2, (%r8,%rdx,4), %xmm12, %xmm12
vpinsrd $0x1, (%r8,%r13,4), %xmm14, %xmm14
vpinsrd $0x2, (%r8,%r12,4), %xmm14, %xmm14
vpinsrd $0x3, (%r8,%rax,4), %xmm12, %xmm12
vpinsrd $0x3, (%r8,%r9,4), %xmm14, %xmm14
vmovd 0x52(%r10,%rbx,4), %xmm16
vinserti128 $0x1, %xmm15, %ymm13, %ymm13
vpermq $0x44, %ymm16, %ymm15 # ymm15 = ymm16[0,1,0,1]
vpshufb %ymm3, %ymm15, %ymm15
vptestnmb %ymm4, %ymm15, %k1
vpsubb %ymm11, %ymm0, %ymm15
vmovdqu8 %ymm11, %ymm15 {%k1}
vinserti128 $0x1, %xmm12, %ymm14, %ymm11
vmovd 0x56(%r10,%rbx,4), %xmm12
vpermq $0x44, %ymm12, %ymm12 # ymm12 = ymm12[0,1,0,1]
vpshufb %ymm3, %ymm12, %ymm12
vptestnmb %ymm4, %ymm12, %k1
vpmaddubsw %ymm15, %ymm13, %ymm12
vpsubb %ymm10, %ymm0, %ymm13
vmovdqu8 %ymm10, %ymm13 {%k1}
movzbl (%r10,%r14), %eax
movl %eax, %edx
andl $0xf, %edx
leal 0x1(,%rdx,2), %edx
vpmaddubsw %ymm13, %ymm11, %ymm10
vpbroadcastw %edx, %ymm11
vpmaddwd %ymm11, %ymm12, %ymm11
shrl $0x3, %eax
orl $0x1, %eax
vpbroadcastw %eax, %ymm12
vpaddd %ymm8, %ymm11, %ymm8
vpmaddwd %ymm12, %ymm10, %ymm10
vpaddd %ymm9, %ymm10, %ymm9
addq $0x2, %rbx
incq %r14
addq $0x40, %r11
cmpq $0x6, %rbx
jb 0x32906
vmulss %xmm7, %xmm6, %xmm6
vbroadcastss %xmm6, %ymm7
vpaddd %ymm9, %ymm8, %ymm6
vcvtdq2ps %ymm6, %ymm6
vfmadd213ps %ymm5, %ymm7, %ymm6 # ymm6 = (ymm7 * ymm6) + ymm5
incq %rcx
addq $0x6e, %r10
vmovaps %ymm6, %ymm5
cmpq %rdi, %rcx
jne 0x328bb
vextractf128 $0x1, %ymm6, %xmm0
vaddps %xmm6, %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
movq -0x10(%rsp), %rax
vmovss %xmm0, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
|
ggml_vec_dot_iq3_s_q8_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
mov [rsp+30h+var_38], r9
mov [rsp+30h+var_48], rcx
mov [rsp+30h+var_40], rsi
vxorps xmm6, xmm6, xmm6
cmp edi, 100h
jl loc_32B02
shr edi, 8
vpxor xmm0, xmm0, xmm0
xor ecx, ecx
vpmovsxbd ymm1, cs:qword_555D0
vpbroadcastd ymm2, cs:dword_5536C
lea r8, iq3s_grid
vmovdqa ymm3, cs:ymmword_55380
vpbroadcastq ymm4, cs:qword_555C0
mov r10, [rsp+30h+var_48]
vxorps xmm5, xmm5, xmm5
loc_328BB:
imul r11, rcx, 6Eh ; 'n'
mov rax, [rsp+30h+var_48]
movzx r11d, word ptr [rax+r11]
mov rax, cs:ggml_table_f32_f16_ptr
vmovss xmm6, dword ptr [rax+r11*4]
imul r11, rcx, 124h
mov rax, [rsp+30h+var_38]
add r11, rax
add r11, 4
vmovss xmm7, dword ptr [r11-4]
mov rbx, 0FFFFFFFFFFFFFFFEh
mov r14d, 6Ah ; 'j'
vpxor xmm8, xmm8, xmm8
vpxor xmm9, xmm9, xmm9
loc_32906:
vmovdqu ymm11, ymmword ptr [r11]
vpmovzxbw ymm12, xmmword ptr [r10+rbx*8+12h]
vmovdqu ymm10, ymmword ptr [r11+20h]
movzx ebp, byte ptr [r10+rbx+44h]
vpbroadcastd ymm13, ebp
movzx ebp, byte ptr [r10+rbx+45h]
vpbroadcastd ymm14, ebp
vpsllvd ymm13, ymm13, ymm1
vpsllvd ymm14, ymm14, ymm1
vpmovzxwd ymm15, xmm12
vpternlogd ymm15, ymm13, ymm2, 0F8h
vextracti128 xmm12, ymm12, 1
vpmovzxwd ymm12, xmm12
vextracti128 xmm13, ymm15, 1
vpextrd r15d, xmm13, 3
vpextrd r12d, xmm15, 3
vpextrd r13d, xmm13, 2
vpextrd rbp, xmm15, 2
vpextrd rdx, xmm15, 1
vpextrd rsi, xmm13, 1
vmovd eax, xmm13
vmovd r9d, xmm15
vmovd xmm13, dword ptr [r8+r9*4]
vmovd xmm15, dword ptr [r8+rax*4]
vpinsrd xmm13, xmm13, dword ptr [r8+rdx*4], 1
vpinsrd xmm13, xmm13, dword ptr [r8+rbp*4], 2
vpinsrd xmm15, xmm15, dword ptr [r8+rsi*4], 1
vpternlogd ymm12, ymm14, ymm2, 0F8h
vpinsrd xmm13, xmm13, dword ptr [r8+r12*4], 3
vextracti128 xmm14, ymm12, 1
vpextrd rax, xmm14, 3
vpextrd rdx, xmm14, 2
vpextrd rsi, xmm14, 1
vpinsrd xmm15, xmm15, dword ptr [r8+r13*4], 2
vpextrd r9d, xmm12, 3
vpextrd r12d, xmm12, 2
vpinsrd xmm15, xmm15, dword ptr [r8+r15*4], 3
vmovd r15d, xmm14
vpextrd r13d, xmm12, 1
vmovd ebp, xmm12
vmovd xmm12, dword ptr [r8+r15*4]
vpinsrd xmm12, xmm12, dword ptr [r8+rsi*4], 1
vmovd xmm14, dword ptr [r8+rbp*4]
vpinsrd xmm12, xmm12, dword ptr [r8+rdx*4], 2
vpinsrd xmm14, xmm14, dword ptr [r8+r13*4], 1
vpinsrd xmm14, xmm14, dword ptr [r8+r12*4], 2
vpinsrd xmm12, xmm12, dword ptr [r8+rax*4], 3
vpinsrd xmm14, xmm14, dword ptr [r8+r9*4], 3
vmovd xmm16, dword ptr [r10+rbx*4+52h]
vinserti128 ymm13, ymm13, xmm15, 1
vpermq ymm15, ymm16, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm11
vmovdqu8 ymm15{k1}, ymm11
vinserti128 ymm11, ymm14, xmm12, 1
vmovd xmm12, dword ptr [r10+rbx*4+56h]
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpmaddubsw ymm12, ymm13, ymm15
vpsubb ymm13, ymm0, ymm10
vmovdqu8 ymm13{k1}, ymm10
movzx eax, byte ptr [r10+r14]
mov edx, eax
and edx, 0Fh
lea edx, ds:1[rdx*2]
vpmaddubsw ymm10, ymm11, ymm13
vpbroadcastw ymm11, edx
vpmaddwd ymm11, ymm12, ymm11
shr eax, 3
or eax, 1
vpbroadcastw ymm12, eax
vpaddd ymm8, ymm11, ymm8
vpmaddwd ymm10, ymm10, ymm12
vpaddd ymm9, ymm10, ymm9
add rbx, 2
inc r14
add r11, 40h ; '@'
cmp rbx, 6
jb loc_32906
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm8, ymm9
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
inc rcx
add r10, 6Eh ; 'n'
vmovaps ymm5, ymm6
cmp rcx, rdi
jnz loc_328BB
loc_32B02:
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
mov rax, [rsp+30h+var_40]
vmovss dword ptr [rax], xmm0
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
|
long long ggml_vec_dot_iq3_s_q8_K(
int a1,
long long a2,
__m128 _XMM0,
double a4,
double a5,
double a6,
double a7,
__m128 _XMM5,
__m128 _XMM6,
long long a10,
long long a11,
long long a12,
long long _R9)
{
long long v21; // rdi
long long v23; // rcx
long long v37; // r14
long long result; // rax
long long v111; // [rsp+10h] [rbp-38h]
v111 = _R9;
__asm { vxorps xmm6, xmm6, xmm6 }
if ( a1 >= 256 )
{
v21 = (unsigned int)a1 >> 8;
__asm { vpxor xmm0, xmm0, xmm0 }
v23 = 0LL;
__asm
{
vpmovsxbd ymm1, cs:qword_555D0
vpbroadcastd ymm2, cs:dword_5536C
}
_R8 = &iq3s_grid;
__asm
{
vmovdqa ymm3, cs:ymmword_55380
vpbroadcastq ymm4, cs:qword_555C0
}
_R10 = a11;
__asm { vxorps xmm5, xmm5, xmm5 }
do
{
_R11 = *(unsigned __int16 *)(a11 + 110 * v23);
_RAX = &ggml_table_f32_f16;
__asm { vmovss xmm6, dword ptr [rax+r11*4] }
HIDWORD(_RAX) = HIDWORD(v111);
_R11 = v111 + 292 * v23 + 4;
__asm { vmovss xmm7, dword ptr [r11-4] }
_RBX = -2LL;
v37 = 106LL;
__asm
{
vpxor xmm8, xmm8, xmm8
vpxor xmm9, xmm9, xmm9
}
do
{
__asm
{
vmovdqu ymm11, ymmword ptr [r11]
vpmovzxbw ymm12, xmmword ptr [r10+rbx*8+12h]
vmovdqu ymm10, ymmword ptr [r11+20h]
}
_EBP = *(unsigned __int8 *)(_R10 + _RBX + 68);
__asm { vpbroadcastd ymm13, ebp }
_EBP = *(unsigned __int8 *)(_R10 + _RBX + 69);
__asm
{
vpbroadcastd ymm14, ebp
vpsllvd ymm13, ymm13, ymm1
vpsllvd ymm14, ymm14, ymm1
vpmovzxwd ymm15, xmm12
vpternlogd ymm15, ymm13, ymm2, 0F8h
vextracti128 xmm12, ymm12, 1
vpmovzxwd ymm12, xmm12
vextracti128 xmm13, ymm15, 1
vpextrd r15d, xmm13, 3
vpextrd r12d, xmm15, 3
vpextrd r13d, xmm13, 2
vpextrd rbp, xmm15, 2
vpextrd rdx, xmm15, 1
vpextrd rsi, xmm13, 1
vmovd eax, xmm13
vmovd r9d, xmm15
vmovd xmm13, dword ptr [r8+r9*4]
vmovd xmm15, dword ptr [r8+rax*4]
vpinsrd xmm13, xmm13, dword ptr [r8+rdx*4], 1
vpinsrd xmm13, xmm13, dword ptr [r8+rbp*4], 2
vpinsrd xmm15, xmm15, dword ptr [r8+rsi*4], 1
vpternlogd ymm12, ymm14, ymm2, 0F8h
vpinsrd xmm13, xmm13, dword ptr [r8+r12*4], 3
vextracti128 xmm14, ymm12, 1
vpextrd rax, xmm14, 3
vpextrd rdx, xmm14, 2
vpextrd rsi, xmm14, 1
vpinsrd xmm15, xmm15, dword ptr [r8+r13*4], 2
vpextrd r9d, xmm12, 3
vpextrd r12d, xmm12, 2
vpinsrd xmm15, xmm15, dword ptr [r8+r15*4], 3
vmovd r15d, xmm14
vpextrd r13d, xmm12, 1
vmovd ebp, xmm12
vmovd xmm12, dword ptr [r8+r15*4]
vpinsrd xmm12, xmm12, dword ptr [r8+rsi*4], 1
vmovd xmm14, dword ptr [r8+rbp*4]
vpinsrd xmm12, xmm12, dword ptr [r8+rdx*4], 2
vpinsrd xmm14, xmm14, dword ptr [r8+r13*4], 1
vpinsrd xmm14, xmm14, dword ptr [r8+r12*4], 2
vpinsrd xmm12, xmm12, dword ptr [r8+rax*4], 3
vpinsrd xmm14, xmm14, dword ptr [r8+r9*4], 3
vmovd xmm16, dword ptr [r10+rbx*4+52h]
vinserti128 ymm13, ymm13, xmm15, 1
vpermq ymm15, ymm16, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm11
vmovdqu8 ymm15{k1}, ymm11
vinserti128 ymm11, ymm14, xmm12, 1
vmovd xmm12, dword ptr [r10+rbx*4+56h]
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpmaddubsw ymm12, ymm13, ymm15
vpsubb ymm13, ymm0, ymm10
vmovdqu8 ymm13{k1}, ymm10
}
LODWORD(_RDX) = 2 * (*(_BYTE *)(_R10 + v37) & 0xF) + 1;
__asm
{
vpmaddubsw ymm10, ymm11, ymm13
vpbroadcastw ymm11, edx
vpmaddwd ymm11, ymm12, ymm11
}
_RAX = (void *)((*(unsigned __int8 *)(_R10 + v37) >> 3) | 1u);
__asm
{
vpbroadcastw ymm12, eax
vpaddd ymm8, ymm11, ymm8
vpmaddwd ymm10, ymm10, ymm12
vpaddd ymm9, ymm10, ymm9
}
_RBX += 2LL;
++v37;
_R11 += 64LL;
}
while ( _RBX < 6 );
__asm
{
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm8, ymm9
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
}
++v23;
_R10 += 110LL;
__asm { vmovaps ymm5, ymm6 }
}
while ( v23 != v21 );
}
__asm
{
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
}
result = a2;
__asm
{
vmovss dword ptr [rax], xmm0
vzeroupper
}
return result;
}
|
ggml_vec_dot_iq3_s_q8_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV qword ptr [RSP + -0x8],R9
MOV qword ptr [RSP + -0x18],RCX
MOV qword ptr [RSP + -0x10],RSI
VXORPS XMM6,XMM6,XMM6
CMP EDI,0x100
JL 0x00132b02
SHR EDI,0x8
VPXOR XMM0,XMM0,XMM0
XOR ECX,ECX
VPMOVSXBD YMM1,qword ptr [0x001555d0]
VPBROADCASTD YMM2,dword ptr [0x0015536c]
LEA R8,[0x159620]
VMOVDQA YMM3,ymmword ptr [0x00155380]
VPBROADCASTQ YMM4,qword ptr [0x001555c0]
MOV R10,qword ptr [RSP + -0x18]
VXORPS XMM5,XMM5,XMM5
LAB_001328bb:
IMUL R11,RCX,0x6e
MOV RAX,qword ptr [RSP + -0x18]
MOVZX R11D,word ptr [RAX + R11*0x1]
MOV RAX,qword ptr [0x00164f70]
VMOVSS XMM6,dword ptr [RAX + R11*0x4]
IMUL R11,RCX,0x124
MOV RAX,qword ptr [RSP + -0x8]
ADD R11,RAX
ADD R11,0x4
VMOVSS XMM7,dword ptr [R11 + -0x4]
MOV RBX,-0x2
MOV R14D,0x6a
VPXOR XMM8,XMM8,XMM8
VPXOR XMM9,XMM9,XMM9
LAB_00132906:
VMOVDQU YMM11,ymmword ptr [R11]
VPMOVZXBW YMM12,xmmword ptr [R10 + RBX*0x8 + 0x12]
VMOVDQU YMM10,ymmword ptr [R11 + 0x20]
MOVZX EBP,byte ptr [R10 + RBX*0x1 + 0x44]
VPBROADCASTD YMM13
MOVZX EBP,byte ptr [R10 + RBX*0x1 + 0x45]
VPBROADCASTD YMM14
VPSLLVD YMM13,YMM13,YMM1
VPSLLVD YMM14,YMM14,YMM1
VPMOVZXWD YMM15,XMM12
VPTERNLOGD YMM15,YMM13,YMM2,0xf8
VEXTRACTI128 XMM12,YMM12,0x1
VPMOVZXWD YMM12,XMM12
VEXTRACTI128 XMM13,YMM15,0x1
VPEXTRD R15D,XMM13,0x3
VPEXTRD R12D,XMM15,0x3
VPEXTRD R13D,XMM13,0x2
VPEXTRD EBP,XMM15,0x2
VPEXTRD EDX,XMM15,0x1
VPEXTRD ESI,XMM13,0x1
VMOVD EAX,XMM13
VMOVD R9D,XMM15
VMOVD XMM13,dword ptr [R8 + R9*0x4]
VMOVD XMM15,dword ptr [R8 + RAX*0x4]
VPINSRD XMM13,XMM13,dword ptr [R8 + RDX*0x4],0x1
VPINSRD XMM13,XMM13,dword ptr [R8 + RBP*0x4],0x2
VPINSRD XMM15,XMM15,dword ptr [R8 + RSI*0x4],0x1
VPTERNLOGD YMM12,YMM14,YMM2,0xf8
VPINSRD XMM13,XMM13,dword ptr [R8 + R12*0x4],0x3
VEXTRACTI128 XMM14,YMM12,0x1
VPEXTRD EAX,XMM14,0x3
VPEXTRD EDX,XMM14,0x2
VPEXTRD ESI,XMM14,0x1
VPINSRD XMM15,XMM15,dword ptr [R8 + R13*0x4],0x2
VPEXTRD R9D,XMM12,0x3
VPEXTRD R12D,XMM12,0x2
VPINSRD XMM15,XMM15,dword ptr [R8 + R15*0x4],0x3
VMOVD R15D,XMM14
VPEXTRD R13D,XMM12,0x1
VMOVD EBP,XMM12
VMOVD XMM12,dword ptr [R8 + R15*0x4]
VPINSRD XMM12,XMM12,dword ptr [R8 + RSI*0x4],0x1
VMOVD XMM14,dword ptr [R8 + RBP*0x4]
VPINSRD XMM12,XMM12,dword ptr [R8 + RDX*0x4],0x2
VPINSRD XMM14,XMM14,dword ptr [R8 + R13*0x4],0x1
VPINSRD XMM14,XMM14,dword ptr [R8 + R12*0x4],0x2
VPINSRD XMM12,XMM12,dword ptr [R8 + RAX*0x4],0x3
VPINSRD XMM14,XMM14,dword ptr [R8 + R9*0x4],0x3
VMOVD XMM0,dword ptr [R10 + RBX*0x4 + 0x52]
VINSERTI128 YMM13,YMM13,XMM15,0x1
VPERMQ YMM15,YMM0,0x44
VPSHUFB YMM15,YMM15,YMM3
VPTESTNMB K1 {K0},YMM15,YMM4
VPSUBB YMM15,YMM0,YMM11
VMOVDQU8 YMM15{K1},YMM11
VINSERTI128 YMM11,YMM14,XMM12,0x1
VMOVD XMM12,dword ptr [R10 + RBX*0x4 + 0x56]
VPERMQ YMM12,YMM12,0x44
VPSHUFB YMM12,YMM12,YMM3
VPTESTNMB K1 {K0},YMM12,YMM4
VPMADDUBSW YMM12,YMM13,YMM15
VPSUBB YMM13,YMM0,YMM10
VMOVDQU8 YMM13{K1},YMM10
MOVZX EAX,byte ptr [R10 + R14*0x1]
MOV EDX,EAX
AND EDX,0xf
LEA EDX,[0x1 + RDX*0x2]
VPMADDUBSW YMM10,YMM11,YMM13
VPBROADCASTW YMM11
VPMADDWD YMM11,YMM12,YMM11
SHR EAX,0x3
OR EAX,0x1
VPBROADCASTW YMM12
VPADDD YMM8,YMM11,YMM8
VPMADDWD YMM10,YMM10,YMM12
VPADDD YMM9,YMM10,YMM9
ADD RBX,0x2
INC R14
ADD R11,0x40
CMP RBX,0x6
JC 0x00132906
VMULSS XMM6,XMM6,XMM7
VBROADCASTSS YMM7,XMM6
VPADDD YMM6,YMM8,YMM9
VCVTDQ2PS YMM6,YMM6
VFMADD213PS YMM6,YMM7,YMM5
INC RCX
ADD R10,0x6e
VMOVAPS YMM5,YMM6
CMP RCX,RDI
JNZ 0x001328bb
LAB_00132b02:
VEXTRACTF128 XMM0,YMM6,0x1
VADDPS XMM0,XMM0,XMM6
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
MOV RAX,qword ptr [RSP + -0x10]
VMOVSS dword ptr [RAX],XMM0
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_iq3_s_q8_K
(uint param_1,int4 *param_2,int8 param_3,long param_4,int8 param_5,
long param_6)
{
bool bVar1;
float fVar2;
int1 auVar3 [32];
int4 uVar5;
long lVar4;
ulong uVar6;
int4 uVar7;
int4 uVar8;
ulong uVar9;
uint uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
long lVar14;
float *pfVar15;
int1 (*pauVar16) [32];
int4 uVar17;
int4 uVar18;
long unaff_R12;
int4 uVar19;
int4 uVar20;
long unaff_R13;
int4 uVar21;
int4 uVar22;
long unaff_R15;
int4 uVar23;
uint in_K0;
ulong uVar24;
int1 auVar25 [32];
int1 auVar26 [32];
int1 auVar27 [32];
int1 auVar28 [32];
int1 auVar29 [16];
int1 auVar30 [16];
int1 auVar31 [64];
int1 auVar32 [32];
int1 auVar33 [32];
int1 auVar34 [16];
int1 auVar35 [32];
int1 auVar36 [64];
int1 auVar37 [64];
int1 auVar38 [32];
int1 auVar39 [16];
int1 auVar40 [16];
int1 auVar41 [32];
uVar13 = (int4)((ulong)param_6 >> 0x20);
uVar12 = (int4)((ulong)param_2 >> 0x20);
auVar34 = ZEXT816(0) << 0x40;
if (0xff < (int)param_1) {
auVar31 = ZEXT1664((int1 [16])0x0);
uVar6 = 0;
auVar34._8_8_ = 0;
auVar34._0_8_ = DAT_001555d0;
auVar3 = vpmovsxbd_avx2(auVar34);
auVar32._4_4_ = DAT_0015536c;
auVar32._0_4_ = DAT_0015536c;
auVar32._8_4_ = DAT_0015536c;
auVar32._12_4_ = DAT_0015536c;
auVar32._16_4_ = DAT_0015536c;
auVar32._20_4_ = DAT_0015536c;
auVar32._24_4_ = DAT_0015536c;
auVar32._28_4_ = DAT_0015536c;
auVar33._8_8_ = DAT_001555c0;
auVar33._0_8_ = DAT_001555c0;
auVar33._16_8_ = DAT_001555c0;
auVar33._24_8_ = DAT_001555c0;
auVar34 = ZEXT816(0) << 0x40;
lVar14 = param_4;
do {
pfVar15 = (float *)(uVar6 * 0x124 + param_6);
pauVar16 = (int1 (*) [32])(pfVar15 + 1);
uVar9 = 0xfffffffffffffffe;
auVar36 = ZEXT1664((int1 [16])0x0);
auVar37 = ZEXT1664((int1 [16])0x0);
lVar4 = param_6;
do {
auVar27 = vpmovzxbw_avx2(*(int1 (*) [16])(lVar14 + 0x12 + uVar9 * 8));
auVar25 = vpbroadcastd_avx512vl();
auVar26 = vpbroadcastd_avx512vl();
auVar28 = vpsllvd_avx2(auVar25,auVar3);
auVar26 = vpsllvd_avx2(auVar26,auVar3);
auVar25 = vpmovzxwd_avx2(auVar27._0_16_);
auVar25 = vpternlogd_avx512vl(auVar25,auVar28,auVar32,0xf8);
auVar27 = vpmovzxwd_avx2(auVar27._16_16_);
auVar29 = auVar25._0_16_;
auVar30 = auVar25._16_16_;
uVar23 = (int4)((ulong)unaff_R15 >> 0x20);
uVar22 = vpextrd_avx(auVar30,3);
uVar19 = (int4)((ulong)unaff_R12 >> 0x20);
uVar17 = vpextrd_avx(auVar29,3);
uVar21 = (int4)((ulong)unaff_R13 >> 0x20);
uVar20 = vpextrd_avx(auVar30,2);
uVar10 = vpextrd_avx(auVar29,2);
uVar8 = (int4)((ulong)param_3 >> 0x20);
uVar7 = vpextrd_avx(auVar29,1);
uVar11 = vpextrd_avx(auVar30,1);
uVar5 = (int4)((ulong)lVar4 >> 0x20);
auVar29 = vpinsrd_avx(ZEXT416(*(uint *)(iq3s_grid + CONCAT44(uVar13,auVar25._0_4_) * 4)),
*(int4 *)(iq3s_grid + CONCAT44(uVar8,uVar7) * 4),1);
auVar29 = vpinsrd_avx(auVar29,*(int4 *)(iq3s_grid + (ulong)uVar10 * 4),2);
auVar30 = vpinsrd_avx(ZEXT416(*(uint *)(iq3s_grid + CONCAT44(uVar5,auVar25._16_4_) * 4)),
*(int4 *)(iq3s_grid + CONCAT44(uVar12,uVar11) * 4),1);
auVar27 = vpternlogd_avx512vl(auVar27,auVar26,auVar32,0xf8);
auVar29 = vpinsrd_avx(auVar29,*(int4 *)(iq3s_grid + CONCAT44(uVar19,uVar17) * 4),3);
auVar39 = auVar27._0_16_;
auVar40 = auVar27._16_16_;
uVar7 = vpextrd_avx(auVar40,3);
uVar11 = vpextrd_avx(auVar40,2);
uVar17 = vpextrd_avx(auVar40,1);
auVar30 = vpinsrd_avx(auVar30,*(int4 *)(iq3s_grid + CONCAT44(uVar21,uVar20) * 4),2);
uVar20 = vpextrd_avx(auVar39,3);
uVar18 = vpextrd_avx(auVar39,2);
unaff_R12 = CONCAT44(uVar19,uVar18);
auVar30 = vpinsrd_avx(auVar30,*(int4 *)(iq3s_grid + CONCAT44(uVar23,uVar22) * 4),3);
unaff_R15 = CONCAT44(uVar23,auVar27._16_4_);
uVar18 = vpextrd_avx(auVar39,1);
unaff_R13 = CONCAT44(uVar21,uVar18);
auVar39 = vpinsrd_avx(ZEXT416(*(uint *)(iq3s_grid + unaff_R15 * 4)),
*(int4 *)(iq3s_grid + CONCAT44(uVar12,uVar17) * 4),1);
auVar39 = vpinsrd_avx(auVar39,*(int4 *)(iq3s_grid + CONCAT44(uVar8,uVar11) * 4),2);
auVar40 = vpinsrd_avx(ZEXT416(*(uint *)(iq3s_grid + (ulong)auVar27._0_4_ * 4)),
*(int4 *)(iq3s_grid + unaff_R13 * 4),1);
auVar40 = vpinsrd_avx(auVar40,*(int4 *)(iq3s_grid + unaff_R12 * 4),2);
auVar39 = vpinsrd_avx(auVar39,*(int4 *)(iq3s_grid + CONCAT44(uVar5,uVar7) * 4),3);
auVar40 = vpinsrd_avx(auVar40,*(int4 *)(iq3s_grid + CONCAT44(uVar13,uVar20) * 4),3);
auVar31._0_16_ = ZEXT416(*(uint *)(lVar14 + 0x52 + uVar9 * 4));
auVar41._0_16_ = ZEXT116(0) * auVar30 + ZEXT116(1) * auVar29;
auVar41._16_16_ = ZEXT116(0) * SUB4816((int1 [48])0x0,0) + ZEXT116(1) * auVar30;
auVar26 = auVar31._0_32_;
auVar27 = vpermq_avx512vl(auVar26,0x44);
auVar27 = vpshufb_avx2(auVar27,_DAT_00155380);
uVar24 = vptestnmb_avx512vl(auVar27,auVar33);
uVar24 = in_K0 & uVar24;
auVar27 = vpsubb_avx2(auVar26,*pauVar16);
auVar25 = vmovdqu8_avx512vl(*pauVar16);
bVar1 = (bool)((byte)uVar24 & 1);
auVar28[0] = bVar1 * auVar25[0] | !bVar1 * auVar27[0];
bVar1 = (bool)((byte)(uVar24 >> 1) & 1);
auVar28[1] = bVar1 * auVar25[1] | !bVar1 * auVar27[1];
bVar1 = (bool)((byte)(uVar24 >> 2) & 1);
auVar28[2] = bVar1 * auVar25[2] | !bVar1 * auVar27[2];
bVar1 = (bool)((byte)(uVar24 >> 3) & 1);
auVar28[3] = bVar1 * auVar25[3] | !bVar1 * auVar27[3];
bVar1 = (bool)((byte)(uVar24 >> 4) & 1);
auVar28[4] = bVar1 * auVar25[4] | !bVar1 * auVar27[4];
bVar1 = (bool)((byte)(uVar24 >> 5) & 1);
auVar28[5] = bVar1 * auVar25[5] | !bVar1 * auVar27[5];
bVar1 = (bool)((byte)(uVar24 >> 6) & 1);
auVar28[6] = bVar1 * auVar25[6] | !bVar1 * auVar27[6];
bVar1 = (bool)((byte)(uVar24 >> 7) & 1);
auVar28[7] = bVar1 * auVar25[7] | !bVar1 * auVar27[7];
bVar1 = (bool)((byte)(uVar24 >> 8) & 1);
auVar28[8] = bVar1 * auVar25[8] | !bVar1 * auVar27[8];
bVar1 = (bool)((byte)(uVar24 >> 9) & 1);
auVar28[9] = bVar1 * auVar25[9] | !bVar1 * auVar27[9];
bVar1 = (bool)((byte)(uVar24 >> 10) & 1);
auVar28[10] = bVar1 * auVar25[10] | !bVar1 * auVar27[10];
bVar1 = (bool)((byte)(uVar24 >> 0xb) & 1);
auVar28[0xb] = bVar1 * auVar25[0xb] | !bVar1 * auVar27[0xb];
bVar1 = (bool)((byte)(uVar24 >> 0xc) & 1);
auVar28[0xc] = bVar1 * auVar25[0xc] | !bVar1 * auVar27[0xc];
bVar1 = (bool)((byte)(uVar24 >> 0xd) & 1);
auVar28[0xd] = bVar1 * auVar25[0xd] | !bVar1 * auVar27[0xd];
bVar1 = (bool)((byte)(uVar24 >> 0xe) & 1);
auVar28[0xe] = bVar1 * auVar25[0xe] | !bVar1 * auVar27[0xe];
bVar1 = (bool)((byte)(uVar24 >> 0xf) & 1);
auVar28[0xf] = bVar1 * auVar25[0xf] | !bVar1 * auVar27[0xf];
bVar1 = (bool)((byte)(uVar24 >> 0x10) & 1);
auVar28[0x10] = bVar1 * auVar25[0x10] | !bVar1 * auVar27[0x10];
bVar1 = (bool)((byte)(uVar24 >> 0x11) & 1);
auVar28[0x11] = bVar1 * auVar25[0x11] | !bVar1 * auVar27[0x11];
bVar1 = (bool)((byte)(uVar24 >> 0x12) & 1);
auVar28[0x12] = bVar1 * auVar25[0x12] | !bVar1 * auVar27[0x12];
bVar1 = (bool)((byte)(uVar24 >> 0x13) & 1);
auVar28[0x13] = bVar1 * auVar25[0x13] | !bVar1 * auVar27[0x13];
bVar1 = (bool)((byte)(uVar24 >> 0x14) & 1);
auVar28[0x14] = bVar1 * auVar25[0x14] | !bVar1 * auVar27[0x14];
bVar1 = (bool)((byte)(uVar24 >> 0x15) & 1);
auVar28[0x15] = bVar1 * auVar25[0x15] | !bVar1 * auVar27[0x15];
bVar1 = (bool)((byte)(uVar24 >> 0x16) & 1);
auVar28[0x16] = bVar1 * auVar25[0x16] | !bVar1 * auVar27[0x16];
bVar1 = (bool)((byte)(uVar24 >> 0x17) & 1);
auVar28[0x17] = bVar1 * auVar25[0x17] | !bVar1 * auVar27[0x17];
bVar1 = (bool)((byte)(uVar24 >> 0x18) & 1);
auVar28[0x18] = bVar1 * auVar25[0x18] | !bVar1 * auVar27[0x18];
bVar1 = (bool)((byte)(uVar24 >> 0x19) & 1);
auVar28[0x19] = bVar1 * auVar25[0x19] | !bVar1 * auVar27[0x19];
bVar1 = (bool)((byte)(uVar24 >> 0x1a) & 1);
auVar28[0x1a] = bVar1 * auVar25[0x1a] | !bVar1 * auVar27[0x1a];
bVar1 = (bool)((byte)(uVar24 >> 0x1b) & 1);
auVar28[0x1b] = bVar1 * auVar25[0x1b] | !bVar1 * auVar27[0x1b];
bVar1 = (bool)((byte)(uVar24 >> 0x1c) & 1);
auVar28[0x1c] = bVar1 * auVar25[0x1c] | !bVar1 * auVar27[0x1c];
bVar1 = (bool)((byte)(uVar24 >> 0x1d) & 1);
auVar28._30_2_ = auVar25._30_2_;
auVar28[0x1d] = bVar1 * auVar25[0x1d] | !bVar1 * auVar27[0x1d];
auVar38._0_16_ = ZEXT116(0) * auVar39 + ZEXT116(1) * auVar40;
auVar38._16_16_ = ZEXT116(1) * auVar39;
auVar27 = vpermq_avx2(ZEXT432(*(uint *)(lVar14 + 0x56 + uVar9 * 4)),0x44);
auVar27 = vpshufb_avx2(auVar27,_DAT_00155380);
uVar24 = vptestnmb_avx512vl(auVar27,auVar33);
uVar24 = in_K0 & uVar24;
auVar27 = vpmaddubsw_avx2(auVar41,auVar28);
auVar25 = vpsubb_avx2(auVar26,pauVar16[1]);
auVar28 = vmovdqu8_avx512vl(pauVar16[1]);
bVar1 = (bool)((byte)uVar24 & 1);
auVar26[0] = bVar1 * auVar28[0] | !bVar1 * auVar25[0];
bVar1 = (bool)((byte)(uVar24 >> 1) & 1);
auVar26[1] = bVar1 * auVar28[1] | !bVar1 * auVar25[1];
bVar1 = (bool)((byte)(uVar24 >> 2) & 1);
auVar26[2] = bVar1 * auVar28[2] | !bVar1 * auVar25[2];
bVar1 = (bool)((byte)(uVar24 >> 3) & 1);
auVar26[3] = bVar1 * auVar28[3] | !bVar1 * auVar25[3];
bVar1 = (bool)((byte)(uVar24 >> 4) & 1);
auVar26[4] = bVar1 * auVar28[4] | !bVar1 * auVar25[4];
bVar1 = (bool)((byte)(uVar24 >> 5) & 1);
auVar26[5] = bVar1 * auVar28[5] | !bVar1 * auVar25[5];
bVar1 = (bool)((byte)(uVar24 >> 6) & 1);
auVar26[6] = bVar1 * auVar28[6] | !bVar1 * auVar25[6];
bVar1 = (bool)((byte)(uVar24 >> 7) & 1);
auVar26[7] = bVar1 * auVar28[7] | !bVar1 * auVar25[7];
bVar1 = (bool)((byte)(uVar24 >> 8) & 1);
auVar26[8] = bVar1 * auVar28[8] | !bVar1 * auVar25[8];
bVar1 = (bool)((byte)(uVar24 >> 9) & 1);
auVar26[9] = bVar1 * auVar28[9] | !bVar1 * auVar25[9];
bVar1 = (bool)((byte)(uVar24 >> 10) & 1);
auVar26[10] = bVar1 * auVar28[10] | !bVar1 * auVar25[10];
bVar1 = (bool)((byte)(uVar24 >> 0xb) & 1);
auVar26[0xb] = bVar1 * auVar28[0xb] | !bVar1 * auVar25[0xb];
bVar1 = (bool)((byte)(uVar24 >> 0xc) & 1);
auVar26[0xc] = bVar1 * auVar28[0xc] | !bVar1 * auVar25[0xc];
bVar1 = (bool)((byte)(uVar24 >> 0xd) & 1);
auVar26[0xd] = bVar1 * auVar28[0xd] | !bVar1 * auVar25[0xd];
bVar1 = (bool)((byte)(uVar24 >> 0xe) & 1);
auVar26[0xe] = bVar1 * auVar28[0xe] | !bVar1 * auVar25[0xe];
bVar1 = (bool)((byte)(uVar24 >> 0xf) & 1);
auVar26[0xf] = bVar1 * auVar28[0xf] | !bVar1 * auVar25[0xf];
bVar1 = (bool)((byte)(uVar24 >> 0x10) & 1);
auVar26[0x10] = bVar1 * auVar28[0x10] | !bVar1 * auVar25[0x10];
bVar1 = (bool)((byte)(uVar24 >> 0x11) & 1);
auVar26[0x11] = bVar1 * auVar28[0x11] | !bVar1 * auVar25[0x11];
bVar1 = (bool)((byte)(uVar24 >> 0x12) & 1);
auVar26[0x12] = bVar1 * auVar28[0x12] | !bVar1 * auVar25[0x12];
bVar1 = (bool)((byte)(uVar24 >> 0x13) & 1);
auVar26[0x13] = bVar1 * auVar28[0x13] | !bVar1 * auVar25[0x13];
bVar1 = (bool)((byte)(uVar24 >> 0x14) & 1);
auVar26[0x14] = bVar1 * auVar28[0x14] | !bVar1 * auVar25[0x14];
bVar1 = (bool)((byte)(uVar24 >> 0x15) & 1);
auVar26[0x15] = bVar1 * auVar28[0x15] | !bVar1 * auVar25[0x15];
bVar1 = (bool)((byte)(uVar24 >> 0x16) & 1);
auVar26[0x16] = bVar1 * auVar28[0x16] | !bVar1 * auVar25[0x16];
bVar1 = (bool)((byte)(uVar24 >> 0x17) & 1);
auVar26[0x17] = bVar1 * auVar28[0x17] | !bVar1 * auVar25[0x17];
bVar1 = (bool)((byte)(uVar24 >> 0x18) & 1);
auVar26[0x18] = bVar1 * auVar28[0x18] | !bVar1 * auVar25[0x18];
bVar1 = (bool)((byte)(uVar24 >> 0x19) & 1);
auVar26[0x19] = bVar1 * auVar28[0x19] | !bVar1 * auVar25[0x19];
bVar1 = (bool)((byte)(uVar24 >> 0x1a) & 1);
auVar26[0x1a] = bVar1 * auVar28[0x1a] | !bVar1 * auVar25[0x1a];
bVar1 = (bool)((byte)(uVar24 >> 0x1b) & 1);
auVar26[0x1b] = bVar1 * auVar28[0x1b] | !bVar1 * auVar25[0x1b];
bVar1 = (bool)((byte)(uVar24 >> 0x1c) & 1);
auVar26[0x1c] = bVar1 * auVar28[0x1c] | !bVar1 * auVar25[0x1c];
bVar1 = (bool)((byte)(uVar24 >> 0x1d) & 1);
auVar26._30_2_ = auVar28._30_2_;
auVar26[0x1d] = bVar1 * auVar28[0x1d] | !bVar1 * auVar25[0x1d];
param_3 = 0;
auVar25 = vpmaddubsw_avx2(auVar38,auVar26);
auVar28 = vpbroadcastw_avx512vl();
auVar27 = vpmaddwd_avx2(auVar27,auVar28);
lVar4 = 0;
auVar28 = vpbroadcastw_avx512vl();
auVar27 = vpaddd_avx2(auVar27,auVar36._0_32_);
auVar36 = ZEXT3264(auVar27);
auVar25 = vpmaddwd_avx2(auVar25,auVar28);
auVar25 = vpaddd_avx2(auVar25,auVar37._0_32_);
auVar37 = ZEXT3264(auVar25);
uVar9 = uVar9 + 2;
pauVar16 = pauVar16 + 2;
} while (uVar9 < 6);
fVar2 = *(float *)(PTR_ggml_table_f32_f16_00164f70 +
(ulong)*(ushort *)(param_4 + uVar6 * 0x6e) * 4) * *pfVar15;
auVar35._4_4_ = fVar2;
auVar35._0_4_ = fVar2;
auVar35._8_4_ = fVar2;
auVar35._12_4_ = fVar2;
auVar35._16_4_ = fVar2;
auVar35._20_4_ = fVar2;
auVar35._24_4_ = fVar2;
auVar35._28_4_ = fVar2;
auVar27 = vpaddd_avx2(auVar27,auVar25);
auVar27 = vcvtdq2ps_avx(auVar27);
auVar34 = vfmadd213ps_fma(auVar27,auVar35,ZEXT1632(auVar34));
uVar6 = uVar6 + 1;
lVar14 = lVar14 + 0x6e;
} while (uVar6 != param_1 >> 8);
}
auVar29._0_4_ = auVar34._0_4_ + 0.0;
auVar29._4_4_ = auVar34._4_4_ + 0.0;
auVar29._8_4_ = auVar34._8_4_ + 0.0;
auVar29._12_4_ = auVar34._12_4_ + 0.0;
auVar34 = vshufpd_avx(auVar29,auVar29,1);
auVar30._0_4_ = auVar29._0_4_ + auVar34._0_4_;
auVar30._4_4_ = auVar29._4_4_ + auVar34._4_4_;
auVar30._8_4_ = auVar29._8_4_ + auVar34._8_4_;
auVar30._12_4_ = auVar29._12_4_ + auVar34._12_4_;
auVar34 = vhaddps_avx(auVar30,auVar30);
*param_2 = auVar34._0_4_;
return;
}
|
|
13,989
|
ftxui::ScreenInteractive::Loop(std::shared_ptr<ftxui::ComponentBase>)
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/screen_interactive.cpp
|
void ScreenInteractive::Loop(Component component) { // NOLINT
class Loop loop(this, std::move(component));
loop.Run();
}
|
O3
|
cpp
|
ftxui::ScreenInteractive::Loop(std::shared_ptr<ftxui::ComponentBase>):
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rax
movups (%rsi), %xmm0
xorl %ecx, %ecx
movq %rcx, 0x8(%rsi)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq %rcx, (%rsi)
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x36818
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d644
callq 0x14af8
leaq 0x18(%rsp), %rdi
callq 0x3696a
leaq 0x18(%rsp), %rdi
callq 0x36860
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x36860
jmp 0x2d67f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d67f
callq 0x14af8
movq %rbx, %rdi
callq 0xb780
nop
|
_ZN5ftxui17ScreenInteractive4LoopESt10shared_ptrINS_13ComponentBaseEE:
push rbx
sub rsp, 30h
mov rax, rdi
movups xmm0, xmmword ptr [rsi]
xor ecx, ecx
mov [rsi+8], rcx
mov rdx, rsp
movaps xmmword ptr [rdx], xmm0
mov [rsi], rcx
lea rdi, [rsp+38h+var_20]
mov rsi, rax
call _ZN5ftxui4LoopC2EPNS_17ScreenInteractiveESt10shared_ptrINS_13ComponentBaseEE; ftxui::Loop::Loop(ftxui::ScreenInteractive *,std::shared_ptr<ftxui::ComponentBase>)
mov rdi, [rsp+38h+var_30]
test rdi, rdi
jz short loc_2D644
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_2D644:
lea rdi, [rsp+38h+var_20]; this
call _ZN5ftxui4Loop3RunEv; ftxui::Loop::Run(void)
lea rdi, [rsp+38h+var_20]; this
call _ZN5ftxui4LoopD2Ev; ftxui::Loop::~Loop()
add rsp, 30h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_10]; this
call _ZN5ftxui4LoopD2Ev; ftxui::Loop::~Loop()
jmp short loc_2D67F
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_2D67F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_2D67F:
mov rdi, rbx
call __Unwind_Resume
|
void ftxui::ScreenInteractive::Loop(long long a1, __int128 *a2)
{
__int128 v2; // xmm0
_BYTE v3[32]; // [rsp+18h] [rbp-20h] BYREF
v2 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_QWORD *)a2 = 0LL;
ftxui::Loop::Loop(v3, a1);
if ( *((_QWORD *)&v2 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v2 + 1));
ftxui::Loop::Run((ftxui::Loop *)v3);
ftxui::Loop::~Loop((ftxui::Loop *)v3);
}
|
Loop:
PUSH RBX
SUB RSP,0x30
MOV RAX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
XOR ECX,ECX
MOV qword ptr [RSI + 0x8],RCX
MOV RDX,RSP
MOVAPS xmmword ptr [RDX],XMM0
MOV qword ptr [RSI],RCX
LAB_0012d628:
LEA RDI,[RSP + 0x18]
MOV RSI,RAX
CALL 0x00136818
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0012d644
CALL 0x00114af8
LAB_0012d644:
LEA RDI,[RSP + 0x18]
CALL 0x0013696a
LAB_0012d64e:
LEA RDI,[RSP + 0x18]
CALL 0x00136860
ADD RSP,0x30
POP RBX
RET
|
/* ftxui::ScreenInteractive::Loop(std::shared_ptr<ftxui::ComponentBase>) */
void __thiscall ftxui::ScreenInteractive::Loop(ScreenInteractive *this,int8 *param_2)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
Loop local_20 [24];
this_00 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 0012d628 to 0012d634 has its CatchHandler @ 0012d66d */
ftxui::Loop::Loop(local_20,this);
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
/* try { // try from 0012d644 to 0012d64d has its CatchHandler @ 0012d65e */
ftxui::Loop::Run(local_20);
ftxui::Loop::~Loop(local_20);
return;
}
|
|
13,990
|
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>::basic_json(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> const&)
|
llama.cpp/common/json.hpp
|
basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value = *other.m_data.m_value.object;
break;
}
case value_t::array:
{
m_data.m_value = *other.m_data.m_value.array;
break;
}
case value_t::string:
{
m_data.m_value = *other.m_data.m_value.string;
break;
}
case value_t::boolean:
{
m_data.m_value = other.m_data.m_value.boolean;
break;
}
case value_t::number_integer:
{
m_data.m_value = other.m_data.m_value.number_integer;
break;
}
case value_t::number_unsigned:
{
m_data.m_value = other.m_data.m_value.number_unsigned;
break;
}
case value_t::number_float:
{
m_data.m_value = other.m_data.m_value.number_float;
break;
}
case value_t::binary:
{
m_data.m_value = *other.m_data.m_value.binary;
break;
}
case value_t::null:
case value_t::discarded:
default:
break;
}
set_parents();
assert_invariant();
}
|
O3
|
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>::basic_json(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> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movq %rsi, %rdi
movl $0x1, %esi
callq 0x72c26
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x7830a
leaq 0x998e2(%rip), %rcx # 0x111ba8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
jmp 0x78306
movq 0x8(%r14), %rdi
callq 0x78c28
jmp 0x78306
movq 0x8(%r14), %rdi
callq 0x78c78
jmp 0x78306
movzbl 0x8(%r14), %eax
jmp 0x78306
movq 0x8(%r14), %rdi
callq 0x7878c
jmp 0x78306
movq 0x8(%r14), %rdi
callq 0x78ab4
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x72c26
jmp 0x78324
jmp 0x78324
jmp 0x78324
movq %rax, %r14
movq %rbx, %rdi
callq 0x78774
movq %r14, %rdi
callq 0x20ad0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov al, [rsi]
mov [rdi], al
mov rdi, rsi
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
movzx eax, byte ptr [rbx]
dec eax; switch 8 cases
cmp eax, 7
ja short def_782CD; jumptable 00000000000782CD default case
lea rcx, jpt_782CD
movsxd rax, ds:(jpt_782CD - 111BA8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_782CF:
mov rax, [r14+8]; jumptable 00000000000782CD cases 5-7
jmp short loc_78306
loc_782D5:
mov rdi, [r14+8]; jumptable 00000000000782CD case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_DpOT0_; 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>::create<std::string,std::string const&>(std::string const&)
jmp short loc_78306
loc_782E0:
mov rdi, [r14+8]; jumptable 00000000000782CD case 8
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS0_27byte_container_with_subtypeISC_EEJRKSG_EEEPT_DpOT0_; 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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&>(nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&)
jmp short loc_78306
loc_782EB:
movzx eax, byte ptr [r14+8]; jumptable 00000000000782CD case 4
jmp short loc_78306
loc_782F2:
mov rdi, [r14+8]; jumptable 00000000000782CD case 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEJRKSL_EEEPT_DpOT0_; 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>::create<std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&>(std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
jmp short loc_78306
loc_782FD:
mov rdi, [r14+8]; jumptable 00000000000782CD case 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJRKSG_EEEPT_DpOT0_; 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>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&>(std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
loc_78306:
mov [rbx+8], rax
def_782CD:
mov rdi, rbx; jumptable 00000000000782CD default case
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_78324
jmp short loc_78324
jmp short $+2
loc_78324:
mov r14, rax
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 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(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
long long result; // rax
*(_OWORD *)a1 = 0LL;
*a1 = *a2;
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>::assert_invariant((char *)a2);
result = (unsigned int)*a1 - 1;
switch ( *a1 )
{
case 1u:
result = 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>::create<std::map<std::string,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>>,std::map<std::string,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>> const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 2u:
result = 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>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 3u:
result = 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>::create<std::string,std::string const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 4u:
result = a2[8];
goto LABEL_8;
case 5u:
case 6u:
case 7u:
result = *((_QWORD *)a2 + 1);
goto LABEL_8;
case 8u:
result = nlohmann::json_abi_v3_11_3::basic_json<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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>> const&>(
*((_QWORD *)a2 + 1),
1LL);
LABEL_8:
*((_QWORD *)a1 + 1) = result;
break;
default:
break;
}
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>::assert_invariant((char *)a1);
return result;
}
|
basic_json:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV AL,byte ptr [RSI]
MOV byte ptr [RDI],AL
MOV RDI,RSI
MOV ESI,0x1
CALL 0x00172c26
MOVZX EAX,byte ptr [RBX]
DEC EAX
CMP EAX,0x7
JA 0x0017830a
LEA RCX,[0x211ba8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x00178306
caseD_3:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001782d9:
CALL 0x00178c28
JMP 0x00178306
caseD_8:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001782e4:
CALL 0x00178c78
JMP 0x00178306
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x00178306
caseD_1:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001782f6:
CALL 0x0017878c
JMP 0x00178306
caseD_2:
MOV RDI,qword ptr [R14 + 0x8]
LAB_00178301:
CALL 0x00178ab4
LAB_00178306:
MOV qword ptr [RBX + 0x8],RAX
default:
MOV RDI,RBX
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00172c26
|
/* 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(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> const&) */
void __thiscall
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(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
string *psVar1;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*this = (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;
assert_invariant(SUB81(param_1,0));
switch(*this) {
case (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1:
/* try { // try from 001782f6 to 001782fa has its CatchHandler @ 00178320 */
psVar1 = (string *)
create<std::map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,std::map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>const&>
(*(map **)(param_1 + 8));
break;
case (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2:
/* try { // try from 00178301 to 00178305 has its CatchHandler @ 0017831e */
psVar1 = (string *)
create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>const&>
(*(vector **)(param_1 + 8));
break;
case (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x3:
/* try { // try from 001782d9 to 001782dd has its CatchHandler @ 00178324 */
psVar1 = create<std::__cxx11::string,std::__cxx11::string_const&>(*(string **)(param_1 + 8));
break;
case (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>
)0x4:
psVar1 = (string *)(ulong)(byte)param_1[8];
break;
case (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>
)0x5:
case (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>
)0x6:
case (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>
)0x7:
psVar1 = *(string **)(param_1 + 8);
break;
case (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8:
/* try { // try from 001782e4 to 001782e8 has its CatchHandler @ 00178322 */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>const&>
(*(byte_container_with_subtype **)(param_1 + 8));
break;
default:
goto switchD_001782cd_default;
}
*(string **)(this + 8) = psVar1;
switchD_001782cd_default:
assert_invariant(SUB81(this,0));
return;
}
|
|
13,991
|
mbedtls_mpi_write_file
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/bignum.c
|
int mbedtls_mpi_write_file(const char *p, const mbedtls_mpi *X, int radix, FILE *fout)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t n, slen, plen;
/*
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
char s[MBEDTLS_MPI_RW_BUFFER_SIZE];
MPI_VALIDATE_RET(X != NULL);
if (radix < 2 || radix > 16) {
return MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
}
memset(s, 0, sizeof(s));
MBEDTLS_MPI_CHK(mbedtls_mpi_write_string(X, radix, s, sizeof(s) - 2, &n));
if (p == NULL) {
p = "";
}
plen = strlen(p);
slen = strlen(s);
s[slen++] = '\r';
s[slen++] = '\n';
if (fout != NULL) {
if (fwrite(p, 1, plen, fout) != plen ||
fwrite(s, 1, slen, fout) != slen) {
return MBEDTLS_ERR_MPI_FILE_IO_ERROR;
}
} else {
mbedtls_printf("%s%s", p, s);
}
cleanup:
return ret;
}
|
O3
|
c
|
mbedtls_mpi_write_file:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9c8, %rsp # imm = 0x9C8
movl %edx, %r12d
leal -0x11(%r12), %eax
movl $0xfffffffc, %r15d # imm = 0xFFFFFFFC
cmpl $-0xf, %eax
jb 0x7eae6
movq %rcx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x9b4, %edx # imm = 0x9B4
movq %r15, %rdi
xorl %esi, %esi
callq 0xf2b0
leaq 0x8(%rsp), %r8
movl $0x9b2, %ecx # imm = 0x9B2
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x7e6f2
movl %eax, %ebp
testl %eax, %eax
je 0x7eafb
movl %ebp, %r15d
movl %r15d, %eax
addq $0x9c8, %rsp # imm = 0x9C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
leaq 0x33866(%rip), %r15 # 0xb236b
cmovneq %r14, %r15
movq %r15, %rdi
callq 0xf240
movq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0xf240
movw $0xa0d, 0x10(%rsp,%rax) # imm = 0xA0D
testq %rbx, %rbx
je 0x7eb72
movq %rax, %r14
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xf860
movl $0xfffffffe, %r15d # imm = 0xFFFFFFFE
cmpq %r12, %rax
jne 0x7eae6
addq $0x2, %r14
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xf860
cmpq %r14, %rax
je 0x7eae3
jmp 0x7eae6
leaq 0x2cf37(%rip), %rdi # 0xabab0
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0xf070
jmp 0x7eae3
|
mbedtls_mpi_write_file:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 9C8h
mov r12d, edx
lea eax, [r12-11h]
mov r15d, 0FFFFFFFCh
cmp eax, 0FFFFFFF1h
jb short loc_7EAE6
mov rbx, rcx
mov r13, rsi
mov r14, rdi
lea r15, [rsp+9F8h+var_9E8]
mov edx, 9B4h
mov rdi, r15
xor esi, esi
call _memset
lea r8, [rsp+9F8h+var_9F0]
mov ecx, 9B2h
mov rdi, r13
mov esi, r12d
mov rdx, r15
call mbedtls_mpi_write_string
mov ebp, eax
test eax, eax
jz short loc_7EAFB
loc_7EAE3:
mov r15d, ebp
loc_7EAE6:
mov eax, r15d
add rsp, 9C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7EAFB:
test r14, r14
lea r15, unk_B236B
cmovnz r15, r14
mov rdi, r15
call _strlen
mov r12, rax
lea rdi, [rsp+9F8h+var_9E8]
call _strlen
mov [rsp+rax+9F8h+var_9E8], 0A0Dh
test rbx, rbx
jz short loc_7EB72
mov r14, rax
mov esi, 1
mov rdi, r15
mov rdx, r12
mov rcx, rbx
call _fwrite
mov r15d, 0FFFFFFFEh
cmp rax, r12
jnz short loc_7EAE6
add r14, 2
lea rdi, [rsp+9F8h+var_9E8]
mov esi, 1
mov rdx, r14
mov rcx, rbx
call _fwrite
cmp rax, r14
jz loc_7EAE3
jmp loc_7EAE6
loc_7EB72:
lea rdi, aSS; "%s%s"
lea rdx, [rsp+9F8h+var_9E8]
mov rsi, r15
xor eax, eax
call _printf
jmp loc_7EAE3
|
long long mbedtls_mpi_write_file(const char *a1, long long a2, unsigned int a3, long long a4)
{
unsigned int v5; // r15d
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
unsigned int v11; // ebp
long long v12; // r8
long long v13; // r9
const char *v15; // r15
long long v16; // r12
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
long long v21; // rax
long long v22; // r14
long long v23; // rax
unsigned long long v24; // [rsp+8h] [rbp-9F0h] BYREF
char v25[2536]; // [rsp+10h] [rbp-9E8h] BYREF
v5 = -4;
if ( a3 - 17 >= 0xFFFFFFF1 )
{
memset(v25, 0LL, 2484LL);
v8 = a3;
v11 = mbedtls_mpi_write_string(a2, a3, v25, 0x9B2uLL, &v24);
if ( v11 )
return v11;
v15 = (const char *)&unk_B236B;
if ( a1 )
v15 = a1;
v16 = strlen(v15, a3, v9, v10, v12, v13);
v21 = strlen(v25, v8, v17, v18, v19, v20);
*(_WORD *)&v25[v21] = 2573;
if ( !a4 )
{
printf("%s%s", v15, v25);
return v11;
}
v22 = v21;
v23 = fwrite(v15, 1LL, v16, a4);
v5 = -2;
if ( v23 == v16 && fwrite(v25, 1LL, v22 + 2, a4) == v22 + 2 )
return v11;
}
return v5;
}
|
mbedtls_mpi_write_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x9c8
MOV R12D,EDX
LEA EAX,[R12 + -0x11]
MOV R15D,0xfffffffc
CMP EAX,-0xf
JC 0x0017eae6
MOV RBX,RCX
MOV R13,RSI
MOV R14,RDI
LEA R15,[RSP + 0x10]
MOV EDX,0x9b4
MOV RDI,R15
XOR ESI,ESI
CALL 0x0010f2b0
LEA R8,[RSP + 0x8]
MOV ECX,0x9b2
MOV RDI,R13
MOV ESI,R12D
MOV RDX,R15
CALL 0x0017e6f2
MOV EBP,EAX
TEST EAX,EAX
JZ 0x0017eafb
LAB_0017eae3:
MOV R15D,EBP
LAB_0017eae6:
MOV EAX,R15D
ADD RSP,0x9c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017eafb:
TEST R14,R14
LEA R15,[0x1b236b]
CMOVNZ R15,R14
MOV RDI,R15
CALL 0x0010f240
MOV R12,RAX
LEA RDI,[RSP + 0x10]
CALL 0x0010f240
MOV word ptr [RSP + RAX*0x1 + 0x10],0xa0d
TEST RBX,RBX
JZ 0x0017eb72
MOV R14,RAX
MOV ESI,0x1
MOV RDI,R15
MOV RDX,R12
MOV RCX,RBX
CALL 0x0010f860
MOV R15D,0xfffffffe
CMP RAX,R12
JNZ 0x0017eae6
ADD R14,0x2
LEA RDI,[RSP + 0x10]
MOV ESI,0x1
MOV RDX,R14
MOV RCX,RBX
CALL 0x0010f860
CMP RAX,R14
JZ 0x0017eae3
JMP 0x0017eae6
LAB_0017eb72:
LEA RDI,[0x1abab0]
LEA RDX,[RSP + 0x10]
MOV RSI,R15
XOR EAX,EAX
CALL 0x0010f070
JMP 0x0017eae3
|
int mbedtls_mpi_write_file(char *param_1,int8 param_2,int param_3,FILE *param_4)
{
int iVar1;
size_t sVar2;
size_t sVar3;
size_t sVar4;
char *__s;
int1 local_9f0 [8];
char local_9e8 [2488];
iVar1 = -4;
if (0xfffffff0 < param_3 - 0x11U) {
memset(local_9e8,0,0x9b4);
iVar1 = mbedtls_mpi_write_string(param_2,param_3,local_9e8,0x9b2,local_9f0);
if (iVar1 == 0) {
__s = "";
if (param_1 != (char *)0x0) {
__s = param_1;
}
sVar2 = strlen(__s);
sVar3 = strlen(local_9e8);
(local_9e8 + sVar3)[0] = '\r';
(local_9e8 + sVar3)[1] = '\n';
if (param_4 == (FILE *)0x0) {
printf("%s%s",__s,local_9e8);
}
else {
sVar4 = fwrite(__s,1,sVar2,param_4);
if (sVar4 != sVar2) {
return -2;
}
sVar2 = fwrite(local_9e8,1,sVar3 + 2,param_4);
if (sVar2 != sVar3 + 2) {
return -2;
}
}
}
}
return iVar1;
}
|
|
13,992
|
stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
{
int diff,dc;
int t;
if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
if (j->succ_high == 0) {
// first scan for DC coefficient, must be first
memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
diff = t ? stbi__extend_receive(j, t) : 0;
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
data[0] = (short) (dc * (1 << j->succ_low));
} else {
// refinement scan for DC coefficient
if (stbi__jpeg_get_bit(j))
data[0] += (short) (1 << j->succ_low);
}
return 1;
}
|
O0
|
c
|
stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x4838(%rax)
je 0x29fba
leaq 0x154ec5(%rip), %rdi # 0x17ee71
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2a178
movq 0x28(%rsp), %rax
cmpl $0x10, 0x4824(%rax)
jge 0x29fd2
movq 0x28(%rsp), %rdi
callq 0x29e80
movq 0x28(%rsp), %rax
cmpl $0x0, 0x483c(%rax)
jne 0x2a13d
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0xb390
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2a760
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x2a016
cmpl $0xf, 0x8(%rsp)
jle 0x2a02b
leaq 0x154e54(%rip), %rdi # 0x17ee71
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2a178
cmpl $0x0, 0x8(%rsp)
je 0x2a046
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x2a960
movl %eax, 0x4(%rsp)
jmp 0x2a04e
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x2a04e
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x14(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %edi
movl 0x10(%rsp), %esi
callq 0x2aa70
cmpl $0x0, %eax
jne 0x2a093
leaq 0x154de2(%rip), %rdi # 0x17ee67
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2a178
movq 0x28(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x14(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
addl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x14(%rsp), %rdx
imulq $0x60, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movl 0xc(%rsp), %eax
movw %ax, 0x2(%rsp)
movq 0x28(%rsp), %rax
movl 0x4840(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movw 0x2(%rsp), %cx
movswl %cx, %edi
movswl %ax, %esi
callq 0x2aaf0
cmpl $0x0, %eax
jne 0x2a115
leaq 0x154d67(%rip), %rdi # 0x17ee71
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2a178
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
movl 0x4840(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
imull %ecx, %eax
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, (%rax)
jmp 0x2a170
movq 0x28(%rsp), %rdi
callq 0x2abe0
cmpl $0x0, %eax
je 0x2a16e
movq 0x28(%rsp), %rax
movl 0x4840(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movswl %ax, %edx
movq 0x20(%rsp), %rax
movswl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
jmp 0x2a170
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZL31stbi__jpeg_decode_block_prog_dcP10stbi__jpegPsP13stbi__huffmani:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov [rsp+38h+var_24], ecx
mov rax, [rsp+38h+var_10]
cmp dword ptr [rax+4838h], 0
jz short loc_29FBA
lea rdi, aCanTMergeDcAnd; "can't merge dc and ac"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2A178
loc_29FBA:
mov rax, [rsp+38h+var_10]
cmp dword ptr [rax+4824h], 10h
jge short loc_29FD2
mov rdi, [rsp+38h+var_10]
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
loc_29FD2:
mov rax, [rsp+38h+var_10]
cmp dword ptr [rax+483Ch], 0
jnz loc_2A13D
mov rdi, [rsp+38h+var_18]
xor esi, esi
mov edx, 80h
call _memset
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_20]
call _ZL22stbi__jpeg_huff_decodeP10stbi__jpegP13stbi__huffman; stbi__jpeg_huff_decode(stbi__jpeg *,stbi__huffman *)
mov [rsp+38h+var_30], eax
cmp [rsp+38h+var_30], 0
jl short loc_2A016
cmp [rsp+38h+var_30], 0Fh
jle short loc_2A02B
loc_2A016:
lea rdi, aCanTMergeDcAnd; "can't merge dc and ac"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2A178
loc_2A02B:
cmp [rsp+38h+var_30], 0
jz short loc_2A046
mov rdi, [rsp+38h+var_10]
mov esi, [rsp+38h+var_30]
call _ZL20stbi__extend_receiveP10stbi__jpegi; stbi__extend_receive(stbi__jpeg *,int)
mov [rsp+38h+var_34], eax
jmp short loc_2A04E
loc_2A046:
xor eax, eax
mov [rsp+38h+var_34], eax
jmp short $+2
loc_2A04E:
mov eax, [rsp+38h+var_34]
mov [rsp+38h+var_28], eax
mov rax, [rsp+38h+var_10]
add rax, 46A0h
movsxd rcx, [rsp+38h+var_24]
imul rcx, 60h ; '`'
add rax, rcx
mov edi, [rax+18h]; int
mov esi, [rsp+38h+var_28]; int
call _ZL19stbi__addints_validii; stbi__addints_valid(int,int)
cmp eax, 0
jnz short loc_2A093
lea rdi, aBadDelta; "bad delta"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2A178
loc_2A093:
mov rax, [rsp+38h+var_10]
add rax, 46A0h
movsxd rcx, [rsp+38h+var_24]
imul rcx, 60h ; '`'
add rax, rcx
mov eax, [rax+18h]
add eax, [rsp+38h+var_28]
mov [rsp+38h+var_2C], eax
mov ecx, [rsp+38h+var_2C]
mov rax, [rsp+38h+var_10]
add rax, 46A0h
movsxd rdx, [rsp+38h+var_24]
imul rdx, 60h ; '`'
add rax, rdx
mov [rax+18h], ecx
mov eax, [rsp+38h+var_2C]
mov [rsp+38h+var_36], ax
mov rax, [rsp+38h+var_10]
mov ecx, [rax+4840h]
mov eax, 1
shl eax, cl
mov cx, [rsp+38h+var_36]
movsx edi, cx; __int16
movsx esi, ax; __int16
call _ZL22stbi__mul2shorts_validss; stbi__mul2shorts_valid(short,short)
cmp eax, 0
jnz short loc_2A115
lea rdi, aCanTMergeDcAnd; "can't merge dc and ac"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp short loc_2A178
loc_2A115:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_10]
mov ecx, [rcx+4840h]
mov edx, 1
shl edx, cl
mov ecx, edx
imul eax, ecx
mov cx, ax
mov rax, [rsp+38h+var_18]
mov [rax], cx
jmp short loc_2A170
loc_2A13D:
mov rdi, [rsp+38h+var_10]
call _ZL18stbi__jpeg_get_bitP10stbi__jpeg; stbi__jpeg_get_bit(stbi__jpeg *)
cmp eax, 0
jz short loc_2A16E
mov rax, [rsp+38h+var_10]
mov ecx, [rax+4840h]
mov eax, 1
shl eax, cl
movsx edx, ax
mov rax, [rsp+38h+var_18]
movsx ecx, word ptr [rax]
add ecx, edx
mov [rax], cx
loc_2A16E:
jmp short $+2
loc_2A170:
mov [rsp+38h+var_4], 1
loc_2A178:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long stbi__jpeg_decode_block_prog_dc(int *a1, _WORD *a2, long long a3, int a4)
{
int v5; // [rsp+4h] [rbp-34h]
unsigned int v6; // [rsp+8h] [rbp-30h]
int v7; // [rsp+Ch] [rbp-2Ch]
if ( a1[4622] )
return (unsigned int)stbi__err("can't merge dc and ac");
if ( a1[4617] < 16 )
stbi__grow_buffer_unsafe((long long)a1);
if ( a1[4623] )
{
if ( (unsigned int)stbi__jpeg_get_bit(a1) )
*a2 += 1 << a1[4624];
return 1;
}
memset(a2, 0LL, 128LL);
v6 = stbi__jpeg_huff_decode(a1, a3);
if ( v6 >= 0x10 )
return (unsigned int)stbi__err("can't merge dc and ac");
if ( v6 )
v5 = stbi__extend_receive(a1, v6);
else
v5 = 0;
if ( (unsigned int)stbi__addints_valid(a1[24 * a4 + 4526], v5) )
{
v7 = v5 + a1[24 * a4 + 4526];
a1[24 * a4 + 4526] = v7;
if ( !(unsigned int)stbi__mul2shorts_valid(v7, 1 << a1[4624]) )
return (unsigned int)stbi__err("can't merge dc and ac");
*a2 = (1 << a1[4624]) * v7;
return 1;
}
return (unsigned int)stbi__err("bad delta");
}
|
stbi__jpeg_decode_block_prog_dc:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x14],ECX
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX + 0x4838],0x0
JZ 0x00129fba
LEA RDI,[0x27ee71]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012a178
LAB_00129fba:
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX + 0x4824],0x10
JGE 0x00129fd2
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00129e80
LAB_00129fd2:
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX + 0x483c],0x0
JNZ 0x0012a13d
MOV RDI,qword ptr [RSP + 0x20]
XOR ESI,ESI
MOV EDX,0x80
CALL 0x0010b390
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0012a760
MOV dword ptr [RSP + 0x8],EAX
CMP dword ptr [RSP + 0x8],0x0
JL 0x0012a016
CMP dword ptr [RSP + 0x8],0xf
JLE 0x0012a02b
LAB_0012a016:
LEA RDI,[0x27ee71]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012a178
LAB_0012a02b:
CMP dword ptr [RSP + 0x8],0x0
JZ 0x0012a046
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x8]
CALL 0x0012a960
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0012a04e
LAB_0012a046:
XOR EAX,EAX
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0012a04e
LAB_0012a04e:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x10],EAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x46a0
MOVSXD RCX,dword ptr [RSP + 0x14]
IMUL RCX,RCX,0x60
ADD RAX,RCX
MOV EDI,dword ptr [RAX + 0x18]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x0012aa70
CMP EAX,0x0
JNZ 0x0012a093
LEA RDI,[0x27ee67]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012a178
LAB_0012a093:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x46a0
MOVSXD RCX,dword ptr [RSP + 0x14]
IMUL RCX,RCX,0x60
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x18]
ADD EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0xc],EAX
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x46a0
MOVSXD RDX,dword ptr [RSP + 0x14]
IMUL RDX,RDX,0x60
ADD RAX,RDX
MOV dword ptr [RAX + 0x18],ECX
MOV EAX,dword ptr [RSP + 0xc]
MOV word ptr [RSP + 0x2],AX
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x4840]
MOV EAX,0x1
SHL EAX,CL
MOV CX,word ptr [RSP + 0x2]
MOVSX EDI,CX
MOVSX ESI,AX
CALL 0x0012aaf0
CMP EAX,0x0
JNZ 0x0012a115
LEA RDI,[0x27ee71]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012a178
LAB_0012a115:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RCX + 0x4840]
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
IMUL EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RSP + 0x20]
MOV word ptr [RAX],CX
JMP 0x0012a170
LAB_0012a13d:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0012abe0
CMP EAX,0x0
JZ 0x0012a16e
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x4840]
MOV EAX,0x1
SHL EAX,CL
MOVSX EDX,AX
MOV RAX,qword ptr [RSP + 0x20]
MOVSX ECX,word ptr [RAX]
ADD ECX,EDX
MOV word ptr [RAX],CX
LAB_0012a16e:
JMP 0x0012a170
LAB_0012a170:
MOV dword ptr [RSP + 0x34],0x1
LAB_0012a178:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int) */
int4
stbi__jpeg_decode_block_prog_dc
(stbi__jpeg *param_1,short *param_2,stbi__huffman *param_3,int param_4)
{
short sVar1;
int4 uVar2;
int iVar3;
int local_34;
if (*(int *)(param_1 + 0x4838) != 0) {
uVar2 = stbi__err("can\'t merge dc and ac");
return uVar2;
}
if (*(int *)(param_1 + 0x4824) < 0x10) {
stbi__grow_buffer_unsafe(param_1);
}
if (*(int *)(param_1 + 0x483c) == 0) {
memset(param_2,0,0x80);
iVar3 = stbi__jpeg_huff_decode(param_1,param_3);
if ((iVar3 < 0) || (0xf < iVar3)) {
uVar2 = stbi__err("can\'t merge dc and ac");
return uVar2;
}
if (iVar3 == 0) {
local_34 = 0;
}
else {
local_34 = stbi__extend_receive(param_1,iVar3);
}
iVar3 = stbi__addints_valid(*(int *)(param_1 + (long)param_4 * 0x60 + 0x46b8),local_34);
if (iVar3 == 0) {
uVar2 = stbi__err("bad delta");
return uVar2;
}
iVar3 = *(int *)(param_1 + (long)param_4 * 0x60 + 0x46b8);
*(int *)(param_1 + (long)param_4 * 0x60 + 0x46b8) = iVar3 + local_34;
sVar1 = (short)(iVar3 + local_34);
iVar3 = stbi__mul2shorts_valid
(sVar1,(short)(1 << ((byte)*(int4 *)(param_1 + 0x4840) & 0x1f)));
if (iVar3 == 0) {
uVar2 = stbi__err("can\'t merge dc and ac");
return uVar2;
}
*param_2 = sVar1 * (short)(1 << ((byte)*(int4 *)(param_1 + 0x4840) & 0x1f));
}
else {
iVar3 = stbi__jpeg_get_bit(param_1);
if (iVar3 != 0) {
*param_2 = *param_2 + (short)(1 << ((byte)*(int4 *)(param_1 + 0x4840) & 0x1f));
}
}
return 1;
}
|
|
13,993
|
stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
{
int diff,dc;
int t;
if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
if (j->succ_high == 0) {
// first scan for DC coefficient, must be first
memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
diff = t ? stbi__extend_receive(j, t) : 0;
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
data[0] = (short) (dc * (1 << j->succ_low));
} else {
// refinement scan for DC coefficient
if (stbi__jpeg_get_bit(j))
data[0] += (short) (1 << j->succ_low);
}
return 1;
}
|
O3
|
c
|
stbi__jpeg_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int):
cmpl $0x0, 0x4838(%rdi)
je 0x2c493
leaq 0x8f694(%rip), %rax # 0xbbb17
movq %rax, %fs:-0x20
xorl %esi, %esi
jmp 0x2c76a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xf, 0x4824(%rdi)
jg 0x2c4b7
movq %r14, %rdi
callq 0x2c367
cmpl $0x0, 0x483c(%r14)
je 0x2c520
movl 0x4824(%r14), %eax
testl %eax, %eax
jg 0x2c4e3
movq %r14, %rdi
callq 0x2c367
movl 0x4824(%r14), %eax
testl %eax, %eax
jle 0x2c6a6
movl 0x4820(%r14), %ecx
leal (%rcx,%rcx), %edx
movl %edx, 0x4820(%r14)
decl %eax
movl %eax, 0x4824(%r14)
movl $0x1, %esi
testl %ecx, %ecx
jns 0x2c762
movb 0x4840(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
addw %ax, (%rbx)
jmp 0x2c762
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0xf, 0x4824(%r14)
jg 0x2c554
movq %r14, %rdi
callq 0x2c367
movl 0x4820(%r14), %esi
movl %esi, %eax
shrl $0x17, %eax
movzbl (%r15,%rax), %eax
cmpq $0xff, %rax
je 0x2c673
movzbl 0x500(%r15,%rax), %ecx
movl 0x4824(%r14), %edx
subl %ecx, %edx
jl 0x2c750
shll %cl, %esi
movl %esi, 0x4820(%r14)
movl %edx, 0x4824(%r14)
addq %r15, %rax
addq $0x400, %rax # imm = 0x400
movzbl (%rax), %r15d
cmpl $0x10, %r15d
jae 0x2c750
xorl %r12d, %r12d
testl %r15d, %r15d
je 0x2c619
cmpl %r15d, %edx
jge 0x2c5cc
movq %r14, %rdi
callq 0x2c367
movl 0x4824(%r14), %edx
subl %r15d, %edx
jl 0x2c619
movl 0x4820(%r14), %esi
movl %esi, %eax
movl %r15d, %ecx
roll %cl, %eax
shll $0x2, %r15d
leaq 0x8df26(%rip), %rcx # 0xba510
movl (%r15,%rcx), %ecx
movl %ecx, %edi
notl %edi
andl %eax, %edi
movl %edi, 0x4820(%r14)
andl %ecx, %eax
movl %edx, 0x4824(%r14)
xorl %r12d, %r12d
testl %esi, %esi
js 0x2c616
leaq 0x8df4e(%rip), %rcx # 0xba560
movl (%r15,%rcx), %r12d
addl %eax, %r12d
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
movl 0x46b8(%r14,%rax), %edi
movl %edi, %ecx
xorl %r12d, %ecx
js 0x2c703
movl $0x80000000, %ecx # imm = 0x80000000
subl %r12d, %ecx
xorl %edx, %edx
cmpl %edi, %ecx
setg %dl
movl %r12d, %ecx
xorl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpl %edi, %ecx
setl %sil
testl %r12d, %edi
cmovsl %edx, %esi
cmpb $0x1, %sil
jne 0x2c703
leaq 0x8f49f(%rip), %rax # 0xbbb0d
jmp 0x2c757
movl %esi, %eax
shrl $0x10, %eax
xorl %edi, %edi
movq %rdi, %rcx
incq %rdi
cmpl 0x62c(%r15,%rcx,4), %eax
jae 0x2c67a
movl 0x4824(%r14), %edx
cmpq $0x8, %rdi
jne 0x2c6b0
addl $-0x10, %edx
movl %edx, 0x4824(%r14)
jmp 0x2c750
movl $0x1, %esi
jmp 0x2c762
leaq 0x9(%rdi), %rax
cmpl %eax, %edx
jl 0x2c750
movb $0x17, %cl
subb %dil, %cl
movl %esi, %r8d
shrl %cl, %r8d
leaq 0x8de42(%rip), %rcx # 0xba510
andl 0x24(%rcx,%rdi,4), %r8d
addl 0x670(%r15,%rdi,4), %r8d
cmpl $0xff, %r8d
ja 0x2c750
subl %edi, %edx
addl $-0x9, %edx
movl %eax, %ecx
shll %cl, %esi
movl %edx, 0x4824(%r14)
movl %esi, 0x4820(%r14)
movl %r8d, %eax
jmp 0x2c599
addq %r14, %rax
addq $0x46b8, %rax # imm = 0x46B8
addl %r12d, %edi
movl %edi, (%rax)
movl 0x4840(%r14), %ecx
movl $0x1, %r8d
shll %cl, %r8d
movl $0x10000, %r9d # imm = 0x10000
shll %cl, %r9d
movl $0x1, %esi
leal 0x1(%r8), %eax
cmpw $0x2, %ax
jb 0x2c789
movl %r8d, %eax
xorw %di, %ax
js 0x2c76d
movw $0x7fff, %ax # imm = 0x7FFF
xorl %edx, %edx
divw %r8w
cmpw %di, %ax
jge 0x2c789
leaq 0x8f3c0(%rip), %rax # 0xbbb17
movq %rax, %fs:-0x20
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl %esi, %eax
retq
sarl $0x10, %r9d
movswl %di, %r10d
movl $0xffff8000, %eax # imm = 0xFFFF8000
cltd
idivl %r9d
testw %r8w, %r8w
js 0x2c790
cmpl %r10d, %eax
jg 0x2c750
shll %cl, %edi
movw %di, (%rbx)
jmp 0x2c762
cmpl %r10d, %eax
jl 0x2c750
jmp 0x2c789
|
_ZL31stbi__jpeg_decode_block_prog_dcP10stbi__jpegPsP13stbi__huffmani:
cmp dword ptr [rdi+4838h], 0
jz short loc_2C493
lea rax, aCanTMergeDcAnd; "can't merge dc and ac"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor esi, esi
jmp loc_2C76A
loc_2C493:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, ecx
mov r15, rdx
mov rbx, rsi
mov r14, rdi
cmp dword ptr [rdi+4824h], 0Fh
jg short loc_2C4B7
mov rdi, r14
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
loc_2C4B7:
cmp dword ptr [r14+483Ch], 0
jz short loc_2C520
mov eax, [r14+4824h]
test eax, eax
jg short loc_2C4E3
mov rdi, r14
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
mov eax, [r14+4824h]
test eax, eax
jle loc_2C6A6
loc_2C4E3:
mov ecx, [r14+4820h]
lea edx, [rcx+rcx]
mov [r14+4820h], edx
dec eax
mov [r14+4824h], eax
mov esi, 1
test ecx, ecx
jns loc_2C762
mov cl, [r14+4840h]
mov eax, 1
shl eax, cl
add [rbx], ax
jmp loc_2C762
loc_2C520:
xorps xmm0, xmm0
movups xmmword ptr [rbx+70h], xmm0
movups xmmword ptr [rbx+60h], xmm0
movups xmmword ptr [rbx+50h], xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
cmp dword ptr [r14+4824h], 0Fh
jg short loc_2C554
mov rdi, r14
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
loc_2C554:
mov esi, [r14+4820h]
mov eax, esi
shr eax, 17h
movzx eax, byte ptr [r15+rax]
cmp rax, 0FFh
jz loc_2C673
movzx ecx, byte ptr [r15+rax+500h]
mov edx, [r14+4824h]
sub edx, ecx
jl loc_2C750
shl esi, cl
mov [r14+4820h], esi
mov [r14+4824h], edx
loc_2C599:
add rax, r15
add rax, 400h
movzx r15d, byte ptr [rax]
cmp r15d, 10h
jnb loc_2C750
xor r12d, r12d
test r15d, r15d
jz short loc_2C619
cmp edx, r15d
jge short loc_2C5CC
mov rdi, r14
call _ZL24stbi__grow_buffer_unsafeP10stbi__jpeg; stbi__grow_buffer_unsafe(stbi__jpeg *)
mov edx, [r14+4824h]
loc_2C5CC:
sub edx, r15d
jl short loc_2C619
mov esi, [r14+4820h]
mov eax, esi
mov ecx, r15d
rol eax, cl
shl r15d, 2
lea rcx, _ZL11stbi__bmask; stbi__bmask
mov ecx, [r15+rcx]
mov edi, ecx
not edi
and edi, eax
mov [r14+4820h], edi
and eax, ecx
mov [r14+4824h], edx
xor r12d, r12d
test esi, esi
js short loc_2C616
lea rcx, _ZL11stbi__jbias; stbi__jbias
mov r12d, [r15+rcx]
loc_2C616:
add r12d, eax
loc_2C619:
movsxd rax, ebp
lea rax, [rax+rax*2]
shl rax, 5
mov edi, [r14+rax+46B8h]
mov ecx, edi
xor ecx, r12d
js loc_2C703
mov ecx, 80000000h
sub ecx, r12d
xor edx, edx
cmp ecx, edi
setnle dl
mov ecx, r12d
xor ecx, 7FFFFFFFh
xor esi, esi
cmp ecx, edi
setl sil
test edi, r12d
cmovs esi, edx
cmp sil, 1
jnz loc_2C703
lea rax, aBadDelta; "bad delta"
jmp loc_2C757
loc_2C673:
mov eax, esi
shr eax, 10h
xor edi, edi
loc_2C67A:
mov rcx, rdi
inc rdi
cmp eax, [r15+rcx*4+62Ch]
jnb short loc_2C67A
mov edx, [r14+4824h]
cmp rdi, 8
jnz short loc_2C6B0
add edx, 0FFFFFFF0h
mov [r14+4824h], edx
jmp loc_2C750
loc_2C6A6:
mov esi, 1
jmp loc_2C762
loc_2C6B0:
lea rax, [rdi+9]
cmp edx, eax
jl loc_2C750
mov cl, 17h
sub cl, dil
mov r8d, esi
shr r8d, cl
lea rcx, _ZL11stbi__bmask; stbi__bmask
and r8d, [rcx+rdi*4+24h]
add r8d, [r15+rdi*4+670h]
cmp r8d, 0FFh
ja short loc_2C750
sub edx, edi
add edx, 0FFFFFFF7h
mov ecx, eax
shl esi, cl
mov [r14+4824h], edx
mov [r14+4820h], esi
mov eax, r8d
jmp loc_2C599
loc_2C703:
add rax, r14
add rax, 46B8h
add edi, r12d
mov [rax], edi
mov ecx, [r14+4840h]
mov r8d, 1
shl r8d, cl
mov r9d, 10000h
shl r9d, cl
mov esi, 1
lea eax, [r8+1]
cmp ax, 2
jb short loc_2C789
mov eax, r8d
xor ax, di
js short loc_2C76D
mov ax, 7FFFh
xor edx, edx
div r8w
cmp ax, di
jge short loc_2C789
loc_2C750:
lea rax, aCanTMergeDcAnd; "can't merge dc and ac"
loc_2C757:
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor esi, esi
loc_2C762:
pop rbx
pop r12
pop r14
pop r15
pop rbp
loc_2C76A:
mov eax, esi
retn
loc_2C76D:
sar r9d, 10h
movsx r10d, di
mov eax, 0FFFF8000h
cdq
idiv r9d
test r8w, r8w
js short loc_2C790
cmp eax, r10d
jg short loc_2C750
loc_2C789:
shl edi, cl
mov [rbx], di
jmp short loc_2C762
loc_2C790:
cmp eax, r10d
jl short loc_2C750
jmp short loc_2C789
|
long long stbi__jpeg_decode_block_prog_dc(_DWORD *a1, _OWORD *a2, long long a3, int a4)
{
unsigned int v4; // esi
int v9; // eax
int v10; // ecx
unsigned int v11; // esi
long long v12; // rax
int v13; // ecx
int v14; // edx
bool v15; // cc
signed int v16; // edx
signed int v17; // r15d
int v18; // r12d
int v19; // edx
int v20; // esi
int v21; // eax
long long v22; // r15
int v23; // ecx
int v24; // eax
int v25; // r12d
long long v26; // rax
int v27; // edi
bool v28; // si
const char *v29; // rax
long long v30; // rdi
long long v31; // rcx
int v32; // edx
unsigned int v33; // r8d
int v34; // edi
int v35; // ecx
int v36; // r8d
int v38; // eax
if ( a1[4622] )
{
__writefsqword(0xFFFFFFE0, (unsigned long long)"can't merge dc and ac");
return 0;
}
if ( (int)a1[4617] <= 15 )
stbi__grow_buffer_unsafe(a1);
if ( !a1[4623] )
{
a2[7] = 0LL;
a2[6] = 0LL;
a2[5] = 0LL;
a2[4] = 0LL;
a2[3] = 0LL;
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
if ( (int)a1[4617] <= 15 )
stbi__grow_buffer_unsafe(a1);
v11 = a1[4616];
v12 = *(unsigned __int8 *)(a3 + (v11 >> 23));
if ( v12 == 255 )
{
v30 = 0LL;
do
v31 = v30++;
while ( HIWORD(v11) >= *(_DWORD *)(a3 + 4 * v31 + 1580) );
v32 = a1[4617];
if ( v30 == 8 )
{
a1[4617] = v32 - 16;
goto LABEL_39;
}
if ( v32 < (int)v30 + 9 )
goto LABEL_39;
v33 = *(_DWORD *)(a3 + 4 * v30 + 1648) + (stbi__bmask[v30 + 9] & (v11 >> (23 - v30)));
if ( v33 > 0xFF )
goto LABEL_39;
v16 = v32 - v30 - 9;
a1[4617] = v16;
a1[4616] = v11 << (v30 + 9);
v12 = v33;
}
else
{
v13 = *(unsigned __int8 *)(a3 + v12 + 1280);
v14 = a1[4617];
v15 = v14 < v13;
v16 = v14 - v13;
if ( v15 )
goto LABEL_39;
a1[4616] = v11 << v13;
a1[4617] = v16;
}
v17 = *(unsigned __int8 *)(a3 + v12 + 1024);
if ( (unsigned int)v17 < 0x10 )
{
v18 = 0;
if ( v17 )
{
if ( v16 < v17 )
{
stbi__grow_buffer_unsafe(a1);
v16 = a1[4617];
}
v15 = v16 < v17;
v19 = v16 - v17;
if ( !v15 )
{
v20 = a1[4616];
v21 = __ROL4__(v20, v17);
v22 = (unsigned int)(4 * v17);
v23 = *(_DWORD *)((char *)stbi__bmask + v22);
a1[4616] = v21 & ~v23;
v24 = v23 & v21;
a1[4617] = v19;
v25 = 0;
if ( v20 >= 0 )
v25 = *(_DWORD *)((char *)&stbi__jbias + v22);
v18 = v24 + v25;
}
}
v26 = 24LL * a4;
v27 = a1[v26 + 4526];
if ( (v18 ^ v27) >= 0 )
{
v28 = (v18 ^ 0x7FFFFFFF) < v27;
if ( (v18 & v27) < 0 )
v28 = (int)(0x80000000 - v18) > v27;
if ( v28 )
{
v29 = "bad delta";
LABEL_40:
__writefsqword(0xFFFFFFE0, (unsigned long long)v29);
return 0;
}
}
v34 = v18 + v27;
a1[v26 + 4526] = v34;
v35 = a1[4624];
v36 = 1 << v35;
v4 = 1;
if ( (unsigned __int16)((1 << v35) + 1) >= 2u )
{
if ( ((v34 ^ v36) & 0x8000u) != 0 )
{
v38 = -32768 / (0x10000 << v35 >> 16);
if ( (v36 & 0x8000u) != 0 )
{
if ( v38 < (__int16)v34 )
goto LABEL_39;
}
else if ( v38 > (__int16)v34 )
{
goto LABEL_39;
}
}
else if ( (__int16)(0x7FFFu / (unsigned __int16)v36) < (__int16)v34 )
{
goto LABEL_39;
}
}
*(_WORD *)a2 = v34 << v35;
return v4;
}
LABEL_39:
v29 = "can't merge dc and ac";
goto LABEL_40;
}
v9 = a1[4617];
if ( v9 <= 0 && (stbi__grow_buffer_unsafe(a1), v9 = a1[4617], v9 <= 0) )
{
return 1;
}
else
{
v10 = a1[4616];
a1[4616] = 2 * v10;
a1[4617] = v9 - 1;
v4 = 1;
if ( v10 < 0 )
*(_WORD *)a2 += 1 << *((_BYTE *)a1 + 18496);
}
return v4;
}
| |||
13,994
|
JS_AddIntrinsicWeakRef
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_AddIntrinsicWeakRef(JSContext *ctx)
{
JSRuntime *rt = ctx->rt;
/* WeakRef */
if (!JS_IsRegisteredClass(rt, JS_CLASS_WEAK_REF)) {
init_class_range(rt, js_weakref_class_def, JS_CLASS_WEAK_REF,
countof(js_weakref_class_def));
}
ctx->class_proto[JS_CLASS_WEAK_REF] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_WEAK_REF],
js_weakref_proto_funcs,
countof(js_weakref_proto_funcs));
JS_NewGlobalCConstructor(ctx, "WeakRef", js_weakref_constructor, 1, ctx->class_proto[JS_CLASS_WEAK_REF]);
/* FinalizationRegistry */
if (!JS_IsRegisteredClass(rt, JS_CLASS_FINALIZATION_REGISTRY)) {
init_class_range(rt, js_finrec_class_def, JS_CLASS_FINALIZATION_REGISTRY,
countof(js_finrec_class_def));
}
ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY],
js_finrec_proto_funcs,
countof(js_finrec_proto_funcs));
JS_NewGlobalCConstructor(ctx, "FinalizationRegistry", js_finrec_constructor, 1, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY]);
}
|
O0
|
c
|
JS_AddIntrinsicWeakRef:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3a, %esi
callq 0x29230
cmpl $0x0, %eax
jne 0x276f6
movq 0x58(%rsp), %rdi
leaq 0x109e29(%rip), %rsi # 0x131510
movl $0x3a, %edx
movl $0x1, %ecx
callq 0x224f0
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2a570
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x3a0(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x3a8(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x3a0(%rax), %rsi
movq 0x3a8(%rax), %rdx
leaq 0x10e315(%rip), %rcx # 0x135a70
movl $0x2, %r8d
callq 0x4cb00
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x3a0(%rax), %r8
movq 0x3a8(%rax), %r9
leaq 0xe676f(%rip), %rsi # 0x10def8
leaq 0x32e60(%rip), %rdx # 0x5a5f0
movl $0x1, %ecx
callq 0x4e170
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movl $0x3b, %esi
callq 0x29230
cmpl $0x0, %eax
jne 0x277d3
movq 0x58(%rsp), %rdi
leaq 0x109d6c(%rip), %rsi # 0x131530
movl $0x3b, %edx
movl $0x1, %ecx
callq 0x224f0
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2a570
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x3b0(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x3b8(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x3b0(%rax), %rsi
movq 0x3b8(%rax), %rdx
leaq 0x10e278(%rip), %rcx # 0x135ab0
movl $0x3, %r8d
callq 0x4cb00
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x3b0(%rax), %r8
movq 0x3b8(%rax), %r9
leaq 0xe669a(%rip), %rsi # 0x10df00
leaq 0x32f93(%rip), %rdx # 0x5a800
movl $0x1, %ecx
callq 0x4e170
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
JS_AddIntrinsicWeakRef:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov rax, [rsp+68h+var_8]
mov rax, [rax+18h]
mov [rsp+68h+var_10], rax
mov rdi, [rsp+68h+var_10]
mov esi, 3Ah ; ':'
call JS_IsRegisteredClass
cmp eax, 0
jnz short loc_276F6
mov rdi, [rsp+68h+var_10]
lea rsi, js_weakref_class_def
mov edx, 3Ah ; ':'
mov ecx, 1
call init_class_range
loc_276F6:
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov [rsp+68h+var_58], rax
mov rdi, [rsp+68h+var_8]
call JS_NewObject
mov rcx, rax
mov rax, [rsp+68h+var_58]
mov [rsp+68h+var_20], rcx
mov [rsp+68h+var_18], rdx
mov rcx, [rsp+68h+var_20]
mov [rax+3A0h], rcx
mov rcx, [rsp+68h+var_18]
mov [rax+3A8h], rcx
mov rdi, [rsp+68h+var_8]
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+3A0h]
mov rdx, [rax+3A8h]
lea rcx, js_weakref_proto_funcs
mov r8d, 2
call JS_SetPropertyFunctionList
mov rdi, [rsp+68h+var_8]
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov r8, [rax+3A0h]
mov r9, [rax+3A8h]
lea rsi, aWeakref; "WeakRef"
lea rdx, js_weakref_constructor
mov ecx, 1
call JS_NewGlobalCConstructor
mov [rsp+68h+var_30], rax
mov [rsp+68h+var_28], rdx
mov rdi, [rsp+68h+var_10]
mov esi, 3Bh ; ';'
call JS_IsRegisteredClass
cmp eax, 0
jnz short loc_277D3
mov rdi, [rsp+68h+var_10]
lea rsi, js_finrec_class_def
mov edx, 3Bh ; ';'
mov ecx, 1
call init_class_range
loc_277D3:
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_8]
call JS_NewObject
mov rcx, rax
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_40], rcx
mov [rsp+68h+var_38], rdx
mov rcx, [rsp+68h+var_40]
mov [rax+3B0h], rcx
mov rcx, [rsp+68h+var_38]
mov [rax+3B8h], rcx
mov rdi, [rsp+68h+var_8]
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+3B0h]
mov rdx, [rax+3B8h]
lea rcx, js_finrec_proto_funcs
mov r8d, 3
call JS_SetPropertyFunctionList
mov rdi, [rsp+68h+var_8]
mov rax, [rsp+68h+var_8]
mov rax, [rax+40h]
mov r8, [rax+3B0h]
mov r9, [rax+3B8h]
lea rsi, aFinalizationre; "FinalizationRegistry"
lea rdx, js_finrec_constructor
mov ecx, 1
call JS_NewGlobalCConstructor
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_48], rdx
add rsp, 68h
retn
|
long long JS_AddIntrinsicWeakRef(long long a1)
{
long long v1; // rdx
long long v2; // rdx
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+10h] [rbp-58h]
long long v6; // [rsp+58h] [rbp-10h]
v6 = *(_QWORD *)(a1 + 24);
if ( !(unsigned int)JS_IsRegisteredClass(v6, 58LL) )
init_class_range(v6, (long long)&js_weakref_class_def, 58, 1);
v5 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(v5 + 928) = JS_NewObject(a1);
*(_QWORD *)(v5 + 936) = v1;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 928LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 936LL),
&js_weakref_proto_funcs,
2LL);
JS_NewGlobalCConstructor(
a1,
"WeakRef",
js_weakref_constructor,
1LL,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 928LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 936LL));
if ( !(unsigned int)JS_IsRegisteredClass(v6, 59LL) )
init_class_range(v6, (long long)&js_finrec_class_def, 59, 1);
v4 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(v4 + 944) = JS_NewObject(a1);
*(_QWORD *)(v4 + 952) = v2;
JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 944LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 952LL),
&js_finrec_proto_funcs,
3LL);
return JS_NewGlobalCConstructor(
a1,
"FinalizationRegistry",
js_finrec_constructor,
1LL,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 944LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 952LL));
}
|
JS_AddIntrinsicWeakRef:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,0x3a
CALL 0x00129230
CMP EAX,0x0
JNZ 0x001276f6
MOV RDI,qword ptr [RSP + 0x58]
LEA RSI,[0x231510]
MOV EDX,0x3a
MOV ECX,0x1
CALL 0x001224f0
LAB_001276f6:
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0012a570
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],RDX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x3a0],RCX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + 0x3a8],RCX
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x3a0]
MOV RDX,qword ptr [RAX + 0x3a8]
LEA RCX,[0x235a70]
MOV R8D,0x2
CALL 0x0014cb00
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV R8,qword ptr [RAX + 0x3a0]
MOV R9,qword ptr [RAX + 0x3a8]
LEA RSI,[0x20def8]
LEA RDX,[0x15a5f0]
MOV ECX,0x1
CALL 0x0014e170
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,0x3b
CALL 0x00129230
CMP EAX,0x0
JNZ 0x001277d3
MOV RDI,qword ptr [RSP + 0x58]
LEA RSI,[0x231530]
MOV EDX,0x3b
MOV ECX,0x1
CALL 0x001224f0
LAB_001277d3:
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0012a570
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RDX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x3b0],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x3b8],RCX
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x3b0]
MOV RDX,qword ptr [RAX + 0x3b8]
LEA RCX,[0x235ab0]
MOV R8D,0x3
CALL 0x0014cb00
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX + 0x40]
MOV R8,qword ptr [RAX + 0x3b0]
MOV R9,qword ptr [RAX + 0x3b8]
LEA RSI,[0x20df00]
LEA RDX,[0x15a800]
MOV ECX,0x1
CALL 0x0014e170
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
ADD RSP,0x68
RET
|
void JS_AddIntrinsicWeakRef(long param_1)
{
int8 uVar1;
long lVar2;
int iVar3;
int1 auVar4 [16];
uVar1 = *(int8 *)(param_1 + 0x18);
iVar3 = JS_IsRegisteredClass(uVar1,0x3a);
if (iVar3 == 0) {
init_class_range(uVar1,js_weakref_class_def,0x3a,1);
}
lVar2 = *(long *)(param_1 + 0x40);
auVar4 = JS_NewObject(param_1);
*(int1 (*) [16])(lVar2 + 0x3a0) = auVar4;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a8),js_weakref_proto_funcs,2);
JS_NewGlobalCConstructor
(param_1,"WeakRef",js_weakref_constructor,1,
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a8));
iVar3 = JS_IsRegisteredClass(uVar1,0x3b);
if (iVar3 == 0) {
init_class_range(uVar1,js_finrec_class_def,0x3b,1);
}
lVar2 = *(long *)(param_1 + 0x40);
auVar4 = JS_NewObject(param_1);
*(int1 (*) [16])(lVar2 + 0x3b0) = auVar4;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b8),js_finrec_proto_funcs,3);
JS_NewGlobalCConstructor
(param_1,"FinalizationRegistry",js_finrec_constructor,1,
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b8));
return;
}
|
|
13,995
|
JS_AddIntrinsicWeakRef
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_AddIntrinsicWeakRef(JSContext *ctx)
{
JSRuntime *rt = ctx->rt;
/* WeakRef */
if (!JS_IsRegisteredClass(rt, JS_CLASS_WEAK_REF)) {
init_class_range(rt, js_weakref_class_def, JS_CLASS_WEAK_REF,
countof(js_weakref_class_def));
}
ctx->class_proto[JS_CLASS_WEAK_REF] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_WEAK_REF],
js_weakref_proto_funcs,
countof(js_weakref_proto_funcs));
JS_NewGlobalCConstructor(ctx, "WeakRef", js_weakref_constructor, 1, ctx->class_proto[JS_CLASS_WEAK_REF]);
/* FinalizationRegistry */
if (!JS_IsRegisteredClass(rt, JS_CLASS_FINALIZATION_REGISTRY)) {
init_class_range(rt, js_finrec_class_def, JS_CLASS_FINALIZATION_REGISTRY,
countof(js_finrec_class_def));
}
ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY],
js_finrec_proto_funcs,
countof(js_finrec_proto_funcs));
JS_NewGlobalCConstructor(ctx, "FinalizationRegistry", js_finrec_constructor, 1, ctx->class_proto[JS_CLASS_FINALIZATION_REGISTRY]);
}
|
O1
|
c
|
JS_AddIntrinsicWeakRef:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpl $0x3b, 0x78(%r14)
jb 0x1f78b
movq 0x80(%r14), %rax
cmpl $0x0, 0x910(%rax)
jne 0x1f7a4
leaq 0xa8c8e(%rip), %rsi # 0xc8420
movq %r14, %rdi
movl $0x3a, %edx
movl $0x1, %ecx
callq 0x1ce49
movq 0x40(%rbx), %r15
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20f05
movq %rax, 0x3a0(%r15)
movq %rdx, 0x3a8(%r15)
movq 0x40(%rbx), %rax
movq 0x3a0(%rax), %rsi
movq 0x3a8(%rax), %rdx
leaq 0xad1ac(%rip), %rcx # 0xcc990
movq %rbx, %rdi
movl $0x2, %r8d
callq 0x32c67
movq 0x40(%rbx), %rax
movq 0x3a0(%rax), %r15
movq 0x3a8(%rax), %r12
leaq 0x48(%rbx), %rbp
movups 0x48(%rbx), %xmm0
movups %xmm0, (%rsp)
leaq 0x1ab58(%rip), %rsi # 0x3a36f
leaq 0x7f676(%rip), %r13 # 0x9ee94
movq %rbx, %rdi
movq %r13, %rdx
movl $0x1, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x21006
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x361aa
cmpl $0x3c, 0x78(%r14)
jb 0x1f862
movq 0x80(%r14), %rax
cmpl $0x0, 0x938(%rax)
jne 0x1f87b
leaq 0xa8bd7(%rip), %rsi # 0xc8440
movq %r14, %rdi
movl $0x3b, %edx
movl $0x1, %ecx
callq 0x1ce49
movq 0x40(%rbx), %r14
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20f05
movq %rax, 0x3b0(%r14)
movq %rdx, 0x3b8(%r14)
movq 0x40(%rbx), %rax
movq 0x3b0(%rax), %rsi
movq 0x3b8(%rax), %rdx
leaq 0xad115(%rip), %rcx # 0xcc9d0
movq %rbx, %rdi
movl $0x3, %r8d
callq 0x32c67
movq 0x40(%rbx), %rax
movq 0x3b0(%rax), %r14
movq 0x3b8(%rax), %r15
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1abde(%rip), %rsi # 0x3a4c8
leaq 0x7f5ab(%rip), %r12 # 0x9ee9c
movq %rbx, %rdi
movq %r12, %rdx
movl $0x1, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x21006
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rcx
movq %r14, %r8
movq %r15, %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x361aa
|
JS_AddIntrinsicWeakRef:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r14, [rdi+18h]
cmp dword ptr [r14+78h], 3Bh ; ';'
jb short loc_1F78B
mov rax, [r14+80h]
cmp dword ptr [rax+910h], 0
jnz short loc_1F7A4
loc_1F78B:
lea rsi, js_weakref_class_def
mov rdi, r14
mov edx, 3Ah ; ':'
mov ecx, 1
call init_class_range
loc_1F7A4:
mov r15, [rbx+40h]
mov rsi, [r15+10h]
mov rdx, [r15+18h]
mov rdi, rbx
mov ecx, 1
call JS_NewObjectProtoClass
mov [r15+3A0h], rax
mov [r15+3A8h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+3A0h]
mov rdx, [rax+3A8h]
lea rcx, js_weakref_proto_funcs
mov rdi, rbx
mov r8d, 2
call JS_SetPropertyFunctionList
mov rax, [rbx+40h]
mov r15, [rax+3A0h]
mov r12, [rax+3A8h]
lea rbp, [rbx+48h]
movups xmm0, xmmword ptr [rbx+48h]
movups [rsp+48h+var_48], xmm0
lea rsi, js_weakref_constructor
lea r13, aWeakref; "WeakRef"
mov rdi, rbx
mov rdx, r13
mov ecx, 1
mov r8d, 4
xor r9d, r9d
call JS_NewCFunction3
mov rdi, rbx
mov rsi, rax
mov rcx, r13
mov r8, r15
mov r9, r12
call JS_NewGlobalCConstructor2
cmp dword ptr [r14+78h], 3Ch ; '<'
jb short loc_1F862
mov rax, [r14+80h]
cmp dword ptr [rax+938h], 0
jnz short loc_1F87B
loc_1F862:
lea rsi, js_finrec_class_def
mov rdi, r14
mov edx, 3Bh ; ';'
mov ecx, 1
call init_class_range
loc_1F87B:
mov r14, [rbx+40h]
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov rdi, rbx
mov ecx, 1
call JS_NewObjectProtoClass
mov [r14+3B0h], rax
mov [r14+3B8h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+3B0h]
mov rdx, [rax+3B8h]
lea rcx, js_finrec_proto_funcs
mov rdi, rbx
mov r8d, 3
call JS_SetPropertyFunctionList
mov rax, [rbx+40h]
mov r14, [rax+3B0h]
mov r15, [rax+3B8h]
movups xmm0, xmmword ptr [rbp+0]
movups [rsp+48h+var_48], xmm0
lea rsi, js_finrec_constructor
lea r12, aFinalizationre; "FinalizationRegistry"
mov rdi, rbx
mov rdx, r12
mov ecx, 1
mov r8d, 4
xor r9d, r9d
call JS_NewCFunction3
mov rdi, rbx
mov rsi, rax
mov rcx, r12
mov r8, r14
mov r9, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_NewGlobalCConstructor2
|
long long JS_AddIntrinsicWeakRef(long long *a1)
{
long long v1; // r14
_QWORD *v2; // r15
long long v3; // rdx
long long v4; // rax
long long v5; // r15
long long v6; // r12
long long v7; // rax
long long v8; // rdx
_QWORD *v9; // r14
long long v10; // rdx
long long v11; // rax
long long v12; // r14
long long v13; // r15
long long v14; // rax
long long v15; // rdx
v1 = a1[3];
if ( *(_DWORD *)(v1 + 120) < 0x3Bu || !*(_DWORD *)(*(_QWORD *)(v1 + 128) + 2320LL) )
init_class_range(a1[3], (long long)&js_weakref_class_def, 0x3Au, 1);
v2 = (_QWORD *)a1[8];
v2[116] = JS_NewObjectProtoClass(a1, v2[2], v2[3], 1LL);
v2[117] = v3;
JS_SetPropertyFunctionList(a1, *(_QWORD *)(a1[8] + 928), *(_QWORD *)(a1[8] + 936), &js_weakref_proto_funcs, 2LL);
v4 = a1[8];
v5 = *(_QWORD *)(v4 + 928);
v6 = *(_QWORD *)(v4 + 936);
v7 = JS_NewCFunction3(
(_DWORD)a1,
(unsigned int)js_weakref_constructor,
(unsigned int)"WeakRef",
1,
4,
0,
a1[9],
a1[10]);
JS_NewGlobalCConstructor2(a1, v7, v8, "WeakRef", v5, v6);
if ( *(_DWORD *)(v1 + 120) < 0x3Cu || !*(_DWORD *)(*(_QWORD *)(v1 + 128) + 2360LL) )
init_class_range(v1, (long long)&js_finrec_class_def, 0x3Bu, 1);
v9 = (_QWORD *)a1[8];
v9[118] = JS_NewObjectProtoClass(a1, v9[2], v9[3], 1LL);
v9[119] = v10;
JS_SetPropertyFunctionList(a1, *(_QWORD *)(a1[8] + 944), *(_QWORD *)(a1[8] + 952), &js_finrec_proto_funcs, 3LL);
v11 = a1[8];
v12 = *(_QWORD *)(v11 + 944);
v13 = *(_QWORD *)(v11 + 952);
v14 = JS_NewCFunction3(
(_DWORD)a1,
(unsigned int)js_finrec_constructor,
(unsigned int)"FinalizationRegistry",
1,
4,
0,
a1[9],
a1[10]);
return JS_NewGlobalCConstructor2(a1, v14, v15, "FinalizationRegistry", v12, v13);
}
|
JS_AddIntrinsicWeakRef:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x18]
CMP dword ptr [R14 + 0x78],0x3b
JC 0x0011f78b
MOV RAX,qword ptr [R14 + 0x80]
CMP dword ptr [RAX + 0x910],0x0
JNZ 0x0011f7a4
LAB_0011f78b:
LEA RSI,[0x1c8420]
MOV RDI,R14
MOV EDX,0x3a
MOV ECX,0x1
CALL 0x0011ce49
LAB_0011f7a4:
MOV R15,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [R15 + 0x10]
MOV RDX,qword ptr [R15 + 0x18]
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00120f05
MOV qword ptr [R15 + 0x3a0],RAX
MOV qword ptr [R15 + 0x3a8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0x3a0]
MOV RDX,qword ptr [RAX + 0x3a8]
LEA RCX,[0x1cc990]
MOV RDI,RBX
MOV R8D,0x2
CALL 0x00132c67
MOV RAX,qword ptr [RBX + 0x40]
MOV R15,qword ptr [RAX + 0x3a0]
MOV R12,qword ptr [RAX + 0x3a8]
LEA RBP,[RBX + 0x48]
MOVUPS XMM0,xmmword ptr [RBX + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x13a36f]
LEA R13,[0x19ee94]
MOV RDI,RBX
MOV RDX,R13
MOV ECX,0x1
MOV R8D,0x4
XOR R9D,R9D
CALL 0x00121006
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,R13
MOV R8,R15
MOV R9,R12
CALL 0x001361aa
CMP dword ptr [R14 + 0x78],0x3c
JC 0x0011f862
MOV RAX,qword ptr [R14 + 0x80]
CMP dword ptr [RAX + 0x938],0x0
JNZ 0x0011f87b
LAB_0011f862:
LEA RSI,[0x1c8440]
MOV RDI,R14
MOV EDX,0x3b
MOV ECX,0x1
CALL 0x0011ce49
LAB_0011f87b:
MOV R14,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x18]
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00120f05
MOV qword ptr [R14 + 0x3b0],RAX
MOV qword ptr [R14 + 0x3b8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0x3b0]
MOV RDX,qword ptr [RAX + 0x3b8]
LEA RCX,[0x1cc9d0]
MOV RDI,RBX
MOV R8D,0x3
CALL 0x00132c67
MOV RAX,qword ptr [RBX + 0x40]
MOV R14,qword ptr [RAX + 0x3b0]
MOV R15,qword ptr [RAX + 0x3b8]
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x13a4c8]
LEA R12,[0x19ee9c]
MOV RDI,RBX
MOV RDX,R12
MOV ECX,0x1
MOV R8D,0x4
XOR R9D,R9D
CALL 0x00121006
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,R12
MOV R8,R14
MOV R9,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001361aa
|
void JS_AddIntrinsicWeakRef(long param_1)
{
long lVar1;
long lVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
lVar1 = *(long *)(param_1 + 0x18);
if ((*(uint *)(lVar1 + 0x78) < 0x3b) || (*(int *)(*(long *)(lVar1 + 0x80) + 0x910) == 0)) {
init_class_range(lVar1,js_weakref_class_def,0x3a,1);
}
lVar2 = *(long *)(param_1 + 0x40);
auVar5 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar2 + 0x10),*(int8 *)(lVar2 + 0x18),1);
*(int1 (*) [16])(lVar2 + 0x3a0) = auVar5;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3a8),js_weakref_proto_funcs,2);
uVar3 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x3a0);
uVar4 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x3a8);
auVar5 = JS_NewCFunction3(param_1,js_weakref_constructor,"WeakRef",1,4,0,
*(int4 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50));
JS_NewGlobalCConstructor2(param_1,auVar5._0_8_,auVar5._8_8_,"WeakRef",uVar3,uVar4);
if ((*(uint *)(lVar1 + 0x78) < 0x3c) || (*(int *)(*(long *)(lVar1 + 0x80) + 0x938) == 0)) {
init_class_range(lVar1,js_finrec_class_def,0x3b,1);
}
lVar1 = *(long *)(param_1 + 0x40);
auVar5 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x10),*(int8 *)(lVar1 + 0x18),1);
*(int1 (*) [16])(lVar1 + 0x3b0) = auVar5;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x3b8),js_finrec_proto_funcs,3);
uVar3 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x3b0);
uVar4 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x3b8);
auVar5 = JS_NewCFunction3(param_1,js_finrec_constructor,"FinalizationRegistry",1,4,0,
*(int4 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50));
JS_NewGlobalCConstructor2(param_1,auVar5._0_8_,auVar5._8_8_,"FinalizationRegistry",uVar3,uVar4);
return;
}
|
|
13,996
|
my_thread_destroy_common_mutex
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_destroy_common_mutex(void)
{
mysql_mutex_destroy(&THR_LOCK_open);
mysql_mutex_destroy(&THR_LOCK_lock);
mysql_mutex_destroy(&THR_LOCK_myisam);
mysql_mutex_destroy(&THR_LOCK_myisam_mmap);
mysql_mutex_destroy(&THR_LOCK_heap);
mysql_mutex_destroy(&THR_LOCK_net);
mysql_mutex_destroy(&THR_LOCK_charset);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_destroy(&LOCK_localtime_r);
#endif
}
|
O0
|
c
|
my_thread_destroy_common_mutex:
pushq %rbp
movq %rsp, %rbp
leaq 0x372be5(%rip), %rdi # 0x3a6750
callq 0x33bc0
leaq 0x372c21(%rip), %rdi # 0x3a6798
callq 0x33bc0
leaq 0x372c5d(%rip), %rdi # 0x3a67e0
callq 0x33bc0
leaq 0x372c99(%rip), %rdi # 0x3a6828
callq 0x33bc0
leaq 0x372cd5(%rip), %rdi # 0x3a6870
callq 0x33bc0
leaq 0x372d11(%rip), %rdi # 0x3a68b8
callq 0x33bc0
leaq 0x372d4d(%rip), %rdi # 0x3a6900
callq 0x33bc0
popq %rbp
retq
nopw (%rax,%rax)
|
my_thread_destroy_common_mutex:
push rbp
mov rbp, rsp
lea rdi, THR_LOCK_open
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_lock
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_myisam
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_myisam_mmap
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_heap
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_net
call inline_mysql_mutex_destroy
lea rdi, THR_LOCK_charset
call inline_mysql_mutex_destroy
pop rbp
retn
|
long long my_thread_destroy_common_mutex()
{
inline_mysql_mutex_destroy(&THR_LOCK_open);
inline_mysql_mutex_destroy(&THR_LOCK_lock);
inline_mysql_mutex_destroy(&THR_LOCK_myisam);
inline_mysql_mutex_destroy(&THR_LOCK_myisam_mmap);
inline_mysql_mutex_destroy(&THR_LOCK_heap);
inline_mysql_mutex_destroy(&THR_LOCK_net);
return inline_mysql_mutex_destroy(&THR_LOCK_charset);
}
|
my_thread_destroy_common_mutex:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x4a6750]
CALL 0x00133bc0
LEA RDI,[0x4a6798]
CALL 0x00133bc0
LEA RDI,[0x4a67e0]
CALL 0x00133bc0
LEA RDI,[0x4a6828]
CALL 0x00133bc0
LEA RDI,[0x4a6870]
CALL 0x00133bc0
LEA RDI,[0x4a68b8]
CALL 0x00133bc0
LEA RDI,[0x4a6900]
CALL 0x00133bc0
POP RBP
RET
|
void my_thread_destroy_common_mutex(void)
{
inline_mysql_mutex_destroy(THR_LOCK_open);
inline_mysql_mutex_destroy(THR_LOCK_lock);
inline_mysql_mutex_destroy(THR_LOCK_myisam);
inline_mysql_mutex_destroy(THR_LOCK_myisam_mmap);
inline_mysql_mutex_destroy(THR_LOCK_heap);
inline_mysql_mutex_destroy(THR_LOCK_net);
inline_mysql_mutex_destroy(THR_LOCK_charset);
return;
}
|
|
13,997
|
VSmileJoy::QueueJoyUpdates()
|
sp1187[P]veesem/src/core/vsmile/vsmile_joy.cc
|
void VSmileJoy::QueueJoyUpdates() {
bool update_buttons = current_.enter != last_sent_.enter || current_.back != last_sent_.back ||
current_.help != last_sent_.help || current_.abc != last_sent_.abc;
bool update_colors = current_.green != last_sent_.green || current_.blue != last_sent_.blue ||
current_.yellow != last_sent_.yellow || current_.red != last_sent_.red;
bool update_joy = current_.x != last_sent_.x || current_.y != last_sent_.y;
if (!update_buttons && !update_colors && !update_joy)
return;
if (update_buttons) {
uint8_t button_value = 0xa0;
if (current_.enter)
button_value = 0xa1;
else if (current_.back)
button_value = 0xa2;
else if (current_.help)
button_value = 0xa3;
else if (current_.abc)
button_value = 0xa4;
QueueTx(button_value);
}
if (update_colors) {
uint8_t color_value =
0x90 | current_.green | (current_.blue << 1) | (current_.yellow << 2) | (current_.red << 3);
QueueTx(color_value);
}
if (update_joy) {
uint8_t x_value = 0xc0, y_value = 0x80;
if (current_.x != 0) {
x_value = (current_.x < 0 ? 0xcb : 0xc3) + std::clamp(std::abs(current_.x), 1, 5) - 1;
}
if (current_.y != 0) {
y_value = (current_.y < 0 ? 0x8b : 0x83) + std::clamp(std::abs(current_.y), 1, 5) - 1;
}
QueueTx(x_value);
QueueTx(y_value);
}
idle_timer_.Reset();
last_sent_ = current_;
current_updated_ = false;
}
|
O0
|
cpp
|
VSmileJoy::QueueJoyUpdates():
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x10(%rax), %cl
shrb $0x4, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jne 0x10a3a
movq -0x38(%rbp), %rax
movb 0x10(%rax), %cl
shrb $0x5, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb $0x5, %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jne 0x10a3a
movq -0x38(%rbp), %rax
movb 0x10(%rax), %cl
shrb $0x6, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb $0x6, %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jne 0x10a3a
movq -0x38(%rbp), %rcx
movb 0x10(%rcx), %al
shrb $0x7, %al
movzbl %al, %eax
movb 0x1c(%rcx), %cl
shrb $0x7, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rax
movb -0x29(%rbp), %cl
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movb 0x10(%rax), %cl
shrb $0x3, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jne 0x10aca
movq -0x38(%rbp), %rax
movb 0x10(%rax), %cl
shrb $0x2, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jne 0x10aca
movq -0x38(%rbp), %rax
movb 0x10(%rax), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
movb 0x1c(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
jne 0x10aca
movq -0x38(%rbp), %rcx
movb 0x10(%rcx), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x1c(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x39(%rbp)
movq -0x38(%rbp), %rdx
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movl 0xc(%rdx), %ecx
movb $0x1, %al
cmpl 0x18(%rdx), %ecx
movb %al, -0x3a(%rbp)
jne 0x10af3
movq -0x38(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0x14(%rcx), %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movb %al, -0xb(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x10b12
testb $0x1, -0xa(%rbp)
jne 0x10b12
testb $0x1, -0xb(%rbp)
jne 0x10b12
jmp 0x10cf2
testb $0x1, -0x9(%rbp)
je 0x10b93
movq -0x38(%rbp), %rax
movb $-0x60, -0xc(%rbp)
movb 0x10(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10b36
movb $-0x5f, -0xc(%rbp)
jmp 0x10b86
movq -0x38(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x5, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10b50
movb $-0x5e, -0xc(%rbp)
jmp 0x10b84
movq -0x38(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x6, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10b6a
movb $-0x5d, -0xc(%rbp)
jmp 0x10b82
movq -0x38(%rbp), %rax
movb 0x10(%rax), %al
shrb $0x7, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x10b80
movb $-0x5c, -0xc(%rbp)
jmp 0x10b82
jmp 0x10b84
jmp 0x10b86
movq -0x38(%rbp), %rdi
movzbl -0xc(%rbp), %esi
callq 0x107e0
testb $0x1, -0xa(%rbp)
je 0x10be7
movq -0x38(%rbp), %rdi
movb 0x10(%rdi), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
orl $0x90, %eax
movb 0x10(%rdi), %cl
shrb $0x2, %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
orl %ecx, %eax
movb 0x10(%rdi), %cl
shrb %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movb 0x10(%rdi), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %esi
callq 0x107e0
testb $0x1, -0xb(%rbp)
je 0x10ccf
movq -0x38(%rbp), %rax
movb $-0x40, -0xe(%rbp)
movb $-0x80, -0xf(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x10c57
movq -0x38(%rbp), %rax
movl 0xc(%rax), %esi
movl $0xc3, %ecx
movl $0xcb, %edx
cmpl $0x0, %esi
cmovll %edx, %ecx
movl %ecx, -0x40(%rbp)
movl 0xc(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x5, -0x1c(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xebf0
movq %rax, %rcx
movl -0x40(%rbp), %eax
addl (%rcx), %eax
subl $0x1, %eax
movb %al, -0xe(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x10cb5
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x83, %ecx
movl $0x8b, %edx
cmpl $0x0, %esi
cmovll %edx, %ecx
movl %ecx, -0x44(%rbp)
movl 0x8(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x5, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xebf0
movq %rax, %rcx
movl -0x44(%rbp), %eax
addl (%rcx), %eax
subl $0x1, %eax
movb %al, -0xf(%rbp)
movq -0x38(%rbp), %rdi
movzbl -0xe(%rbp), %esi
callq 0x107e0
movq -0x38(%rbp), %rdi
movzbl -0xf(%rbp), %esi
callq 0x107e0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x11060
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x14(%rax)
movb 0x10(%rax), %cl
movb %cl, 0x1c(%rax)
movb $0x0, 0x51(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN9VSmileJoy15QueueJoyUpdatesEv:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov cl, [rax+10h]
shr cl, 4
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 4
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_29], al
jnz short loc_10A3A
mov rax, [rbp+var_38]
mov cl, [rax+10h]
shr cl, 5
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 5
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_29], al
jnz short loc_10A3A
mov rax, [rbp+var_38]
mov cl, [rax+10h]
shr cl, 6
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 6
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_29], al
jnz short loc_10A3A
mov rcx, [rbp+var_38]
mov al, [rcx+10h]
shr al, 7
movzx eax, al
mov cl, [rcx+1Ch]
shr cl, 7
movzx ecx, cl
cmp eax, ecx
setnz al
mov [rbp+var_29], al
loc_10A3A:
mov rax, [rbp+var_38]
mov cl, [rbp+var_29]
and cl, 1
mov [rbp+var_9], cl
mov cl, [rax+10h]
shr cl, 3
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 3
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_39], al
jnz short loc_10ACA
mov rax, [rbp+var_38]
mov cl, [rax+10h]
shr cl, 2
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 2
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_39], al
jnz short loc_10ACA
mov rax, [rbp+var_38]
mov cl, [rax+10h]
shr cl, 1
and cl, 1
movzx ecx, cl
mov al, [rax+1Ch]
shr al, 1
and al, 1
movzx edx, al
mov al, 1
cmp ecx, edx
mov [rbp+var_39], al
jnz short loc_10ACA
mov rcx, [rbp+var_38]
mov al, [rcx+10h]
and al, 1
movzx eax, al
mov cl, [rcx+1Ch]
and cl, 1
movzx ecx, cl
cmp eax, ecx
setnz al
mov [rbp+var_39], al
loc_10ACA:
mov rdx, [rbp+var_38]
mov al, [rbp+var_39]
and al, 1
mov [rbp+var_A], al
mov ecx, [rdx+0Ch]
mov al, 1
cmp ecx, [rdx+18h]
mov [rbp+var_3A], al
jnz short loc_10AF3
mov rcx, [rbp+var_38]
mov eax, [rcx+8]
cmp eax, [rcx+14h]
setnz al
mov [rbp+var_3A], al
loc_10AF3:
mov al, [rbp+var_3A]
and al, 1
mov [rbp+var_B], al
test [rbp+var_9], 1
jnz short loc_10B12
test [rbp+var_A], 1
jnz short loc_10B12
test [rbp+var_B], 1
jnz short loc_10B12
jmp loc_10CF2
loc_10B12:
test [rbp+var_9], 1
jz short loc_10B93
mov rax, [rbp+var_38]
mov [rbp+var_C], 0A0h
mov al, [rax+10h]
shr al, 4
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_10B36
mov [rbp+var_C], 0A1h
jmp short loc_10B86
loc_10B36:
mov rax, [rbp+var_38]
mov al, [rax+10h]
shr al, 5
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_10B50
mov [rbp+var_C], 0A2h
jmp short loc_10B84
loc_10B50:
mov rax, [rbp+var_38]
mov al, [rax+10h]
shr al, 6
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_10B6A
mov [rbp+var_C], 0A3h
jmp short loc_10B82
loc_10B6A:
mov rax, [rbp+var_38]
mov al, [rax+10h]
shr al, 7
movzx eax, al
cmp eax, 0
jz short loc_10B80
mov [rbp+var_C], 0A4h
loc_10B80:
jmp short $+2
loc_10B82:
jmp short $+2
loc_10B84:
jmp short $+2
loc_10B86:
mov rdi, [rbp+var_38]; this
movzx esi, [rbp+var_C]; unsigned __int8
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_10B93:
test [rbp+var_A], 1
jz short loc_10BE7
mov rdi, [rbp+var_38]; this
mov al, [rdi+10h]
shr al, 3
and al, 1
movzx eax, al
or eax, 90h
mov cl, [rdi+10h]
shr cl, 2
and cl, 1
movzx ecx, cl
shl ecx, 1
or eax, ecx
mov cl, [rdi+10h]
shr cl, 1
and cl, 1
movzx ecx, cl
shl ecx, 2
or eax, ecx
mov cl, [rdi+10h]
and cl, 1
movzx ecx, cl
shl ecx, 3
or eax, ecx
mov [rbp+var_D], al
movzx esi, [rbp+var_D]; unsigned __int8
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_10BE7:
test [rbp+var_B], 1
jz loc_10CCF
mov rax, [rbp+var_38]
mov [rbp+var_E], 0C0h
mov [rbp+var_F], 80h
cmp dword ptr [rax+0Ch], 0
jz short loc_10C57
mov rax, [rbp+var_38]
mov esi, [rax+0Ch]
mov ecx, 0C3h
mov edx, 0CBh
cmp esi, 0
cmovl ecx, edx
mov [rbp+var_40], ecx
mov eax, [rax+0Ch]
mov ecx, eax
neg ecx
cmovns eax, ecx
mov [rbp+var_14], eax
mov [rbp+var_18], 1
mov [rbp+var_1C], 5
lea rdi, [rbp+var_14]
lea rsi, [rbp+var_18]
lea rdx, [rbp+var_1C]
call _ZSt5clampIiERKT_S2_S2_S2_; std::clamp<int>(int const&,int const&,int const&)
mov rcx, rax
mov eax, [rbp+var_40]
add eax, [rcx]
sub eax, 1
mov [rbp+var_E], al
loc_10C57:
mov rax, [rbp+var_38]
cmp dword ptr [rax+8], 0
jz short loc_10CB5
mov rax, [rbp+var_38]
mov esi, [rax+8]
mov ecx, 83h
mov edx, 8Bh
cmp esi, 0
cmovl ecx, edx
mov [rbp+var_44], ecx
mov eax, [rax+8]
mov ecx, eax
neg ecx
cmovns eax, ecx
mov [rbp+var_20], eax
mov [rbp+var_24], 1
mov [rbp+var_28], 5
lea rdi, [rbp+var_20]
lea rsi, [rbp+var_24]
lea rdx, [rbp+var_28]
call _ZSt5clampIiERKT_S2_S2_S2_; std::clamp<int>(int const&,int const&,int const&)
mov rcx, rax
mov eax, [rbp+var_44]
add eax, [rcx]
sub eax, 1
mov [rbp+var_F], al
loc_10CB5:
mov rdi, [rbp+var_38]; this
movzx esi, [rbp+var_E]; unsigned __int8
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
mov rdi, [rbp+var_38]; this
movzx esi, [rbp+var_F]; unsigned __int8
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_10CCF:
mov rdi, [rbp+var_38]
add rdi, 20h ; ' '
call _ZN11SimpleClockILi27000000ELi1EE5ResetEv; SimpleClock<27000000,1>::Reset(void)
mov rax, [rbp+var_38]
mov rcx, [rax+8]
mov [rax+14h], rcx
mov cl, [rax+10h]
mov [rax+1Ch], cl
mov byte ptr [rax+51h], 0
loc_10CF2:
add rsp, 50h
pop rbp
retn
|
char VSmileJoy::QueueJoyUpdates(VSmileJoy *this)
{
char result; // al
char v2; // cl
int v3; // eax
char v4; // cl
int v5; // eax
bool v6; // [rsp+16h] [rbp-3Ah]
bool v7; // [rsp+17h] [rbp-39h]
bool v8; // [rsp+27h] [rbp-29h]
int v9; // [rsp+28h] [rbp-28h] BYREF
int v10; // [rsp+2Ch] [rbp-24h] BYREF
int v11; // [rsp+30h] [rbp-20h] BYREF
int v12; // [rsp+34h] [rbp-1Ch] BYREF
int v13; // [rsp+38h] [rbp-18h] BYREF
int v14; // [rsp+3Ch] [rbp-14h] BYREF
char v15; // [rsp+41h] [rbp-Fh]
char v16; // [rsp+42h] [rbp-Eh]
char v17; // [rsp+43h] [rbp-Dh]
char v18; // [rsp+44h] [rbp-Ch]
bool v19; // [rsp+45h] [rbp-Bh]
bool v20; // [rsp+46h] [rbp-Ah]
bool v21; // [rsp+47h] [rbp-9h]
VSmileJoy *v22; // [rsp+48h] [rbp-8h]
v22 = this;
v8 = 1;
if ( ((*((_BYTE *)this + 16) & 0x10) != 0) == ((*((_BYTE *)this + 28) & 0x10) != 0) )
{
v8 = 1;
if ( ((*((_BYTE *)this + 16) & 0x20) != 0) == ((*((_BYTE *)this + 28) & 0x20) != 0) )
{
v8 = 1;
if ( ((*((_BYTE *)this + 16) & 0x40) != 0) == ((*((_BYTE *)this + 28) & 0x40) != 0) )
v8 = *((_BYTE *)this + 16) >> 7 != *((_BYTE *)this + 28) >> 7;
}
}
v21 = v8;
v7 = 1;
if ( ((*((_BYTE *)this + 16) & 8) != 0) == ((*((_BYTE *)this + 28) & 8) != 0) )
{
v7 = 1;
if ( ((*((_BYTE *)this + 16) & 4) != 0) == ((*((_BYTE *)this + 28) & 4) != 0) )
{
v7 = 1;
if ( ((*((_BYTE *)this + 16) & 2) != 0) == ((*((_BYTE *)this + 28) & 2) != 0) )
v7 = (*((_BYTE *)this + 16) & 1) != (*((_BYTE *)this + 28) & 1);
}
}
v20 = v7;
v6 = 1;
if ( *((_DWORD *)this + 3) == *((_DWORD *)this + 6) )
v6 = *((_DWORD *)this + 2) != *((_DWORD *)this + 5);
result = v6;
v19 = v6;
if ( v21 || v20 || v19 )
{
if ( v21 )
{
v18 = -96;
if ( (*((_BYTE *)this + 16) & 0x10) != 0 )
{
v18 = -95;
}
else if ( (*((_BYTE *)this + 16) & 0x20) != 0 )
{
v18 = -94;
}
else if ( (*((_BYTE *)this + 16) & 0x40) != 0 )
{
v18 = -93;
}
else if ( *((char *)this + 16) < 0 )
{
v18 = -92;
}
VSmileJoy::QueueTx(this, v18);
}
if ( v20 )
{
v17 = (8 * (*((_BYTE *)this + 16) & 1)) | (4 * ((*((_BYTE *)this + 16) & 2) != 0)) | (2
* ((*((_BYTE *)this + 16) & 4) != 0)) | ((*((_BYTE *)this + 16) & 8) != 0) | 0x90;
VSmileJoy::QueueTx(this, v17);
}
if ( v19 )
{
v16 = -64;
v15 = 0x80;
if ( *((_DWORD *)this + 3) )
{
v2 = -61;
if ( *((int *)this + 3) < 0 )
v2 = -53;
v3 = *((_DWORD *)this + 3);
if ( v3 <= 0 )
v3 = -v3;
v14 = v3;
v13 = 1;
v12 = 5;
v16 = *(_BYTE *)std::clamp<int>(&v14, &v13, &v12) + v2 - 1;
}
if ( *((_DWORD *)this + 2) )
{
v4 = -125;
if ( *((int *)this + 2) < 0 )
v4 = -117;
v5 = *((_DWORD *)this + 2);
if ( v5 <= 0 )
v5 = -v5;
v11 = v5;
v10 = 1;
v9 = 5;
v15 = *(_BYTE *)std::clamp<int>(&v11, &v10, &v9) + v4 - 1;
}
VSmileJoy::QueueTx(this, v16);
VSmileJoy::QueueTx(this, v15);
}
SimpleClock<27000000,1>::Reset((char *)this + 32);
result = (char)this;
*(_QWORD *)((char *)this + 20) = *((_QWORD *)this + 1);
*((_BYTE *)this + 28) = *((_BYTE *)this + 16);
*((_BYTE *)this + 81) = 0;
}
return result;
}
|
QueueJoyUpdates:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x4
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x4
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00110a3a
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x5
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x5
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00110a3a
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x6
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x6
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00110a3a
MOV RCX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RCX + 0x10]
SHR AL,0x7
MOVZX EAX,AL
MOV CL,byte ptr [RCX + 0x1c]
SHR CL,0x7
MOVZX ECX,CL
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_00110a3a:
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RBP + -0x29]
AND CL,0x1
MOV byte ptr [RBP + -0x9],CL
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x3
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x3
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x39],AL
JNZ 0x00110aca
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x2
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x2
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x39],AL
JNZ 0x00110aca
MOV RAX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RAX + 0x10]
SHR CL,0x1
AND CL,0x1
MOVZX ECX,CL
MOV AL,byte ptr [RAX + 0x1c]
SHR AL,0x1
AND AL,0x1
MOVZX EDX,AL
MOV AL,0x1
CMP ECX,EDX
MOV byte ptr [RBP + -0x39],AL
JNZ 0x00110aca
MOV RCX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RCX + 0x10]
AND AL,0x1
MOVZX EAX,AL
MOV CL,byte ptr [RCX + 0x1c]
AND CL,0x1
MOVZX ECX,CL
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x39],AL
LAB_00110aca:
MOV RDX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RBP + -0x39]
AND AL,0x1
MOV byte ptr [RBP + -0xa],AL
MOV ECX,dword ptr [RDX + 0xc]
MOV AL,0x1
CMP ECX,dword ptr [RDX + 0x18]
MOV byte ptr [RBP + -0x3a],AL
JNZ 0x00110af3
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RCX + 0x8]
CMP EAX,dword ptr [RCX + 0x14]
SETNZ AL
MOV byte ptr [RBP + -0x3a],AL
LAB_00110af3:
MOV AL,byte ptr [RBP + -0x3a]
AND AL,0x1
MOV byte ptr [RBP + -0xb],AL
TEST byte ptr [RBP + -0x9],0x1
JNZ 0x00110b12
TEST byte ptr [RBP + -0xa],0x1
JNZ 0x00110b12
TEST byte ptr [RBP + -0xb],0x1
JNZ 0x00110b12
JMP 0x00110cf2
LAB_00110b12:
TEST byte ptr [RBP + -0x9],0x1
JZ 0x00110b93
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0xc],0xa0
MOV AL,byte ptr [RAX + 0x10]
SHR AL,0x4
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00110b36
MOV byte ptr [RBP + -0xc],0xa1
JMP 0x00110b86
LAB_00110b36:
MOV RAX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RAX + 0x10]
SHR AL,0x5
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00110b50
MOV byte ptr [RBP + -0xc],0xa2
JMP 0x00110b84
LAB_00110b50:
MOV RAX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RAX + 0x10]
SHR AL,0x6
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00110b6a
MOV byte ptr [RBP + -0xc],0xa3
JMP 0x00110b82
LAB_00110b6a:
MOV RAX,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RAX + 0x10]
SHR AL,0x7
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00110b80
MOV byte ptr [RBP + -0xc],0xa4
LAB_00110b80:
JMP 0x00110b82
LAB_00110b82:
JMP 0x00110b84
LAB_00110b84:
JMP 0x00110b86
LAB_00110b86:
MOV RDI,qword ptr [RBP + -0x38]
MOVZX ESI,byte ptr [RBP + -0xc]
CALL 0x001107e0
LAB_00110b93:
TEST byte ptr [RBP + -0xa],0x1
JZ 0x00110be7
MOV RDI,qword ptr [RBP + -0x38]
MOV AL,byte ptr [RDI + 0x10]
SHR AL,0x3
AND AL,0x1
MOVZX EAX,AL
OR EAX,0x90
MOV CL,byte ptr [RDI + 0x10]
SHR CL,0x2
AND CL,0x1
MOVZX ECX,CL
SHL ECX,0x1
OR EAX,ECX
MOV CL,byte ptr [RDI + 0x10]
SHR CL,0x1
AND CL,0x1
MOVZX ECX,CL
SHL ECX,0x2
OR EAX,ECX
MOV CL,byte ptr [RDI + 0x10]
AND CL,0x1
MOVZX ECX,CL
SHL ECX,0x3
OR EAX,ECX
MOV byte ptr [RBP + -0xd],AL
MOVZX ESI,byte ptr [RBP + -0xd]
CALL 0x001107e0
LAB_00110be7:
TEST byte ptr [RBP + -0xb],0x1
JZ 0x00110ccf
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0xe],0xc0
MOV byte ptr [RBP + -0xf],0x80
CMP dword ptr [RAX + 0xc],0x0
JZ 0x00110c57
MOV RAX,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RAX + 0xc]
MOV ECX,0xc3
MOV EDX,0xcb
CMP ESI,0x0
CMOVL ECX,EDX
MOV dword ptr [RBP + -0x40],ECX
MOV EAX,dword ptr [RAX + 0xc]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x18],0x1
MOV dword ptr [RBP + -0x1c],0x5
LEA RDI,[RBP + -0x14]
LEA RSI,[RBP + -0x18]
LEA RDX,[RBP + -0x1c]
CALL 0x0010ebf0
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,dword ptr [RCX]
SUB EAX,0x1
MOV byte ptr [RBP + -0xe],AL
LAB_00110c57:
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00110cb5
MOV RAX,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RAX + 0x8]
MOV ECX,0x83
MOV EDX,0x8b
CMP ESI,0x0
CMOVL ECX,EDX
MOV dword ptr [RBP + -0x44],ECX
MOV EAX,dword ptr [RAX + 0x8]
MOV ECX,EAX
NEG ECX
CMOVNS EAX,ECX
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x24],0x1
MOV dword ptr [RBP + -0x28],0x5
LEA RDI,[RBP + -0x20]
LEA RSI,[RBP + -0x24]
LEA RDX,[RBP + -0x28]
CALL 0x0010ebf0
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RCX]
SUB EAX,0x1
MOV byte ptr [RBP + -0xf],AL
LAB_00110cb5:
MOV RDI,qword ptr [RBP + -0x38]
MOVZX ESI,byte ptr [RBP + -0xe]
CALL 0x001107e0
MOV RDI,qword ptr [RBP + -0x38]
MOVZX ESI,byte ptr [RBP + -0xf]
CALL 0x001107e0
LAB_00110ccf:
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x20
CALL 0x00111060
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x14],RCX
MOV CL,byte ptr [RAX + 0x10]
MOV byte ptr [RAX + 0x1c],CL
MOV byte ptr [RAX + 0x51],0x0
LAB_00110cf2:
ADD RSP,0x50
POP RBP
RET
|
/* VSmileJoy::QueueJoyUpdates() */
void __thiscall VSmileJoy::QueueJoyUpdates(VSmileJoy *this)
{
int *piVar1;
char cVar2;
bool local_42;
bool local_41;
bool local_31;
int local_30 [3];
int local_24 [3];
uchar local_17;
uchar local_16;
byte local_15;
uchar local_14;
bool local_13;
bool local_12;
bool local_11;
VSmileJoy *local_10;
local_31 = true;
if (((((byte)this[0x10] >> 4 & 1) == ((byte)this[0x1c] >> 4 & 1)) &&
(local_31 = true, ((byte)this[0x10] >> 5 & 1) == ((byte)this[0x1c] >> 5 & 1))) &&
(local_31 = true, ((byte)this[0x10] >> 6 & 1) == ((byte)this[0x1c] >> 6 & 1))) {
local_31 = (byte)this[0x10] >> 7 != (byte)this[0x1c] >> 7;
}
local_11 = local_31;
local_41 = true;
if (((((byte)this[0x10] >> 3 & 1) == ((byte)this[0x1c] >> 3 & 1)) &&
(local_41 = true, ((byte)this[0x10] >> 2 & 1) == ((byte)this[0x1c] >> 2 & 1))) &&
(local_41 = true, ((byte)this[0x10] >> 1 & 1) == ((byte)this[0x1c] >> 1 & 1))) {
local_41 = ((byte)this[0x10] & 1) != ((byte)this[0x1c] & 1);
}
local_12 = local_41;
local_42 = true;
if (*(int *)(this + 0xc) == *(int *)(this + 0x18)) {
local_42 = *(int *)(this + 8) != *(int *)(this + 0x14);
}
local_13 = local_42;
if (((local_31 != false) || (local_41 != false)) || (local_42 != false)) {
local_10 = this;
if (local_31 != false) {
local_14 = 0xa0;
if (((byte)this[0x10] >> 4 & 1) == 0) {
if (((byte)this[0x10] >> 5 & 1) == 0) {
if (((byte)this[0x10] >> 6 & 1) == 0) {
if ((char)this[0x10] < '\0') {
local_14 = 0xa4;
}
}
else {
local_14 = 0xa3;
}
}
else {
local_14 = 0xa2;
}
}
else {
local_14 = 0xa1;
}
QueueTx(this,local_14);
}
if ((local_12 & 1U) != 0) {
local_15 = (byte)this[0x10] >> 3 & 1 | 0x90 | ((byte)this[0x10] >> 2 & 1) << 1 |
((byte)this[0x10] >> 1 & 1) << 2 | ((byte)this[0x10] & 1) << 3;
QueueTx(this,local_15);
}
if ((local_13 & 1U) != 0) {
local_16 = 0xc0;
local_17 = 0x80;
if (*(int *)(this + 0xc) != 0) {
cVar2 = -0x3d;
if (*(int *)(this + 0xc) < 0) {
cVar2 = -0x35;
}
local_24[2] = *(int *)(this + 0xc);
if (local_24[2] < 1) {
local_24[2] = -local_24[2];
}
local_24[1] = 1;
local_24[0] = 5;
piVar1 = std::clamp<int>(local_24 + 2,local_24 + 1,local_24);
local_16 = cVar2 + (char)*piVar1 + 0xff;
}
if (*(int *)(this + 8) != 0) {
cVar2 = -0x7d;
if (*(int *)(this + 8) < 0) {
cVar2 = -0x75;
}
local_30[2] = *(int *)(this + 8);
if (local_30[2] < 1) {
local_30[2] = -local_30[2];
}
local_30[1] = 1;
local_30[0] = 5;
piVar1 = std::clamp<int>(local_30 + 2,local_30 + 1,local_30);
local_17 = cVar2 + (char)*piVar1 + 0xff;
}
QueueTx(this,local_16);
QueueTx(this,local_17);
}
SimpleClock<27000000,1>::Reset((SimpleClock<27000000,1> *)(this + 0x20));
*(int8 *)(this + 0x14) = *(int8 *)(this + 8);
this[0x1c] = this[0x10];
this[0x51] = (VSmileJoy)0x0;
}
return;
}
|
|
13,998
|
VSmileJoy::QueueJoyUpdates()
|
sp1187[P]veesem/src/core/vsmile/vsmile_joy.cc
|
void VSmileJoy::QueueJoyUpdates() {
bool update_buttons = current_.enter != last_sent_.enter || current_.back != last_sent_.back ||
current_.help != last_sent_.help || current_.abc != last_sent_.abc;
bool update_colors = current_.green != last_sent_.green || current_.blue != last_sent_.blue ||
current_.yellow != last_sent_.yellow || current_.red != last_sent_.red;
bool update_joy = current_.x != last_sent_.x || current_.y != last_sent_.y;
if (!update_buttons && !update_colors && !update_joy)
return;
if (update_buttons) {
uint8_t button_value = 0xa0;
if (current_.enter)
button_value = 0xa1;
else if (current_.back)
button_value = 0xa2;
else if (current_.help)
button_value = 0xa3;
else if (current_.abc)
button_value = 0xa4;
QueueTx(button_value);
}
if (update_colors) {
uint8_t color_value =
0x90 | current_.green | (current_.blue << 1) | (current_.yellow << 2) | (current_.red << 3);
QueueTx(color_value);
}
if (update_joy) {
uint8_t x_value = 0xc0, y_value = 0x80;
if (current_.x != 0) {
x_value = (current_.x < 0 ? 0xcb : 0xc3) + std::clamp(std::abs(current_.x), 1, 5) - 1;
}
if (current_.y != 0) {
y_value = (current_.y < 0 ? 0x8b : 0x83) + std::clamp(std::abs(current_.y), 1, 5) - 1;
}
QueueTx(x_value);
QueueTx(y_value);
}
idle_timer_.Reset();
last_sent_ = current_;
current_updated_ = false;
}
|
O3
|
cpp
|
VSmileJoy::QueueJoyUpdates():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %ecx
xorl 0x18(%rdi), %ecx
movb 0x10(%rdi), %al
movl 0x14(%rdi), %edx
xorl 0x8(%rdi), %edx
movb 0x1c(%rdi), %r14b
orl %ecx, %edx
setne %bpl
cmpb %al, %r14b
jne 0xa7d3
testb %bpl, %bpl
je 0xa8cc
xorb %al, %r14b
cmpb $0x10, %r14b
jb 0xa802
movb $-0x5f, %cl
testb $0x10, %al
jne 0xa7f7
movb $-0x5e, %cl
testb $0x20, %al
jne 0xa7f7
movb $-0x5d, %cl
testb $0x40, %al
jne 0xa7f7
shrb $0x5, %al
andb $0x4, %al
orb $-0x60, %al
movl %eax, %ecx
movzbl %cl, %esi
movq %rbx, %rdi
callq 0xa6dc
testb $0xf, %r14b
je 0xa83e
movb 0x10(%rbx), %al
movl %eax, %ecx
andb $0x8, %cl
leal (%rax,%rax), %edx
andb $0x4, %dl
leal (,%rax,8), %esi
andb $0x8, %sil
orb %dl, %sil
shrb %al
andb $0x2, %al
orb %sil, %al
shrb $0x3, %cl
orb %al, %cl
orb $-0x70, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0xa6dc
leaq 0x8(%rbx), %r14
leaq 0x14(%rbx), %r15
testb %bpl, %bpl
je 0xa8b3
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0xa870
movl %eax, %ecx
shrl $0x1f, %ecx
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x5, %edx
movl $0x5, %eax
cmovbl %edx, %eax
leal (%rax,%rcx,8), %eax
addb $-0x3e, %al
jmp 0xa872
movb $-0x40, %al
movl (%r14), %ecx
testl %ecx, %ecx
je 0xa899
movl %ecx, %edx
shrl $0x1f, %edx
movl %ecx, %esi
negl %esi
cmovsl %ecx, %esi
cmpl $0x5, %esi
movl $0x5, %ecx
cmovbl %esi, %ecx
leal (%rcx,%rdx,8), %ebp
addb $-0x7e, %bpl
jmp 0xa89c
movb $-0x80, %bpl
movzbl %al, %esi
movq %rbx, %rdi
callq 0xa6dc
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0xa6dc
movl $0x19bfcc0, 0x20(%rbx) # imm = 0x19BFCC0
movb 0x8(%r14), %al
movb %al, 0x8(%r15)
movq (%r14), %rax
movq %rax, (%r15)
movb $0x0, 0x51(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN9VSmileJoy15QueueJoyUpdatesEv:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov ecx, [rdi+0Ch]
xor ecx, [rdi+18h]
mov al, [rdi+10h]
mov edx, [rdi+14h]
xor edx, [rdi+8]
mov r14b, [rdi+1Ch]
or edx, ecx
setnz bpl
cmp r14b, al
jnz short loc_A7D3
test bpl, bpl
jz loc_A8CC
loc_A7D3:
xor r14b, al
cmp r14b, 10h
jb short loc_A802
mov cl, 0A1h
test al, 10h
jnz short loc_A7F7
mov cl, 0A2h
test al, 20h
jnz short loc_A7F7
mov cl, 0A3h
test al, 40h
jnz short loc_A7F7
shr al, 5
and al, 4
or al, 0A0h
mov ecx, eax
loc_A7F7:
movzx esi, cl; unsigned __int8
mov rdi, rbx; this
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_A802:
test r14b, 0Fh
jz short loc_A83E
mov al, [rbx+10h]
mov ecx, eax
and cl, 8
lea edx, [rax+rax]
and dl, 4
lea esi, ds:0[rax*8]
and sil, 8
or sil, dl
shr al, 1
and al, 2
or al, sil
shr cl, 3
or cl, al
or cl, 90h
movzx esi, cl; unsigned __int8
mov rdi, rbx; this
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_A83E:
lea r14, [rbx+8]
lea r15, [rbx+14h]
test bpl, bpl
jz short loc_A8B3
mov eax, [rbx+0Ch]
test eax, eax
jz short loc_A870
mov ecx, eax
shr ecx, 1Fh
mov edx, eax
neg edx
cmovs edx, eax
cmp edx, 5
mov eax, 5
cmovb eax, edx
lea eax, [rax+rcx*8]
add al, 0C2h
jmp short loc_A872
loc_A870:
mov al, 0C0h
loc_A872:
mov ecx, [r14]
test ecx, ecx
jz short loc_A899
mov edx, ecx
shr edx, 1Fh
mov esi, ecx
neg esi
cmovs esi, ecx
cmp esi, 5
mov ecx, 5
cmovb ecx, esi
lea ebp, [rcx+rdx*8]
add bpl, 82h
jmp short loc_A89C
loc_A899:
mov bpl, 80h
loc_A89C:
movzx esi, al; unsigned __int8
mov rdi, rbx; this
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
movzx esi, bpl; unsigned __int8
mov rdi, rbx; this
call _ZN9VSmileJoy7QueueTxEh; VSmileJoy::QueueTx(uchar)
loc_A8B3:
mov dword ptr [rbx+20h], 19BFCC0h
mov al, [r14+8]
mov [r15+8], al
mov rax, [r14]
mov [r15], rax
mov byte ptr [rbx+51h], 0
loc_A8CC:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
char VSmileJoy::QueueJoyUpdates(VSmileJoy *this)
{
long long v1; // rax
char v2; // r14
bool v3; // bp
unsigned __int8 v4; // r14
char v5; // cl
int *v6; // r14
int v7; // eax
unsigned int v8; // ecx
unsigned int v9; // edx
char v10; // al
char v11; // al
int v12; // ecx
unsigned int v13; // edx
unsigned int v14; // esi
char v15; // cl
char v16; // bp
LOBYTE(v1) = *((_BYTE *)this + 16);
v2 = *((_BYTE *)this + 28);
v3 = *((_QWORD *)this + 1) != *(_QWORD *)((char *)this + 20);
if ( v2 != (_BYTE)v1 || *((_QWORD *)this + 1) != *(_QWORD *)((char *)this + 20) )
{
v4 = v1 ^ v2;
if ( v4 >= 0x10u )
{
v5 = -95;
if ( (v1 & 0x10) == 0 )
{
v5 = -94;
if ( (v1 & 0x20) == 0 )
{
v5 = -93;
if ( (v1 & 0x40) == 0 )
v5 = ((unsigned __int8)v1 >> 5) & 4 | 0xA0;
}
}
VSmileJoy::QueueTx(this, v5);
}
if ( (v4 & 0xF) != 0 )
VSmileJoy::QueueTx(
this,
(2 * *((_BYTE *)this + 16)) & 4 | (8 * *((_BYTE *)this + 16)) & 8 | (*((_BYTE *)this + 16) >> 1) & 2 | ((unsigned __int8)(*((_BYTE *)this + 16) & 8) >> 3) | 0x90);
v6 = (int *)((char *)this + 8);
if ( v3 )
{
v7 = *((_DWORD *)this + 3);
if ( v7 )
{
v8 = (unsigned int)v7 >> 31;
v9 = -v7;
if ( v7 > 0 )
v9 = *((_DWORD *)this + 3);
v10 = 5;
if ( v9 < 5 )
v10 = v9;
v11 = v10 + 8 * v8 - 62;
}
else
{
v11 = -64;
}
v12 = *v6;
if ( *v6 )
{
v13 = (unsigned int)v12 >> 31;
v14 = -v12;
if ( v12 > 0 )
v14 = *v6;
v15 = 5;
if ( v14 < 5 )
v15 = v14;
v16 = v15 + 8 * v13 - 126;
}
else
{
v16 = 0x80;
}
VSmileJoy::QueueTx(this, v11);
VSmileJoy::QueueTx(this, v16);
}
*((_DWORD *)this + 8) = 27000000;
*((_BYTE *)this + 28) = *((_BYTE *)this + 16);
v1 = *(_QWORD *)v6;
*(_QWORD *)((char *)this + 20) = *(_QWORD *)v6;
*((_BYTE *)this + 81) = 0;
}
return v1;
}
|
QueueJoyUpdates:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV ECX,dword ptr [RDI + 0xc]
XOR ECX,dword ptr [RDI + 0x18]
MOV AL,byte ptr [RDI + 0x10]
MOV EDX,dword ptr [RDI + 0x14]
XOR EDX,dword ptr [RDI + 0x8]
MOV R14B,byte ptr [RDI + 0x1c]
OR EDX,ECX
SETNZ BPL
CMP R14B,AL
JNZ 0x0010a7d3
TEST BPL,BPL
JZ 0x0010a8cc
LAB_0010a7d3:
XOR R14B,AL
CMP R14B,0x10
JC 0x0010a802
MOV CL,0xa1
TEST AL,0x10
JNZ 0x0010a7f7
MOV CL,0xa2
TEST AL,0x20
JNZ 0x0010a7f7
MOV CL,0xa3
TEST AL,0x40
JNZ 0x0010a7f7
SHR AL,0x5
AND AL,0x4
OR AL,0xa0
MOV ECX,EAX
LAB_0010a7f7:
MOVZX ESI,CL
MOV RDI,RBX
CALL 0x0010a6dc
LAB_0010a802:
TEST R14B,0xf
JZ 0x0010a83e
MOV AL,byte ptr [RBX + 0x10]
MOV ECX,EAX
AND CL,0x8
LEA EDX,[RAX + RAX*0x1]
AND DL,0x4
LEA ESI,[RAX*0x8]
AND SIL,0x8
OR SIL,DL
SHR AL,0x1
AND AL,0x2
OR AL,SIL
SHR CL,0x3
OR CL,AL
OR CL,0x90
MOVZX ESI,CL
MOV RDI,RBX
CALL 0x0010a6dc
LAB_0010a83e:
LEA R14,[RBX + 0x8]
LEA R15,[RBX + 0x14]
TEST BPL,BPL
JZ 0x0010a8b3
MOV EAX,dword ptr [RBX + 0xc]
TEST EAX,EAX
JZ 0x0010a870
MOV ECX,EAX
SHR ECX,0x1f
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
CMP EDX,0x5
MOV EAX,0x5
CMOVC EAX,EDX
LEA EAX,[RAX + RCX*0x8]
ADD AL,0xc2
JMP 0x0010a872
LAB_0010a870:
MOV AL,0xc0
LAB_0010a872:
MOV ECX,dword ptr [R14]
TEST ECX,ECX
JZ 0x0010a899
MOV EDX,ECX
SHR EDX,0x1f
MOV ESI,ECX
NEG ESI
CMOVS ESI,ECX
CMP ESI,0x5
MOV ECX,0x5
CMOVC ECX,ESI
LEA EBP,[RCX + RDX*0x8]
ADD BPL,0x82
JMP 0x0010a89c
LAB_0010a899:
MOV BPL,0x80
LAB_0010a89c:
MOVZX ESI,AL
MOV RDI,RBX
CALL 0x0010a6dc
MOVZX ESI,BPL
MOV RDI,RBX
CALL 0x0010a6dc
LAB_0010a8b3:
MOV dword ptr [RBX + 0x20],0x19bfcc0
MOV AL,byte ptr [R14 + 0x8]
MOV byte ptr [R15 + 0x8],AL
MOV RAX,qword ptr [R14]
MOV qword ptr [R15],RAX
MOV byte ptr [RBX + 0x51],0x0
LAB_0010a8cc:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* VSmileJoy::QueueJoyUpdates() */
void __thiscall VSmileJoy::QueueJoyUpdates(VSmileJoy *this)
{
VSmileJoy VVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
uint uVar6;
byte bVar7;
uchar uVar8;
uint uVar9;
uint uVar10;
uchar uVar11;
byte bVar12;
iVar2 = *(int *)(this + 0xc);
iVar3 = *(int *)(this + 0x18);
VVar1 = this[0x10];
iVar4 = *(int *)(this + 0x14);
iVar5 = *(int *)(this + 8);
if ((this[0x1c] != VVar1) || (iVar4 != iVar5 || iVar2 != iVar3)) {
bVar12 = (byte)this[0x1c] ^ (byte)VVar1;
if (0xf < bVar12) {
bVar7 = 0xa1;
if (((((byte)VVar1 & 0x10) == 0) && (bVar7 = 0xa2, ((byte)VVar1 & 0x20) == 0)) &&
(bVar7 = 0xa3, ((byte)VVar1 & 0x40) == 0)) {
bVar7 = (byte)VVar1 >> 5 & 4 | 0xa0;
}
QueueTx(this,bVar7);
}
if ((bVar12 & 0xf) != 0) {
VVar1 = this[0x10];
QueueTx(this,((byte)VVar1 & 8) >> 3 |
(byte)VVar1 >> 1 & 2 | (char)VVar1 * '\b' & 8U | (char)VVar1 * '\x02' & 4U | 0x90
);
}
if (iVar4 != iVar5 || iVar2 != iVar3) {
uVar6 = *(uint *)(this + 0xc);
if (uVar6 == 0) {
uVar8 = 0xc0;
}
else {
uVar10 = -uVar6;
if (0 < (int)uVar6) {
uVar10 = uVar6;
}
uVar9 = 5;
if (uVar10 < 5) {
uVar9 = uVar10;
}
uVar8 = (char)uVar9 + (char)((int)uVar6 >> 0x1f) * -8 + 0xc2;
}
uVar6 = *(uint *)(this + 8);
if (uVar6 == 0) {
uVar11 = 0x80;
}
else {
uVar10 = -uVar6;
if (0 < (int)uVar6) {
uVar10 = uVar6;
}
uVar9 = 5;
if (uVar10 < 5) {
uVar9 = uVar10;
}
uVar11 = (char)uVar9 + (char)((int)uVar6 >> 0x1f) * -8 + 0x82;
}
QueueTx(this,uVar8);
QueueTx(this,uVar11);
}
*(int4 *)(this + 0x20) = 27000000;
this[0x1c] = this[0x10];
*(int8 *)(this + 0x14) = *(int8 *)(this + 8);
this[0x51] = (VSmileJoy)0x0;
}
return;
}
|
|
13,999
|
expect_tool_parameters(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&, 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&)
|
monkey531[P]llama/common/chat.cpp
|
static void expect_tool_parameters(const std::string & name, const json & parameters, const std::vector<std::string> & expected_properties) {
if (!parameters.is_object() || !parameters.contains("type") || parameters["type"] != "object" || !parameters.contains("properties") || !parameters.contains("required")) {
throw std::runtime_error("Parameters of tool " + name + " must be an object w/ required properties");
}
const auto & parameters_properties = parameters.at("properties");
const auto & parameters_required = parameters.at("required");
for (const auto & prop : expected_properties) {
if (!parameters_properties.contains(prop)) {
throw std::runtime_error("Parameters of tool " + name + " is missing property: " + prop);
}
if (std::find(parameters_required.begin(), parameters_required.end(), json(prop)) == parameters_required.end()) {
throw std::runtime_error("Parameters of tool " + name + " must have property marked as required: " + prop);
}
}
if (parameters_properties.size() != expected_properties.size()) {
throw std::runtime_error("Parameters of tool " + name + " must only have these properties:" + string_join(expected_properties, ", "));
}
}
|
O2
|
cpp
|
expect_tool_parameters(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&, 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&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x8(%rsp)
cmpb $0x1, (%rsi)
jne 0xa3e71
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x9180(%rip), %rsi # 0xacd91
movq %rbx, %rdi
callq 0x7abce
testb %al, %al
je 0xa3e71
leaq 0x9169(%rip), %rsi # 0xacd91
movq %rbx, %rdi
callq 0x7b9ac
leaq 0x10f2a(%rip), %rsi # 0xb4b61
movq %rax, %rdi
callq 0x7b576
testb %al, %al
jne 0xa3e71
leaq 0x16d59(%rip), %rsi # 0xba9a7
movq %rbx, %rdi
callq 0x7ad56
testb %al, %al
je 0xa3e71
leaq 0xf960(%rip), %rsi # 0xb35c5
movq %rbx, %rdi
callq 0x911f0
testb %al, %al
je 0xa3e71
leaq 0x16d2b(%rip), %rsi # 0xba9a7
movq %rbx, %rdi
callq 0xa8f90
movq %rax, 0x58(%rsp)
leaq 0xf935(%rip), %rsi # 0xb35c5
movq %rbx, %rdi
callq 0x7b702
movq %rax, %r13
movq (%r14), %r15
movq %r14, 0x50(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x80(%rsp)
leaq 0x60(%rsp), %r14
leaq 0x30(%rsp), %rbp
cmpq 0x80(%rsp), %r15
je 0xa3d50
movq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x96d46
testb %al, %al
je 0xa3dfb
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x68800
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x68a6c
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d522
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xa90e4
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x68a6c
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x68894
movl %eax, %ebx
movq %r14, %rdi
callq 0x42fee
testb %bl, %bl
jne 0xa3d85
addq $0x20, %r15
jmp 0xa3cb9
movq 0x58(%rsp), %rdi
callq 0x42a32
movq 0x50(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
jne 0xa3ed5
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x16bdd(%rip), %rsi # 0xba974
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x3a250
leaq 0x16c1c(%rip), %rdx # 0xba9c9
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x38ff4
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x3b81a
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x23e50
xorl %ebp, %ebp
movq 0x5a209(%rip), %rsi # 0xfdff0
movq 0x5a16a(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f20
jmp 0xa3f7e
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x16b67(%rip), %rsi # 0xba974
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x3a250
leaq 0x16b8f(%rip), %rdx # 0xba9b2
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x38ff4
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x3b81a
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x23e50
xorl %ebp, %ebp
movq 0x5a193(%rip), %rsi # 0xfdff0
movq 0x5a0f4(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f20
jmp 0xa3f7e
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x16af1(%rip), %rsi # 0xba974
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x3a250
leaq 0x16aef(%rip), %rdx # 0xba988
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38ff4
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x23e50
xorl %ebp, %ebp
movq 0x5a12f(%rip), %rsi # 0xfdff0
movq 0x5a090(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f20
jmp 0xa3f7e
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r15
leaq 0x16a8d(%rip), %rsi # 0xba974
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x3a250
leaq 0x16af5(%rip), %rdx # 0xba9f2
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x38ff4
leaq 0xf5b0(%rip), %rsi # 0xb34c3
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27c44
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
movq 0x50(%rsp), %rsi
callq 0x54736
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x3a083
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x23e50
xorl %ebp, %ebp
movq 0x5a081(%rip), %rsi # 0xfdff0
movq 0x59fe2(%rip), %rdx # 0xfdf58
movq %r15, %rdi
callq 0x23f20
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x241f8
jmp 0xa3f93
movq %rax, %rbx
movb $0x1, %bpl
leaq 0xa8(%rsp), %rdi
callq 0x241f8
jmp 0xa3fa8
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x241f8
jmp 0xa3fbd
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x241f8
jmp 0xa3fcf
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x241f8
testb %bpl, %bpl
jne 0xa3fe6
jmp 0xa4065
movq %rax, %rbx
movq %r15, %rdi
jmp 0xa404f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x241f8
jmp 0xa4000
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
jmp 0xa403b
jmp 0xa4049
jmp 0xa400d
jmp 0xa401c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x241f8
jmp 0xa4022
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x241f8
jmp 0xa4036
jmp 0xa4030
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x241f8
testb %bpl, %bpl
jne 0xa404c
jmp 0xa4065
jmp 0xa4049
movq %rax, %rbx
movq %r14, %rdi
callq 0x23690
jmp 0xa4065
jmp 0xa4058
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x42fee
movq %rbx, %rdi
callq 0x23fb0
nop
|
_ZL22expect_tool_parametersRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS4_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEERKSB_IS4_SaIS4_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
mov [rsp+138h+var_130], rdi
cmp byte ptr [rsi], 1
jnz loc_A3E71
mov r14, rdx
mov rbx, rsi
lea rsi, aPplOutputType+0Dh; "type"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_A3E71
lea rsi, aPplOutputType+0Dh; "type"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERKSD_PT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
lea rsi, aIsNotAnObject+0Ch; "object"
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
test al, al
jnz loc_A3E71
lea rsi, aMustBeAnObject+1Fh; "properties"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_A3E71
lea rsi, aRequired; "required"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_A3E71
lea rsi, aMustBeAnObject+1Fh; "properties"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov [rsp+138h+var_E0], rax
lea rsi, aRequired; "required"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov r13, rax
mov r15, [r14]
mov [rsp+138h+var_E8], r14
mov rax, [r14+8]
mov [rsp+138h+var_B8], rax
lea r14, [rsp+138h+var_D8]
lea rbp, [rsp+138h+var_108]
loc_A3CB9:
cmp r15, [rsp+138h+var_B8]
jz loc_A3D50
mov rdi, [rsp+138h+var_E0]
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsERKS9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::contains(std::string const&)
test al, al
jz loc_A3DFB
lea rbx, [rsp+138h+var_50]
mov rdi, rbx
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6cbeginEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cbegin(void)
lea r12, [rsp+138h+var_70]
mov rdi, r12
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cend(void)
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
mov rdi, rbp
mov rsi, rbx
mov rdx, r12
mov rcx, r14
call _ZSt4findIN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEESG_ET_SJ_SJ_RKT0_; std::find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rbx, [rsp+138h+var_128]
mov rdi, rbx
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cend(void)
mov rdi, rbp
mov rsi, rbx
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
mov ebx, eax
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()
test bl, bl
jnz short loc_A3D85
add r15, 20h ; ' '
jmp loc_A3CB9
loc_A3D50:
mov rdi, [rsp+138h+var_E0]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::size(void)
mov rdx, [rsp+138h+var_E8]
mov rcx, [rdx+8]
sub rcx, [rdx]
sar rcx, 5
cmp rax, rcx
jnz loc_A3ED5
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A3D85:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustHaveProper; " must have property marked as required:"...
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_A3F7E
loc_A3DFB:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aIsMissingPrope; " is missing property: "
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_A3F7E
loc_A3E71:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_128]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustBeAnObject; " must be an object w/ required properti"...
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_A3F7E
loc_A3ED5:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustOnlyHaveTh; " must only have these properties:"
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rsi, aZuD+6; ", "
lea rdi, [rsp+138h+var_B0]
lea rdx, [rsp+138h+var_131]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+138h+var_90]
lea rdx, [rsp+138h+var_B0]
mov rsi, [rsp+138h+var_E8]
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
lea rdx, [rsp+138h+var_90]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_A3F7E:
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A3F93
mov rbx, rax
mov bpl, 1
loc_A3F93:
lea rdi, [rsp+138h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A3FA8
mov rbx, rax
mov bpl, 1
loc_A3FA8:
lea rdi, [rsp+138h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A3FBD
mov rbx, rax
mov bpl, 1
loc_A3FBD:
lea rdi, [rsp+138h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A3FCF
mov rbx, rax
mov bpl, 1
loc_A3FCF:
lea rdi, [rsp+138h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_A3FE6
jmp loc_A4065
mov rbx, rax
loc_A3FE6:
mov rdi, r15
jmp short loc_A404F
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A4000
mov rbx, rax
mov bpl, 1
loc_A4000:
lea rdi, [rsp+138h+var_128]
jmp short loc_A403B
jmp short loc_A4049
jmp short loc_A400D
jmp short loc_A401C
loc_A400D:
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A4022
loc_A401C:
mov rbx, rax
mov bpl, 1
loc_A4022:
lea rdi, [rsp+138h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_A4036
jmp short $+2
loc_A4030:
mov rbx, rax
mov bpl, 1
loc_A4036:
lea rdi, [rsp+138h+var_D8]; void *
loc_A403B:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_A404C
jmp short loc_A4065
jmp short $+2
loc_A4049:
mov rbx, rax
loc_A404C:
mov rdi, r14; void *
loc_A404F:
call ___cxa_free_exception
jmp short loc_A4065
jmp short $+2
loc_A4058:
mov rbx, rax
lea rdi, [rsp+138h+var_D8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_A4065:
mov rdi, rbx
call __Unwind_Resume
|
long long expect_tool_parameters(long long a1, _BYTE *a2, long long *a3)
{
long long v4; // rax
long long v5; // r13
_QWORD *v6; // r15
char v7; // bl
long long result; // rax
void *v9; // r14
void *v10; // r14
void *exception; // r14
void *v12; // r15
_QWORD v13[4]; // [rsp+10h] [rbp-128h] BYREF
_BYTE v14[32]; // [rsp+30h] [rbp-108h] BYREF
long long *v15; // [rsp+50h] [rbp-E8h]
unsigned __int8 *v16; // [rsp+58h] [rbp-E0h]
unsigned __int8 v17[32]; // [rsp+60h] [rbp-D8h] BYREF
_QWORD *v18; // [rsp+80h] [rbp-B8h]
_QWORD v19[4]; // [rsp+88h] [rbp-B0h] BYREF
_QWORD v20[4]; // [rsp+A8h] [rbp-90h] BYREF
_BYTE v21[32]; // [rsp+C8h] [rbp-70h] BYREF
_BYTE v22[80]; // [rsp+E8h] [rbp-50h] BYREF
if ( *a2 != 1
|| !ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_((long long)a2)
|| (v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(long long)a2,
(long long)"type"),
(unsigned __int8)ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
v4,
(long long)"object"))
|| !ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_((long long)a2)
|| !ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_((long long)a2) )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v14, (long long)v13, (long long)" must be an object w/ required properties");
std::runtime_error::runtime_error(exception, v14);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v16 = (unsigned __int8 *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"properties");
v5 = ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
(long long)a2,
(long long)"required");
v6 = (_QWORD *)*a3;
v15 = a3;
v18 = (_QWORD *)a3[1];
while ( v6 != v18 )
{
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::contains(
(long long)v16,
v6) )
{
v10 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" is missing property: ");
std::operator+<char>((long long)v14, (long long)v13, (long long)v6);
std::runtime_error::runtime_error(v10, v14);
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::cbegin(
(long long)v22,
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>::cend(
(long long)v21,
v5);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_(
v17,
(long long)v6);
std::find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>,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>>(
v14,
v22,
v21,
v17);
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>::cend(
(long long)v13,
v5);
v7 = ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(v14);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v17);
if ( v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" must have property marked as required: ");
std::operator+<char>((long long)v14, (long long)v13, (long long)v6);
std::runtime_error::runtime_error(v9, v14);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 += 4;
}
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::size(v16);
if ( result != (v15[1] - *v15) >> 5 )
{
v12 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" must only have these properties:");
std::string::basic_string<std::allocator<char>>(v19, (long long)", ");
string_join((long long)v20, v15, (long long)v19);
std::operator+<char>((long long)v14, v13, v20);
std::runtime_error::runtime_error(v12, v14);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
|
expect_tool_parameters:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOV qword ptr [RSP + 0x8],RDI
CMP byte ptr [RSI],0x1
JNZ 0x001a3e71
MOV R14,RDX
MOV RBX,RSI
LEA RSI,[0x1acd91]
MOV RDI,RBX
CALL 0x0017abce
TEST AL,AL
JZ 0x001a3e71
LEA RSI,[0x1acd91]
MOV RDI,RBX
CALL 0x0017b9ac
LEA RSI,[0x1b4b61]
MOV RDI,RAX
CALL 0x0017b576
TEST AL,AL
JNZ 0x001a3e71
LEA RSI,[0x1ba9a7]
MOV RDI,RBX
CALL 0x0017ad56
TEST AL,AL
JZ 0x001a3e71
LEA RSI,[0x1b35c5]
MOV RDI,RBX
CALL 0x001911f0
TEST AL,AL
JZ 0x001a3e71
LEA RSI,[0x1ba9a7]
MOV RDI,RBX
CALL 0x001a8f90
MOV qword ptr [RSP + 0x58],RAX
LEA RSI,[0x1b35c5]
MOV RDI,RBX
CALL 0x0017b702
MOV R13,RAX
MOV R15,qword ptr [R14]
MOV qword ptr [RSP + 0x50],R14
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x80],RAX
LEA R14,[RSP + 0x60]
LEA RBP,[RSP + 0x30]
LAB_001a3cb9:
CMP R15,qword ptr [RSP + 0x80]
JZ 0x001a3d50
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,R15
CALL 0x00196d46
TEST AL,AL
JZ 0x001a3dfb
LEA RBX,[RSP + 0xe8]
MOV RDI,RBX
MOV RSI,R13
CALL 0x00168800
LEA R12,[RSP + 0xc8]
MOV RDI,R12
MOV RSI,R13
CALL 0x00168a6c
MOV RDI,R14
MOV RSI,R15
CALL 0x0015d522
LAB_001a3d0d:
MOV RDI,RBP
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R14
CALL 0x001a90e4
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R13
CALL 0x00168a6c
LAB_001a3d2e:
MOV RDI,RBP
MOV RSI,RBX
CALL 0x00168894
LAB_001a3d39:
MOV EBX,EAX
MOV RDI,R14
CALL 0x00142fee
TEST BL,BL
JNZ 0x001a3d85
ADD R15,0x20
JMP 0x001a3cb9
LAB_001a3d50:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00142a32
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RDX + 0x8]
SUB RCX,qword ptr [RDX]
SAR RCX,0x5
CMP RAX,RCX
JNZ 0x001a3ed5
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a3d85:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_001a3d90:
LEA RSI,[0x1ba974]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0013a250
LAB_001a3da6:
LEA RDX,[0x1ba9c9]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00138ff4
LAB_001a3dbc:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
MOV RDX,R15
CALL 0x0013b81a
MOV BPL,0x1
LAB_001a3dd1:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00123e50
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f20
LAB_001a3dfb:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_001a3e06:
LEA RSI,[0x1ba974]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0013a250
LAB_001a3e1c:
LEA RDX,[0x1ba9b2]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00138ff4
LAB_001a3e32:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
MOV RDX,R15
CALL 0x0013b81a
MOV BPL,0x1
LAB_001a3e47:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00123e50
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f20
LAB_001a3e71:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_001a3e7c:
LEA RSI,[0x1ba974]
LEA RDI,[RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0013a250
LAB_001a3e92:
LEA RDX,[0x1ba988]
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
CALL 0x00138ff4
MOV BPL,0x1
LAB_001a3eab:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00123e50
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f20
LAB_001a3ed5:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R15,RAX
LAB_001a3ee0:
LEA RSI,[0x1ba974]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0013a250
LAB_001a3ef6:
LEA RDX,[0x1ba9f2]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00138ff4
LAB_001a3f0c:
LEA RSI,[0x1b34c3]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x7]
CALL 0x00127c44
LAB_001a3f25:
LEA RDI,[RSP + 0xa8]
LEA RDX,[RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x00154736
LAB_001a3f3f:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0xa8]
CALL 0x0013a083
MOV BPL,0x1
LAB_001a3f59:
LEA RSI,[RSP + 0x30]
MOV RDI,R15
CALL 0x00123e50
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R15
CALL 0x00123f20
|
/* expect_tool_parameters(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&, std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&) */
void expect_tool_parameters(string *param_1,basic_json *param_2,vector *param_3)
{
char cVar1;
basic_json *pbVar2;
long lVar3;
runtime_error *prVar4;
string *psVar5;
allocator local_131;
string *local_130;
string local_128 [32];
string local_108 [32];
vector *local_e8;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_e0;
data local_d8 [32];
string *local_b8;
string local_b0 [32];
vector local_90 [32];
int1 local_70 [32];
int1 local_50 [32];
local_130 = param_1;
if (*param_2 == '\x01') {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,"type");
if (cVar1 != '\0') {
pbVar2 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_2,"type");
cVar1 = _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(pbVar2,"object");
if (cVar1 == '\0') {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,"properties");
if (cVar1 != '\0') {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,"required");
if (cVar1 != '\0') {
local_e0 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(param_2,"properties");
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(param_2,"required");
psVar5 = *(string **)param_3;
local_b8 = *(string **)(param_3 + 8);
local_e8 = param_3;
while( true ) {
if (psVar5 == local_b8) {
lVar3 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::size(local_e0);
if (lVar3 == *(long *)(local_e8 + 8) - *(long *)local_e8 >> 5) {
return;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a3ee0 to 001a3ef5 has its CatchHandler @ 001a3fe3 */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 001a3ef6 to 001a3f0b has its CatchHandler @ 001a3fc9 */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 001a3f0c to 001a3f24 has its CatchHandler @ 001a3fb7 */
std::__cxx11::string::string<std::allocator<char>>(local_b0,", ",&local_131);
/* try { // try from 001a3f25 to 001a3f3e has its CatchHandler @ 001a3fa2 */
string_join(local_90,(string *)local_e8);
/* try { // try from 001a3f3f to 001a3f55 has its CatchHandler @ 001a3f8d */
std::operator+(local_108,local_128);
/* try { // try from 001a3f59 to 001a3f7d has its CatchHandler @ 001a3f7e */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
cVar1 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::contains(local_e0,psVar5);
if (cVar1 == '\0') break;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cbegin();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
(local_d8,psVar5);
/* try { // try from 001a3d0d to 001a3d1d has its CatchHandler @ 001a4056 */
std::
find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_108,local_50,local_70,local_d8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
/* try { // try from 001a3d2e to 001a3d38 has its CatchHandler @ 001a4058 */
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(local_108,local_128);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_d8);
if (cVar1 != '\0') {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a3d90 to 001a3da5 has its CatchHandler @ 001a4049 */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 001a3da6 to 001a3dbb has its CatchHandler @ 001a4030 */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 001a3dbc to 001a3dcd has its CatchHandler @ 001a401c */
std::operator+(local_108,local_128);
/* try { // try from 001a3dd1 to 001a3df5 has its CatchHandler @ 001a400d */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
psVar5 = psVar5 + 0x20;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a3e06 to 001a3e1b has its CatchHandler @ 001a4047 */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 001a3e1c to 001a3e31 has its CatchHandler @ 001a402e */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 001a3e32 to 001a3e43 has its CatchHandler @ 001a400b */
std::operator+(local_108,local_128);
/* try { // try from 001a3e47 to 001a3e6b has its CatchHandler @ 001a4009 */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
}
}
}
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a3e7c to 001a3e91 has its CatchHandler @ 001a4007 */
std::operator+((char *)local_128,(string *)"Parameters of tool ");
/* try { // try from 001a3e92 to 001a3ea7 has its CatchHandler @ 001a3ffa */
std::operator+(local_108,(char *)local_128);
/* try { // try from 001a3eab to 001a3ecf has its CatchHandler @ 001a3feb */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.