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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
9,600 |
common_log::pause()
|
monkey531[P]llama/common/log.cpp
|
void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
}
|
O2
|
cpp
|
common_log::pause():
pushq %rbx
movq %rdi, %rbx
callq 0x8420c
cmpb $0x1, 0x6a(%rbx)
jne 0x83a1c
movb $0x0, 0x6a(%rbx)
movq 0x78(%rbx), %rdx
movq 0x98(%rbx), %rcx
imulq $0x30, %rcx, %rax
movb $0x1, 0x28(%rdx,%rax)
incq %rcx
movq 0x80(%rbx), %rax
subq %rdx, %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x98(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x213b0
movq %rbx, %rdi
callq 0x21560
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x21b60
movq %rbx, %rdi
popq %rbx
jmp 0x21560
nop
|
_ZN10common_log5pauseEv:
push rbx
mov rbx, rdi
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
cmp byte ptr [rbx+6Ah], 1
jnz short loc_83A1C
mov byte ptr [rbx+6Ah], 0
mov rdx, [rbx+78h]
mov rcx, [rbx+98h]
imul rax, rcx, 30h ; '0'
mov byte ptr [rdx+rax+28h], 1
inc rcx
mov rax, [rbx+80h]
sub rax, rdx
push 30h ; '0'
pop rsi
cqo
idiv rsi
mov rsi, rax
mov rax, rcx
xor edx, edx
div rsi
mov [rbx+98h], rdx
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov rdi, rbx
call _pthread_mutex_unlock
add rbx, 28h ; '('
mov rdi, rbx; this
pop rbx
jmp __ZNSt6thread4joinEv; std::thread::join(void)
loc_83A1C:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
|
long long common_log::pause(common_log *this)
{
long long v1; // rdx
long long v2; // rcx
std::mutex::lock(this);
if ( *((_BYTE *)this + 106) != 1 )
return pthread_mutex_unlock(this);
*((_BYTE *)this + 106) = 0;
v1 = *((_QWORD *)this + 15);
v2 = *((_QWORD *)this + 19);
*(_BYTE *)(v1 + 48 * v2 + 40) = 1;
*((_QWORD *)this + 19) = (v2 + 1) % (unsigned long long)((*((_QWORD *)this + 16) - v1) / 48);
std::condition_variable::notify_one((common_log *)((char *)this + 48));
pthread_mutex_unlock(this);
return std::thread::join((common_log *)((char *)this + 40));
}
|
pause:
PUSH RBX
MOV RBX,RDI
CALL 0x0018420c
CMP byte ptr [RBX + 0x6a],0x1
JNZ 0x00183a1c
MOV byte ptr [RBX + 0x6a],0x0
MOV RDX,qword ptr [RBX + 0x78]
MOV RCX,qword ptr [RBX + 0x98]
IMUL RAX,RCX,0x30
MOV byte ptr [RDX + RAX*0x1 + 0x28],0x1
INC RCX
MOV RAX,qword ptr [RBX + 0x80]
SUB RAX,RDX
PUSH 0x30
POP RSI
CQO
IDIV RSI
MOV RSI,RAX
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x98],RDX
LEA RDI,[RBX + 0x30]
CALL 0x001213b0
MOV RDI,RBX
CALL 0x00121560
ADD RBX,0x28
MOV RDI,RBX
POP RBX
JMP 0x00121b60
LAB_00183a1c:
MOV RDI,RBX
POP RBX
JMP 0x00121560
|
/* common_log::pause() */
void __thiscall common_log::pause(common_log *this)
{
long lVar1;
long lVar2;
std::mutex::lock((mutex *)this);
if (this[0x6a] == (common_log)0x1) {
this[0x6a] = (common_log)0x0;
lVar1 = *(long *)(this + 0x78);
lVar2 = *(long *)(this + 0x98);
*(int1 *)(lVar1 + 0x28 + lVar2 * 0x30) = 1;
*(ulong *)(this + 0x98) = (lVar2 + 1U) % (ulong)((*(long *)(this + 0x80) - lVar1) / 0x30);
std::condition_variable::notify_one();
pthread_mutex_unlock((pthread_mutex_t *)this);
std::thread::join();
return;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
|
|
9,601 |
common_log::pause()
|
monkey531[P]llama/common/log.cpp
|
void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
}
|
O3
|
cpp
|
common_log::pause():
pushq %rbx
movq %rdi, %rbx
callq 0x19a00
testl %eax, %eax
jne 0x9aeb1
cmpb $0x0, 0x6a(%rbx)
je 0x9aea8
movb $0x0, 0x6a(%rbx)
movq 0x78(%rbx), %rcx
movq 0x98(%rbx), %rax
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movb $0x1, 0x28(%rcx,%rdx)
incq %rax
movq 0x80(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x98(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x19380
movq %rbx, %rdi
callq 0x19540
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x19b60
movq %rbx, %rdi
popq %rbx
jmp 0x19540
movl %eax, %edi
callq 0x194a0
|
_ZN10common_log5pauseEv:
push rbx
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_9AEB1
cmp byte ptr [rbx+6Ah], 0
jz short loc_9AEA8
mov byte ptr [rbx+6Ah], 0
mov rcx, [rbx+78h]
mov rax, [rbx+98h]
lea rdx, [rax+rax*2]
shl rdx, 4
mov byte ptr [rcx+rdx+28h], 1
inc rax
mov rdx, [rbx+80h]
sub rdx, rcx
sar rdx, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rcx, rdx
xor edx, edx
div rcx
mov [rbx+98h], rdx
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov rdi, rbx
call _pthread_mutex_unlock
add rbx, 28h ; '('
mov rdi, rbx; this
pop rbx
jmp __ZNSt6thread4joinEv; std::thread::join(void)
loc_9AEA8:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
loc_9AEB1:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
|
long long common_log::pause(common_log *this)
{
int v1; // eax
long long v2; // rcx
long long v3; // rax
v1 = pthread_mutex_lock();
if ( v1 )
std::__throw_system_error(v1);
if ( !*((_BYTE *)this + 106) )
return pthread_mutex_unlock(this);
*((_BYTE *)this + 106) = 0;
v2 = *((_QWORD *)this + 15);
v3 = *((_QWORD *)this + 19);
*(_BYTE *)(v2 + 48 * v3 + 40) = 1;
*((_QWORD *)this + 19) = (v3 + 1) % (0xAAAAAAAAAAAAAAABLL * ((*((_QWORD *)this + 16) - v2) >> 4));
std::condition_variable::notify_one((common_log *)((char *)this + 48));
pthread_mutex_unlock(this);
return std::thread::join((common_log *)((char *)this + 40));
}
|
pause:
PUSH RBX
MOV RBX,RDI
CALL 0x00119a00
TEST EAX,EAX
JNZ 0x0019aeb1
CMP byte ptr [RBX + 0x6a],0x0
JZ 0x0019aea8
MOV byte ptr [RBX + 0x6a],0x0
MOV RCX,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RBX + 0x98]
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x4
MOV byte ptr [RCX + RDX*0x1 + 0x28],0x1
INC RAX
MOV RDX,qword ptr [RBX + 0x80]
SUB RDX,RCX
SAR RDX,0x4
MOV RCX,-0x5555555555555555
IMUL RCX,RDX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x98],RDX
LEA RDI,[RBX + 0x30]
CALL 0x00119380
MOV RDI,RBX
CALL 0x00119540
ADD RBX,0x28
MOV RDI,RBX
POP RBX
JMP 0x00119b60
LAB_0019aea8:
MOV RDI,RBX
POP RBX
JMP 0x00119540
LAB_0019aeb1:
MOV EDI,EAX
CALL 0x001194a0
|
/* common_log::pause() */
void __thiscall common_log::pause(common_log *this)
{
long lVar1;
long lVar2;
int iVar3;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
if (this[0x6a] != (common_log)0x0) {
this[0x6a] = (common_log)0x0;
lVar1 = *(long *)(this + 0x78);
lVar2 = *(long *)(this + 0x98);
*(int1 *)(lVar1 + 0x28 + lVar2 * 0x30) = 1;
*(ulong *)(this + 0x98) =
(lVar2 + 1U) % (ulong)((*(long *)(this + 0x80) - lVar1 >> 4) * -0x5555555555555555);
std::condition_variable::notify_one();
pthread_mutex_unlock((pthread_mutex_t *)this);
std::thread::join();
return;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
|
|
9,602 |
inline_mysql_file_read
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_read(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, 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_read(file, buffer, count, 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_read(file, buffer, count, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_read:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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 0x2131e0(%rip), %rax # 0x2bf098
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 0xabfc7
leaq 0x213196(%rip), %rax # 0x2bf098
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
callq 0xf3fb0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xabf72
cmpq $0x0, -0x38(%rbp)
jne 0xabf57
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xabf62
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xabf62
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xabf9f
cmpq $-0x1, -0x38(%rbp)
je 0xabf86
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xabf91
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xabf91
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x2130f2(%rip), %rax # 0x2bf098
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 0xabfe7
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xf3fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
inline_mysql_file_read_1:
push rbp
mov rbp, rsp
sub rsp, 0A0h
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_ABFC7
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]
call my_read
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_ABF72
cmp [rbp+var_38], 0
jnz short loc_ABF57
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_ABF62
loc_ABF57:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_ABF62:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_ABF9F
loc_ABF72:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_ABF86
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_ABF91
loc_ABF86:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_ABF91:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_ABF9F:
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_ABFE7
loc_ABFC7:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_read
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_ABFE7:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long inline_mysql_file_read_1(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // [rsp+0h] [rbp-A0h]
long long v8; // [rsp+8h] [rbp-98h]
_BYTE v9[72]; // [rsp+18h] [rbp-88h] BYREF
long long v10; // [rsp+60h] [rbp-40h]
long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+70h] [rbp-30h]
long long v13; // [rsp+78h] [rbp-28h]
long long v14; // [rsp+80h] [rbp-20h]
unsigned int v15; // [rsp+88h] [rbp-18h]
unsigned int v16; // [rsp+8Ch] [rbp-14h]
long long v17; // [rsp+90h] [rbp-10h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
v12 = a6;
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, a3, 6LL);
if ( v10 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v10, v13, v17, v16);
v11 = my_read(v15, v14, v13, v12);
if ( (v12 & 6) != 0 )
{
if ( v11 )
v8 = 0LL;
else
v8 = v13;
((void ( *)(long long, long long))PSI_server[67])(v10, v8);
}
else
{
if ( v11 == -1 )
v7 = 0LL;
else
v7 = v11;
((void ( *)(long long, long long))PSI_server[67])(v10, v7);
}
return v11;
}
else
{
return my_read(v15, v14, v13, v12);
}
}
|
inline_mysql_file_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
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,[0x3bf098]
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 0x001abfc7
LEA RAX,[0x3bf098]
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]
CALL 0x001f3fb0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001abf72
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001abf57
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001abf62
LAB_001abf57:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001abf62
LAB_001abf62:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001abf9f
LAB_001abf72:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001abf86
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001abf91
LAB_001abf86:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001abf91
LAB_001abf91:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001abf9f:
LEA RAX,[0x3bf098]
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 0x001abfe7
LAB_001abfc7:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f3fb0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001abfe7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_read
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,ulong param_6)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
ulong 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_read(local_20,local_28,local_30,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_read(local_20,local_28,local_30,local_38);
if ((local_38 & 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;
}
|
|
9,603 |
my_uni_utf16
|
eloqsql/strings/ctype-ucs2.c
|
int
my_uni_utf16(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (wc <= 0xFFFF)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (MY_UTF16_SURROGATE(wc))
return MY_CS_ILUNI;
*s++= (uchar) (wc >> 8);
*s= (uchar) (wc & 0xFF);
return 2;
}
if (wc <= 0x10FFFF)
{
if (s + 4 > e)
return MY_CS_TOOSMALL4;
*s++= (uchar) ((wc-= 0x10000) >> 18) | 0xD8;
*s++= (uchar) (wc >> 10) & 0xFF;
*s++= (uchar) ((wc >> 8) & 3) | 0xDC;
*s= (uchar) wc & 0xFF;
return 4;
}
return MY_CS_ILUNI;
}
|
O0
|
c
|
my_uni_utf16:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x6d49f
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6d448
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6d562
movq -0x18(%rbp), %rax
andq $0xf800, %rax # imm = 0xF800
cmpq $0xd800, %rax # imm = 0xD800
jne 0x6d466
movl $0x0, -0x4(%rbp)
jmp 0x6d562
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x6d562
cmpq $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
ja 0x6d55b
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6d4c7
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x6d562
movq -0x18(%rbp), %rax
subq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
shrq $0x12, %rax
movzbl %al, %eax
orl $0xd8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
andq $0x3, %rax
movzbl %al, %eax
orl $0xdc, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x6d562
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_uni_utf16:
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], 0FFFFh
ja short loc_6D49F
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6D448
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_6D562
loc_6D448:
mov rax, [rbp+var_18]
and rax, 0F800h
cmp rax, 0D800h
jnz short loc_6D466
mov [rbp+var_4], 0
jmp loc_6D562
loc_6D466:
mov rax, [rbp+var_18]
shr rax, 8
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
and rax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 2
jmp loc_6D562
loc_6D49F:
cmp [rbp+var_18], offset unk_10FFFF
ja loc_6D55B
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_6D4C7
mov [rbp+var_4], 0FFFFFF98h
jmp loc_6D562
loc_6D4C7:
mov rax, [rbp+var_18]
sub rax, offset stru_10000
mov [rbp+var_18], rax
shr rax, 12h
movzx eax, al
or eax, 0D8h
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 0Ah
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 8
and rax, 3
movzx eax, al
or eax, 0DCh
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_18]
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 4
jmp short loc_6D562
loc_6D55B:
mov [rbp+var_4], 0
loc_6D562:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_utf16(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( a2 > 0xFFFF )
{
if ( a2 > (unsigned long long)&unk_10FFFF )
{
return 0;
}
else if ( (unsigned long long)(a3 + 4) <= a4 )
{
*a3 = ((a2 - (unsigned long long)&stru_10000) >> 18) | 0xD8;
a3[1] = (a2 - (unsigned long long)&stru_10000) >> 10;
a3[2] = ((unsigned __int16)(a2 - (_QWORD)&stru_10000) >> 8) & 3 | 0xDC;
a3[3] = a2 - (_QWORD)&stru_10000;
return 4;
}
else
{
return (unsigned int)-104;
}
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( (a2 & 0xF800) == 0xD800 )
{
return 0;
}
else
{
*a3 = BYTE1(a2);
a3[1] = a2;
return 2;
}
}
else
{
return (unsigned int)-102;
}
}
|
my_uni_utf16:
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],0xffff
JA 0x0016d49f
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016d448
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016d562
LAB_0016d448:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0xf800
CMP RAX,0xd800
JNZ 0x0016d466
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016d562
LAB_0016d466:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0016d562
LAB_0016d49f:
CMP qword ptr [RBP + -0x18],0x10ffff
JA 0x0016d55b
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016d4c7
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x0016d562
LAB_0016d4c7:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
SHR RAX,0x12
MOVZX EAX,AL
OR EAX,0xd8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0xa
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
AND RAX,0x3
MOVZX EAX,AL
OR EAX,0xdc
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0016d562
LAB_0016d55b:
MOV dword ptr [RBP + -0x4],0x0
LAB_0016d562:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf16(int8 param_1,ulong param_2,byte *param_3,byte *param_4)
{
int4 local_c;
if (param_2 < 0x10000) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2 & 0xf800) == 0xd800) {
local_c = 0;
}
else {
*param_3 = (byte)(param_2 >> 8);
param_3[1] = (byte)param_2;
local_c = 2;
}
}
else if (param_2 < 0x110000) {
if (param_4 < param_3 + 4) {
local_c = 0xffffff98;
}
else {
param_2 = param_2 - 0x10000;
*param_3 = (byte)(param_2 >> 0x12) | 0xd8;
param_3[1] = (byte)(param_2 >> 10);
param_3[2] = (byte)(param_2 >> 8) & 3 | 0xdc;
param_3[3] = (byte)param_2;
local_c = 4;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
9,604 |
my_strxfrm_desc_and_reverse
|
eloqsql/strings/ctype-simple.c
|
void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
}
|
O3
|
c
|
my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movl %edx, %r8d
shrl %cl, %r8d
movl $0x10000, %eax # imm = 0x10000
shll %cl, %eax
btl $0x8, %r8d
jae 0x4266c
testl %edx, %eax
je 0x4269f
decq %rsi
cmpq %rdi, %rsi
jb 0x426ae
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
notb %cl
movb %cl, -0x1(%rdi)
notb %al
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jbe 0x4264d
jmp 0x426ae
testl %edx, %eax
setne %al
decq %rsi
cmpq %rdi, %rsi
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x426ae
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
movb %cl, -0x1(%rdi)
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jb 0x42684
jmp 0x426ae
cmpq %rsi, %rdi
jae 0x426ae
notb (%rdi)
incq %rdi
cmpq %rsi, %rdi
jne 0x426a4
popq %rbp
retq
|
my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov r8d, edx
shr r8d, cl
mov eax, offset stru_10000
shl eax, cl
bt r8d, 8
jnb short loc_4266C
test eax, edx
jz short loc_4269F
dec rsi
cmp rsi, rdi
jb short loc_426AE
inc rdi
loc_4264D:
mov al, [rdi-1]
mov cl, [rsi]
not cl
mov [rdi-1], cl
not al
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jbe short loc_4264D
jmp short loc_426AE
loc_4266C:
test eax, edx
setnz al
dec rsi
cmp rsi, rdi
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_426AE
inc rdi
loc_42684:
mov al, [rdi-1]
mov cl, [rsi]
mov [rdi-1], cl
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jb short loc_42684
jmp short loc_426AE
loc_4269F:
cmp rdi, rsi
jnb short loc_426AE
loc_426A4:
not byte ptr [rdi]
inc rdi
cmp rdi, rsi
jnz short loc_426A4
loc_426AE:
pop rbp
retn
|
char my_strxfrm_desc_and_reverse(_BYTE *a1, _BYTE *a2, unsigned int a3, char a4)
{
int v4; // eax
_BYTE *v5; // rsi
_BYTE *v6; // rdi
char v7; // al
_BYTE *v9; // rsi
_BYTE *v10; // rdi
char v11; // al
v4 = (_DWORD)&stru_10000 << a4;
if ( ((a3 >> a4) & 0x100) != 0 )
{
if ( (a3 & v4) != 0 )
{
v5 = a2 - 1;
if ( v5 >= a1 )
{
v6 = a1 + 1;
do
{
v7 = *(v6 - 1);
*(v6 - 1) = ~*v5;
*v5-- = ~v7;
LOBYTE(v4) = (_BYTE)v6 + 1;
}
while ( v6++ <= v5 );
}
}
else if ( a1 < a2 )
{
do
{
*a1 = ~*a1;
++a1;
}
while ( a1 != a2 );
}
}
else
{
LOBYTE(v4) = (a3 & v4) != 0;
v9 = a2 - 1;
if ( ((unsigned __int8)v4 & (v9 > a1)) == 1 )
{
v10 = a1 + 1;
do
{
v11 = *(v10 - 1);
*(v10 - 1) = *v9;
*v9-- = v11;
LOBYTE(v4) = (_BYTE)v10 + 1;
}
while ( v10++ < v9 );
}
}
return v4;
}
|
my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV R8D,EDX
SHR R8D,CL
MOV EAX,0x10000
SHL EAX,CL
BT R8D,0x8
JNC 0x0014266c
TEST EAX,EDX
JZ 0x0014269f
DEC RSI
CMP RSI,RDI
JC 0x001426ae
INC RDI
LAB_0014264d:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
NOT CL
MOV byte ptr [RDI + -0x1],CL
NOT AL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JBE 0x0014264d
JMP 0x001426ae
LAB_0014266c:
TEST EAX,EDX
SETNZ AL
DEC RSI
CMP RSI,RDI
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x001426ae
INC RDI
LAB_00142684:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
MOV byte ptr [RDI + -0x1],CL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JC 0x00142684
JMP 0x001426ae
LAB_0014269f:
CMP RDI,RSI
JNC 0x001426ae
LAB_001426a4:
NOT byte ptr [RDI]
INC RDI
CMP RDI,RSI
JNZ 0x001426a4
LAB_001426ae:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
bool bVar4;
uVar2 = 0x10000 << (param_4 & 0x1f);
if (((param_3 >> (param_4 & 0x1f)) >> 8 & 1) == 0) {
param_2 = param_2 + -1;
if (param_1 < param_2 && (uVar2 & param_3) != 0) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = *param_2;
*param_2 = bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 < param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
else if ((uVar2 & param_3) == 0) {
if (param_1 < param_2) {
do {
*param_1 = ~*param_1;
param_1 = param_1 + 1;
} while (param_1 != param_2);
}
}
else {
param_2 = param_2 + -1;
if (param_1 <= param_2) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = ~*param_2;
*param_2 = ~bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 <= param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
return;
}
|
|
9,605 |
my_strnxfrm_unicode_full_bin_internal
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strnxfrm_unicode_full_bin_internal(CHARSET_INFO *cs,
uchar *dst, uchar *de, uint *nweights,
const uchar *src, const uchar *se)
{
my_wc_t UNINIT_VAR(wc);
uchar *dst0= dst;
DBUG_ASSERT(src || !se);
DBUG_ASSERT(cs->state & MY_CS_BINSORT);
for (; dst < de && *nweights; (*nweights)--)
{
int res;
if ((res= my_ci_mb_wc(cs, &wc, src, se)) <= 0)
break;
src+= res;
*dst++= (uchar) (wc >> 16);
if (dst < de)
{
*dst++= (uchar) ((wc >> 8) & 0xFF);
if (dst < de)
*dst++= (uchar) (wc & 0xFF);
}
}
return dst - dst0;
}
|
O3
|
c
|
my_strnxfrm_unicode_full_bin_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x40(%rbp)
movq %rsi, %rax
movq %rsi, -0x38(%rbp)
cmpq %rdx, %rsi
jae 0x8fe49
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movl (%rcx), %ecx
movq -0x38(%rbp), %r14
testl %ecx, %ecx
je 0x8fe46
movq 0xb8(%rbx), %rax
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq -0x40(%rbp), %rcx
callq *0x28(%rax)
testl %eax, %eax
jle 0x8fe46
movl %eax, %ecx
movb -0x2e(%rbp), %dl
leaq 0x1(%r14), %rax
movb %dl, (%r14)
cmpq %r13, %rax
jae 0x8fe2d
movb -0x2f(%rbp), %dl
leaq 0x2(%r14), %rax
movb %dl, 0x1(%r14)
cmpq %r13, %rax
jae 0x8fe2d
movb -0x30(%rbp), %al
movb %al, 0x2(%r14)
addq $0x3, %r14
movq %r14, %rax
movl %ecx, %ecx
addq %rcx, %r15
movl (%r12), %ecx
decl %ecx
movl %ecx, (%r12)
movq %rax, %r14
cmpq %r13, %rax
jb 0x8fdde
jmp 0x8fe49
movq %r14, %rax
subq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_unicode_full_bin_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], r9
mov rax, rsi
mov [rbp+var_38], rsi
cmp rsi, rdx
jnb short loc_8FE49
mov r15, r8
mov r12, rcx
mov r13, rdx
mov rbx, rdi
mov ecx, [rcx]
mov r14, [rbp+var_38]
loc_8FDDE:
test ecx, ecx
jz short loc_8FE46
mov rax, [rbx+0B8h]
mov rdi, rbx
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, [rbp+var_40]
call qword ptr [rax+28h]
test eax, eax
jle short loc_8FE46
mov ecx, eax
mov dl, [rbp+var_2E]
lea rax, [r14+1]
mov [r14], dl
cmp rax, r13
jnb short loc_8FE2D
mov dl, [rbp+var_2F]
lea rax, [r14+2]
mov [r14+1], dl
cmp rax, r13
jnb short loc_8FE2D
mov al, [rbp+var_30]
mov [r14+2], al
add r14, 3
mov rax, r14
loc_8FE2D:
mov ecx, ecx
add r15, rcx
mov ecx, [r12]
dec ecx
mov [r12], ecx
mov r14, rax
cmp rax, r13
jb short loc_8FDDE
jmp short loc_8FE49
loc_8FE46:
mov rax, r14
loc_8FE49:
sub rax, [rbp+var_38]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnxfrm_unicode_full_bin_internal(
long long a1,
_BYTE *a2,
unsigned long long a3,
int *a4,
long long a5,
long long a6)
{
_BYTE *v6; // rax
int v10; // ecx
_BYTE *v11; // r14
int v12; // eax
unsigned int v13; // ecx
_BYTE v16[48]; // [rsp+10h] [rbp-30h] BYREF
v6 = a2;
if ( (unsigned long long)a2 < a3 )
{
v10 = *a4;
v11 = a2;
while ( v10 )
{
v12 = (*(long long ( **)(long long, _BYTE *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v16,
a5,
a6);
if ( v12 <= 0 )
break;
v13 = v12;
v6 = v11 + 1;
*v11 = v16[2];
if ( (unsigned long long)(v11 + 1) < a3 )
{
v6 = v11 + 2;
v11[1] = v16[1];
if ( (unsigned long long)(v11 + 2) < a3 )
{
v11[2] = v16[0];
v6 = v11 + 3;
}
}
a5 += v13;
v10 = *a4 - 1;
*a4 = v10;
v11 = v6;
if ( (unsigned long long)v6 >= a3 )
return v6 - a2;
}
v6 = v11;
}
return v6 - a2;
}
|
my_strnxfrm_unicode_full_bin_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],R9
MOV RAX,RSI
MOV qword ptr [RBP + -0x38],RSI
CMP RSI,RDX
JNC 0x0018fe49
MOV R15,R8
MOV R12,RCX
MOV R13,RDX
MOV RBX,RDI
MOV ECX,dword ptr [RCX]
MOV R14,qword ptr [RBP + -0x38]
LAB_0018fdde:
TEST ECX,ECX
JZ 0x0018fe46
MOV RAX,qword ptr [RBX + 0xb8]
MOV RDI,RBX
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JLE 0x0018fe46
MOV ECX,EAX
MOV DL,byte ptr [RBP + -0x2e]
LEA RAX,[R14 + 0x1]
MOV byte ptr [R14],DL
CMP RAX,R13
JNC 0x0018fe2d
MOV DL,byte ptr [RBP + -0x2f]
LEA RAX,[R14 + 0x2]
MOV byte ptr [R14 + 0x1],DL
CMP RAX,R13
JNC 0x0018fe2d
MOV AL,byte ptr [RBP + -0x30]
MOV byte ptr [R14 + 0x2],AL
ADD R14,0x3
MOV RAX,R14
LAB_0018fe2d:
MOV ECX,ECX
ADD R15,RCX
MOV ECX,dword ptr [R12]
DEC ECX
MOV dword ptr [R12],ECX
MOV R14,RAX
CMP RAX,R13
JC 0x0018fdde
JMP 0x0018fe49
LAB_0018fe46:
MOV RAX,R14
LAB_0018fe49:
SUB RAX,qword ptr [RBP + -0x38]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin_internal
(long param_1,int1 *param_2,int1 *param_3,int *param_4,long param_5,
int8 param_6)
{
uint uVar1;
int iVar2;
int1 *puVar3;
int1 *puVar4;
int1 local_38;
int1 local_37;
int1 local_36;
puVar4 = param_2;
if (param_2 < param_3) {
iVar2 = *param_4;
puVar3 = param_2;
do {
puVar4 = puVar3;
if ((iVar2 == 0) ||
(uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_38,param_5,param_6)
, (int)uVar1 < 1)) break;
puVar4 = puVar3 + 1;
*puVar3 = local_36;
if (puVar4 < param_3) {
puVar4 = puVar3 + 2;
puVar3[1] = local_37;
if (puVar4 < param_3) {
puVar3[2] = local_38;
puVar4 = puVar3 + 3;
}
}
param_5 = param_5 + (ulong)uVar1;
iVar2 = *param_4 + -1;
*param_4 = iVar2;
puVar3 = puVar4;
} while (puVar4 < param_3);
}
return (long)puVar4 - (long)param_2;
}
|
|
9,606 |
myisam_log_record
|
eloqsql/storage/myisam/mi_log.c
|
void _myisam_log_record(enum myisam_log_commands command, MI_INFO *info,
const uchar *record, my_off_t filepos, int result)
{
uchar buff[21],*pos;
int error,old_errno;
uint length;
ulong pid=(ulong) GETPID();
old_errno=my_errno;
if (!info->s->base.blobs)
length=info->s->base.reclength;
else
length=info->s->base.reclength+ _mi_calc_total_blob_length(info,record);
buff[0]=(uchar) command;
mi_int2store(buff+1,info->dfile);
mi_int4store(buff+3,pid);
mi_int2store(buff+7,result);
mi_sizestore(buff+9,filepos);
mi_int4store(buff+17,length);
mysql_mutex_lock(&THR_LOCK_myisam);
error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
(void) mysql_file_write(myisam_log_file, buff, sizeof(buff), MYF(0));
(void) mysql_file_write(myisam_log_file, record, info->s->base.reclength, MYF(0));
if (info->s->base.blobs)
{
MI_BLOB *blob,*end;
for (end=info->blobs+info->s->base.blobs, blob= info->blobs;
blob != end ;
blob++)
{
memcpy(&pos, record+blob->offset+blob->pack_length,
sizeof(char*));
(void) mysql_file_write(myisam_log_file, pos, blob->length, MYF(0));
}
}
if (!error)
error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
mysql_mutex_unlock(&THR_LOCK_myisam);
my_errno=old_errno;
}
|
O0
|
c
|
myisam_log_record:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x24(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movl %r8d, -0x44(%rbp)
cmpl $0x1, 0xbc8556(%rip) # 0xc7a608
jne 0xb20c4
movq 0xbc8545(%rip), %rax # 0xc7a600
movq %rax, -0xc0(%rbp)
jmp 0xb20d0
callq 0xf6690
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0xf6090
movl (%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
jne 0xb2108
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rax
movl %eax, -0x5c(%rbp)
jmp 0xb213a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa88a0
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x5c(%rbp)
movl -0x24(%rbp), %eax
movb %al, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl 0x1c0(%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movb %al, -0x1e(%rbp)
movl -0x6c(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x1f(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb %al, -0x1a(%rbp)
movq -0x78(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x1b(%rbp)
movq -0x78(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x1c(%rbp)
movq -0x78(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x1d(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movb %al, -0x18(%rbp)
movl -0x7c(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x19(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x40(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movb %al, -0x14(%rbp)
movq -0x98(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x15(%rbp)
movq -0x98(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x16(%rbp)
movq -0x98(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x17(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movb %al, -0x10(%rbp)
movq -0xa0(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x11(%rbp)
movq -0xa0(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x12(%rbp)
movq -0xa0(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x13(%rbp)
movl -0x5c(%rbp), %eax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movb %al, -0xc(%rbp)
movq -0xa8(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xd(%rbp)
movq -0xa8(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xe(%rbp)
movq -0xa8(%rbp), %rax
shrq $0x18, %rax
movb %al, -0xf(%rbp)
leaq 0xbd113c(%rip), %rdi # 0xc833c0
leaq 0xa18a5(%rip), %rsi # 0x153b30
movl $0x88, %edx
callq 0xb1c80
leaq 0x20cf14(%rip), %rax # 0x2bf1b0
movl (%rax), %edi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %r8d
movq %rcx, %rdx
callq 0xf3500
movl %eax, -0x54(%rbp)
leaq 0x20cef1(%rip), %rax # 0x2bf1b0
movl (%rax), %edx
leaq -0x20(%rbp), %rcx
leaq 0xa1864(%rip), %rdi # 0x153b30
movl $0x8a, %esi
movl $0x15, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xb1cf0
leaq 0x20cec8(%rip), %rax # 0x2bf1b0
movl (%rax), %edx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %r8
leaq 0xa182d(%rip), %rdi # 0x153b30
movl $0x8b, %esi
xorl %eax, %eax
movl %eax, %r9d
callq 0xb1cf0
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xb23cc
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movl 0x188(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xb8(%rbp), %rax
je 0xb23ca
movq -0x38(%rbp), %rax
movq -0xb0(%rbp), %rcx
addq (%rcx), %rax
movq -0xb0(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x50(%rbp)
leaq 0x20ce21(%rip), %rax # 0x2bf1b0
movl (%rax), %edx
movq -0x50(%rbp), %rcx
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0xa1789(%rip), %rdi # 0x153b30
movl $0x96, %esi
xorl %eax, %eax
movl %eax, %r9d
callq 0xb1cf0
movq -0xb0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb0(%rbp)
jmp 0xb2358
jmp 0xb23cc
cmpl $0x0, -0x54(%rbp)
jne 0xb23f5
leaq 0x20cdd7(%rip), %rax # 0x2bf1b0
movl (%rax), %edi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %r8d
movq %rcx, %rdx
callq 0xf3500
movl %eax, -0x54(%rbp)
leaq 0xbd0fc4(%rip), %rdi # 0xc833c0
callq 0xb1e60
movl -0x58(%rbp), %eax
movl %eax, -0xcc(%rbp)
callq 0xf6090
movl -0xcc(%rbp), %ecx
movl %ecx, (%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb2432
addq $0xd0, %rsp
popq %rbp
retq
callq 0x2a270
nopw (%rax,%rax)
|
_myisam_log_record:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_40], rcx
mov [rbp+var_44], r8d
cmp cs:log_type, 1
jnz short loc_B20C4
mov rax, cs:myisam_pid
mov [rbp+var_C0], rax
jmp short loc_B20D0
loc_B20C4:
call my_thread_dbug_id
mov [rbp+var_C0], rax
loc_B20D0:
mov rax, [rbp+var_C0]
mov [rbp+var_68], rax
call _my_thread_var
mov eax, [rax]
mov [rbp+var_58], eax
mov rax, [rbp+var_30]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jnz short loc_B2108
mov rax, [rbp+var_30]
mov rax, [rax]
mov rax, [rax+140h]
mov [rbp+var_5C], eax
jmp short loc_B213A
loc_B2108:
mov rax, [rbp+var_30]
mov rax, [rax]
mov rax, [rax+140h]
mov [rbp+var_C8], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
call _mi_calc_total_blob_length
mov rcx, rax
mov rax, [rbp+var_C8]
add rax, rcx
mov [rbp+var_5C], eax
loc_B213A:
mov eax, [rbp+var_24]
mov [rbp+var_20], al
mov rax, [rbp+var_30]
mov eax, [rax+1C0h]
mov [rbp+var_6C], eax
mov eax, [rbp+var_6C]
mov [rbp+var_1E], al
mov eax, [rbp+var_6C]
shr eax, 8
mov [rbp+var_1F], al
mov rax, [rbp+var_68]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_1A], al
mov rax, [rbp+var_78]
shr rax, 8
mov [rbp+var_1B], al
mov rax, [rbp+var_78]
shr rax, 10h
mov [rbp+var_1C], al
mov rax, [rbp+var_78]
shr rax, 18h
mov [rbp+var_1D], al
mov eax, [rbp+var_44]
mov [rbp+var_7C], eax
mov eax, [rbp+var_7C]
mov [rbp+var_18], al
mov eax, [rbp+var_7C]
shr eax, 8
mov [rbp+var_19], al
mov rax, [rbp+var_40]
mov [rbp+var_88], rax
mov rax, [rbp+var_40]
shr rax, 20h
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
mov [rbp+var_14], al
mov rax, [rbp+var_98]
shr rax, 8
mov [rbp+var_15], al
mov rax, [rbp+var_98]
shr rax, 10h
mov [rbp+var_16], al
mov rax, [rbp+var_98]
shr rax, 18h
mov [rbp+var_17], al
mov rax, [rbp+var_88]
mov [rbp+var_A0], rax
mov rax, [rbp+var_A0]
mov [rbp+var_10], al
mov rax, [rbp+var_A0]
shr rax, 8
mov [rbp+var_11], al
mov rax, [rbp+var_A0]
shr rax, 10h
mov [rbp+var_12], al
mov rax, [rbp+var_A0]
shr rax, 18h
mov [rbp+var_13], al
mov eax, [rbp+var_5C]
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
mov [rbp+var_C], al
mov rax, [rbp+var_A8]
shr rax, 8
mov [rbp+var_D], al
mov rax, [rbp+var_A8]
shr rax, 10h
mov [rbp+var_E], al
mov rax, [rbp+var_A8]
shr rax, 18h
mov [rbp+var_F], al
lea rdi, THR_LOCK_myisam
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 88h
call inline_mysql_mutex_lock_18
lea rax, myisam_log_file
mov edi, [rax]
mov esi, 1
xor eax, eax
mov ecx, eax
mov r8d, 20h ; ' '
mov rdx, rcx
call my_lock
mov [rbp+var_54], eax
lea rax, myisam_log_file
mov edx, [rax]
lea rcx, [rbp+var_20]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 8Ah
mov r8d, 15h
xor eax, eax
mov r9d, eax
call inline_mysql_file_write_1
lea rax, myisam_log_file
mov edx, [rax]
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov rax, [rax]
mov r8, [rax+140h]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 8Bh
xor eax, eax
mov r9d, eax
call inline_mysql_file_write_1
mov rax, [rbp+var_30]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz loc_B23CC
mov rax, [rbp+var_30]
mov rax, [rax+48h]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
mov ecx, [rcx+188h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_B8], rax
mov rax, [rbp+var_30]
mov rax, [rax+48h]
mov [rbp+var_B0], rax
loc_B2358:
mov rax, [rbp+var_B0]
cmp rax, [rbp+var_B8]
jz short loc_B23CA
mov rax, [rbp+var_38]
mov rcx, [rbp+var_B0]
add rax, [rcx]
mov rcx, [rbp+var_B0]
mov ecx, [rcx+8]
mov rax, [rax+rcx]
mov [rbp+var_50], rax
lea rax, myisam_log_file
mov edx, [rax]
mov rcx, [rbp+var_50]
mov rax, [rbp+var_B0]
mov r8, [rax+10h]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 96h
xor eax, eax
mov r9d, eax
call inline_mysql_file_write_1
mov rax, [rbp+var_B0]
add rax, 18h
mov [rbp+var_B0], rax
jmp short loc_B2358
loc_B23CA:
jmp short $+2
loc_B23CC:
cmp [rbp+var_54], 0
jnz short loc_B23F5
lea rax, myisam_log_file
mov edi, [rax]
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 20h ; ' '
mov rdx, rcx
call my_lock
mov [rbp+var_54], eax
loc_B23F5:
lea rdi, THR_LOCK_myisam
call inline_mysql_mutex_unlock_19
mov eax, [rbp+var_58]
mov [rbp+var_CC], eax
call _my_thread_var
mov ecx, [rbp+var_CC]
mov [rax], ecx
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B2432
add rsp, 0D0h
pop rbp
retn
loc_B2432:
call ___stack_chk_fail
|
unsigned long long myisam_log_record(long long a1, long long a2, long long a3, long long a4, __int16 a5)
{
__int16 v5; // kr00_2
const char *v6; // rsi
long long v8; // [rsp+8h] [rbp-C8h]
int v9; // [rsp+10h] [rbp-C0h]
long long v10; // [rsp+18h] [rbp-B8h]
long long i; // [rsp+20h] [rbp-B0h]
int v12; // [rsp+74h] [rbp-5Ch]
int v13; // [rsp+78h] [rbp-58h]
int v14; // [rsp+7Ch] [rbp-54h]
_BYTE v19[24]; // [rsp+B0h] [rbp-20h] BYREF
unsigned long long v20; // [rsp+C8h] [rbp-8h]
v20 = __readfsqword(0x28u);
if ( log_type == 1 )
v9 = myisam_pid;
else
v9 = my_thread_dbug_id();
v13 = *(_DWORD *)my_thread_var(a1, (const char *)a2);
if ( *(_DWORD *)(*(_QWORD *)a2 + 392LL) )
{
v8 = *(_QWORD *)(*(_QWORD *)a2 + 320LL);
v12 = mi_calc_total_blob_length((_QWORD *)a2, a3) + v8;
}
else
{
v12 = *(_QWORD *)(*(_QWORD *)a2 + 320LL);
}
v19[0] = a1;
v5 = *(_DWORD *)(a2 + 448);
v19[1] = HIBYTE(v5);
v19[2] = v5;
v19[5] = BYTE1(v9);
v19[6] = v9;
v19[3] = HIBYTE(v9);
v19[4] = BYTE2(v9);
v19[7] = HIBYTE(a5);
v19[8] = a5;
v19[11] = BYTE5(a4);
v19[12] = BYTE4(a4);
v19[9] = HIBYTE(a4);
v19[10] = BYTE6(a4);
v19[15] = BYTE1(a4);
v19[16] = a4;
v19[13] = BYTE3(a4);
v19[14] = BYTE2(a4);
v19[19] = BYTE1(v12);
v19[20] = v12;
v19[17] = HIBYTE(v12);
v19[18] = BYTE2(v12);
inline_mysql_mutex_lock_18(
(long long)&THR_LOCK_myisam,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x88u);
v14 = my_lock(myisam_log_file, 1LL, 0LL, 0LL, 32LL);
inline_mysql_file_write_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x8Au,
myisam_log_file,
(long long)v19,
21LL,
0LL);
v6 = (_BYTE *)(off_88 + 3);
inline_mysql_file_write_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x8Bu,
myisam_log_file,
a3,
*(_QWORD *)(*(_QWORD *)a2 + 320LL),
0LL);
if ( *(_DWORD *)(*(_QWORD *)a2 + 392LL) )
{
v10 = 24LL * *(unsigned int *)(*(_QWORD *)a2 + 392LL) + *(_QWORD *)(a2 + 72);
for ( i = *(_QWORD *)(a2 + 72); i != v10; i += 24LL )
{
v6 = (_BYTE *)(&qword_90 + 6);
inline_mysql_file_write_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
0x96u,
myisam_log_file,
*(_QWORD *)(*(_QWORD *)i + a3 + *(unsigned int *)(i + 8)),
*(_QWORD *)(i + 16),
0LL);
}
}
if ( !v14 )
{
v6 = (_BYTE *)(&dword_0 + 2);
my_lock(myisam_log_file, 2LL, 0LL, 0LL, 32LL);
}
inline_mysql_mutex_unlock_19((long long)&THR_LOCK_myisam);
*(_DWORD *)my_thread_var(&THR_LOCK_myisam, v6) = v13;
return __readfsqword(0x28u);
}
|
_myisam_log_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RBP + -0x44],R8D
CMP dword ptr [0x00d7a608],0x1
JNZ 0x001b20c4
MOV RAX,qword ptr [0x00d7a600]
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x001b20d0
LAB_001b20c4:
CALL 0x001f6690
MOV qword ptr [RBP + -0xc0],RAX
LAB_001b20d0:
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x68],RAX
CALL 0x001f6090
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JNZ 0x001b2108
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x140]
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x001b213a
LAB_001b2108:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0xc8],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001a88a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0xc8]
ADD RAX,RCX
MOV dword ptr [RBP + -0x5c],EAX
LAB_001b213a:
MOV EAX,dword ptr [RBP + -0x24]
MOV byte ptr [RBP + -0x20],AL
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x1c0]
MOV dword ptr [RBP + -0x6c],EAX
MOV EAX,dword ptr [RBP + -0x6c]
MOV byte ptr [RBP + -0x1e],AL
MOV EAX,dword ptr [RBP + -0x6c]
SHR EAX,0x8
MOV byte ptr [RBP + -0x1f],AL
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RBP + -0x1a],AL
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x8
MOV byte ptr [RBP + -0x1b],AL
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x10
MOV byte ptr [RBP + -0x1c],AL
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x18
MOV byte ptr [RBP + -0x1d],AL
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x7c],EAX
MOV EAX,dword ptr [RBP + -0x7c]
MOV byte ptr [RBP + -0x18],AL
MOV EAX,dword ptr [RBP + -0x7c]
SHR EAX,0x8
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x40]
SHR RAX,0x20
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV byte ptr [RBP + -0x14],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x8
MOV byte ptr [RBP + -0x15],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x10
MOV byte ptr [RBP + -0x16],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x18
MOV byte ptr [RBP + -0x17],AL
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0xa0]
SHR RAX,0x8
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0xa0]
SHR RAX,0x10
MOV byte ptr [RBP + -0x12],AL
MOV RAX,qword ptr [RBP + -0xa0]
SHR RAX,0x18
MOV byte ptr [RBP + -0x13],AL
MOV EAX,dword ptr [RBP + -0x5c]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0xa8]
SHR RAX,0x8
MOV byte ptr [RBP + -0xd],AL
MOV RAX,qword ptr [RBP + -0xa8]
SHR RAX,0x10
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0xa8]
SHR RAX,0x18
MOV byte ptr [RBP + -0xf],AL
LEA RDI,[0xd833c0]
LEA RSI,[0x253b30]
MOV EDX,0x88
CALL 0x001b1c80
LEA RAX,[0x3bf1b0]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x20
MOV RDX,RCX
CALL 0x001f3500
MOV dword ptr [RBP + -0x54],EAX
LEA RAX,[0x3bf1b0]
MOV EDX,dword ptr [RAX]
LEA RCX,[RBP + -0x20]
LEA RDI,[0x253b30]
MOV ESI,0x8a
MOV R8D,0x15
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001b1cf0
LEA RAX,[0x3bf1b0]
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x140]
LEA RDI,[0x253b30]
MOV ESI,0x8b
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001b1cf0
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001b23cc
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x188]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0xb0],RAX
LAB_001b2358:
MOV RAX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RBP + -0xb8]
JZ 0x001b23ca
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0xb0]
ADD RAX,qword ptr [RCX]
MOV RCX,qword ptr [RBP + -0xb0]
MOV ECX,dword ptr [RCX + 0x8]
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0x3bf1b0]
MOV EDX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0xb0]
MOV R8,qword ptr [RAX + 0x10]
LEA RDI,[0x253b30]
MOV ESI,0x96
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001b1cf0
MOV RAX,qword ptr [RBP + -0xb0]
ADD RAX,0x18
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001b2358
LAB_001b23ca:
JMP 0x001b23cc
LAB_001b23cc:
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x001b23f5
LEA RAX,[0x3bf1b0]
MOV EDI,dword ptr [RAX]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x20
MOV RDX,RCX
CALL 0x001f3500
MOV dword ptr [RBP + -0x54],EAX
LAB_001b23f5:
LEA RDI,[0xd833c0]
CALL 0x001b1e60
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0xcc],EAX
CALL 0x001f6090
MOV ECX,dword ptr [RBP + -0xcc]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b2432
ADD RSP,0xd0
POP RBP
RET
LAB_001b2432:
CALL 0x0012a270
|
void _myisam_log_record(int1 param_1,long *param_2,long param_3,int8 param_4,
int4 param_5)
{
int4 uVar1;
uint uVar2;
int8 uVar3;
long lVar4;
int iVar5;
int4 *puVar6;
long in_FS_OFFSET;
int4 local_c8;
long *local_b8;
int local_64;
int1 local_28;
int1 local_27;
int1 local_26;
int1 local_25;
int1 local_24;
int1 local_23;
int1 local_22;
int1 local_21;
int1 local_20;
int1 local_1f;
int1 local_1e;
int1 local_1d;
int1 local_1c;
int1 local_1b;
int1 local_1a;
int1 local_19;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (log_type == 1) {
local_c8 = (int4)myisam_pid;
}
else {
local_c8 = my_thread_dbug_id();
}
puVar6 = (int4 *)_my_thread_var();
uVar1 = *puVar6;
if (*(int *)(*param_2 + 0x188) == 0) {
local_64 = (int)*(int8 *)(*param_2 + 0x140);
}
else {
uVar3 = *(int8 *)(*param_2 + 0x140);
local_64 = _mi_calc_total_blob_length(param_2,param_3);
local_64 = (int)uVar3 + local_64;
}
local_26 = (int1)(int)param_2[0x38];
local_27 = (int1)((uint)(int)param_2[0x38] >> 8);
local_22 = (int1)local_c8;
local_23 = (int1)((uint)local_c8 >> 8);
local_24 = (int1)((uint)local_c8 >> 0x10);
local_25 = (int1)((uint)local_c8 >> 0x18);
local_20 = (int1)param_5;
local_21 = (int1)((uint)param_5 >> 8);
local_1c = (int1)((ulong)param_4 >> 0x20);
local_1d = (int1)((ulong)param_4 >> 0x28);
local_1e = (int1)((ulong)param_4 >> 0x30);
local_1f = (int1)((ulong)param_4 >> 0x38);
local_18 = (int1)param_4;
local_19 = (int1)((ulong)param_4 >> 8);
local_1a = (int1)((ulong)param_4 >> 0x10);
local_1b = (int1)((ulong)param_4 >> 0x18);
local_14 = (int1)local_64;
local_15 = (int1)((uint)local_64 >> 8);
local_16 = (int1)((uint)local_64 >> 0x10);
local_17 = (int1)((uint)local_64 >> 0x18);
local_28 = param_1;
inline_mysql_mutex_lock
(THR_LOCK_myisam,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x88
);
iVar5 = my_lock(myisam_log_file,1,0,0,0x20);
inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x8a,myisam_log_file
,&local_28,0x15,0);
inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x8b,myisam_log_file
,param_3,*(int8 *)(*param_2 + 0x140),0);
if (*(int *)(*param_2 + 0x188) != 0) {
lVar4 = param_2[9];
uVar2 = *(uint *)(*param_2 + 0x188);
for (local_b8 = (long *)param_2[9]; local_b8 != (long *)(lVar4 + (ulong)uVar2 * 0x18);
local_b8 = local_b8 + 3) {
inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x96,
myisam_log_file,
*(int8 *)(param_3 + *local_b8 + (ulong)*(uint *)(local_b8 + 1)),local_b8[2],0
);
}
}
if (iVar5 == 0) {
my_lock(myisam_log_file,2,0,0,0x20);
}
inline_mysql_mutex_unlock(THR_LOCK_myisam);
puVar6 = (int4 *)_my_thread_var();
*puVar6 = uVar1;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
9,607 |
alloc_root
|
eloqsql/mysys/my_alloc.c
|
void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, length,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->left= 0;
next->size= length;
mem_root->used= next;
DBUG_PRINT("exit",("ptr: %p", (((char*)next)+ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((((uchar*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
/* Avoid reusing an already allocated block */
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length= ALIGN_SIZE(length) + REDZONE_SIZE;
if ((*(prev= &mem_root->free)) != NULL)
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
block_size= (mem_root->block_size & ~1) * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= MY_MAX(get_size, block_size);
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, get_size,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->
block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
TRASH_MEM(next);
}
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
point+= REDZONE_SIZE;
TRASH_ALLOC(point, original_length);
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN((void*) point);
#endif
}
|
O0
|
c
|
alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3b432
jmp 0x3b434
jmp 0x3b436
jmp 0x3b438
jmp 0x3b43a
movq -0x18(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq $0x0, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
je 0x3b522
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x3b4d9
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x2c(%rcx)
cmpl $0xa, %eax
jb 0x3b4d9
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq $0x1000, 0x8(%rax) # imm = 0x1000
jae 0x3b4d9
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x49(%rbp)
je 0x3b502
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3b50b
jmp 0x3b520
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3b4e4
jmp 0x3b522
cmpq $0x0, -0x38(%rbp)
jne 0x3b625
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $-0x2, %rax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x3b56d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x3b575
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
andq $0x1, %rdx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpq $0x0, %rdx
cmovnel %ecx, %eax
orl $0x1010, %eax # imm = 0x1010
movl %eax, %eax
movl %eax, %edx
callq 0x2e060
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x3b5db
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3b5cc
movq -0x10(%rbp), %rax
callq *0x30(%rax)
jmp 0x3b5ce
movq $0x0, -0x8(%rbp)
jmp 0x3b6ad
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3b61f
jmp 0x3b621
jmp 0x3b623
jmp 0x3b625
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x38(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x3b691
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3b69b
jmp 0x3b69d
jmp 0x3b69f
jmp 0x3b6a1
jmp 0x3b6a3
jmp 0x3b6a5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
alloc_root:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_38], 0
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
jmp short $+2
loc_3B432:
jmp short $+2
loc_3B434:
jmp short $+2
loc_3B436:
jmp short $+2
loc_3B438:
jmp short $+2
loc_3B43A:
mov rax, [rbp+var_18]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, 0
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
cmp qword ptr [rax], 0
jz loc_3B522
mov rax, [rbp+var_40]
mov rax, [rax]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnb short loc_3B4D9
mov rcx, [rbp+var_10]
mov eax, [rcx+2Ch]
mov edx, eax
add edx, 1
mov [rcx+2Ch], edx
cmp eax, 0Ah
jb short loc_3B4D9
mov rax, [rbp+var_40]
mov rax, [rax]
cmp qword ptr [rax+8], 1000h
jnb short loc_3B4D9
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_3B4D9:
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rbp+var_38], rax
loc_3B4E4:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_49], al
jz short loc_3B502
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
setb al
mov [rbp+var_49], al
loc_3B502:
mov al, [rbp+var_49]
test al, 1
jnz short loc_3B50B
jmp short loc_3B520
loc_3B50B:
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_3B4E4
loc_3B520:
jmp short $+2
loc_3B522:
cmp [rbp+var_38], 0
jnz loc_3B625
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 0FFFFFFFFFFFFFFFEh
mov rcx, [rbp+var_10]
mov ecx, [rcx+28h]
shr ecx, 2
mov ecx, ecx
imul rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jbe short loc_3B56D
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
jmp short loc_3B575
loc_3B56D:
mov rax, [rbp+var_28]
mov [rbp+var_58], rax
loc_3B575:
mov rax, [rbp+var_58]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov edi, [rax+38h]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
and rdx, 1
xor eax, eax
mov ecx, offset stru_10000
cmp rdx, 0
cmovnz eax, ecx
or eax, 1010h
mov eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_3B5DB
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 0
jz short loc_3B5CC
mov rax, [rbp+var_10]
call qword ptr [rax+30h]
loc_3B5CC:
jmp short $+2
loc_3B5CE:
mov [rbp+var_8], 0
jmp loc_3B6AD
loc_3B5DB:
mov rax, [rbp+var_10]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_40]
mov rcx, [rax]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax], rcx
jmp short $+2
loc_3B61F:
jmp short $+2
loc_3B621:
jmp short $+2
loc_3B623:
jmp short $+2
loc_3B625:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_38]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_38]
mov rax, [rcx+8]
sub rax, rdx
mov [rcx+8], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jnb short loc_3B691
mov rax, [rbp+var_38]
mov rcx, [rax]
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
mov [rax], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+2Ch], 0
loc_3B691:
mov rax, [rbp+var_30]
mov [rbp+var_30], rax
jmp short $+2
loc_3B69B:
jmp short $+2
loc_3B69D:
jmp short $+2
loc_3B69F:
jmp short $+2
loc_3B6A1:
jmp short $+2
loc_3B6A3:
jmp short $+2
loc_3B6A5:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_3B6AD:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
char * alloc_root(_QWORD **a1, long long a2)
{
unsigned int v2; // eax
unsigned int v3; // edi
unsigned int v4; // eax
unsigned long long v5; // rax
unsigned long long v7; // [rsp+8h] [rbp-58h]
bool v8; // [rsp+17h] [rbp-49h]
_QWORD *v9; // [rsp+20h] [rbp-40h]
_QWORD *i; // [rsp+28h] [rbp-38h]
_QWORD *v11; // [rsp+28h] [rbp-38h]
char *v12; // [rsp+30h] [rbp-30h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
i = 0LL;
v13 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v9 = a1;
if ( *a1 )
{
if ( (*a1)[1] < v13 )
{
v2 = *((_DWORD *)a1 + 11);
*((_DWORD *)a1 + 11) = v2 + 1;
if ( v2 >= 0xA && (*a1)[1] < 0x1000uLL )
{
v11 = *a1;
*a1 = (_QWORD *)**a1;
*v11 = a1[1];
a1[1] = v11;
*((_DWORD *)a1 + 11) = 0;
}
}
for ( i = *a1; ; i = (_QWORD *)*i )
{
v8 = 0;
if ( i )
v8 = i[1] < v13;
if ( !v8 )
break;
v9 = i;
}
}
if ( !i )
{
if ( v13 + 24 <= (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL) )
v7 = (*((_DWORD *)a1 + 10) >> 2) * ((unsigned long long)a1[4] & 0xFFFFFFFFFFFFFFFELL);
else
v7 = v13 + 24;
v3 = *((_DWORD *)a1 + 14);
v4 = 0;
if ( ((unsigned long long)a1[4] & 1) != 0 )
v4 = (unsigned int)&stru_10000;
i = (_QWORD *)my_malloc(v3, v7, v4 | 0x1010);
if ( !i )
{
if ( a1[6] )
((void (*)(void))a1[6])();
return 0LL;
}
++*((_DWORD *)a1 + 10);
*i = *v9;
i[2] = v7;
i[1] = v7 - 24;
*v9 = i;
}
v12 = (char *)i + i[2] - i[1];
v5 = i[1] - v13;
i[1] = v5;
if ( v5 < (unsigned long long)a1[3] )
{
*v9 = *i;
*i = a1[1];
a1[1] = i;
*((_DWORD *)a1 + 11) = 0;
}
return v12;
}
|
alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0013b432
LAB_0013b432:
JMP 0x0013b434
LAB_0013b434:
JMP 0x0013b436
LAB_0013b436:
JMP 0x0013b438
LAB_0013b438:
JMP 0x0013b43a
LAB_0013b43a:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,0x0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RAX],0x0
JZ 0x0013b522
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x0013b4d9
MOV RCX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RCX + 0x2c]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x2c],EDX
CMP EAX,0xa
JC 0x0013b4d9
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x8],0x1000
JNC 0x0013b4d9
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2c],0x0
LAB_0013b4d9:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_0013b4e4:
XOR EAX,EAX
CMP qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x49],AL
JZ 0x0013b502
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
SETC AL
MOV byte ptr [RBP + -0x49],AL
LAB_0013b502:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x0013b50b
JMP 0x0013b520
LAB_0013b50b:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013b4e4
LAB_0013b520:
JMP 0x0013b522
LAB_0013b522:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0013b625
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,-0x2
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x28]
SHR ECX,0x2
MOV ECX,ECX
IMUL RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013b56d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0013b575
LAB_0013b56d:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
LAB_0013b575:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x38]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
AND RDX,0x1
XOR EAX,EAX
MOV ECX,0x10000
CMP RDX,0x0
CMOVNZ EAX,ECX
OR EAX,0x1010
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012e060
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x0013b5db
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x0013b5cc
MOV RAX,qword ptr [RBP + -0x10]
CALL qword ptr [RAX + 0x30]
LAB_0013b5cc:
JMP 0x0013b5ce
LAB_0013b5ce:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0013b6ad
LAB_0013b5db:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x28]
ADD ECX,0x1
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
JMP 0x0013b61f
LAB_0013b61f:
JMP 0x0013b621
LAB_0013b621:
JMP 0x0013b623
LAB_0013b623:
JMP 0x0013b625
LAB_0013b625:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
SUB RCX,qword ptr [RDX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,RDX
MOV qword ptr [RCX + 0x8],RAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x0013b691
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2c],0x0
LAB_0013b691:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0013b69b
LAB_0013b69b:
JMP 0x0013b69d
LAB_0013b69d:
JMP 0x0013b69f
LAB_0013b69f:
JMP 0x0013b6a1
LAB_0013b6a1:
JMP 0x0013b6a3
LAB_0013b6a3:
JMP 0x0013b6a5
LAB_0013b6a5:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013b6ad:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
long alloc_root(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
long lVar3;
long lVar4;
uint uVar5;
ulong uVar6;
bool bVar7;
ulong local_60;
long *local_48;
long *local_40;
local_40 = (long *)0x0;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
local_48 = param_1;
if (*param_1 != 0) {
if (((*(ulong *)(*param_1 + 8) < uVar6) &&
(uVar5 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar5 + 1,
9 < uVar5)) && (*(ulong *)(*param_1 + 8) < 0x1000)) {
plVar1 = (long *)*param_1;
*param_1 = *plVar1;
*plVar1 = param_1[1];
param_1[1] = (long)plVar1;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
local_40 = (long *)*param_1;
while( true ) {
bVar7 = false;
if (local_40 != (long *)0x0) {
bVar7 = (ulong)local_40[1] < uVar6;
}
if (!bVar7) break;
local_48 = local_40;
local_40 = (long *)*local_40;
}
}
if (local_40 == (long *)0x0) {
local_60 = (param_1[4] & 0xfffffffffffffffeU) * (ulong)(*(uint *)(param_1 + 5) >> 2);
if (local_60 < uVar6 + 0x18) {
local_60 = uVar6 + 0x18;
}
uVar5 = 0;
if ((param_1[4] & 1U) != 0) {
uVar5 = 0x10000;
}
local_40 = (long *)my_malloc((int)param_1[7],local_60,uVar5 | 0x1010);
if (local_40 == (long *)0x0) {
if (param_1[6] != 0) {
(*(code *)param_1[6])();
}
return 0;
}
*(int *)(param_1 + 5) = (int)param_1[5] + 1;
*local_40 = *local_48;
local_40[2] = local_60;
local_40[1] = local_60 - 0x18;
*local_48 = (long)local_40;
}
lVar2 = local_40[2];
lVar3 = local_40[1];
lVar4 = local_40[1];
local_40[1] = lVar4 - uVar6;
if (lVar4 - uVar6 < (ulong)param_1[3]) {
*local_48 = *local_40;
*local_40 = param_1[1];
param_1[1] = (long)local_40;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (long)local_40 + (lVar2 - lVar3);
}
|
|
9,608 |
alloc_root
|
eloqsql/mysys/my_alloc.c
|
void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_valgrind) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, length,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->left= 0;
next->size= length;
mem_root->used= next;
DBUG_PRINT("exit",("ptr: %p", (((char*)next)+ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((((uchar*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
size_t original_length __attribute__((unused)) = length;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: %p", mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
/* Avoid reusing an already allocated block */
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_SET("-d,simulate_out_of_memory");
DBUG_RETURN((void*) 0); /* purecov: inspected */
});
length= ALIGN_SIZE(length) + REDZONE_SIZE;
if ((*(prev= &mem_root->free)) != NULL)
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
block_size= (mem_root->block_size & ~1) * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= MY_MAX(get_size, block_size);
if (!(next = (USED_MEM*) my_malloc(mem_root->m_psi_key, get_size,
MYF(MY_WME | ME_FATAL |
MALLOC_FLAG(mem_root->
block_size)))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
TRASH_MEM(next);
}
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
point+= REDZONE_SIZE;
TRASH_ALLOC(point, original_length);
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN((void*) point);
#endif
}
|
O3
|
c
|
alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x7, %r14
andq $-0x8, %r14
movq (%rdi), %rax
movq %rdi, %r12
testq %rax, %rax
je 0x318ba
cmpq %r14, 0x8(%rax)
jae 0x318a1
movl 0x2c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x2c(%rbx)
cmpl $0xa, %ecx
jb 0x318a1
cmpq $0xfff, 0x8(%rax) # imm = 0xFFF
ja 0x318a1
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
movq %rbx, %rax
movq %rax, %r12
movq (%rax), %rax
testq %rax, %rax
je 0x318ba
movq 0x8(%rax), %rdx
cmpq %r14, %rdx
jb 0x318a4
jmp 0x31917
movq 0x20(%rbx), %rdx
movq %rdx, %rax
andq $-0x2, %rax
movl 0x28(%rbx), %r15d
shrl $0x2, %r15d
imulq %rax, %r15
leaq 0x18(%r14), %rax
cmpq %r15, %rax
cmovaq %rax, %r15
movl 0x38(%rbx), %edi
andl $0x1, %edx
shll $0x10, %edx
orq $0x1010, %rdx # imm = 0x1010
movq %r15, %rsi
callq 0x2ada5
testq %rax, %rax
je 0x31949
incl 0x28(%rbx)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
addq $-0x18, %r15
movq %r15, 0x8(%rax)
movq %rax, (%r12)
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
addq %rax, %rcx
subq %r14, %rdx
movq %rdx, 0x8(%rax)
cmpq 0x18(%rbx), %rdx
jae 0x31956
movq (%rax), %rdx
movq %rdx, (%r12)
movq 0x8(%rbx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rbx)
movl $0x0, 0x2c(%rbx)
jmp 0x31956
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x31954
callq *%rax
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
add r14, 7
and r14, 0FFFFFFFFFFFFFFF8h
mov rax, [rdi]
mov r12, rdi
test rax, rax
jz short loc_318BA
cmp [rax+8], r14
jnb short loc_318A1
mov ecx, [rbx+2Ch]
lea edx, [rcx+1]
mov [rbx+2Ch], edx
cmp ecx, 0Ah
jb short loc_318A1
cmp qword ptr [rax+8], 0FFFh
ja short loc_318A1
mov rcx, [rax]
mov [rbx], rcx
mov rcx, [rbx+8]
mov [rax], rcx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
loc_318A1:
mov rax, rbx
loc_318A4:
mov r12, rax
mov rax, [rax]
test rax, rax
jz short loc_318BA
mov rdx, [rax+8]
cmp rdx, r14
jb short loc_318A4
jmp short loc_31917
loc_318BA:
mov rdx, [rbx+20h]
mov rax, rdx
and rax, 0FFFFFFFFFFFFFFFEh
mov r15d, [rbx+28h]
shr r15d, 2
imul r15, rax
lea rax, [r14+18h]
cmp rax, r15
cmova r15, rax
mov edi, [rbx+38h]
and edx, 1
shl edx, 10h
or rdx, 1010h
mov rsi, r15
call my_malloc
test rax, rax
jz short loc_31949
inc dword ptr [rbx+28h]
mov rcx, [r12]
mov [rax], rcx
mov [rax+10h], r15
add r15, 0FFFFFFFFFFFFFFE8h
mov [rax+8], r15
mov [r12], rax
mov rdx, [rax+8]
loc_31917:
mov rcx, [rax+10h]
sub rcx, rdx
add rcx, rax
sub rdx, r14
mov [rax+8], rdx
cmp rdx, [rbx+18h]
jnb short loc_31956
mov rdx, [rax]
mov [r12], rdx
mov rdx, [rbx+8]
mov [rax], rdx
mov [rbx+8], rax
mov dword ptr [rbx+2Ch], 0
jmp short loc_31956
loc_31949:
mov rax, [rbx+30h]
test rax, rax
jz short loc_31954
call rax
loc_31954:
xor ecx, ecx
loc_31956:
mov rax, rcx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
char * alloc_root(long long a1, long long a2)
{
unsigned long long v2; // r14
_QWORD *v3; // rax
_QWORD *v4; // r12
unsigned int v5; // ecx
_QWORD *v6; // rax
unsigned long long v7; // rdx
long long v8; // rdx
unsigned long long v9; // r15
char *v10; // rcx
unsigned long long v11; // rdx
void (*v12)(void); // rax
v2 = (a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = *(_QWORD **)a1;
v4 = (_QWORD *)a1;
if ( *(_QWORD *)a1 )
{
if ( v3[1] < v2 )
{
v5 = *(_DWORD *)(a1 + 44);
*(_DWORD *)(a1 + 44) = v5 + 1;
if ( v5 >= 0xA && v3[1] <= 0xFFFuLL )
{
*(_QWORD *)a1 = *v3;
*v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v3;
*(_DWORD *)(a1 + 44) = 0;
}
}
v6 = (_QWORD *)a1;
while ( 1 )
{
v4 = v6;
v6 = (_QWORD *)*v6;
if ( !v6 )
break;
v7 = v6[1];
if ( v7 >= v2 )
goto LABEL_14;
}
}
v8 = *(_QWORD *)(a1 + 32);
v9 = (v8 & 0xFFFFFFFFFFFFFFFELL) * (*(_DWORD *)(a1 + 40) >> 2);
if ( v2 + 24 > v9 )
v9 = v2 + 24;
v6 = (_QWORD *)my_malloc(*(_DWORD *)(a1 + 56), v9, ((v8 & 1) << 16) | 0x1010);
if ( v6 )
{
++*(_DWORD *)(a1 + 40);
*v6 = *v4;
v6[2] = v9;
v6[1] = v9 - 24;
*v4 = v6;
v7 = v6[1];
LABEL_14:
v10 = (char *)v6 + v6[2] - v7;
v11 = v7 - v2;
v6[1] = v11;
if ( v11 < *(_QWORD *)(a1 + 24) )
{
*v4 = *v6;
*v6 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v6;
*(_DWORD *)(a1 + 44) = 0;
}
}
else
{
v12 = *(void (**)(void))(a1 + 48);
if ( v12 )
v12();
return 0LL;
}
return v10;
}
|
alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
ADD R14,0x7
AND R14,-0x8
MOV RAX,qword ptr [RDI]
MOV R12,RDI
TEST RAX,RAX
JZ 0x001318ba
CMP qword ptr [RAX + 0x8],R14
JNC 0x001318a1
MOV ECX,dword ptr [RBX + 0x2c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0x2c],EDX
CMP ECX,0xa
JC 0x001318a1
CMP qword ptr [RAX + 0x8],0xfff
JA 0x001318a1
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
LAB_001318a1:
MOV RAX,RBX
LAB_001318a4:
MOV R12,RAX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001318ba
MOV RDX,qword ptr [RAX + 0x8]
CMP RDX,R14
JC 0x001318a4
JMP 0x00131917
LAB_001318ba:
MOV RDX,qword ptr [RBX + 0x20]
MOV RAX,RDX
AND RAX,-0x2
MOV R15D,dword ptr [RBX + 0x28]
SHR R15D,0x2
IMUL R15,RAX
LEA RAX,[R14 + 0x18]
CMP RAX,R15
CMOVA R15,RAX
MOV EDI,dword ptr [RBX + 0x38]
AND EDX,0x1
SHL EDX,0x10
OR RDX,0x1010
MOV RSI,R15
CALL 0x0012ada5
TEST RAX,RAX
JZ 0x00131949
INC dword ptr [RBX + 0x28]
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x10],R15
ADD R15,-0x18
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [R12],RAX
MOV RDX,qword ptr [RAX + 0x8]
LAB_00131917:
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
ADD RCX,RAX
SUB RDX,R14
MOV qword ptr [RAX + 0x8],RDX
CMP RDX,qword ptr [RBX + 0x18]
JNC 0x00131956
MOV RDX,qword ptr [RAX]
MOV qword ptr [R12],RDX
MOV RDX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x2c],0x0
JMP 0x00131956
LAB_00131949:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x00131954
CALL RAX
LAB_00131954:
XOR ECX,ECX
LAB_00131956:
MOV RAX,RCX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long alloc_root(long *param_1,long param_2)
{
uint uVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
ulong uVar6;
ulong uVar7;
uVar6 = param_2 + 7U & 0xfffffffffffffff8;
plVar2 = (long *)*param_1;
plVar5 = param_1;
if (plVar2 == (long *)0x0) {
LAB_001318ba:
uVar7 = (ulong)(*(uint *)(param_1 + 5) >> 2) * (param_1[4] & 0xfffffffffffffffeU);
if (uVar7 < uVar6 + 0x18) {
uVar7 = uVar6 + 0x18;
}
plVar4 = (long *)my_malloc((int)param_1[7],uVar7,((uint)param_1[4] & 1) << 0x10 | 0x1010);
if (plVar4 == (long *)0x0) {
if ((code *)param_1[6] != (code *)0x0) {
(*(code *)param_1[6])();
}
return 0;
}
*(int *)(param_1 + 5) = (int)param_1[5] + 1;
*plVar4 = *plVar5;
plVar4[2] = uVar7;
plVar4[1] = uVar7 - 0x18;
*plVar5 = (long)plVar4;
uVar7 = plVar4[1];
}
else {
plVar4 = param_1;
if ((((ulong)plVar2[1] < uVar6) &&
(uVar1 = *(uint *)((long)param_1 + 0x2c), *(uint *)((long)param_1 + 0x2c) = uVar1 + 1,
9 < uVar1)) && ((ulong)plVar2[1] < 0x1000)) {
*param_1 = *plVar2;
*plVar2 = param_1[1];
param_1[1] = (long)plVar2;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
do {
plVar5 = plVar4;
plVar4 = (long *)*plVar5;
if (plVar4 == (long *)0x0) goto LAB_001318ba;
uVar7 = plVar4[1];
} while (uVar7 < uVar6);
}
lVar3 = plVar4[2];
plVar4[1] = uVar7 - uVar6;
if (uVar7 - uVar6 < (ulong)param_1[3]) {
*plVar5 = *plVar4;
*plVar4 = param_1[1];
param_1[1] = (long)plVar4;
*(int4 *)((long)param_1 + 0x2c) = 0;
}
return (lVar3 - uVar7) + (long)plVar4;
}
|
|
9,609 |
write_tail
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool write_tail(MARIA_HA *info,
MARIA_BITMAP_BLOCK *block,
uchar *row_part, uint org_length)
{
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE page_link;
uint block_size= share->block_size, empty_space, length= org_length;
struct st_row_pos_info row_pos;
my_off_t position;
my_bool res, block_is_read;
DBUG_ENTER("write_tail");
DBUG_PRINT("enter", ("page: %lu length: %u",
(ulong) block->page, length));
info->keyread_buff_used= 1;
/*
Don't allocate smaller block than MIN_TAIL_SIZE (we want to give rows
some place to grow in the future)
*/
if (length < MIN_TAIL_SIZE)
length= MIN_TAIL_SIZE;
if (block->page_count == TAIL_PAGE_COUNT_MARKER)
{
/*
Create new tail
page will be pinned & locked by get_head_or_tail_page
*/
if (get_head_or_tail_page(info, block, info->keyread_buff, length,
TAIL_PAGE, PAGECACHE_LOCK_WRITE,
&row_pos))
DBUG_RETURN(1);
}
else
{
/* Write tail on predefined row position */
if (get_rowpos_in_head_or_tail_page(info, block, info->keyread_buff,
length, TAIL_PAGE,
PAGECACHE_LOCK_WRITE,
block->page_count & ~TAIL_BIT,
&row_pos))
DBUG_RETURN(1);
}
DBUG_PRINT("info", ("tailid: %lu (%lu:%u)",
(ulong) ma_recordpos(block->page, row_pos.rownr),
(ulong) block->page, row_pos.rownr));
block_is_read= block->org_bitmap_value != 0;
memcpy(row_pos.data, row_part, org_length);
if (share->now_transactional)
{
/* Log changes in tail block */
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + DIRPOS_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
/*
Log REDO changes of tail page
Note that we have to log length, not org_length, to be sure that
REDO, which doesn't use write_tail, also creates a block of at least
MIN_TAIL_SIZE
*/
page_store(log_data + FILEID_STORE_SIZE, block->page);
dirpos_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE,
row_pos.rownr);
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= row_pos.data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
if (translog_write_record(&lsn,
(block_is_read ? LOGREC_REDO_INSERT_ROW_TAIL :
LOGREC_REDO_NEW_ROW_TAIL),
info->trn, info,
(translog_size_t) (sizeof(log_data) + length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
}
int2store(row_pos.dir + 2, length);
empty_space= row_pos.empty_space - length;
int2store(row_pos.buff + EMPTY_SPACE_OFFSET, empty_space);
block->page_count= row_pos.rownr + TAIL_BIT;
/*
If there is less directory entries free than number of possible tails
we can write for a row, we mark the page full to ensure that we don't
during _ma_bitmap_find_place() allocate more entries on the tail page
than it can hold
*/
block->empty_space= (enough_free_entries(row_pos.buff, share->block_size,
1 + share->base.blobs) ?
empty_space : 0);
/* Keep BLOCKUSED_USE_ORG_BITMAP */
block->used|= BLOCKUSED_USED | BLOCKUSED_TAIL;
if (block_is_read)
{
/* Current page link is last element in pinned_pages */
MARIA_PINNED_PAGE *page_link;
page_link= dynamic_element(&info->pinned_pages,
info->pinned_pages.elements-1,
MARIA_PINNED_PAGE*);
pagecache_unlock_by_link(share->pagecache, page_link->link,
PAGECACHE_LOCK_WRITE_TO_READ,
PAGECACHE_PIN_LEFT_PINNED, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 1, FALSE);
DBUG_ASSERT(page_link->changed);
page_link->unlock= PAGECACHE_LOCK_READ_UNLOCK;
res= 0;
}
else
{
if (!(res= pagecache_write(share->pagecache,
&info->dfile, block->page, 0,
row_pos.buff,share->page_type,
PAGECACHE_LOCK_READ,
PAGECACHE_PIN,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE)))
{
DBUG_ASSERT(page_link.link);
page_link.unlock= PAGECACHE_LOCK_READ_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
/* Increase data file size, if extended */
position= (my_off_t) block->page * block_size;
if (share->state.state.data_file_length <= position)
{
/*
We are modifying a state member before writing the UNDO; this is a WAL
violation. But for data_file_length this is ok, as long as we change
data_file_length after writing any log record (FILE_ID/REDO/UNDO) (see
collect_tables()).
*/
_ma_set_share_data_file_length(share, position + block_size);
}
}
DBUG_RETURN(res);
}
|
O0
|
c
|
write_tail:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x805d7
movq -0x20(%rbp), %rax
movb $0x1, 0x685(%rax)
cmpl $0x20, -0x64(%rbp)
jae 0x805ef
movl $0x20, -0x64(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xffff, 0x8(%rax) # imm = 0xFFFF
jne 0x8063f
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x380(%rax), %rdx
movl -0x64(%rbp), %ecx
movl $0x2, %r8d
movl $0x4, %r9d
leaq -0x90(%rbp), %rax
movq %rax, (%rsp)
callq 0x7fc80
cmpb $0x0, %al
je 0x8063d
jmp 0x80634
movb $0x1, -0x11(%rbp)
jmp 0x809e8
jmp 0x80696
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x380(%rax), %rdx
movl -0x64(%rbp), %ecx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %r10d
andl $0xffff7fff, %r10d # imm = 0xFFFF7FFF
movl $0x2, %r8d
movl $0x4, %r9d
leaq -0x90(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x7cb70
cmpb $0x0, %al
je 0x80694
jmp 0x8068b
movb $0x1, -0x11(%rbp)
jmp 0x809e8
jmp 0x80696
jmp 0x80698
jmp 0x8069a
movq -0x28(%rbp), %rax
movzbl 0x15(%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9a(%rbp)
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x40(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x807b7
jmp 0x806db
leaq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xf0(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0xf0(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0xf0(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0x74(%rbp), %eax
movb %al, -0x9(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x8, -0xb8(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x64(%rbp), %eax
movq %rax, -0xa8(%rbp)
movsbl -0x9a(%rbp), %ecx
movl $0x4, %esi
movl $0x2, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movl -0x64(%rbp), %eax
addq $0x8, %rax
movl %eax, %r8d
leaq -0xe0(%rbp), %r10
leaq -0x10(%rbp), %rax
leaq -0xe8(%rbp), %rdi
movl $0x4, %r9d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x53ff0
cmpb $0x0, %al
je 0x807b5
jmp 0x807ac
movb $0x1, -0x11(%rbp)
jmp 0x809e8
jmp 0x807b7
jmp 0x807b9
movq -0x80(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xf8(%rbp)
movl -0x64(%rbp), %eax
movw %ax, %cx
movq -0xf8(%rbp), %rax
movw %cx, (%rax)
movl -0x70(%rbp), %eax
subl -0x64(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x90(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x100(%rbp)
movl -0x60(%rbp), %eax
movw %ax, %cx
movq -0x100(%rbp), %rax
movw %cx, (%rax)
movl -0x74(%rbp), %ecx
addl $0x8000, %ecx # imm = 0x8000
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x7bc(%rax), %esi
movq -0x40(%rbp), %rax
movl 0x3f0(%rax), %edx
addl $0x1, %edx
callq 0x74700
movsbl %al, %eax
cmpl $0x0, %eax
je 0x80849
movl -0x60(%rbp), %eax
movl %eax, -0x10c(%rbp)
jmp 0x80853
xorl %eax, %eax
movl %eax, -0x10c(%rbp)
jmp 0x80853
movl -0x10c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movzbl 0x14(%rax), %ecx
orl $0x5, %ecx
movb %cl, 0x14(%rax)
cmpb $0x0, -0x9a(%rbp)
je 0x808f3
movq -0x20(%rbp), %rax
movq 0x2e8(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x2f0(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x108(%rbp), %rax
movq (%rax), %rsi
movl $0x7, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x2d710
jmp 0x808d9
movq -0x108(%rbp), %rax
movl $0x5, 0x8(%rax)
movb $0x0, -0x99(%rbp)
jmp 0x809dd
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x90(%rbp), %r8
movq -0x40(%rbp), %rax
movl 0x7d4(%rax), %r9d
leaq -0x58(%rbp), %r10
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
xorl %r11d, %r11d
movl $0x3, (%rsp)
movl $0x2, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x2f070
movb %al, -0x99(%rbp)
cmpb $0x0, %al
jne 0x8099f
jmp 0x8097e
jmp 0x80980
movl $0x5, -0x50(%rbp)
movb $0x1, -0x48(%rbp)
movq -0x20(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x58(%rbp), %rsi
callq 0xda940
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl -0x5c(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x98(%rbp), %rax
ja 0x809db
movq -0x40(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x5c(%rbp), %eax
addq %rax, %rsi
callq 0x37300
jmp 0x809dd
jmp 0x809df
movb -0x99(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x10d(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x80a12
movb -0x10d(%rbp), %al
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
callq 0x2a270
nopw (%rax,%rax)
|
write_tail:
push rbp
mov rbp, rsp
sub rsp, 150h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov eax, [rax+7BCh]
mov [rbp+var_5C], eax
mov eax, [rbp+var_34]
mov [rbp+var_64], eax
jmp short $+2
loc_805D7:
mov rax, [rbp+var_20]
mov byte ptr [rax+685h], 1
cmp [rbp+var_64], 20h ; ' '
jnb short loc_805EF
mov [rbp+var_64], 20h ; ' '
loc_805EF:
mov rax, [rbp+var_28]
cmp dword ptr [rax+8], 0FFFFh
jnz short loc_8063F
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rax, [rbp+var_20]
mov rdx, [rax+380h]
mov ecx, [rbp+var_64]
mov r8d, 2
mov r9d, 4
lea rax, [rbp+var_90]
mov [rsp+150h+var_150], rax
call get_head_or_tail_page
cmp al, 0
jz short loc_8063D
jmp short $+2
loc_80634:
mov [rbp+var_11], 1
jmp loc_809E8
loc_8063D:
jmp short loc_80696
loc_8063F:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rax, [rbp+var_20]
mov rdx, [rax+380h]
mov ecx, [rbp+var_64]
mov rax, [rbp+var_28]
mov r10d, [rax+8]
and r10d, 0FFFF7FFFh
mov r8d, 2
mov r9d, 4
lea rax, [rbp+var_90]
mov dword ptr [rsp+150h+var_150], r10d
mov [rsp+150h+var_148], rax
call get_rowpos_in_head_or_tail_page
cmp al, 0
jz short loc_80694
jmp short $+2
loc_8068B:
mov [rbp+var_11], 1
jmp loc_809E8
loc_80694:
jmp short $+2
loc_80696:
jmp short $+2
loc_80698:
jmp short $+2
loc_8069A:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+15h]
cmp eax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9A], al
mov rdi, [rbp+var_88]
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
mov edx, eax
call _memcpy
mov rax, [rbp+var_40]
cmp byte ptr [rax+7E7h], 0
jz loc_807B7
jmp short $+2
loc_806DB:
lea rax, [rbp+var_10]
add rax, 2
mov [rbp+var_F0], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov ecx, eax
mov rax, [rbp+var_F0]
mov [rax], ecx
mov rax, [rbp+var_28]
mov rax, [rax]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_F0]
mov [rax+4], cl
mov eax, [rbp+var_74]
mov [rbp+var_9], al
lea rax, [rbp+var_10]
mov [rbp+var_C0], rax
mov [rbp+var_B8], 8
mov rax, [rbp+var_88]
mov [rbp+var_B0], rax
mov eax, [rbp+var_64]
mov [rbp+var_A8], rax
movsx ecx, [rbp+var_9A]
mov esi, 4
mov eax, 2
cmp ecx, 0
cmovnz esi, eax
mov rax, [rbp+var_20]
mov rdx, [rax+8]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_64]
add rax, 8
mov r8d, eax
lea r10, [rbp+var_E0]
lea rax, [rbp+var_10]
lea rdi, [rbp+var_E8]
mov r9d, 4
xor r11d, r11d
mov [rsp+150h+var_150], r10
mov [rsp+150h+var_148], rax
mov [rsp+150h+var_140], 0
call translog_write_record
cmp al, 0
jz short loc_807B5
jmp short $+2
loc_807AC:
mov [rbp+var_11], 1
jmp loc_809E8
loc_807B5:
jmp short $+2
loc_807B7:
jmp short $+2
loc_807B9:
mov rax, [rbp+var_80]
add rax, 2
mov [rbp+var_F8], rax
mov eax, [rbp+var_64]
mov cx, ax
mov rax, [rbp+var_F8]
mov [rax], cx
mov eax, [rbp+var_70]
sub eax, [rbp+var_64]
mov [rbp+var_60], eax
mov rax, [rbp+var_90]
add rax, 0Ah
mov [rbp+var_100], rax
mov eax, [rbp+var_60]
mov cx, ax
mov rax, [rbp+var_100]
mov [rax], cx
mov ecx, [rbp+var_74]
add ecx, 8000h
mov rax, [rbp+var_28]
mov [rax+8], ecx
mov rdi, [rbp+var_90]
mov rax, [rbp+var_40]
mov esi, [rax+7BCh]
mov rax, [rbp+var_40]
mov edx, [rax+3F0h]
add edx, 1
call enough_free_entries
movsx eax, al
cmp eax, 0
jz short loc_80849
mov eax, [rbp+var_60]
mov [rbp+var_10C], eax
jmp short loc_80853
loc_80849:
xor eax, eax
mov [rbp+var_10C], eax
jmp short $+2
loc_80853:
mov ecx, [rbp+var_10C]
mov rax, [rbp+var_28]
mov [rax+0Ch], ecx
mov rax, [rbp+var_28]
movzx ecx, byte ptr [rax+14h]
or ecx, 5
mov [rax+14h], cl
cmp [rbp+var_9A], 0
jz short loc_808F3
mov rax, [rbp+var_20]
mov rax, [rax+2E8h]
mov rcx, [rbp+var_20]
mov ecx, [rcx+2F0h]
sub ecx, 1
mov ecx, ecx
imul rcx, 18h
add rax, rcx
mov [rbp+var_108], rax
mov rax, [rbp+var_40]
mov rdi, [rax+600h]
mov rax, [rbp+var_108]
mov rsi, [rax]
mov edx, 7
xor ecx, ecx
xor eax, eax
mov r9d, eax
mov r8, r9
mov dword ptr [rsp+150h+var_150], 1
mov dword ptr [rsp+150h+var_148], 0
call pagecache_unlock_by_link
jmp short $+2
loc_808D9:
mov rax, [rbp+var_108]
mov dword ptr [rax+8], 5
mov [rbp+var_99], 0
jmp loc_809DD
loc_808F3:
mov rax, [rbp+var_40]
mov rdi, [rax+600h]
mov rsi, [rbp+var_20]
add rsi, 470h
mov rax, [rbp+var_28]
mov rdx, [rax]
mov r8, [rbp+var_90]
mov rax, [rbp+var_40]
mov r9d, [rax+7D4h]
lea r10, [rbp+var_58]
mov rax, [rbp+var_40]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
xor r11d, r11d
mov dword ptr [rsp+150h+var_150], 3
mov dword ptr [rsp+150h+var_148], 2
mov dword ptr [rsp+150h+var_140], 0
mov [rsp+150h+var_138], r10
mov [rsp+150h+var_130], 0
mov [rsp+150h+var_128], 0
mov [rsp+150h+var_120], eax
call pagecache_write_part
mov [rbp+var_99], al
cmp al, 0
jnz short loc_8099F
jmp short $+2
loc_8097E:
jmp short $+2
loc_80980:
mov [rbp+var_50], 5
mov [rbp+var_48], 1
mov rdi, [rbp+var_20]
add rdi, 2E8h
lea rsi, [rbp+var_58]
call insert_dynamic
loc_8099F:
mov rax, [rbp+var_28]
mov rax, [rax]
mov ecx, [rbp+var_5C]
imul rax, rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_40]
mov rax, [rax+40h]
cmp rax, [rbp+var_98]
ja short loc_809DB
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_98]
mov eax, [rbp+var_5C]
add rsi, rax
call _ma_set_share_data_file_length
loc_809DB:
jmp short $+2
loc_809DD:
jmp short $+2
loc_809DF:
mov al, [rbp+var_99]
mov [rbp+var_11], al
loc_809E8:
mov al, [rbp+var_11]
mov [rbp+var_10D], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_80A12
mov al, [rbp+var_10D]
add rsp, 150h
pop rbp
retn
loc_80A12:
call ___stack_chk_fail
|
char write_tail(long long a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v4; // esi
int v6; // [rsp+44h] [rbp-10Ch]
long long v7; // [rsp+48h] [rbp-108h]
_BYTE v8[8]; // [rsp+68h] [rbp-E8h] BYREF
_QWORD v9[8]; // [rsp+70h] [rbp-E0h] BYREF
bool v10; // [rsp+B6h] [rbp-9Ah]
char v11; // [rsp+B7h] [rbp-99h]
unsigned long long v12; // [rsp+B8h] [rbp-98h]
long long v13; // [rsp+C0h] [rbp-90h] BYREF
long long v14; // [rsp+C8h] [rbp-88h]
long long v15; // [rsp+D0h] [rbp-80h]
int v16; // [rsp+DCh] [rbp-74h]
int v17; // [rsp+E0h] [rbp-70h]
unsigned int v18; // [rsp+ECh] [rbp-64h]
int v19; // [rsp+F0h] [rbp-60h]
unsigned int v20; // [rsp+F4h] [rbp-5Ch]
char v21[8]; // [rsp+F8h] [rbp-58h] BYREF
int v22; // [rsp+100h] [rbp-50h]
char v23; // [rsp+108h] [rbp-48h]
long long v24; // [rsp+110h] [rbp-40h]
unsigned int v25; // [rsp+11Ch] [rbp-34h]
long long v26; // [rsp+120h] [rbp-30h]
long long v27; // [rsp+128h] [rbp-28h]
long long *v28; // [rsp+130h] [rbp-20h]
__int16 v30; // [rsp+140h] [rbp-10h] BYREF
int v31; // [rsp+142h] [rbp-Eh]
char v32; // [rsp+146h] [rbp-Ah]
char v33; // [rsp+147h] [rbp-9h]
unsigned long long v34; // [rsp+148h] [rbp-8h]
v34 = __readfsqword(0x28u);
v28 = (long long *)a1;
v27 = a2;
v26 = a3;
v25 = a4;
v24 = *(_QWORD *)a1;
v20 = *(_DWORD *)(v24 + 1980);
v18 = a4;
*(_BYTE *)(a1 + 1669) = 1;
if ( v18 < 0x20 )
v18 = 32;
if ( *(_DWORD *)(v27 + 8) == 0xFFFF )
{
if ( get_head_or_tail_page(v28, v27, (_BYTE *)v28[112], v18, 2, 4u, (long long)&v13) )
return 1;
}
else if ( get_rowpos_in_head_or_tail_page(
v28,
v27,
(_BYTE *)v28[112],
v18,
2,
4u,
*(_DWORD *)(v27 + 8) & 0xFFFF7FFF,
(long long)&v13) )
{
return 1;
}
v10 = *(_BYTE *)(v27 + 21) != 0;
memcpy(v14, v26, v25);
if ( !*(_BYTE *)(v24 + 2023) )
goto LABEL_14;
v31 = *(_QWORD *)v27;
v32 = BYTE4(*(_QWORD *)v27);
v33 = v16;
v9[4] = &v30;
v9[5] = 8LL;
v9[6] = v14;
v9[7] = v18;
v4 = 4;
if ( v10 )
v4 = 2;
if ( translog_write_record((long long)v8, v4, v28[1], v28, v18 + 8, 4u, v9, &v30, 0LL) )
return 1;
LABEL_14:
*(_WORD *)(v15 + 2) = v18;
v19 = v17 - v18;
*(_WORD *)(v13 + 10) = v17 - v18;
*(_DWORD *)(v27 + 8) = v16 + 0x8000;
if ( enough_free_entries(v13, *(_DWORD *)(v24 + 1980), *(_DWORD *)(v24 + 1008) + 1) )
v6 = v19;
else
v6 = 0;
*(_DWORD *)(v27 + 12) = v6;
*(_BYTE *)(v27 + 20) |= 5u;
if ( v10 )
{
v7 = 24LL * (unsigned int)(*((_DWORD *)v28 + 188) - 1) + v28[93];
pagecache_unlock_by_link(*(_QWORD **)(v24 + 1536), *(_QWORD *)v7, 7, 0, 0LL, 0LL, 1, 0);
*(_DWORD *)(v7 + 8) = 5;
return 0;
}
else
{
v11 = pagecache_write_part(
*(_QWORD **)(v24 + 1536),
(long long)(v28 + 142),
*(_QWORD *)v27,
0,
v13,
*(_DWORD *)(v24 + 2004),
3u,
2u,
0,
v21,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v24 + 1536) + 128LL));
if ( !v11 )
{
v22 = 5;
v23 = 1;
insert_dynamic(v28 + 93, v21);
}
v12 = v20 * *(_QWORD *)v27;
if ( *(_QWORD *)(v24 + 64) <= v12 )
ma_set_share_data_file_length(v24, v20 + v12);
}
return v11;
}
|
write_tail:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x5c],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x64],EAX
JMP 0x001805d7
LAB_001805d7:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x685],0x1
CMP dword ptr [RBP + -0x64],0x20
JNC 0x001805ef
MOV dword ptr [RBP + -0x64],0x20
LAB_001805ef:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x8],0xffff
JNZ 0x0018063f
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX + 0x380]
MOV ECX,dword ptr [RBP + -0x64]
MOV R8D,0x2
MOV R9D,0x4
LEA RAX,[RBP + -0x90]
MOV qword ptr [RSP],RAX
CALL 0x0017fc80
CMP AL,0x0
JZ 0x0018063d
JMP 0x00180634
LAB_00180634:
MOV byte ptr [RBP + -0x11],0x1
JMP 0x001809e8
LAB_0018063d:
JMP 0x00180696
LAB_0018063f:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX + 0x380]
MOV ECX,dword ptr [RBP + -0x64]
MOV RAX,qword ptr [RBP + -0x28]
MOV R10D,dword ptr [RAX + 0x8]
AND R10D,0xffff7fff
MOV R8D,0x2
MOV R9D,0x4
LEA RAX,[RBP + -0x90]
MOV dword ptr [RSP],R10D
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0017cb70
CMP AL,0x0
JZ 0x00180694
JMP 0x0018068b
LAB_0018068b:
MOV byte ptr [RBP + -0x11],0x1
JMP 0x001809e8
LAB_00180694:
JMP 0x00180696
LAB_00180696:
JMP 0x00180698
LAB_00180698:
JMP 0x0018069a
LAB_0018069a:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x15]
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9a],AL
MOV RDI,qword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x40]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x001807b7
JMP 0x001806db
LAB_001806db:
LEA RAX,[RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0xf0],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0xf0]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xf0]
MOV byte ptr [RAX + 0x4],CL
MOV EAX,dword ptr [RBP + -0x74]
MOV byte ptr [RBP + -0x9],AL
LEA RAX,[RBP + -0x10]
MOV qword ptr [RBP + -0xc0],RAX
MOV qword ptr [RBP + -0xb8],0x8
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0xb0],RAX
MOV EAX,dword ptr [RBP + -0x64]
MOV qword ptr [RBP + -0xa8],RAX
MOVSX ECX,byte ptr [RBP + -0x9a]
MOV ESI,0x4
MOV EAX,0x2
CMP ECX,0x0
CMOVNZ ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x64]
ADD RAX,0x8
MOV R8D,EAX
LEA R10,[RBP + -0xe0]
LEA RAX,[RBP + -0x10]
LEA RDI,[RBP + -0xe8]
MOV R9D,0x4
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00153ff0
CMP AL,0x0
JZ 0x001807b5
JMP 0x001807ac
LAB_001807ac:
MOV byte ptr [RBP + -0x11],0x1
JMP 0x001809e8
LAB_001807b5:
JMP 0x001807b7
LAB_001807b7:
JMP 0x001807b9
LAB_001807b9:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x2
MOV qword ptr [RBP + -0xf8],RAX
MOV EAX,dword ptr [RBP + -0x64]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xf8]
MOV word ptr [RAX],CX
MOV EAX,dword ptr [RBP + -0x70]
SUB EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x60],EAX
MOV RAX,qword ptr [RBP + -0x90]
ADD RAX,0xa
MOV qword ptr [RBP + -0x100],RAX
MOV EAX,dword ptr [RBP + -0x60]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x100]
MOV word ptr [RAX],CX
MOV ECX,dword ptr [RBP + -0x74]
ADD ECX,0x8000
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RAX + 0x7bc]
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RAX + 0x3f0]
ADD EDX,0x1
CALL 0x00174700
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00180849
MOV EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x10c],EAX
JMP 0x00180853
LAB_00180849:
XOR EAX,EAX
MOV dword ptr [RBP + -0x10c],EAX
JMP 0x00180853
LAB_00180853:
MOV ECX,dword ptr [RBP + -0x10c]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RAX + 0x14]
OR ECX,0x5
MOV byte ptr [RAX + 0x14],CL
CMP byte ptr [RBP + -0x9a],0x0
JZ 0x001808f3
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0x2f0]
SUB ECX,0x1
MOV ECX,ECX
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x108],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x600]
MOV RAX,qword ptr [RBP + -0x108]
MOV RSI,qword ptr [RAX]
MOV EDX,0x7
XOR ECX,ECX
XOR EAX,EAX
MOV R9D,EAX
MOV R8,R9
MOV dword ptr [RSP],0x1
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0012d710
JMP 0x001808d9
LAB_001808d9:
MOV RAX,qword ptr [RBP + -0x108]
MOV dword ptr [RAX + 0x8],0x5
MOV byte ptr [RBP + -0x99],0x0
JMP 0x001809dd
LAB_001808f3:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x470
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x40]
MOV R9D,dword ptr [RAX + 0x7d4]
LEA R10,[RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
XOR R11D,R11D
MOV dword ptr [RSP],0x3
MOV dword ptr [RSP + 0x8],0x2
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R10
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x0012f070
MOV byte ptr [RBP + -0x99],AL
CMP AL,0x0
JNZ 0x0018099f
JMP 0x0018097e
LAB_0018097e:
JMP 0x00180980
LAB_00180980:
MOV dword ptr [RBP + -0x50],0x5
MOV byte ptr [RBP + -0x48],0x1
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x58]
CALL 0x001da940
LAB_0018099f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x5c]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x40]
CMP RAX,qword ptr [RBP + -0x98]
JA 0x001809db
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x98]
MOV EAX,dword ptr [RBP + -0x5c]
ADD RSI,RAX
CALL 0x00137300
LAB_001809db:
JMP 0x001809dd
LAB_001809dd:
JMP 0x001809df
LAB_001809df:
MOV AL,byte ptr [RBP + -0x99]
MOV byte ptr [RBP + -0x11],AL
LAB_001809e8:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x10d],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00180a12
MOV AL,byte ptr [RBP + -0x10d]
ADD RSP,0x150
POP RBP
RET
LAB_00180a12:
CALL 0x0012a270
|
int8 write_tail(long *param_1,long *param_2,void *param_3,uint param_4)
{
char cVar1;
int8 *puVar2;
int8 uVar3;
long in_FS_OFFSET;
int8 in_stack_fffffffffffffea8;
long *plVar4;
ulong uVar5;
int1 *puVar6;
int4 uVar7;
int8 in_stack_fffffffffffffeb0;
int1 *puVar8;
uint uVar9;
ulong in_stack_fffffffffffffeb8;
int local_114;
int1 local_f0 [8];
int1 local_e8 [32];
int1 *local_c8;
int8 local_c0;
void *local_b8;
ulong local_b0;
char local_a2;
char local_a1;
ulong local_a0;
long local_98;
void *local_90;
long local_88;
int local_7c;
int local_78;
uint local_6c;
int local_68;
uint local_64;
int1 local_60 [8];
int4 local_58;
int1 local_50;
long local_48;
uint local_3c;
void *local_38;
long *local_30;
long *local_28;
char local_19;
int1 local_18 [2];
int4 local_16;
int1 local_12;
int1 local_11;
long local_10;
uVar9 = (uint)((ulong)in_stack_fffffffffffffeb0 >> 0x20);
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = *param_1;
local_64 = *(uint *)(local_48 + 0x7bc);
*(int1 *)((long)param_1 + 0x685) = 1;
local_6c = param_4;
if (param_4 < 0x20) {
local_6c = 0x20;
}
local_3c = param_4;
local_38 = param_3;
local_30 = param_2;
local_28 = param_1;
if ((int)param_2[1] == 0xffff) {
plVar4 = &local_98;
cVar1 = get_head_or_tail_page(param_1,param_2,param_1[0x70],local_6c,2,4,plVar4);
uVar7 = (int4)((ulong)plVar4 >> 0x20);
if (cVar1 != '\0') {
local_19 = '\x01';
goto LAB_001809e8;
}
}
else {
plVar4 = &local_98;
uVar5 = CONCAT44((int)((ulong)in_stack_fffffffffffffea8 >> 0x20),(int)param_2[1]) &
0xffffffffffff7fff;
cVar1 = get_rowpos_in_head_or_tail_page(param_1,param_2,param_1[0x70],local_6c,2,4,uVar5,plVar4)
;
uVar9 = (uint)((ulong)plVar4 >> 0x20);
uVar7 = (int4)(uVar5 >> 0x20);
if (cVar1 != '\0') {
local_19 = '\x01';
goto LAB_001809e8;
}
}
local_a2 = *(char *)((long)local_30 + 0x15) != '\0';
memcpy(local_90,local_38,(ulong)local_3c);
if (*(char *)(local_48 + 0x7e7) != '\0') {
local_16 = (int4)*local_30;
local_12 = (int1)((ulong)*local_30 >> 0x20);
local_11 = (int1)local_7c;
local_c8 = local_18;
local_c0 = 8;
local_b8 = local_90;
local_b0 = (ulong)local_6c;
uVar3 = 4;
if (local_a2 != '\0') {
uVar3 = 2;
}
puVar6 = local_e8;
puVar8 = local_18;
in_stack_fffffffffffffeb8 = 0;
cVar1 = translog_write_record
(local_f0,uVar3,local_28[1],local_28,local_6c + 8,4,puVar6,puVar8,0);
uVar9 = (uint)((ulong)puVar8 >> 0x20);
uVar7 = (int4)((ulong)puVar6 >> 0x20);
if (cVar1 != '\0') {
local_19 = '\x01';
goto LAB_001809e8;
}
}
*(short *)(local_88 + 2) = (short)local_6c;
local_68 = local_78 - local_6c;
*(short *)(local_98 + 10) = (short)local_68;
*(int *)(local_30 + 1) = local_7c + 0x8000;
cVar1 = enough_free_entries(local_98,*(int4 *)(local_48 + 0x7bc),
*(int *)(local_48 + 0x3f0) + 1);
if (cVar1 == '\0') {
local_114 = 0;
}
else {
local_114 = local_68;
}
*(int *)((long)local_30 + 0xc) = local_114;
*(byte *)((long)local_30 + 0x14) = *(byte *)((long)local_30 + 0x14) | 5;
if (local_a2 == '\0') {
local_a1 = pagecache_write_part
(*(int8 *)(local_48 + 0x600),local_28 + 0x8e,*local_30,0,local_98,
*(int4 *)(local_48 + 0x7d4),CONCAT44(uVar7,3),CONCAT44(uVar9,2),
in_stack_fffffffffffffeb8 & 0xffffffff00000000,local_60,0,0,
*(int4 *)(*(long *)(local_48 + 0x600) + 0x80));
if (local_a1 == '\0') {
local_58 = 5;
local_50 = 1;
insert_dynamic(local_28 + 0x5d,local_60);
}
local_a0 = *local_30 * (ulong)local_64;
if (*(ulong *)(local_48 + 0x40) <= local_a0) {
_ma_set_share_data_file_length(local_48,local_a0 + local_64);
}
}
else {
puVar2 = (int8 *)(local_28[0x5d] + (ulong)((int)local_28[0x5e] - 1) * 0x18);
pagecache_unlock_by_link
(*(int8 *)(local_48 + 0x600),*puVar2,7,0,0,0,CONCAT44(uVar7,1),
(ulong)uVar9 << 0x20);
*(int4 *)(puVar2 + 1) = 5;
local_a1 = '\0';
}
local_19 = local_a1;
LAB_001809e8:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_19);
}
|
|
9,610 |
write_tail
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool write_tail(MARIA_HA *info,
MARIA_BITMAP_BLOCK *block,
uchar *row_part, uint org_length)
{
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE page_link;
uint block_size= share->block_size, empty_space, length= org_length;
struct st_row_pos_info row_pos;
my_off_t position;
my_bool res, block_is_read;
DBUG_ENTER("write_tail");
DBUG_PRINT("enter", ("page: %lu length: %u",
(ulong) block->page, length));
info->keyread_buff_used= 1;
/*
Don't allocate smaller block than MIN_TAIL_SIZE (we want to give rows
some place to grow in the future)
*/
if (length < MIN_TAIL_SIZE)
length= MIN_TAIL_SIZE;
if (block->page_count == TAIL_PAGE_COUNT_MARKER)
{
/*
Create new tail
page will be pinned & locked by get_head_or_tail_page
*/
if (get_head_or_tail_page(info, block, info->keyread_buff, length,
TAIL_PAGE, PAGECACHE_LOCK_WRITE,
&row_pos))
DBUG_RETURN(1);
}
else
{
/* Write tail on predefined row position */
if (get_rowpos_in_head_or_tail_page(info, block, info->keyread_buff,
length, TAIL_PAGE,
PAGECACHE_LOCK_WRITE,
block->page_count & ~TAIL_BIT,
&row_pos))
DBUG_RETURN(1);
}
DBUG_PRINT("info", ("tailid: %lu (%lu:%u)",
(ulong) ma_recordpos(block->page, row_pos.rownr),
(ulong) block->page, row_pos.rownr));
block_is_read= block->org_bitmap_value != 0;
memcpy(row_pos.data, row_part, org_length);
if (share->now_transactional)
{
/* Log changes in tail block */
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + DIRPOS_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
/*
Log REDO changes of tail page
Note that we have to log length, not org_length, to be sure that
REDO, which doesn't use write_tail, also creates a block of at least
MIN_TAIL_SIZE
*/
page_store(log_data + FILEID_STORE_SIZE, block->page);
dirpos_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE,
row_pos.rownr);
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= row_pos.data;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= length;
if (translog_write_record(&lsn,
(block_is_read ? LOGREC_REDO_INSERT_ROW_TAIL :
LOGREC_REDO_NEW_ROW_TAIL),
info->trn, info,
(translog_size_t) (sizeof(log_data) + length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
}
int2store(row_pos.dir + 2, length);
empty_space= row_pos.empty_space - length;
int2store(row_pos.buff + EMPTY_SPACE_OFFSET, empty_space);
block->page_count= row_pos.rownr + TAIL_BIT;
/*
If there is less directory entries free than number of possible tails
we can write for a row, we mark the page full to ensure that we don't
during _ma_bitmap_find_place() allocate more entries on the tail page
than it can hold
*/
block->empty_space= (enough_free_entries(row_pos.buff, share->block_size,
1 + share->base.blobs) ?
empty_space : 0);
/* Keep BLOCKUSED_USE_ORG_BITMAP */
block->used|= BLOCKUSED_USED | BLOCKUSED_TAIL;
if (block_is_read)
{
/* Current page link is last element in pinned_pages */
MARIA_PINNED_PAGE *page_link;
page_link= dynamic_element(&info->pinned_pages,
info->pinned_pages.elements-1,
MARIA_PINNED_PAGE*);
pagecache_unlock_by_link(share->pagecache, page_link->link,
PAGECACHE_LOCK_WRITE_TO_READ,
PAGECACHE_PIN_LEFT_PINNED, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 1, FALSE);
DBUG_ASSERT(page_link->changed);
page_link->unlock= PAGECACHE_LOCK_READ_UNLOCK;
res= 0;
}
else
{
if (!(res= pagecache_write(share->pagecache,
&info->dfile, block->page, 0,
row_pos.buff,share->page_type,
PAGECACHE_LOCK_READ,
PAGECACHE_PIN,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE)))
{
DBUG_ASSERT(page_link.link);
page_link.unlock= PAGECACHE_LOCK_READ_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
/* Increase data file size, if extended */
position= (my_off_t) block->page * block_size;
if (share->state.state.data_file_length <= position)
{
/*
We are modifying a state member before writing the UNDO; this is a WAL
violation. But for data_file_length this is ok, as long as we change
data_file_length after writing any log record (FILE_ID/REDO/UNDO) (see
collect_tables()).
*/
_ma_set_share_data_file_length(share, position + block_size);
}
}
DBUG_RETURN(res);
}
|
O3
|
c
|
write_tail:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebx
movq %rdx, -0x60(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
movl 0x7bc(%rax), %eax
movq %rax, -0x58(%rbp)
cmpl $0x21, %ecx
movl $0x20, %r12d
cmovael %ecx, %r12d
movb $0x1, 0x685(%rdi)
movl 0x8(%rsi), %r9d
movq 0x380(%rdi), %rdx
cmpl $0xffff, %r9d # imm = 0xFFFF
jne 0x6330e
leaq -0x88(%rbp), %r9
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movl $0x2, %r8d
callq 0x62e94
jmp 0x63339
andl $0xffff7fff, %r9d # imm = 0xFFFF7FFF
subq $0x8, %rsp
leaq -0x88(%rbp), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movl $0x2, %r8d
pushq %rax
callq 0x610ed
addq $0x10, %rsp
movb $0x1, %r13b
testb %al, %al
je 0x63368
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6358e
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, -0x48(%rbp)
movb 0x15(%r14), %r14b
movq -0x80(%rbp), %r13
movl %ebx, %edx
movq %r13, %rdi
movq -0x60(%rbp), %rsi
callq 0x29080
movq -0x50(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
movb %r14b, -0x39(%rbp)
je 0x63417
xorl %ecx, %ecx
testb %r14b, %r14b
sete %cl
movq -0x48(%rbp), %r14
movq (%r14), %rdx
leaq -0x38(%rbp), %rax
movl %edx, 0x2(%rax)
shrq $0x20, %rdx
movb %dl, 0x6(%rax)
movl -0x6c(%rbp), %ebx
movb %bl, 0x7(%rax)
leaq -0xd0(%rbp), %r10
movq %rax, 0x20(%r10)
movq $0x8, 0x28(%r10)
movq %r13, 0x30(%r10)
movl %r12d, %edx
movq %rdx, 0x38(%r10)
leal 0x2(,%rcx,2), %esi
movq 0x8(%r15), %rdx
leal 0x8(%r12), %r8d
subq $0x8, %rsp
leaq -0x90(%rbp), %rdi
movq %r15, %rcx
movl $0x4, %r9d
pushq $0x0
pushq %rax
pushq %r10
callq 0x2a8ac
addq $0x20, %rsp
movb $0x1, %r13b
testb %al, %al
jne 0x63340
jmp 0x6341e
movl -0x6c(%rbp), %ebx
movq -0x48(%rbp), %r14
movq -0x78(%rbp), %rax
movw %r12w, 0x2(%rax)
movl -0x68(%rbp), %eax
subl %r12d, %eax
movq -0x88(%rbp), %r8
movw %ax, 0xa(%r8)
addl $0x8000, %ebx # imm = 0x8000
movl %ebx, 0x8(%r14)
movq -0x50(%rbp), %r12
movl 0x3f0(%r12), %ecx
movzbl 0x8(%r8), %edx
addl %edx, %ecx
incl %ecx
cmpl $0x100, %ecx # imm = 0x100
jae 0x63466
movb -0x39(%rbp), %r9b
jmp 0x634a1
movb 0x9(%r8), %dl
cmpb $-0x1, %dl
movb -0x39(%rbp), %r9b
je 0x6349f
movl 0x7bc(%r12), %esi
addl $0xffffff01, %ecx # imm = 0xFFFFFF01
addq %r8, %rsi
addq $-0x5, %rsi
decl %ecx
je 0x634a1
movzbl %dl, %edx
shll $0x2, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movb (%rdi), %dl
cmpb $-0x1, %dl
jne 0x63488
xorl %eax, %eax
orb $0x5, 0x14(%r14)
movl %eax, 0xc(%r14)
testb %r9b, %r9b
je 0x634fa
movq 0x2e8(%r15), %rbx
movl 0x2f0(%r15), %eax
decl %eax
leaq (%rax,%rax,2), %r14
movq 0x600(%r12), %rdi
movq (%rbx,%r14,8), %rsi
xorl %r13d, %r13d
movl $0x7, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq $0x1
callq 0x32355
addq $0x10, %rsp
movl $0x5, 0x8(%rbx,%r14,8)
jmp 0x63340
movq 0x600(%r12), %rdi
leaq 0x470(%r15), %rsi
movq (%r14), %rdx
movl 0x7d4(%r12), %r9d
movl 0x80(%rdi), %eax
subq $0x8, %rsp
xorl %r10d, %r10d
leaq -0xd0(%rbp), %r11
xorl %ecx, %ecx
pushq %rax
pushq %r10
pushq $0x0
pushq %r11
pushq %r10
pushq $0x2
pushq $0x3
callq 0x33a9e
addq $0x40, %rsp
movl %eax, %r13d
testb %al, %al
jne 0x63568
leaq -0xd0(%rbp), %rsi
movl $0x5, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
addq $0x2e8, %r15 # imm = 0x2E8
movq %r15, %rdi
callq 0x91bc6
movq (%r14), %rsi
movq -0x58(%rbp), %rax
imulq %rax, %rsi
cmpq %rsi, 0x40(%r12)
ja 0x63340
addq %rax, %rsi
movq %r12, %rdi
callq 0x38d24
jmp 0x63340
callq 0x29270
|
write_tail:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov ebx, ecx
mov [rbp+var_60], rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_50], rax
mov eax, [rax+7BCh]
mov [rbp+var_58], rax
cmp ecx, 21h ; '!'
mov r12d, 20h ; ' '
cmovnb r12d, ecx
mov byte ptr [rdi+685h], 1
mov r9d, [rsi+8]
mov rdx, [rdi+380h]
cmp r9d, 0FFFFh
jnz short loc_6330E
lea r9, [rbp+var_88]
mov rdi, r15
mov rsi, r14
mov ecx, r12d
mov r8d, 2
call get_head_or_tail_page
jmp short loc_63339
loc_6330E:
and r9d, 0FFFF7FFFh
sub rsp, 8
lea rax, [rbp+var_88]
mov rdi, r15
mov rsi, r14
mov ecx, r12d
mov r8d, 2
push rax
call get_rowpos_in_head_or_tail_page
add rsp, 10h
loc_63339:
mov r13b, 1
test al, al
jz short loc_63368
loc_63340:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6358E
mov eax, r13d
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_63368:
mov [rbp+var_48], r14
mov r14b, [r14+15h]
mov r13, [rbp+var_80]
mov edx, ebx
mov rdi, r13
mov rsi, [rbp+var_60]
call _memcpy
mov rax, [rbp+var_50]
cmp byte ptr [rax+7E7h], 0
mov [rbp+var_39], r14b
jz loc_63417
xor ecx, ecx
test r14b, r14b
setz cl
mov r14, [rbp+var_48]
mov rdx, [r14]
lea rax, [rbp+var_38]
mov [rax+2], edx
shr rdx, 20h
mov [rax+6], dl
mov ebx, [rbp+var_6C]
mov [rax+7], bl
lea r10, [rbp+var_D0]
mov [r10+20h], rax
mov qword ptr [r10+28h], 8
mov [r10+30h], r13
mov edx, r12d
mov [r10+38h], rdx
lea esi, ds:2[rcx*2]
mov rdx, [r15+8]
lea r8d, [r12+8]
sub rsp, 8
lea rdi, [rbp+var_90]
mov rcx, r15
mov r9d, 4
push 0
push rax
push r10
call translog_write_record
add rsp, 20h
mov r13b, 1
test al, al
jnz loc_63340
jmp short loc_6341E
loc_63417:
mov ebx, [rbp+var_6C]
mov r14, [rbp+var_48]
loc_6341E:
mov rax, [rbp+var_78]
mov [rax+2], r12w
mov eax, [rbp+var_68]
sub eax, r12d
mov r8, [rbp+var_88]
mov [r8+0Ah], ax
add ebx, 8000h
mov [r14+8], ebx
mov r12, [rbp+var_50]
mov ecx, [r12+3F0h]
movzx edx, byte ptr [r8+8]
add ecx, edx
inc ecx
cmp ecx, 100h
jnb short loc_63466
mov r9b, [rbp+var_39]
jmp short loc_634A1
loc_63466:
mov dl, [r8+9]
cmp dl, 0FFh
mov r9b, [rbp+var_39]
jz short loc_6349F
mov esi, [r12+7BCh]
add ecx, 0FFFFFF01h
add rsi, r8
add rsi, 0FFFFFFFFFFFFFFFBh
loc_63488:
dec ecx
jz short loc_634A1
movzx edx, dl
shl edx, 2
mov rdi, rsi
sub rdi, rdx
mov dl, [rdi]
cmp dl, 0FFh
jnz short loc_63488
loc_6349F:
xor eax, eax
loc_634A1:
or byte ptr [r14+14h], 5
mov [r14+0Ch], eax
test r9b, r9b
jz short loc_634FA
mov rbx, [r15+2E8h]
mov eax, [r15+2F0h]
dec eax
lea r14, [rax+rax*2]
mov rdi, [r12+600h]
mov rsi, [rbx+r14*8]
xor r13d, r13d
mov edx, 7
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
push 0
push 1
call pagecache_unlock_by_link
add rsp, 10h
mov dword ptr [rbx+r14*8+8], 5
jmp loc_63340
loc_634FA:
mov rdi, [r12+600h]
lea rsi, [r15+470h]
mov rdx, [r14]
mov r9d, [r12+7D4h]
mov eax, [rdi+80h]
sub rsp, 8
xor r10d, r10d
lea r11, [rbp+var_D0]
xor ecx, ecx
push rax
push r10
push 0
push r11
push r10
push 2
push 3
call pagecache_write_part
add rsp, 40h
mov r13d, eax
test al, al
jnz short loc_63568
lea rsi, [rbp+var_D0]
mov dword ptr [rsi+8], 5
mov byte ptr [rsi+10h], 1
add r15, 2E8h
mov rdi, r15
call insert_dynamic
loc_63568:
mov rsi, [r14]
mov rax, [rbp+var_58]
imul rsi, rax
cmp [r12+40h], rsi
ja loc_63340
add rsi, rax
mov rdi, r12
call _ma_set_share_data_file_length
jmp loc_63340
loc_6358E:
call ___stack_chk_fail
|
long long write_tail(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // r13
unsigned int v6; // r12d
int v7; // r9d
_BYTE *v8; // rdx
char head_or_tail_page; // al
char v11; // r14
bool v12; // zf
BOOL v13; // ecx
_QWORD *v14; // r14
long long v15; // rdx
int v16; // ebx
int v17; // eax
char *v18; // r8
long long v19; // r12
char v20; // r9
unsigned __int8 v21; // dl
int v22; // ecx
long long v23; // rbx
long long v24; // rax
long long v25; // r14
unsigned long long v26; // rsi
__int128 v27; // [rsp+0h] [rbp-D0h] BYREF
char v28; // [rsp+10h] [rbp-C0h]
__int16 *v29; // [rsp+20h] [rbp-B0h]
long long v30; // [rsp+28h] [rbp-A8h]
long long v31; // [rsp+30h] [rbp-A0h]
long long v32; // [rsp+38h] [rbp-98h]
char v33[8]; // [rsp+40h] [rbp-90h] BYREF
long long v34; // [rsp+48h] [rbp-88h] BYREF
long long v35; // [rsp+50h] [rbp-80h]
long long v36; // [rsp+58h] [rbp-78h]
int v37; // [rsp+64h] [rbp-6Ch]
int v38; // [rsp+68h] [rbp-68h]
long long v39; // [rsp+70h] [rbp-60h]
long long v40; // [rsp+78h] [rbp-58h]
long long v41; // [rsp+80h] [rbp-50h]
_QWORD *v42; // [rsp+88h] [rbp-48h]
char v43; // [rsp+97h] [rbp-39h]
__int16 v44; // [rsp+98h] [rbp-38h] BYREF
int v45; // [rsp+9Ah] [rbp-36h]
char v46; // [rsp+9Eh] [rbp-32h]
char v47; // [rsp+9Fh] [rbp-31h]
unsigned long long v48; // [rsp+A0h] [rbp-30h]
v39 = a3;
v48 = __readfsqword(0x28u);
v41 = *(_QWORD *)a1;
v40 = *(unsigned int *)(v41 + 1980);
v6 = 32;
if ( a4 >= 0x21 )
v6 = a4;
*(_BYTE *)(a1 + 1669) = 1;
v7 = *(_DWORD *)(a2 + 8);
v8 = *(_BYTE **)(a1 + 896);
if ( v7 == 0xFFFF )
head_or_tail_page = get_head_or_tail_page((long long *)a1, a2, v8, v6, 2, (long long)&v34);
else
head_or_tail_page = get_rowpos_in_head_or_tail_page((long long *)a1, a2, v8, v6, 2, v7 & 0xFFFF7FFF, (long long)&v34);
LOBYTE(v4) = 1;
if ( !head_or_tail_page )
{
v42 = (_QWORD *)a2;
v11 = *(_BYTE *)(a2 + 21);
v4 = v35;
memcpy(v35, v39, a4);
v12 = *(_BYTE *)(v41 + 2023) == 0;
v43 = v11;
if ( v12 )
{
v16 = v37;
v14 = v42;
}
else
{
v13 = v11 == 0;
v14 = v42;
v15 = *v42;
v45 = *v42;
v46 = BYTE4(v15);
v16 = v37;
v47 = v37;
v29 = &v44;
v30 = 8LL;
v31 = v4;
v32 = v6;
LOBYTE(v4) = 1;
if ( (unsigned __int8)translog_write_record(
(unsigned long long)v33,
(_WORD *)(unsigned int)(2 * v13 + 2),
*(_QWORD *)(a1 + 8),
(_QWORD *)a1,
v6 + 8,
4,
&v27,
&v44,
0LL) )
return (unsigned int)v4;
}
*(_WORD *)(v36 + 2) = v6;
v17 = v38 - v6;
v18 = (char *)v34;
*(_WORD *)(v34 + 10) = v38 - v6;
*((_DWORD *)v14 + 2) = v16 + 0x8000;
v19 = v41;
if ( (unsigned int)(unsigned __int8)v18[8] + *(_DWORD *)(v41 + 1008) + 1 >= 0x100 )
{
v21 = v18[9];
v20 = v43;
if ( v21 == 0xFF )
{
LABEL_18:
v17 = 0;
}
else
{
v22 = (unsigned __int8)v18[8] + *(_DWORD *)(v41 + 1008) - 254;
while ( --v22 )
{
v21 = v18[*(unsigned int *)(v41 + 1980) - 5 + -4 * v21];
if ( v21 == 0xFF )
goto LABEL_18;
}
}
}
else
{
v20 = v43;
}
*((_BYTE *)v14 + 20) |= 5u;
*((_DWORD *)v14 + 3) = v17;
if ( v20 )
{
v23 = *(_QWORD *)(a1 + 744);
v24 = (unsigned int)(*(_DWORD *)(a1 + 752) - 1);
v25 = 3 * v24;
LODWORD(v4) = 0;
pagecache_unlock_by_link(*(_QWORD *)(v19 + 1536), *(_QWORD *)(v23 + 24 * v24), 7, 0, 0LL, 0LL, 1);
*(_DWORD *)(v23 + 8 * v25 + 8) = 5;
}
else
{
LODWORD(v4) = pagecache_write_part(
*(__m128i **)(v19 + 1536),
(char *)(a1 + 1136),
*v14,
0,
v18,
*(_DWORD *)(v19 + 2004),
3u,
2u,
0,
&v27,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v19 + 1536) + 128LL));
if ( !(_BYTE)v4 )
{
DWORD2(v27) = 5;
v28 = 1;
insert_dynamic(a1 + 744, &v27);
}
v26 = v40 * *v14;
if ( *(_QWORD *)(v19 + 64) <= v26 )
ma_set_share_data_file_length(v19, v40 + v26);
}
}
return (unsigned int)v4;
}
|
write_tail:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV EBX,ECX
MOV qword ptr [RBP + -0x60],RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RAX + 0x7bc]
MOV qword ptr [RBP + -0x58],RAX
CMP ECX,0x21
MOV R12D,0x20
CMOVNC R12D,ECX
MOV byte ptr [RDI + 0x685],0x1
MOV R9D,dword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDI + 0x380]
CMP R9D,0xffff
JNZ 0x0016330e
LEA R9,[RBP + -0x88]
MOV RDI,R15
MOV RSI,R14
MOV ECX,R12D
MOV R8D,0x2
CALL 0x00162e94
JMP 0x00163339
LAB_0016330e:
AND R9D,0xffff7fff
SUB RSP,0x8
LEA RAX,[RBP + -0x88]
MOV RDI,R15
MOV RSI,R14
MOV ECX,R12D
MOV R8D,0x2
PUSH RAX
CALL 0x001610ed
ADD RSP,0x10
LAB_00163339:
MOV R13B,0x1
TEST AL,AL
JZ 0x00163368
LAB_00163340:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016358e
MOV EAX,R13D
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00163368:
MOV qword ptr [RBP + -0x48],R14
MOV R14B,byte ptr [R14 + 0x15]
MOV R13,qword ptr [RBP + -0x80]
MOV EDX,EBX
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x60]
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x50]
CMP byte ptr [RAX + 0x7e7],0x0
MOV byte ptr [RBP + -0x39],R14B
JZ 0x00163417
XOR ECX,ECX
TEST R14B,R14B
SETZ CL
MOV R14,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [R14]
LEA RAX,[RBP + -0x38]
MOV dword ptr [RAX + 0x2],EDX
SHR RDX,0x20
MOV byte ptr [RAX + 0x6],DL
MOV EBX,dword ptr [RBP + -0x6c]
MOV byte ptr [RAX + 0x7],BL
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x20],RAX
MOV qword ptr [R10 + 0x28],0x8
MOV qword ptr [R10 + 0x30],R13
MOV EDX,R12D
MOV qword ptr [R10 + 0x38],RDX
LEA ESI,[0x2 + RCX*0x2]
MOV RDX,qword ptr [R15 + 0x8]
LEA R8D,[R12 + 0x8]
SUB RSP,0x8
LEA RDI,[RBP + -0x90]
MOV RCX,R15
MOV R9D,0x4
PUSH 0x0
PUSH RAX
PUSH R10
CALL 0x0012a8ac
ADD RSP,0x20
MOV R13B,0x1
TEST AL,AL
JNZ 0x00163340
JMP 0x0016341e
LAB_00163417:
MOV EBX,dword ptr [RBP + -0x6c]
MOV R14,qword ptr [RBP + -0x48]
LAB_0016341e:
MOV RAX,qword ptr [RBP + -0x78]
MOV word ptr [RAX + 0x2],R12W
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,R12D
MOV R8,qword ptr [RBP + -0x88]
MOV word ptr [R8 + 0xa],AX
ADD EBX,0x8000
MOV dword ptr [R14 + 0x8],EBX
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [R12 + 0x3f0]
MOVZX EDX,byte ptr [R8 + 0x8]
ADD ECX,EDX
INC ECX
CMP ECX,0x100
JNC 0x00163466
MOV R9B,byte ptr [RBP + -0x39]
JMP 0x001634a1
LAB_00163466:
MOV DL,byte ptr [R8 + 0x9]
CMP DL,0xff
MOV R9B,byte ptr [RBP + -0x39]
JZ 0x0016349f
MOV ESI,dword ptr [R12 + 0x7bc]
ADD ECX,0xffffff01
ADD RSI,R8
ADD RSI,-0x5
LAB_00163488:
DEC ECX
JZ 0x001634a1
MOVZX EDX,DL
SHL EDX,0x2
MOV RDI,RSI
SUB RDI,RDX
MOV DL,byte ptr [RDI]
CMP DL,0xff
JNZ 0x00163488
LAB_0016349f:
XOR EAX,EAX
LAB_001634a1:
OR byte ptr [R14 + 0x14],0x5
MOV dword ptr [R14 + 0xc],EAX
TEST R9B,R9B
JZ 0x001634fa
MOV RBX,qword ptr [R15 + 0x2e8]
MOV EAX,dword ptr [R15 + 0x2f0]
DEC EAX
LEA R14,[RAX + RAX*0x2]
MOV RDI,qword ptr [R12 + 0x600]
MOV RSI,qword ptr [RBX + R14*0x8]
XOR R13D,R13D
MOV EDX,0x7
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
PUSH 0x0
PUSH 0x1
CALL 0x00132355
ADD RSP,0x10
MOV dword ptr [RBX + R14*0x8 + 0x8],0x5
JMP 0x00163340
LAB_001634fa:
MOV RDI,qword ptr [R12 + 0x600]
LEA RSI,[R15 + 0x470]
MOV RDX,qword ptr [R14]
MOV R9D,dword ptr [R12 + 0x7d4]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
XOR R10D,R10D
LEA R11,[RBP + -0xd0]
XOR ECX,ECX
PUSH RAX
PUSH R10
PUSH 0x0
PUSH R11
PUSH R10
PUSH 0x2
PUSH 0x3
CALL 0x00133a9e
ADD RSP,0x40
MOV R13D,EAX
TEST AL,AL
JNZ 0x00163568
LEA RSI,[RBP + -0xd0]
MOV dword ptr [RSI + 0x8],0x5
MOV byte ptr [RSI + 0x10],0x1
ADD R15,0x2e8
MOV RDI,R15
CALL 0x00191bc6
LAB_00163568:
MOV RSI,qword ptr [R14]
MOV RAX,qword ptr [RBP + -0x58]
IMUL RSI,RAX
CMP qword ptr [R12 + 0x40],RSI
JA 0x00163340
ADD RSI,RAX
MOV RDI,R12
CALL 0x00138d24
JMP 0x00163340
LAB_0016358e:
CALL 0x00129270
|
ulong write_tail(long *param_1,long *param_2,void *param_3,uint param_4)
{
long lVar1;
long *plVar2;
char cVar3;
uint uVar4;
int iVar5;
byte bVar6;
ulong uVar7;
int8 unaff_R13;
ulong uVar8;
long in_FS_OFFSET;
int1 local_d8 [8];
int4 local_d0;
int1 local_c8;
int1 *local_b8;
int8 local_b0;
void *local_a8;
ulong local_a0;
int1 local_98 [8];
long local_90;
void *local_88;
long local_80;
int local_74;
int local_70;
void *local_68;
ulong local_60;
long local_58;
long *local_50;
char local_41;
int1 local_40 [2];
int4 local_3e;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = *param_1;
local_60 = (ulong)*(uint *)(local_58 + 0x7bc);
uVar7 = 0x20;
if (0x20 < param_4) {
uVar7 = (ulong)param_4;
}
*(int1 *)((long)param_1 + 0x685) = 1;
local_68 = param_3;
if (*(uint *)(param_2 + 1) == 0xffff) {
cVar3 = get_head_or_tail_page(param_1,param_2,param_1[0x70],uVar7,2,&local_90);
}
else {
cVar3 = get_rowpos_in_head_or_tail_page
(param_1,param_2,param_1[0x70],uVar7,2,*(uint *)(param_2 + 1) & 0xffff7fff,
&local_90);
}
uVar8 = CONCAT71((int7)((ulong)unaff_R13 >> 8),1);
if (cVar3 == '\0') {
cVar3 = *(char *)((long)param_2 + 0x15);
local_50 = param_2;
memcpy(local_88,local_68,(ulong)param_4);
plVar2 = local_50;
local_41 = cVar3;
if (*(char *)(local_58 + 0x7e7) != '\0') {
local_b8 = local_40;
local_3e = (int4)*local_50;
local_3a = (int1)((ulong)*local_50 >> 0x20);
local_39 = (int1)local_74;
local_b0 = 8;
local_a8 = local_88;
local_a0 = uVar7;
cVar3 = translog_write_record
(local_98,(cVar3 == '\0') * '\x02' + '\x02',param_1[1],param_1,
(int)uVar7 + 8,4,local_d8,local_b8,0);
uVar8 = CONCAT71((int7)((ulong)local_88 >> 8),1);
if (cVar3 != '\0') goto LAB_00163340;
}
lVar1 = local_58;
*(short *)(local_80 + 2) = (short)uVar7;
local_70 = local_70 - (int)uVar7;
*(short *)(local_90 + 10) = (short)local_70;
*(int *)(plVar2 + 1) = local_74 + 0x8000;
iVar5 = *(int *)(local_58 + 0x3f0) + (uint)*(byte *)(local_90 + 8);
if (0xff < iVar5 + 1U) {
bVar6 = *(byte *)(local_90 + 9);
if (bVar6 != 0xff) {
iVar5 = iVar5 + -0xfe;
do {
iVar5 = iVar5 + -1;
if (iVar5 == 0) goto LAB_001634a1;
bVar6 = *(byte *)((ulong)*(uint *)(local_58 + 0x7bc) + local_90 + -5 + (ulong)bVar6 * -4);
} while (bVar6 != 0xff);
}
local_70 = 0;
}
LAB_001634a1:
*(byte *)((long)plVar2 + 0x14) = *(byte *)((long)plVar2 + 0x14) | 5;
*(int *)((long)plVar2 + 0xc) = local_70;
if (local_41 == '\0') {
uVar4 = pagecache_write_part
(*(long *)(local_58 + 0x600),param_1 + 0x8e,*plVar2,0,local_90,
*(int4 *)(local_58 + 0x7d4),3,2,0,local_d8,0,0,
*(int4 *)(*(long *)(local_58 + 0x600) + 0x80));
uVar8 = (ulong)uVar4;
if ((char)uVar4 == '\0') {
local_d0 = 5;
local_c8 = 1;
insert_dynamic(param_1 + 0x5d);
}
if (*(ulong *)(lVar1 + 0x40) <= *plVar2 * local_60) {
_ma_set_share_data_file_length(lVar1,*plVar2 * local_60 + local_60);
}
}
else {
lVar1 = param_1[0x5d];
uVar7 = (ulong)((int)param_1[0x5e] - 1);
uVar8 = 0;
pagecache_unlock_by_link
(*(int8 *)(local_58 + 0x600),*(int8 *)(lVar1 + uVar7 * 0x18),7,0,0,0,1,0
);
*(int4 *)(lVar1 + 8 + uVar7 * 0x18) = 5;
}
}
LAB_00163340:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar8 & 0xffffffff;
}
|
|
9,611 |
FileExists
|
csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rcore.c
|
bool FileExists(const char *fileName)
{
bool result = false;
#if defined(_WIN32)
if (_access(fileName, 0) != -1) result = true;
#else
if (access(fileName, F_OK) != -1) result = true;
#endif
// NOTE: Alternatively, stat() can be used instead of access()
//#include <sys/stat.h>
//struct stat statbuf;
//if (stat(filename, &statbuf) == 0) result = true;
return result;
}
|
O3
|
c
|
FileExists:
pushq %rax
xorl %esi, %esi
callq 0xa960
cmpl $-0x1, %eax
setne %al
popq %rcx
retq
|
FileExists:
push rax
xor esi, esi
call _access
cmp eax, 0FFFFFFFFh
setnz al
pop rcx
retn
|
bool FileExists(long long a1)
{
return (unsigned int)access(a1, 0LL) != -1;
}
|
FileExists:
PUSH RAX
XOR ESI,ESI
CALL 0x0010a960
CMP EAX,-0x1
SETNZ AL
POP RCX
RET
|
bool FileExists(char *param_1)
{
int iVar1;
iVar1 = access(param_1,0);
return iVar1 != -1;
}
|
|
9,612 |
JS_LoadModuleInternal
|
bluesky950520[P]quickjs/quickjs.c
|
static void JS_LoadModuleInternal(JSContext *ctx, const char *basename,
const char *filename,
JSValueConst *resolving_funcs)
{
JSValue evaluate_promise;
JSModuleDef *m;
JSValue ret, err, func_obj, evaluate_resolving_funcs[2];
JSValueConst func_data[3];
m = js_host_resolve_imported_module(ctx, basename, filename);
if (!m)
goto fail;
if (js_resolve_module(ctx, m) < 0) {
js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
goto fail;
}
/* Evaluate the module code */
func_obj = JS_NewModuleValue(ctx, m);
evaluate_promise = JS_EvalFunction(ctx, func_obj);
if (JS_IsException(evaluate_promise)) {
fail:
err = JS_GetException(ctx);
ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
1, (JSValueConst *)&err);
JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
JS_FreeValue(ctx, err);
return;
}
func_obj = JS_NewModuleValue(ctx, m);
func_data[0] = resolving_funcs[0];
func_data[1] = resolving_funcs[1];
func_data[2] = func_obj;
evaluate_resolving_funcs[0] = JS_NewCFunctionData(ctx, js_load_module_fulfilled, 0, 0, 3, func_data);
evaluate_resolving_funcs[1] = JS_NewCFunctionData(ctx, js_load_module_rejected, 0, 0, 3, func_data);
JS_FreeValue(ctx, func_obj);
ret = js_promise_then(ctx, evaluate_promise, 2, (JSValueConst *)evaluate_resolving_funcs);
JS_FreeValue(ctx, ret);
JS_FreeValue(ctx, evaluate_resolving_funcs[0]);
JS_FreeValue(ctx, evaluate_resolving_funcs[1]);
JS_FreeValue(ctx, evaluate_promise);
}
|
O1
|
c
|
JS_LoadModuleInternal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r13
movq %rdi, %rbx
callq 0x43b3f
testq %rax, %rax
je 0x31159
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x315c5
testl %eax, %eax
js 0x3114c
incl (%r12)
movq 0x1a0(%rbx), %rcx
movq 0x1a8(%rbx), %r8
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq $-0x3, %rdx
xorl %r9d, %r9d
callq 0x31210
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x31159
incl (%r12)
movups (%r13), %xmm0
leaq 0x40(%rsp), %r14
movaps %xmm0, (%r14)
movups 0x10(%r13), %xmm0
movaps %xmm0, 0x10(%r14)
movq %r12, 0x20(%r14)
movq $-0x3, 0x28(%r14)
leaq 0x12d99(%rip), %rsi # 0x43e13
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x3, %r8d
movq %r14, %r9
movq %rax, 0x28(%rsp)
callq 0x210ea
movq %rax, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x70(%rsp), %rbp
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
leaq 0x12e38(%rip), %rsi # 0x43eea
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x3, %r8d
movq %r14, %r9
callq 0x210ea
movq %rax, %r14
movq %rdx, %r13
movq %rax, 0x10(%rbp)
movq %rdx, 0x18(%rbp)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq $-0x3, %rdx
callq 0x1d8c6
movq %rbx, %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %r8
callq 0x43f7a
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d8c6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1fd30
movq 0x18(%rbx), %rax
movups 0xf0(%rax), %xmm0
xorl %ecx, %ecx
movl %ecx, 0xf0(%rax)
movq $0x4, 0xf8(%rax)
leaq 0x70(%rsp), %r14
movaps %xmm0, (%r14)
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movl %ecx, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x284ca
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1d8c6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_LoadModuleInternal:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r13, rcx
mov rbx, rdi
call js_host_resolve_imported_module
test rax, rax
jz loc_31159
mov r12, rax
mov rdi, rbx
mov rsi, rax
call js_resolve_module
test eax, eax
js loc_3114C
inc dword ptr [r12]
mov rcx, [rbx+1A0h]
mov r8, [rbx+1A8h]
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, rbx
mov rsi, r12
mov rdx, 0FFFFFFFFFFFFFFFDh
xor r9d, r9d
call JS_EvalFunctionInternal
mov r15, rdx
cmp r15d, 6
jz loc_31159
inc dword ptr [r12]
movups xmm0, xmmword ptr [r13+0]
lea r14, [rsp+0C8h+var_88]
movaps xmmword ptr [r14], xmm0
movups xmm0, xmmword ptr [r13+10h]
movaps xmmword ptr [r14+10h], xmm0
mov [r14+20h], r12
mov qword ptr [r14+28h], 0FFFFFFFFFFFFFFFDh
lea rsi, js_load_module_fulfilled
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r8d, 3
mov r9, r14
mov [rsp+0C8h+var_A0], rax
call JS_NewCFunctionData
mov [rsp+0C8h+var_90], rax
mov [rsp+0C8h+var_98], rdx
lea rbp, [rsp+0C8h+var_58]
mov [rbp+0], rax
mov [rbp+8], rdx
lea rsi, js_load_module_rejected
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r8d, 3
mov r9, r14
call JS_NewCFunctionData
mov r14, rax
mov r13, rdx
mov [rbp+10h], rax
mov [rbp+18h], rdx
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, 0FFFFFFFFFFFFFFFDh
call JS_FreeValueRT
mov rdi, rbx
mov r12, [rsp+0C8h+var_A0]
mov rsi, r12
mov rdx, r15
mov r8, rbp
call js_promise_then
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, [rsp+0C8h+var_90]
mov rdx, [rsp+0C8h+var_98]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r13
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, r15
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValueRT
loc_3114C:
mov rdi, rbx
mov esi, 1
call js_free_modules
loc_31159:
mov rax, [rbx+18h]
movups xmm0, xmmword ptr [rax+0F0h]
xor ecx, ecx
mov [rax+0F0h], ecx
mov qword ptr [rax+0F8h], 4
lea r14, [rsp+0C8h+var_58]
movaps xmmword ptr [r14], xmm0
mov rsi, [r13+10h]
mov rdx, [r13+18h]
mov dword ptr [rsp+0C8h+var_88], ecx
mov qword ptr [rsp+0C8h+var_88+8], 3
movups xmm0, [rsp+0C8h+var_88]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B8], r14
mov [rsp+0C8h+var_B0], 2
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, [rbx+18h]
call JS_FreeValueRT
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long JS_LoadModuleInternal(
long long *a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
__m128 *a12)
{
long long v13; // rax
__m128 v14; // xmm4
__m128 v15; // xmm5
_DWORD *v16; // r12
long long v17; // rax
long long v18; // rdx
long long v19; // r15
long long v20; // rdx
_DWORD *v21; // r14
long long v22; // rdx
long long v23; // r13
long long v24; // rcx
_DWORD *v25; // rax
long long v26; // rdx
long long v28; // rax
__int128 v29; // xmm0
long long v30; // rsi
long long v31; // rdx
_DWORD *v32; // rax
long long v33; // rdx
_DWORD *v34; // [rsp+28h] [rbp-A0h]
long long v35; // [rsp+30h] [rbp-98h]
_DWORD *v36; // [rsp+38h] [rbp-90h]
__m128 v37[2]; // [rsp+40h] [rbp-88h] BYREF
_DWORD *v38; // [rsp+60h] [rbp-68h]
long long v39; // [rsp+68h] [rbp-60h]
__int128 v40; // [rsp+70h] [rbp-58h] BYREF
_DWORD *v41; // [rsp+80h] [rbp-48h]
long long v42; // [rsp+88h] [rbp-40h]
v13 = js_host_resolve_imported_module();
if ( v13 )
{
v16 = (_DWORD *)v13;
if ( (int)js_resolve_module(a1, v13) < 0 )
{
js_free_modules((long long)a1, 1);
}
else
{
++*v16;
v17 = JS_EvalFunctionInternal((_DWORD)a1, (_DWORD)v16, -3, a1[52], a1[53], 0, 0LL);
v19 = v18;
if ( (_DWORD)v18 != 6 )
{
++*v16;
v37[0] = *a12;
v37[1] = a12[1];
v38 = v16;
v39 = -3LL;
v34 = (_DWORD *)v17;
v36 = (_DWORD *)JS_NewCFunctionData(a1, (long long)js_load_module_fulfilled, 0, 0, 3, (long long)v37);
v35 = v20;
*(_QWORD *)&v40 = v36;
*((_QWORD *)&v40 + 1) = v20;
v21 = (_DWORD *)JS_NewCFunctionData(a1, (long long)js_load_module_rejected, 0, 0, 3, (long long)v37);
v23 = v22;
v41 = v21;
v42 = v22;
JS_FreeValueRT(a1[3], v16, -3LL);
v25 = (_DWORD *)js_promise_then(a1, v34, v19, v24, &v40);
JS_FreeValueRT(a1[3], v25, v26);
JS_FreeValueRT(a1[3], v36, v35);
JS_FreeValueRT(a1[3], v21, v23);
return JS_FreeValueRT(a1[3], v34, v19);
}
}
}
v28 = a1[3];
v29 = *(_OWORD *)(v28 + 240);
*(_DWORD *)(v28 + 240) = 0;
*(_QWORD *)(v28 + 248) = 4LL;
v40 = v29;
v30 = a12[1].m128_i64[0];
v31 = a12[1].m128_i64[1];
v37[0].m128_i32[0] = 0;
v37[0].m128_u64[1] = 3LL;
v32 = (_DWORD *)JS_CallInternal(
(long long)a1,
v30,
v31,
0LL,
3LL,
1LL,
v37[0],
a3,
a4,
a5,
v14,
v15,
a8,
a9,
0,
3,
(long long)&v40,
2u);
JS_FreeValueRT(a1[3], v32, v33);
return JS_FreeValueRT(a1[3], (_DWORD *)v40, *((long long *)&v40 + 1));
}
| |||
9,613 |
JS_LoadModuleInternal
|
bluesky950520[P]quickjs/quickjs.c
|
static void JS_LoadModuleInternal(JSContext *ctx, const char *basename,
const char *filename,
JSValueConst *resolving_funcs)
{
JSValue evaluate_promise;
JSModuleDef *m;
JSValue ret, err, func_obj, evaluate_resolving_funcs[2];
JSValueConst func_data[3];
m = js_host_resolve_imported_module(ctx, basename, filename);
if (!m)
goto fail;
if (js_resolve_module(ctx, m) < 0) {
js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
goto fail;
}
/* Evaluate the module code */
func_obj = JS_NewModuleValue(ctx, m);
evaluate_promise = JS_EvalFunction(ctx, func_obj);
if (JS_IsException(evaluate_promise)) {
fail:
err = JS_GetException(ctx);
ret = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
1, (JSValueConst *)&err);
JS_FreeValue(ctx, ret); /* XXX: what to do if exception ? */
JS_FreeValue(ctx, err);
return;
}
func_obj = JS_NewModuleValue(ctx, m);
func_data[0] = resolving_funcs[0];
func_data[1] = resolving_funcs[1];
func_data[2] = func_obj;
evaluate_resolving_funcs[0] = JS_NewCFunctionData(ctx, js_load_module_fulfilled, 0, 0, 3, func_data);
evaluate_resolving_funcs[1] = JS_NewCFunctionData(ctx, js_load_module_rejected, 0, 0, 3, func_data);
JS_FreeValue(ctx, func_obj);
ret = js_promise_then(ctx, evaluate_promise, 2, (JSValueConst *)evaluate_resolving_funcs);
JS_FreeValue(ctx, ret);
JS_FreeValue(ctx, evaluate_resolving_funcs[0]);
JS_FreeValue(ctx, evaluate_resolving_funcs[1]);
JS_FreeValue(ctx, evaluate_promise);
}
|
O2
|
c
|
JS_LoadModuleInternal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r13
movq %rdi, %rbx
callq 0x3b675
testq %rax, %rax
je 0x296cc
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29a5e
testl %eax, %eax
js 0x296c1
incl (%r12)
pushq $-0x3
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29739
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x296cc
incl (%r12)
movups (%r13), %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movups 0x10(%r13), %xmm0
movaps %xmm0, 0x10(%r14)
movq %r12, 0x20(%r14)
movq $-0x3, 0x28(%r14)
leaq 0x12285(%rip), %rsi # 0x3b882
pushq $0x3
popq %r13
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r13d, %r8d
movq %r14, %r9
movq %rax, 0x8(%rsp)
callq 0x1b3ba
movq %rax, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x50(%rsp), %rbp
movq %rax, (%rbp)
movq %rdx, 0x8(%rbp)
leaq 0x122f3(%rip), %rsi # 0x3b929
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r13d, %r8d
movq %r14, %r9
callq 0x1b3ba
movq %rax, %r14
movq %rdx, %r13
movq %rax, 0x10(%rbp)
movq %rdx, 0x18(%rbp)
pushq $-0x3
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1801e
movq %rbx, %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %r8
callq 0x3b993
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1801e
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1801e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1a12f
movq 0x18(%rbx), %rax
movups 0xf0(%rax), %xmm0
andl $0x0, 0xf0(%rax)
movq $0x4, 0xf8(%rax)
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %r14, (%rsp)
pushq $0x3
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x21eb6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1801e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_LoadModuleInternal:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r13, rcx
mov rbx, rdi
call js_host_resolve_imported_module
test rax, rax
jz loc_296CC
mov r12, rax
mov rdi, rbx
mov rsi, rax
call js_resolve_module
test eax, eax
js loc_296C1
inc dword ptr [r12]
push 0FFFFFFFFFFFFFFFDh
pop rdx
mov rdi, rbx
mov rsi, r12
call JS_EvalFunction
mov r15, rdx
cmp r15d, 6
jz loc_296CC
inc dword ptr [r12]
movups xmm0, xmmword ptr [r13+0]
lea r14, [rsp+0A8h+var_88]
movaps xmmword ptr [r14], xmm0
movups xmm0, xmmword ptr [r13+10h]
movaps xmmword ptr [r14+10h], xmm0
mov [r14+20h], r12
mov qword ptr [r14+28h], 0FFFFFFFFFFFFFFFDh
lea rsi, js_load_module_fulfilled
push 3
pop r13
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r8d, r13d
mov r9, r14
mov [rsp+0A8h+var_A0], rax
call JS_NewCFunctionData
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_98], rdx
lea rbp, [rsp+0A8h+var_58]
mov [rbp+0], rax
mov [rbp+8], rdx
lea rsi, js_load_module_rejected
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r8d, r13d
mov r9, r14
call JS_NewCFunctionData
mov r14, rax
mov r13, rdx
mov [rbp+10h], rax
mov [rbp+18h], rdx
push 0FFFFFFFFFFFFFFFDh
pop rdx
mov rdi, rbx
mov rsi, r12
call JS_FreeValue
mov rdi, rbx
mov r12, [rsp+0A8h+var_A0]
mov rsi, r12
mov rdx, r15
mov r8, rbp
call js_promise_then
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+0A8h+var_90]
mov rdx, [rsp+0A8h+var_98]
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
mov rdx, r13
call JS_FreeValue
mov rdi, rbx
mov rsi, r12
mov rdx, r15
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValue
loc_296C1:
push 1
pop rsi
mov rdi, rbx
call js_free_modules
loc_296CC:
mov rax, [rbx+18h]
movups xmm0, xmmword ptr [rax+0F0h]
and dword ptr [rax+0F0h], 0
mov qword ptr [rax+0F8h], 4
lea r14, [rsp+0A8h+var_88]
movaps xmmword ptr [r14], xmm0
mov rsi, [r13+10h]
mov rdx, [r13+18h]
mov [rsp+0A8h+var_A8], r14
push 3
pop r8
push 1
pop r9
mov rdi, rbx
xor ecx, ecx
call JS_Call
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_FreeValue
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long JS_LoadModuleInternal(long long a1, long long a2, long long a3, long long a4)
{
long long v5; // rax
_DWORD *v6; // r12
long long v7; // rax
long long v8; // rdx
long long v9; // r15
long long v10; // rdx
unsigned long long v11; // r14
long long v12; // rdx
long long v13; // r13
long long v14; // rcx
long long v15; // rax
long long v16; // rdx
long long v18; // rax
__int128 v19; // xmm0
long long v20; // rax
long long v21; // rdx
long long v22; // [rsp+8h] [rbp-A0h]
long long v23; // [rsp+10h] [rbp-98h]
unsigned long long v24; // [rsp+18h] [rbp-90h]
_OWORD v25[2]; // [rsp+20h] [rbp-88h] BYREF
_DWORD *v26; // [rsp+40h] [rbp-68h]
long long v27; // [rsp+48h] [rbp-60h]
_QWORD v28[11]; // [rsp+50h] [rbp-58h] BYREF
v5 = js_host_resolve_imported_module();
if ( v5 )
{
v6 = (_DWORD *)v5;
if ( (int)js_resolve_module(a1, v5) < 0 )
{
js_free_modules(a1, 1);
}
else
{
++*v6;
v7 = JS_EvalFunction(a1, v6, -3LL);
v9 = v8;
if ( (_DWORD)v8 != 6 )
{
++*v6;
v25[0] = *(_OWORD *)a4;
v25[1] = *(_OWORD *)(a4 + 16);
v26 = v6;
v27 = -3LL;
v22 = v7;
v24 = JS_NewCFunctionData(a1, (long long)js_load_module_fulfilled, 0, 0, 3u, (long long)v25);
v23 = v10;
v28[0] = v24;
v28[1] = v10;
v11 = JS_NewCFunctionData(a1, (long long)js_load_module_rejected, 0, 0, 3u, (long long)v25);
v13 = v12;
v28[2] = v11;
v28[3] = v12;
JS_FreeValue(a1, (long long)v6, -3LL);
v15 = js_promise_then(a1, v22, v9, v14, v28);
JS_FreeValue(a1, v15, v16);
JS_FreeValue(a1, v24, v23);
JS_FreeValue(a1, v11, v13);
return JS_FreeValue(a1, v22, v9);
}
}
}
v18 = *(_QWORD *)(a1 + 24);
v19 = *(_OWORD *)(v18 + 240);
*(_DWORD *)(v18 + 240) = 0;
*(_QWORD *)(v18 + 248) = 4LL;
v25[0] = v19;
v20 = JS_Call(a1, *(_QWORD *)(a4 + 16), *(_QWORD *)(a4 + 24), 0, 3, 1, (long long)v25);
JS_FreeValue(a1, v20, v21);
return JS_FreeValue(a1, *(long long *)&v25[0], *((long long *)&v25[0] + 1));
}
|
JS_LoadModuleInternal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R13,RCX
MOV RBX,RDI
CALL 0x0013b675
TEST RAX,RAX
JZ 0x001296cc
MOV R12,RAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00129a5e
TEST EAX,EAX
JS 0x001296c1
INC dword ptr [R12]
PUSH -0x3
POP RDX
MOV RDI,RBX
MOV RSI,R12
CALL 0x00129739
MOV R15,RDX
CMP R15D,0x6
JZ 0x001296cc
INC dword ptr [R12]
MOVUPS XMM0,xmmword ptr [R13]
LEA R14,[RSP + 0x20]
MOVAPS xmmword ptr [R14],XMM0
MOVUPS XMM0,xmmword ptr [R13 + 0x10]
MOVAPS xmmword ptr [R14 + 0x10],XMM0
MOV qword ptr [R14 + 0x20],R12
MOV qword ptr [R14 + 0x28],-0x3
LEA RSI,[0x13b882]
PUSH 0x3
POP R13
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,R13D
MOV R9,R14
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0011b3ba
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],RDX
LEA RBP,[RSP + 0x50]
MOV qword ptr [RBP],RAX
MOV qword ptr [RBP + 0x8],RDX
LEA RSI,[0x13b929]
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,R13D
MOV R9,R14
CALL 0x0011b3ba
MOV R14,RAX
MOV R13,RDX
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBP + 0x18],RDX
PUSH -0x3
POP RDX
MOV RDI,RBX
MOV RSI,R12
CALL 0x0011801e
MOV RDI,RBX
MOV R12,qword ptr [RSP + 0x8]
MOV RSI,R12
MOV RDX,R15
MOV R8,RBP
CALL 0x0013b993
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011801e
LAB_001296c1:
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x0011a12f
LAB_001296cc:
MOV RAX,qword ptr [RBX + 0x18]
MOVUPS XMM0,xmmword ptr [RAX + 0xf0]
AND dword ptr [RAX + 0xf0],0x0
MOV qword ptr [RAX + 0xf8],0x4
LEA R14,[RSP + 0x20]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [R13 + 0x10]
MOV RDX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP],R14
PUSH 0x3
POP R8
PUSH 0x1
POP R9
MOV RDI,RBX
XOR ECX,ECX
CALL 0x00121eb6
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011801e
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void JS_LoadModuleInternal(long param_1,int8 param_2,int8 param_3,int8 *param_4)
{
long lVar1;
int iVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int1 auVar9 [16];
int8 local_88;
int8 uStack_80;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int *local_68;
int8 local_60;
int1 local_58 [16];
int1 local_48 [16];
piVar3 = (int *)js_host_resolve_imported_module();
if (piVar3 != (int *)0x0) {
iVar2 = js_resolve_module(param_1,piVar3);
if (iVar2 < 0) {
js_free_modules(param_1,1);
}
else {
*piVar3 = *piVar3 + 1;
auVar9 = JS_EvalFunction(param_1,piVar3,0xfffffffffffffffd);
if (auVar9._8_4_ != 6) {
*piVar3 = *piVar3 + 1;
local_88 = *param_4;
uStack_80 = param_4[1];
local_78 = *(int4 *)(param_4 + 2);
uStack_74 = *(int4 *)((long)param_4 + 0x14);
uStack_70 = *(int4 *)(param_4 + 3);
uStack_6c = *(int4 *)((long)param_4 + 0x1c);
local_60 = 0xfffffffffffffffd;
local_68 = piVar3;
local_58 = JS_NewCFunctionData(param_1,js_load_module_fulfilled,0,0,3,&local_88);
uVar7 = local_58._8_8_;
uVar6 = local_58._0_8_;
local_48 = JS_NewCFunctionData(param_1,js_load_module_rejected,0,0,3,&local_88);
uVar8 = local_48._8_8_;
uVar4 = local_48._0_8_;
JS_FreeValue(param_1,piVar3,0xfffffffffffffffd);
uVar5 = js_promise_then(param_1,auVar9._0_8_,auVar9._8_8_);
JS_FreeValue(param_1,uVar5);
JS_FreeValue(param_1,uVar6,uVar7);
JS_FreeValue(param_1,uVar4,uVar8);
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
return;
}
}
}
lVar1 = *(long *)(param_1 + 0x18);
local_88 = *(int8 *)(lVar1 + 0xf0);
uStack_80 = *(int8 *)(lVar1 + 0xf8);
*(int4 *)(lVar1 + 0xf0) = 0;
*(int8 *)(lVar1 + 0xf8) = 4;
uVar6 = JS_Call(param_1,param_4[2],param_4[3],0,3,1,&local_88);
JS_FreeValue(param_1,uVar6);
JS_FreeValue(param_1,local_88,uStack_80);
return;
}
|
|
9,614 |
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!left) throw std::runtime_error("BinaryOpExpr.left is null");
if (!right) throw std::runtime_error("BinaryOpExpr.right is null");
auto l = left->evaluate(context);
auto do_eval = [&](const Value & l) -> Value {
if (op == Op::Is || op == Op::IsNot) {
auto t = dynamic_cast<VariableExpr*>(right.get());
if (!t) throw std::runtime_error("Right side of 'is' operator must be a variable");
auto eval = [&]() {
const auto & name = t->get_name();
if (name == "none") return l.is_null();
if (name == "boolean") return l.is_boolean();
if (name == "integer") return l.is_number_integer();
if (name == "float") return l.is_number_float();
if (name == "number") return l.is_number();
if (name == "string") return l.is_string();
if (name == "mapping") return l.is_object();
if (name == "iterable") return l.is_iterable();
if (name == "sequence") return l.is_array();
if (name == "defined") return !l.is_null();
throw std::runtime_error("Unknown type for 'is' operator: " + name);
};
auto value = eval();
return Value(op == Op::Is ? value : !value);
}
if (op == Op::And) {
if (!l.to_bool()) return Value(false);
return right->evaluate(context).to_bool();
} else if (op == Op::Or) {
if (l.to_bool()) return l;
return right->evaluate(context);
}
auto r = right->evaluate(context);
switch (op) {
case Op::StrConcat: return l.to_str() + r.to_str();
case Op::Add: return l + r;
case Op::Sub: return l - r;
case Op::Mul: return l * r;
case Op::Div: return l / r;
case Op::MulMul: return std::pow(l.get<double>(), r.get<double>());
case Op::DivDiv: return l.get<int64_t>() / r.get<int64_t>();
case Op::Mod: return l.get<int64_t>() % r.get<int64_t>();
case Op::Eq: return l == r;
case Op::Ne: return l != r;
case Op::Lt: return l < r;
case Op::Gt: return l > r;
case Op::Le: return l <= r;
case Op::Ge: return l >= r;
case Op::In: return (r.is_array() || r.is_object()) && r.contains(l);
case Op::NotIn: return !(r.is_array() && r.contains(l));
default: break;
}
throw std::runtime_error("Unknown binary operator");
};
if (l.is_callable()) {
return Value::callable([l, do_eval](const std::shared_ptr<Context> & context, ArgumentsValue & args) {
auto ll = l.call(context, args);
return do_eval(ll); //args[0].second);
});
} else {
return do_eval(l);
}
}
|
O2
|
cpp
|
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x6f695
cmpq $0x0, 0x30(%r15)
je 0x6f6b1
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x62a82
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x30(%r12)
je 0x6f667
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x686e8
movups 0x8(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movups %xmm0, 0x50(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x6f7b8
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f76c
leaq 0x18(%rsp), %rdi
callq 0x47c98
leaq 0x88(%rsp), %rdi
callq 0x62d12
jmp 0x6f679
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x6f800
leaq 0x38(%rsp), %rdi
callq 0x62d12
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x45169(%rip), %rsi # 0xb4810
movq %rax, %rdi
callq 0x23340
jmp 0x6f6cb
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x45167(%rip), %rsi # 0xb482a
movq %rax, %rdi
callq 0x23340
movq 0x8e91e(%rip), %rsi # 0xfdff0
movq 0x8e87f(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f30
jmp 0x6f713
jmp 0x6f6e5
movq %rax, %rbx
movq %r14, %rdi
callq 0x236b0
jmp 0x6f720
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x47c98
jmp 0x6f704
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x62d12
jmp 0x6f716
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62d12
movq %rbx, %rdi
callq 0x23fd0
|
_ZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0E8h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_6F695
cmp qword ptr [r15+30h], 0
jz loc_6F6B1
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+108h+var_D0]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov qword ptr [rsp+108h+var_100], r15
mov qword ptr [rsp+108h+var_100+8], r14
cmp qword ptr [r12+30h], 0
jz short loc_6F667
lea rdi, [rsp+108h+var_80]; this
lea rsi, [rsp+108h+var_D0]; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
movups xmm0, [rsp+108h+var_100]
lea rsi, [rsp+108h+var_80]
movups xmmword ptr [rsi+50h], xmm0
lea rdi, [rsp+108h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEC2IZNKS0_12BinaryOpExpr11do_evaluateES6_EUlS6_S8_E_vEEOT_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1} &&)
lea rsi, [rsp+108h+var_F0]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
lea rdi, [rsp+108h+var_F0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+108h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_6F679
loc_6F667:
lea rsi, [rsp+108h+var_100]
lea rdx, [rsp+108h+var_D0]
mov rdi, rbx; this
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENKUlRKNS_5ValueEE_clES8_; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}::operator()(minja::Value const&)
loc_6F679:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_6F695:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprLe; "BinaryOpExpr.left is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_6F6CB
loc_6F6B1:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprRi; "BinaryOpExpr.right is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_6F6CB:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_6F713
jmp short $+2
loc_6F6E5:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_6F720
mov rbx, rax
lea rdi, [rsp+108h+var_F0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_6F704
mov rbx, rax
loc_6F704:
lea rdi, [rsp+108h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_6F716
loc_6F713:
mov rbx, rax
loc_6F716:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_6F720:
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::BinaryOpExpr::do_evaluate(minja::Value *this, long long a2, long long a3)
{
void (***v4)(void); // rsi
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
std::runtime_error *exception; // r14
__int128 v12; // [rsp+8h] [rbp-100h]
_BYTE v13[32]; // [rsp+18h] [rbp-F0h] BYREF
_BYTE v14[48]; // [rsp+38h] [rbp-D0h] BYREF
long long v15; // [rsp+68h] [rbp-A0h]
_BYTE v16[80]; // [rsp+88h] [rbp-80h] BYREF
__int128 v17; // [rsp+D8h] [rbp-30h]
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.left is null");
goto LABEL_9;
}
if ( !*(_QWORD *)(a2 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.right is null");
LABEL_9:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v14, v4);
*(_QWORD *)&v12 = a2;
*((_QWORD *)&v12 + 1) = a3;
if ( v15 )
{
minja::Value::Value((minja::Value *)v16, (const minja::Value *)v14);
v17 = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(v13);
minja::Value::callable((_DWORD)this, (unsigned int)v13, v6, v7, v8, v9);
std::_Function_base::~_Function_base((std::_Function_base *)v13);
minja::Value::~Value((minja::Value *)v16);
}
else
{
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)const::{lambda(minja::Value const&)#1}::operator()(this);
}
minja::Value::~Value((minja::Value *)v14);
return this;
}
|
do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0016f695
CMP qword ptr [R15 + 0x30],0x0
JZ 0x0016f6b1
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x00162a82
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],R14
CMP qword ptr [R12 + 0x30],0x0
JZ 0x0016f667
LAB_0016f614:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x38]
CALL 0x001686e8
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x88]
MOVUPS xmmword ptr [RSI + 0x50],XMM0
LAB_0016f637:
LEA RDI,[RSP + 0x18]
CALL 0x0016f7b8
LAB_0016f641:
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x0016f76c
LEA RDI,[RSP + 0x18]
CALL 0x00147c98
LEA RDI,[RSP + 0x88]
CALL 0x00162d12
JMP 0x0016f679
LAB_0016f667:
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x38]
MOV RDI,RBX
CALL 0x0016f800
LAB_0016f679:
LEA RDI,[RSP + 0x38]
CALL 0x00162d12
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0016f695:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_0016f6a0:
LEA RSI,[0x1b4810]
MOV RDI,RAX
CALL 0x00123340
LAB_0016f6af:
JMP 0x0016f6cb
LAB_0016f6b1:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_0016f6bc:
LEA RSI,[0x1b482a]
MOV RDI,RAX
CALL 0x00123340
LAB_0016f6cb:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f30
|
/* minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::BinaryOpExpr::do_evaluate(shared_ptr *param_1)
{
runtime_error *this;
int8 in_RDX;
long in_RSI;
long local_100;
int8 uStack_f8;
_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ local_f0 [32];
Expression local_d0 [48];
long local_a0;
Value local_80 [80];
long local_30;
int8 uStack_28;
if (*(shared_ptr **)(in_RSI + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016f6a0 to 0016f6ae has its CatchHandler @ 0016f6e5 */
std::runtime_error::runtime_error(this,"BinaryOpExpr.left is null");
}
else {
if (*(long *)(in_RSI + 0x30) != 0) {
Expression::evaluate(local_d0,*(shared_ptr **)(in_RSI + 0x20));
if (local_a0 == 0) {
/* try { // try from 0016f667 to 0016f678 has its CatchHandler @ 0016f6e1 */
const::{lambda(minja::Value_const&)#1}::operator()
((_lambda_minja__Value_const___1_ *)param_1,(Value *)&local_100);
}
else {
/* try { // try from 0016f614 to 0016f625 has its CatchHandler @ 0016f713 */
local_100 = in_RSI;
uStack_f8 = in_RDX;
Value::Value(local_80,(Value *)local_d0);
local_30 = local_100;
uStack_28 = uStack_f8;
/* try { // try from 0016f637 to 0016f640 has its CatchHandler @ 0016f701 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)_1_,void>
(local_f0);
/* try { // try from 0016f641 to 0016f64d has its CatchHandler @ 0016f6f2 */
Value::callable(param_1);
std::_Function_base::~_Function_base((_Function_base *)local_f0);
Value::~Value(local_80);
}
Value::~Value((Value *)local_d0);
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016f6bc to 0016f6ca has its CatchHandler @ 0016f6e3 */
std::runtime_error::runtime_error(this,"BinaryOpExpr.right is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
|
|
9,615 |
translog_free_link
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_free_link(PAGECACHE_BLOCK_LINK *direct_link)
{
DBUG_ENTER("translog_free_link");
DBUG_PRINT("info", ("Direct link: %p",
direct_link));
if (direct_link)
pagecache_unlock_by_link(log_descriptor.pagecache, direct_link,
PAGECACHE_LOCK_READ_UNLOCK, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, 0, FALSE);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_free_link:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x8c9ce
cmpq $0x0, -0x8(%rbp)
je 0x8ca08
movq 0x3f7ab4(%rip), %rdi # 0x484490
movq -0x8(%rbp), %rsi
movl $0x5, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x96b90
jmp 0x8ca0a
jmp 0x8ca0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
translog_free_link:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_8C9CE:
cmp [rbp+var_8], 0
jz short loc_8CA08
mov rdi, cs:log_descriptor
mov rsi, [rbp+var_8]
mov edx, 5
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+20h+var_20], 0
mov [rsp+20h+var_18], 0
call pagecache_unlock_by_link
loc_8CA08:
jmp short $+2
loc_8CA0A:
jmp short $+2
loc_8CA0C:
add rsp, 20h
pop rbp
retn
|
long long translog_free_link(long long a1)
{
long long result; // rax
if ( a1 )
return pagecache_unlock_by_link(log_descriptor[0], a1, 5, 3, 0, 0, 0, 0);
return result;
}
|
translog_free_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0018c9ce
LAB_0018c9ce:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0018ca08
MOV RDI,qword ptr [0x00584490]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x5
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x00196b90
LAB_0018ca08:
JMP 0x0018ca0a
LAB_0018ca0a:
JMP 0x0018ca0c
LAB_0018ca0c:
ADD RSP,0x20
POP RBP
RET
|
void translog_free_link(long param_1)
{
if (param_1 != 0) {
pagecache_unlock_by_link(log_descriptor,param_1,5,3,0,0,0,0);
}
return;
}
|
|
9,616 |
print_comment
|
eloqsql/mysys/my_getopt.c
|
static uint print_comment(const char *comment,
int curpos, int startpos, int width)
{
const char *end= strend(comment);
int endpos= startpos + width;
for (; curpos < startpos; curpos++)
putchar(' ');
if (*comment == '.' || *comment == ',')
{
putchar(*comment);
comment++;
curpos++;
}
while (end - comment > endpos - curpos)
{
const char *line_end;
for (line_end= comment + endpos - curpos;
line_end > comment && *line_end != ' ';
line_end--);
for (; comment < line_end; comment++)
putchar(*comment);
while (*comment == ' ')
comment++; /* skip the space, as a newline will take it's place now */
putchar('\n');
for (curpos= 0; curpos < startpos; curpos++)
putchar(' ');
}
printf("%s", comment);
return curpos + (int)(end - comment);
}
|
O0
|
c
|
print_comment:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x86e10
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x34fa8
movl $0x20, %edi
callq 0x25470
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34f8b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x34fc0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x34fe1
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x25470
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34fe3
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl -0x24(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x350c8
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x31(%rbp)
jbe 0x3503a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x35043
jmp 0x35053
jmp 0x35045
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3501b
jmp 0x35055
movq -0x8(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x35079
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x25470
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x35055
jmp 0x3507b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x35095
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3507b
movl $0xa, %edi
callq 0x25470
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x350c3
movl $0x20, %edi
callq 0x25470
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x350a6
jmp 0x34fe3
movq -0x8(%rbp), %rsi
leaq 0x57cd7(%rip), %rdi # 0x8cdaa
movb $0x0, %al
callq 0x25050
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
|
print_comment:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_14], ecx
mov rdi, [rbp+var_8]
call strend
mov [rbp+var_20], rax
mov eax, [rbp+var_10]
add eax, [rbp+var_14]
mov [rbp+var_24], eax
loc_34F8B:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jge short loc_34FA8
mov edi, 20h ; ' '
call _putchar
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_34F8B
loc_34FA8:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jz short loc_34FC0
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Ch ; ','
jnz short loc_34FE1
loc_34FC0:
mov rax, [rbp+var_8]
movsx edi, byte ptr [rax]
call _putchar
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_34FE1:
jmp short $+2
loc_34FE3:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
sub rax, rcx
mov ecx, [rbp+var_24]
sub ecx, [rbp+var_C]
movsxd rcx, ecx
cmp rax, rcx
jle loc_350C8
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_24]
add rax, rcx
movsxd rdx, [rbp+var_C]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_30], rax
loc_3501B:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_31], al
jbe short loc_3503A
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
setnz al
mov [rbp+var_31], al
loc_3503A:
mov al, [rbp+var_31]
test al, 1
jnz short loc_35043
jmp short loc_35053
loc_35043:
jmp short $+2
loc_35045:
mov rax, [rbp+var_30]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
jmp short loc_3501B
loc_35053:
jmp short $+2
loc_35055:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_30]
jnb short loc_35079
mov rax, [rbp+var_8]
movsx edi, byte ptr [rax]
call _putchar
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_35055
loc_35079:
jmp short $+2
loc_3507B:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jnz short loc_35095
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_3507B
loc_35095:
mov edi, 0Ah
call _putchar
mov [rbp+var_C], 0
loc_350A6:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jge short loc_350C3
mov edi, 20h ; ' '
call _putchar
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_350A6
loc_350C3:
jmp loc_34FE3
loc_350C8:
mov rsi, [rbp+var_8]
lea rdi, aAtLineDPosDS+13h; "%s"
mov al, 0
call _printf
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
mov rdx, [rbp+var_8]
sub rcx, rdx
add eax, ecx
add rsp, 40h
pop rbp
retn
|
long long print_comment(const char *a1, int j, int a3, int a4)
{
bool v5; // [rsp+Fh] [rbp-31h]
const char *i; // [rsp+10h] [rbp-30h]
int v7; // [rsp+1Ch] [rbp-24h]
long long v8; // [rsp+20h] [rbp-20h]
const char *v12; // [rsp+38h] [rbp-8h]
v12 = a1;
v8 = strend(a1);
v7 = a4 + a3;
while ( j < a3 )
{
putchar(32LL);
++j;
}
if ( *a1 == 46 || *a1 == 44 )
{
putchar((unsigned int)*a1);
v12 = a1 + 1;
++j;
}
while ( v8 - (long long)v12 > v7 - j )
{
for ( i = &v12[v7 - j]; ; --i )
{
v5 = 0;
if ( i > v12 )
v5 = *i != 32;
if ( !v5 )
break;
}
while ( v12 < i )
putchar((unsigned int)*v12++);
while ( *v12 == 32 )
++v12;
putchar(10LL);
for ( j = 0; j < a3; ++j )
putchar(32LL);
}
printf("%s", v12);
return (unsigned int)(v8 - (_DWORD)v12 + j);
}
|
print_comment:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV dword ptr [RBP + -0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00186e10
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
LAB_00134f8b:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x00134fa8
MOV EDI,0x20
CALL 0x00125470
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00134f8b
LAB_00134fa8:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JZ 0x00134fc0
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2c
JNZ 0x00134fe1
LAB_00134fc0:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDI,byte ptr [RAX]
CALL 0x00125470
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_00134fe1:
JMP 0x00134fe3
LAB_00134fe3:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
SUB RAX,RCX
MOV ECX,dword ptr [RBP + -0x24]
SUB ECX,dword ptr [RBP + -0xc]
MOVSXD RCX,ECX
CMP RAX,RCX
JLE 0x001350c8
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOVSXD RDX,dword ptr [RBP + -0xc]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_0013501b:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x31],AL
JBE 0x0013503a
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_0013503a:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x00135043
JMP 0x00135053
LAB_00135043:
JMP 0x00135045
LAB_00135045:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0013501b
LAB_00135053:
JMP 0x00135055
LAB_00135055:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00135079
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EDI,byte ptr [RAX]
CALL 0x00125470
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00135055
LAB_00135079:
JMP 0x0013507b
LAB_0013507b:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JNZ 0x00135095
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013507b
LAB_00135095:
MOV EDI,0xa
CALL 0x00125470
MOV dword ptr [RBP + -0xc],0x0
LAB_001350a6:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x001350c3
MOV EDI,0x20
CALL 0x00125470
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001350a6
LAB_001350c3:
JMP 0x00134fe3
LAB_001350c8:
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x18cdaa]
MOV AL,0x0
CALL 0x00125050
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x8]
SUB RCX,RDX
ADD EAX,ECX
ADD RSP,0x40
POP RBP
RET
|
int print_comment(char *param_1,int param_2,int param_3,int param_4)
{
long lVar1;
bool bVar2;
char *local_38;
int local_14;
char *local_10;
lVar1 = strend(param_1);
for (local_14 = param_2; local_14 < param_3; local_14 = local_14 + 1) {
putchar(0x20);
}
if ((*param_1 == '.') || (local_10 = param_1, *param_1 == ',')) {
putchar((int)*param_1);
local_10 = param_1 + 1;
local_14 = local_14 + 1;
}
while ((long)((param_3 + param_4) - local_14) < lVar1 - (long)local_10) {
local_38 = local_10 + ((long)(param_3 + param_4) - (long)local_14);
while( true ) {
bVar2 = false;
if (local_10 < local_38) {
bVar2 = *local_38 != ' ';
}
if (!bVar2) break;
local_38 = local_38 + -1;
}
for (; local_10 < local_38; local_10 = local_10 + 1) {
putchar((int)*local_10);
}
for (; *local_10 == ' '; local_10 = local_10 + 1) {
}
putchar(10);
for (local_14 = 0; local_14 < param_3; local_14 = local_14 + 1) {
putchar(0x20);
}
}
printf("%s",local_10);
return local_14 + ((int)lVar1 - (int)local_10);
}
|
|
9,617 |
print_comment
|
eloqsql/mysys/my_getopt.c
|
static uint print_comment(const char *comment,
int curpos, int startpos, int width)
{
const char *end= strend(comment);
int endpos= startpos + width;
for (; curpos < startpos; curpos++)
putchar(' ');
if (*comment == '.' || *comment == ',')
{
putchar(*comment);
comment++;
curpos++;
}
while (end - comment > endpos - curpos)
{
const char *line_end;
for (line_end= comment + endpos - curpos;
line_end > comment && *line_end != ' ';
line_end--);
for (; comment < line_end; comment++)
putchar(*comment);
while (*comment == ' ')
comment++; /* skip the space, as a newline will take it's place now */
putchar('\n');
for (curpos= 0; curpos < startpos; curpos++)
putchar(' ');
}
printf("%s", comment);
return curpos + (int)(end - comment);
}
|
O3
|
c
|
print_comment:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
callq 0x6318c
movq %rax, %r14
cmpl $0x15, %r15d
jg 0x2edf5
addl $-0x16, %r15d
movl $0x20, %edi
callq 0x244c0
incl %r15d
jne 0x2ede0
movl $0x16, %r15d
movzbl (%rbx), %edi
movl %edi, %eax
orl $0x2, %eax
cmpl $0x2e, %eax
jne 0x2ee0d
callq 0x244c0
incq %rbx
incl %r15d
movq %r14, %r12
subq %rbx, %r12
movl $0x4f, %eax
subl %r15d, %eax
cltq
cmpq %rax, %r12
jle 0x2eec0
movl %r15d, %eax
incq %r14
movq %rbx, %r15
subq %rax, %r15
addq $0x4f, %r15
cmpq %rbx, %r15
jbe 0x2ee4c
cmpb $0x20, (%r15)
je 0x2ee4c
decq %r15
cmpq %rbx, %r15
ja 0x2ee3b
movq %rbx, %r15
cmpq %r15, %rbx
jae 0x2ee6c
movq %r15, %r12
subq %rbx, %r12
xorl %r13d, %r13d
movsbl (%rbx,%r13), %edi
callq 0x244c0
incq %r13
cmpq %r13, %r12
jne 0x2ee5a
cmpq %r15, %rbx
cmovaq %rbx, %r15
movq %r14, %r12
subq %r15, %r12
decq %r15
movq %r15, %rbx
decq %r12
cmpb $0x20, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
je 0x2ee7f
movl $0xa, %edi
callq 0x244c0
movl $0x16, %r15d
movl $0x20, %edi
callq 0x244c0
decl %r15d
jne 0x2ee9c
movl $0x16, %eax
cmpq $0x3a, %r12
jge 0x2ee2c
movl $0x16, %r15d
leaq 0x38ea4(%rip), %rsi # 0x67d6b
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x24030
addl %r15d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
print_comment:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, esi
mov rbx, rdi
call strend
mov r14, rax
cmp r15d, 15h
jg short loc_2EDF5
add r15d, 0FFFFFFEAh
loc_2EDE0:
mov edi, 20h ; ' '
call _putchar
inc r15d
jnz short loc_2EDE0
mov r15d, 16h
loc_2EDF5:
movzx edi, byte ptr [rbx]
mov eax, edi
or eax, 2
cmp eax, 2Eh ; '.'
jnz short loc_2EE0D
call _putchar
inc rbx
inc r15d
loc_2EE0D:
mov r12, r14
sub r12, rbx
mov eax, 4Fh ; 'O'
sub eax, r15d
cdqe
cmp r12, rax
jle loc_2EEC0
mov eax, r15d
inc r14
loc_2EE2C:
mov r15, rbx
sub r15, rax
add r15, 4Fh ; 'O'
cmp r15, rbx
jbe short loc_2EE4C
loc_2EE3B:
cmp byte ptr [r15], 20h ; ' '
jz short loc_2EE4C
dec r15
cmp r15, rbx
ja short loc_2EE3B
mov r15, rbx
loc_2EE4C:
cmp rbx, r15
jnb short loc_2EE6C
mov r12, r15
sub r12, rbx
xor r13d, r13d
loc_2EE5A:
movsx edi, byte ptr [rbx+r13]
call _putchar
inc r13
cmp r12, r13
jnz short loc_2EE5A
loc_2EE6C:
cmp rbx, r15
cmova r15, rbx
mov r12, r14
sub r12, r15
dec r15
mov rbx, r15
loc_2EE7F:
dec r12
cmp byte ptr [rbx+1], 20h ; ' '
lea rbx, [rbx+1]
jz short loc_2EE7F
mov edi, 0Ah
call _putchar
mov r15d, 16h
loc_2EE9C:
mov edi, 20h ; ' '
call _putchar
dec r15d
jnz short loc_2EE9C
mov eax, 16h
cmp r12, 3Ah ; ':'
jge loc_2EE2C
mov r15d, 16h
loc_2EEC0:
lea rsi, aAtLineDPosDS+13h; "%s"
mov edi, 1
mov rdx, rbx
xor eax, eax
call ___printf_chk
add r12d, r15d
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long print_comment(const char *a1, int a2)
{
unsigned int v2; // r15d
const char *v3; // rbx
long long v4; // r14
int v5; // r15d
long long v6; // rdi
long long v7; // r12
long long v8; // rax
long long v9; // r14
const char *v10; // r15
long long v11; // r13
int v13; // r15d
v2 = a2;
v3 = a1;
v4 = strend(a1);
if ( a2 <= 21 )
{
v5 = a2 - 22;
do
{
putchar(32LL);
++v5;
}
while ( v5 );
v2 = 22;
}
v6 = *(unsigned __int8 *)a1;
if ( (*(unsigned __int8 *)v3 | 2) == 0x2E )
{
putchar(v6);
++v3;
++v2;
}
LODWORD(v7) = v4 - (_DWORD)v3;
if ( v4 - (long long)v3 > (int)(79 - v2) )
{
v8 = v2;
v9 = v4 + 1;
do
{
v10 = &v3[-v8 + 79];
if ( v10 > v3 )
{
while ( *v10 != 32 )
{
if ( --v10 <= v3 )
{
v10 = v3;
break;
}
}
}
if ( v3 < v10 )
{
v11 = 0LL;
do
putchar((unsigned int)v3[v11++]);
while ( v10 - v3 != v11 );
}
if ( v3 > v10 )
v10 = v3;
v7 = v9 - (_QWORD)v10;
v3 = v10 - 1;
do
--v7;
while ( *++v3 == 32 );
putchar(10LL);
v13 = 22;
do
{
putchar(32LL);
--v13;
}
while ( v13 );
v8 = 22LL;
}
while ( v7 >= 58 );
v2 = 22;
}
__printf_chk(1LL, "%s", v3);
return v2 + (unsigned int)v7;
}
|
print_comment:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ESI
MOV RBX,RDI
CALL 0x0016318c
MOV R14,RAX
CMP R15D,0x15
JG 0x0012edf5
ADD R15D,-0x16
LAB_0012ede0:
MOV EDI,0x20
CALL 0x001244c0
INC R15D
JNZ 0x0012ede0
MOV R15D,0x16
LAB_0012edf5:
MOVZX EDI,byte ptr [RBX]
MOV EAX,EDI
OR EAX,0x2
CMP EAX,0x2e
JNZ 0x0012ee0d
CALL 0x001244c0
INC RBX
INC R15D
LAB_0012ee0d:
MOV R12,R14
SUB R12,RBX
MOV EAX,0x4f
SUB EAX,R15D
CDQE
CMP R12,RAX
JLE 0x0012eec0
MOV EAX,R15D
INC R14
LAB_0012ee2c:
MOV R15,RBX
SUB R15,RAX
ADD R15,0x4f
CMP R15,RBX
JBE 0x0012ee4c
LAB_0012ee3b:
CMP byte ptr [R15],0x20
JZ 0x0012ee4c
DEC R15
CMP R15,RBX
JA 0x0012ee3b
MOV R15,RBX
LAB_0012ee4c:
CMP RBX,R15
JNC 0x0012ee6c
MOV R12,R15
SUB R12,RBX
XOR R13D,R13D
LAB_0012ee5a:
MOVSX EDI,byte ptr [RBX + R13*0x1]
CALL 0x001244c0
INC R13
CMP R12,R13
JNZ 0x0012ee5a
LAB_0012ee6c:
CMP RBX,R15
CMOVA R15,RBX
MOV R12,R14
SUB R12,R15
DEC R15
MOV RBX,R15
LAB_0012ee7f:
DEC R12
CMP byte ptr [RBX + 0x1],0x20
LEA RBX,[RBX + 0x1]
JZ 0x0012ee7f
MOV EDI,0xa
CALL 0x001244c0
MOV R15D,0x16
LAB_0012ee9c:
MOV EDI,0x20
CALL 0x001244c0
DEC R15D
JNZ 0x0012ee9c
MOV EAX,0x16
CMP R12,0x3a
JGE 0x0012ee2c
MOV R15D,0x16
LAB_0012eec0:
LEA RSI,[0x167d6b]
MOV EDI,0x1
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00124030
ADD R12D,R15D
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int print_comment(byte *param_1,uint param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uVar4 = (ulong)param_2;
lVar1 = strend();
if ((int)param_2 < 0x16) {
iVar3 = param_2 - 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + 1;
} while (iVar3 != 0);
uVar4 = 0x16;
}
if ((*param_1 | 2) == 0x2e) {
putchar((uint)*param_1);
param_1 = param_1 + 1;
uVar4 = (ulong)((int)uVar4 + 1);
}
lVar2 = lVar1 - (long)param_1;
iVar3 = (int)uVar4;
if (0x4f - iVar3 < lVar2) {
do {
pbVar5 = param_1 + (0x4f - uVar4);
pbVar6 = pbVar5;
for (; (param_1 < pbVar5 && (pbVar6 = pbVar5, *pbVar5 != 0x20)); pbVar5 = pbVar5 + -1) {
pbVar6 = param_1;
}
if (param_1 < pbVar6) {
lVar2 = 0;
do {
putchar((int)(char)param_1[lVar2]);
lVar2 = lVar2 + 1;
} while ((long)pbVar6 - (long)param_1 != lVar2);
}
if (pbVar6 < param_1) {
pbVar6 = param_1;
}
lVar2 = (lVar1 + 1) - (long)pbVar6;
param_1 = pbVar6 + -1;
do {
lVar2 = lVar2 + -1;
pbVar5 = param_1 + 1;
param_1 = param_1 + 1;
} while (*pbVar5 == 0x20);
putchar(10);
iVar3 = 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + -1;
} while (iVar3 != 0);
uVar4 = 0x16;
} while (0x39 < lVar2);
iVar3 = 0x16;
}
__printf_chk(1,"%s",param_1);
return (int)lVar2 + iVar3;
}
|
|
9,618 |
my_wc_to_printable_8bit
|
eloqsql/strings/ctype.c
|
int
my_wc_to_printable_8bit(CHARSET_INFO *cs, my_wc_t wc,
uchar *str, uchar *end)
{
/*
Special case: swe7 does not have the backslash character.
Use dot instead of backslash for escaping.
*/
uint bs= cs->tab_to_uni && cs->tab_to_uni['\\'] != '\\' ? '.' : '\\';
DBUG_ASSERT(cs->mbminlen == 1);
/*
Additionally, if the original swe7 string contains backslashes,
replace them to dots, so this error message:
Invalid swe7 character string: '\xEF\xBC\xB4'
is displayed as:
Invalid swe7 character string: '.xEF.xBC.xB4'
which is more readable than what would happen without '\'-to-dot mapping:
Invalid swe7 character string: '.005CxEF.005CxBC.005CxB4'
*/
if (bs == '.' && wc == '\\')
wc= '.';
return my_wc_to_printable_ex(cs, wc, str, end, bs, 1, 1);
}
|
O0
|
c
|
my_wc_to_printable_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x68(%rcx)
movb %al, -0x25(%rbp)
je 0x735b0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movzwl 0xb8(%rax), %eax
cmpl $0x5c, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %dl
movl $0x5c, %eax
movl $0x2e, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x735c8
cmpl $0x2e, -0x24(%rbp)
jne 0x735dd
cmpq $0x5c, -0x10(%rbp)
jne 0x735dd
movq $0x2e, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl $0x1, %r9d
movl $0x1, (%rsp)
callq 0x73240
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
my_wc_to_printable_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rcx, [rbp+var_8]
xor eax, eax
cmp qword ptr [rcx+68h], 0
mov [rbp+var_25], al
jz short loc_735B0
mov rax, [rbp+var_8]
mov rax, [rax+68h]
movzx eax, word ptr [rax+0B8h]
cmp eax, 5Ch ; '\'
setnz al
mov [rbp+var_25], al
loc_735B0:
mov dl, [rbp+var_25]
mov eax, 5Ch ; '\'
mov ecx, 2Eh ; '.'
test dl, 1
cmovnz eax, ecx
mov [rbp+var_24], eax
jmp short $+2
loc_735C8:
cmp [rbp+var_24], 2Eh ; '.'
jnz short loc_735DD
cmp [rbp+var_10], 5Ch ; '\'
jnz short loc_735DD
mov [rbp+var_10], 2Eh ; '.'
loc_735DD:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8d, [rbp+var_24]
mov r9d, 1
mov [rsp+30h+var_30], 1
call my_wc_to_printable_ex
add rsp, 30h
pop rbp
retn
|
long long my_wc_to_printable_8bit(long long a1, long long a2, long long a3, unsigned long long a4)
{
unsigned int v4; // eax
bool v6; // [rsp+Bh] [rbp-25h]
long long v7; // [rsp+20h] [rbp-10h]
v7 = a2;
v6 = 0;
if ( *(_QWORD *)(a1 + 104) )
v6 = *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 184LL) != 92;
v4 = 92;
if ( v6 )
v4 = 46;
if ( v4 == 46 && a2 == 92 )
v7 = 46LL;
return my_wc_to_printable_ex(a1, v7, a3, a4, v4, 1u, 1u);
}
|
my_wc_to_printable_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RCX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP qword ptr [RCX + 0x68],0x0
MOV byte ptr [RBP + -0x25],AL
JZ 0x001735b0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOVZX EAX,word ptr [RAX + 0xb8]
CMP EAX,0x5c
SETNZ AL
MOV byte ptr [RBP + -0x25],AL
LAB_001735b0:
MOV DL,byte ptr [RBP + -0x25]
MOV EAX,0x5c
MOV ECX,0x2e
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001735c8
LAB_001735c8:
CMP dword ptr [RBP + -0x24],0x2e
JNZ 0x001735dd
CMP qword ptr [RBP + -0x10],0x5c
JNZ 0x001735dd
MOV qword ptr [RBP + -0x10],0x2e
LAB_001735dd:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RBP + -0x24]
MOV R9D,0x1
MOV dword ptr [RSP],0x1
CALL 0x00173240
ADD RSP,0x30
POP RBP
RET
|
void my_wc_to_printable_8bit(long param_1,long param_2,int8 param_3,int8 param_4)
{
int iVar1;
bool bVar2;
int8 local_18;
bVar2 = false;
if (*(long *)(param_1 + 0x68) != 0) {
bVar2 = *(short *)(*(long *)(param_1 + 0x68) + 0xb8) != 0x5c;
}
iVar1 = 0x5c;
if (bVar2) {
iVar1 = 0x2e;
}
local_18 = param_2;
if ((iVar1 == 0x2e) && (param_2 == 0x5c)) {
local_18 = 0x2e;
}
my_wc_to_printable_ex(param_1,local_18,param_3,param_4,iVar1,1,1);
return;
}
|
|
9,619 |
my_setwd
|
eloqsql/mysys/my_getwd.c
|
int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
}
|
O3
|
c
|
my_setwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xa59d3
movq %r14, %rdi
cmpl $0x2f, %eax
jne 0xa59da
cmpb $0x0, 0x1(%r14)
movq %r14, %rdi
jne 0xa59da
leaq 0x40976(%rip), %rdi # 0xe6350
callq 0x2a980
movl %eax, %ebx
testl %eax, %eax
je 0xa5a18
callq 0x2a7a0
movq %rax, %r12
movl (%rax), %r13d
callq 0xa8ec2
movl %r13d, (%rax)
testb $0x10, %r15b
je 0xa5a75
movl (%r12), %ecx
movl $0x4, %esi
movl $0x11, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa30b3
jmp 0xa5a75
leaq 0xb6c7b9(%rip), %rax # 0xc121d8
movq (%rax), %rax
movq %r14, %rcx
movzbl (%rcx), %edx
cmpl $0x7e, %edx
jne 0xa5a3d
cmpb $0x2f, 0x1(%rcx)
jne 0xa5a6b
movq %rax, %rcx
testq %rax, %rax
jne 0xa5a25
jmp 0xa5a6b
cmpl $0x2f, %edx
jne 0xa5a6b
leaq 0xb6c7a7(%rip), %r15 # 0xc121f0
movl $0x1ff, %edx # imm = 0x1FF
movq %r15, %rdi
movq %r14, %rsi
callq 0xdfd6c
cmpb $0x2f, -0x1(%rax)
je 0xa5a75
subl %r15d, %eax
movw $0x2f, (%r15,%rax)
jmp 0xa5a75
leaq 0xb6c77e(%rip), %rax # 0xc121f0
movb $0x0, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_setwd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_A59D3
mov rdi, r14
cmp eax, 2Fh ; '/'
jnz short loc_A59DA
cmp byte ptr [r14+1], 0
mov rdi, r14
jnz short loc_A59DA
loc_A59D3:
lea rdi, unk_E6350
loc_A59DA:
call _chdir
mov ebx, eax
test eax, eax
jz short loc_A5A18
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r15b, 10h
jz short loc_A5A75
mov ecx, [r12]
mov esi, 4
mov edi, 11h
mov rdx, r14
xor eax, eax
call my_error
jmp short loc_A5A75
loc_A5A18:
lea rax, home_dir
mov rax, [rax]
mov rcx, r14
loc_A5A25:
movzx edx, byte ptr [rcx]
cmp edx, 7Eh ; '~'
jnz short loc_A5A3D
cmp byte ptr [rcx+1], 2Fh ; '/'
jnz short loc_A5A6B
mov rcx, rax
test rax, rax
jnz short loc_A5A25
jmp short loc_A5A6B
loc_A5A3D:
cmp edx, 2Fh ; '/'
jnz short loc_A5A6B
lea r15, curr_dir
mov edx, 1FFh
mov rdi, r15
mov rsi, r14
call strmake
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_A5A75
sub eax, r15d
mov word ptr [r15+rax], 2Fh ; '/'
jmp short loc_A5A75
loc_A5A6B:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_A5A75:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_setwd(unsigned __int8 *a1, char a2)
{
unsigned __int8 *v2; // r14
unsigned int v3; // ebx
unsigned int *v4; // r12
unsigned int v5; // r13d
unsigned __int8 *v6; // rcx
int v7; // edx
long long v8; // rax
v2 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
a1 = (unsigned __int8 *)&unk_E6350;
v3 = chdir(a1);
if ( v3 )
{
v4 = (unsigned int *)__errno_location(a1);
v5 = *v4;
*(_DWORD *)my_thread_var(a1) = v5;
if ( (a2 & 0x10) != 0 )
my_error(0x11u, 4LL, v2, *v4);
}
else
{
v6 = v2;
while ( 1 )
{
v7 = *v6;
if ( v7 != 126 )
break;
if ( v6[1] == 47 )
{
v6 = (unsigned __int8 *)home_dir;
if ( home_dir )
continue;
}
goto LABEL_16;
}
if ( v7 != 47 )
{
LABEL_16:
curr_dir[0] = 0;
return v3;
}
v8 = strmake(curr_dir, v2, 511LL);
if ( *(_BYTE *)(v8 - 1) != 47 )
*(_WORD *)&curr_dir[(unsigned int)v8 - (unsigned int)curr_dir] = 47;
}
return v3;
}
|
my_setwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001a59d3
MOV RDI,R14
CMP EAX,0x2f
JNZ 0x001a59da
CMP byte ptr [R14 + 0x1],0x0
MOV RDI,R14
JNZ 0x001a59da
LAB_001a59d3:
LEA RDI,[0x1e6350]
LAB_001a59da:
CALL 0x0012a980
MOV EBX,EAX
TEST EAX,EAX
JZ 0x001a5a18
CALL 0x0012a7a0
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001a8ec2
MOV dword ptr [RAX],R13D
TEST R15B,0x10
JZ 0x001a5a75
MOV ECX,dword ptr [R12]
MOV ESI,0x4
MOV EDI,0x11
MOV RDX,R14
XOR EAX,EAX
CALL 0x001a30b3
JMP 0x001a5a75
LAB_001a5a18:
LEA RAX,[0xd121d8]
MOV RAX,qword ptr [RAX]
MOV RCX,R14
LAB_001a5a25:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x7e
JNZ 0x001a5a3d
CMP byte ptr [RCX + 0x1],0x2f
JNZ 0x001a5a6b
MOV RCX,RAX
TEST RAX,RAX
JNZ 0x001a5a25
JMP 0x001a5a6b
LAB_001a5a3d:
CMP EDX,0x2f
JNZ 0x001a5a6b
LEA R15,[0xd121f0]
MOV EDX,0x1ff
MOV RDI,R15
MOV RSI,R14
CALL 0x001dfd6c
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x001a5a75
SUB EAX,R15D
MOV word ptr [R15 + RAX*0x1],0x2f
JMP 0x001a5a75
LAB_001a5a6b:
LEA RAX,[0xd121f0]
MOV byte ptr [RAX],0x0
LAB_001a5a75:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
char *pcVar6;
if ((*param_1 == '\0') || ((pcVar6 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
pcVar6 = "/";
}
iVar2 = chdir(pcVar6);
pcVar6 = param_1;
if (iVar2 == 0) {
while (*pcVar6 == '~') {
if ((pcVar6[1] != '/') || (pcVar6 = home_dir, home_dir == (char *)0x0)) goto LAB_001a5a6b;
}
if (*pcVar6 == '/') {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) == '/') {
return 0;
}
*(int2 *)(&curr_dir + ((int)lVar5 - 0xd121f0)) = 0x2f;
return 0;
}
LAB_001a5a6b:
curr_dir = 0;
}
else {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((param_2 & 0x10) != 0) {
my_error(0x11,4,param_1,*piVar3);
}
}
return iVar2;
}
|
|
9,620 |
moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long)
|
AlayaLite/build_O0/_deps/concurrentqueue-src/concurrentqueue.h
|
void populate_initial_block_list(size_t blockCount)
{
initialBlockPoolSize = blockCount;
if (initialBlockPoolSize == 0) {
initialBlockPool = nullptr;
return;
}
initialBlockPool = create_array<Block>(blockCount);
if (initialBlockPool == nullptr) {
initialBlockPoolSize = 0;
}
for (size_t i = 0; i < initialBlockPoolSize; ++i) {
initialBlockPool[i].dynamicallyAllocated = false;
}
}
|
O0
|
c
|
moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x68517
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x68586
movq 0x18(%rsp), %rdi
callq 0x68770
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x68541
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x20(%rcx), %rax
jae 0x68586
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
imulq $0x148, 0x10(%rsp), %rcx # imm = 0x148
addq %rcx, %rax
movb $0x0, 0x140(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x6854a
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZN10moodycamel15ConcurrentQueueINSt7__n486116coroutine_handleIvEENS_28ConcurrentQueueDefaultTraitsEE27populate_initial_block_listEm:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rcx, [rsp+28h+var_10]
mov [rax+20h], rcx
cmp qword ptr [rax+20h], 0
jnz short loc_68517
mov rax, [rsp+28h+var_20]
mov qword ptr [rax+18h], 0
jmp short loc_68586
loc_68517:
mov rdi, [rsp+28h+var_10]
call _ZN10moodycamel15ConcurrentQueueINSt7__n486116coroutine_handleIvEENS_28ConcurrentQueueDefaultTraitsEE12create_arrayINS5_5BlockEEEPT_m; moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::create_array<moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::Block>(ulong)
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rax+18h], rcx
cmp qword ptr [rax+18h], 0
jnz short loc_68541
mov rax, [rsp+28h+var_20]
mov qword ptr [rax+20h], 0
loc_68541:
mov [rsp+28h+var_18], 0
loc_6854A:
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_18]
cmp rax, [rcx+20h]
jnb short loc_68586
mov rax, [rsp+28h+var_20]
mov rax, [rax+18h]
imul rcx, [rsp+28h+var_18], 148h
add rax, rcx
mov byte ptr [rax+140h], 0
mov rax, [rsp+28h+var_18]
add rax, 1
mov [rsp+28h+var_18], rax
jmp short loc_6854A
loc_68586:
add rsp, 28h
retn
|
unsigned long long moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(
unsigned long long a1,
long long a2)
{
unsigned long long result; // rax
unsigned long long i; // [rsp+10h] [rbp-18h]
*(_QWORD *)(a1 + 32) = a2;
if ( *(_QWORD *)(a1 + 32) )
{
*(_QWORD *)(a1 + 24) = moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::create_array<moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::Block>(a2);
if ( !*(_QWORD *)(a1 + 24) )
*(_QWORD *)(a1 + 32) = 0LL;
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= *(_QWORD *)(a1 + 32) )
break;
*(_BYTE *)(328 * i + *(_QWORD *)(a1 + 24) + 320) = 0;
}
}
else
{
result = a1;
*(_QWORD *)(a1 + 24) = 0LL;
}
return result;
}
|
populate_initial_block_list:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x20],RCX
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x00168517
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x18],0x0
JMP 0x00168586
LAB_00168517:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00168770
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x18],RCX
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x00168541
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x20],0x0
LAB_00168541:
MOV qword ptr [RSP + 0x10],0x0
LAB_0016854a:
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,qword ptr [RCX + 0x20]
JNC 0x00168586
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x18]
IMUL RCX,qword ptr [RSP + 0x10],0x148
ADD RAX,RCX
MOV byte ptr [RAX + 0x140],0x0
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x1
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0016854a
LAB_00168586:
ADD RSP,0x28
RET
|
/* moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,
moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long) */
void __thiscall
moodycamel::
ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::
populate_initial_block_list
(ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>
*this,ulong param_1)
{
Block *pBVar1;
ulong local_18;
*(ulong *)(this + 0x20) = param_1;
if (*(long *)(this + 0x20) == 0) {
*(int8 *)(this + 0x18) = 0;
}
else {
pBVar1 = create_array<moodycamel::ConcurrentQueue<std::__n4861::coroutine_handle<void>,moodycamel::ConcurrentQueueDefaultTraits>::Block>
(param_1);
*(Block **)(this + 0x18) = pBVar1;
if (*(long *)(this + 0x18) == 0) {
*(int8 *)(this + 0x20) = 0;
}
for (local_18 = 0; local_18 < *(ulong *)(this + 0x20); local_18 = local_18 + 1) {
*(int1 *)(*(long *)(this + 0x18) + local_18 * 0x148 + 0x140) = 0;
}
}
return;
}
|
|
9,621 |
minja::Parser::unexpected(minja::TemplateToken const&) const
|
monkey531[P]llama/common/minja.hpp
|
std::runtime_error unexpected(const TemplateToken & token) const {
return std::runtime_error("Unexpected " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
}
|
O1
|
cpp
|
minja::Parser::unexpected(minja::TemplateToken const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x7f0b8
leaq 0x404c1(%rip), %rcx # 0xbf003
movl $0xb, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19760
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7eb7c
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x7eb84
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x20(%r14), %rdx
leaq 0x48(%rsp), %rdi
callq 0x5d844
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x7ebcf
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x7ebee
leaq 0x58(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x7ebe9
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x7ebff
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x191d0
jmp 0x7ec0d
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19760
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x7ec31
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x7ec37
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 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19ac0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ec7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ec97
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x196b0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ecae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196b0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ecc9
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x196b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ecfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7ecfe
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ed1e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7ed1e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ed3a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7ed3a
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ed55
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x196b0
movq %rbx, %rdi
callq 0x19be0
nop
|
_ZNK5minja6Parser10unexpectedERKNS_13TemplateTokenE:
push r15; int
push r14; int
push r12; int
push rbx; int
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov esi, [rdx+8]
lea r12, [rsp+0A8h+var_40]
mov rdi, r12
call _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE; minja::TemplateToken::typeToString(minja::TemplateToken::Type)
lea rcx, aUnexpected_0; "Unexpected "
mov r8d, 0Bh
mov rdi, r12
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r12, [rsp+0A8h+var_70]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h; int
cmp rdx, rcx
jz short loc_7EB7C
mov [rsp+0A8h+var_80], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_70], rdx
jmp short loc_7EB84
loc_7EB7C:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_7EB84:
mov rdx, [rax+8]
mov qword ptr [rsp+0A8h+var_78], rdx; int
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [r15]; int
mov rdx, [r14+20h]; int
lea rdi, [rsp+0A8h+var_60]; int
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
mov rcx, [rsp+0A8h+var_80]
mov r8, qword ptr [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_58]
lea rax, [rdx+r8]
mov esi, 0Fh
cmp rcx, r12
jz short loc_7EBCF
mov rsi, [rsp+0A8h+var_70]
loc_7EBCF:
cmp rax, rsi
jbe short loc_7EBEE
lea rdi, [rsp+0A8h+var_50]
mov esi, 0Fh
cmp [rdi-10h], rdi
jz short loc_7EBE9
mov rsi, [rsp+0A8h+var_50]
loc_7EBE9:
cmp rax, rsi
jbe short loc_7EBFF
loc_7EBEE:
mov rsi, qword ptr [rsp+0A8h+var_60]
lea rdi, [rsp+0A8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_7EC0D
loc_7EBFF:
lea rdi, [rsp+0A8h+var_60]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_7EC0D:
lea rdx, [rsp+0A8h+var_90]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_7EC31
mov [rsp+0A8h+var_A0], rsi
mov rdx, [rcx]
mov [rsp+0A8h+var_90], rdx
jmp short loc_7EC37
loc_7EC31:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_7EC37:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0A8h+var_98], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, [rsp+0A8h+var_A0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7EC7C
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7EC7C:
lea rax, [rsp+0A8h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7EC97
mov rsi, [rsp+0A8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7EC97:
mov rdi, [rsp+0A8h+var_80]; void *
cmp rdi, r12
jz short loc_7ECAE
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7ECAE:
lea rax, [rsp+0A8h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7ECC9
mov rsi, [rsp+0A8h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7ECC9:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7ECFE
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7ECFE
mov rbx, rax
loc_7ECFE:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7ED1E
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7ED1E
mov rbx, rax
loc_7ED1E:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_7ED3A
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7ED3A
mov rbx, rax
loc_7ED3A:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7ED55
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7ED55:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::unexpected(minja::Parser *this, const minja::TemplateToken *a2, long long a3)
{
long long v4; // rax
__int128 *v5; // rcx
unsigned long long v6; // rax
unsigned long long v7; // rsi
unsigned long long v8; // rsi
void **v9; // rax
__int128 *v10; // rcx
void *v12[2]; // [rsp+8h] [rbp-A0h] BYREF
__int128 v13; // [rsp+18h] [rbp-90h] BYREF
void *v14; // [rsp+28h] [rbp-80h] BYREF
int v15[2]; // [rsp+30h] [rbp-78h]
__int128 v16; // [rsp+38h] [rbp-70h] BYREF
int v17[2]; // [rsp+48h] [rbp-60h] BYREF
long long v18; // [rsp+50h] [rbp-58h]
_QWORD v19[2]; // [rsp+58h] [rbp-50h] BYREF
void *v20[2]; // [rsp+68h] [rbp-40h] BYREF
long long v21; // [rsp+78h] [rbp-30h] BYREF
minja::TemplateToken::typeToString[abi:cxx11](v20, *(unsigned int *)(a3 + 8));
v4 = std::string::replace(v20, 0LL, 0LL);
v14 = &v16;
v5 = (__int128 *)(v4 + 16);
if ( *(_QWORD *)v4 == v4 + 16 )
{
v16 = *v5;
}
else
{
v14 = *(void **)v4;
*(_QWORD *)&v16 = *(_QWORD *)v5;
}
*(_QWORD *)v15 = *(_QWORD *)(v4 + 8);
*(_QWORD *)v4 = v5;
*(_QWORD *)(v4 + 8) = 0LL;
*(_BYTE *)(v4 + 16) = 0;
minja::error_location_suffix((long long)v17, *(_QWORD *)a2, *(_QWORD *)(a3 + 32));
v6 = v18 + *(_QWORD *)v15;
v7 = 15LL;
if ( v14 != &v16 )
v7 = v16;
if ( v6 <= v7 )
goto LABEL_10;
v8 = 15LL;
if ( *(_QWORD **)v17 != v19 )
v8 = v19[0];
if ( v6 <= v8 )
v9 = (void **)std::string::replace(v17, 0LL, 0LL);
else
LABEL_10:
v9 = (void **)std::string::_M_append(&v14, *(_QWORD *)v17, v18);
v12[0] = &v13;
v10 = (__int128 *)(v9 + 2);
if ( *v9 == v9 + 2 )
{
v13 = *v10;
}
else
{
v12[0] = *v9;
*(_QWORD *)&v13 = *(_QWORD *)v10;
}
v12[1] = v9[1];
*v9 = v10;
v9[1] = 0LL;
*(_BYTE *)v10 = 0;
std::runtime_error::runtime_error(this, v12);
if ( v12[0] != &v13 )
operator delete(v12[0], v13 + 1);
if ( *(_QWORD **)v17 != v19 )
operator delete(*(void **)v17, v19[0] + 1LL);
if ( v14 != &v16 )
operator delete(v14, v16 + 1);
if ( v20[0] != &v21 )
operator delete(v20[0], v21 + 1);
return this;
}
|
unexpected:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RDX + 0x8]
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x0017f0b8
LAB_0017eb3b:
LEA RCX,[0x1bf003]
MOV R8D,0xb
MOV RDI,R12
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00119760
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0017eb7c
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0017eb84
LAB_0017eb7c:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_0017eb84:
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 RSI,qword ptr [R15]
MOV RDX,qword ptr [R14 + 0x20]
LAB_0017eba3:
LEA RDI,[RSP + 0x48]
CALL 0x0015d844
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x50]
LEA RAX,[RDX + R8*0x1]
MOV ESI,0xf
CMP RCX,R12
JZ 0x0017ebcf
MOV RSI,qword ptr [RSP + 0x38]
LAB_0017ebcf:
CMP RAX,RSI
JBE 0x0017ebee
LEA RDI,[RSP + 0x58]
MOV ESI,0xf
CMP qword ptr [RDI + -0x10],RDI
JZ 0x0017ebe9
MOV RSI,qword ptr [RSP + 0x58]
LAB_0017ebe9:
CMP RAX,RSI
JBE 0x0017ebff
LAB_0017ebee:
MOV RSI,qword ptr [RSP + 0x48]
LAB_0017ebf3:
LEA RDI,[RSP + 0x28]
CALL 0x001191d0
JMP 0x0017ec0d
LAB_0017ebff:
LEA RDI,[RSP + 0x48]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00119760
LAB_0017ec0d:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x0017ec31
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0017ec37
LAB_0017ec31:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0017ec37:
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_0017ec54:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00119ac0
LAB_0017ec61:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017ec7c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001196b0
LAB_0017ec7c:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017ec97
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001196b0
LAB_0017ec97:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x0017ecae
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001196b0
LAB_0017ecae:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017ecc9
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001196b0
LAB_0017ecc9:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Parser::unexpected(minja::TemplateToken const&) const */
TemplateToken * minja::Parser::unexpected(TemplateToken *param_1)
{
long *plVar1;
int8 *puVar2;
ulong *puVar3;
long in_RDX;
int8 *in_RSI;
ulong uVar4;
long *local_a0;
int8 local_98;
long local_90;
int8 uStack_88;
ulong *local_80;
long local_78;
ulong local_70;
long lStack_68;
ulong *local_60;
long local_58;
ulong local_50 [2];
long *local_40 [2];
long local_30 [2];
TemplateToken::typeToString_abi_cxx11_((TemplateToken *)local_40);
/* try { // try from 0017eb3b to 0017eb53 has its CatchHandler @ 0017ed37 */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,0x1bf003);
puVar3 = (ulong *)(plVar1 + 2);
if ((ulong *)*plVar1 == puVar3) {
local_70 = *puVar3;
lStack_68 = plVar1[3];
local_80 = &local_70;
}
else {
local_70 = *puVar3;
local_80 = (ulong *)*plVar1;
}
local_78 = plVar1[1];
*plVar1 = (long)puVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 0017eba3 to 0017ebac has its CatchHandler @ 0017ed1b */
error_location_suffix((minja *)&local_60,(string *)*in_RSI,*(ulong *)(in_RDX + 0x20));
uVar4 = 0xf;
if (local_80 != &local_70) {
uVar4 = local_70;
}
if (uVar4 < (ulong)(local_58 + local_78)) {
uVar4 = 0xf;
if (local_60 != local_50) {
uVar4 = local_50[0];
}
if ((ulong)(local_58 + local_78) <= uVar4) {
puVar2 = (int8 *)
std::__cxx11::string::replace((ulong)&local_60,0,(char *)0x0,(ulong)local_80);
goto LAB_0017ec0d;
}
}
/* try { // try from 0017ebf3 to 0017ec0c has its CatchHandler @ 0017ecfb */
puVar2 = (int8 *)std::__cxx11::string::_M_append((char *)&local_80,(ulong)local_60);
LAB_0017ec0d:
local_a0 = &local_90;
plVar1 = puVar2 + 2;
if ((long *)*puVar2 == plVar1) {
local_90 = *plVar1;
uStack_88 = puVar2[3];
}
else {
local_90 = *plVar1;
local_a0 = (long *)*puVar2;
}
local_98 = puVar2[1];
*puVar2 = plVar1;
puVar2[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 0017ec54 to 0017ec60 has its CatchHandler @ 0017ecdb */
std::runtime_error::runtime_error((runtime_error *)param_1,(string *)&local_a0);
if (local_a0 != &local_90) {
operator_delete(local_a0,local_90 + 1);
}
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return param_1;
}
|
|
9,622 |
convert_weights_ak_to_gg(ggml_tensor*, float const*)
|
monkey531[P]llama/examples/convert-llama2c-to-ggml/convert-llama2c-to-ggml.cpp
|
static void convert_weights_ak_to_gg(struct ggml_tensor * gg_weights, const float * karpathy_weights) {
int size = 1;
for (int dim = 0; dim < ggml_n_dims(gg_weights); ++dim) {
size *= gg_weights->ne[dim];
}
for (int ct = 0; ct < size; ++ct) {
int64_t i0 = 0; int64_t i1 = 0;
int64_t i2 = 0; int64_t i3 = 0;
ggml_unravel_index(gg_weights, ct, &i0, &i1, &i2, &i3);
ggml_set_f32_nd(gg_weights, i0, i1, i2, i3, karpathy_weights[ct]);
}
}
|
O3
|
cpp
|
convert_weights_ak_to_gg(ggml_tensor*, float const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a0e0
movl $0x1, %ebp
testl %eax, %eax
jle 0x20b67
xorl %r15d, %r15d
imull 0x10(%r14,%r15,8), %ebp
incq %r15
movq %r14, %rdi
callq 0x1a0e0
cltq
cmpq %rax, %r15
jl 0x20b4b
testl %ebp, %ebp
jle 0x20bcd
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %rbp
xorl %r15d, %r15d
movq %r13, 0x20(%rsp)
movq %r13, 0x18(%rsp)
movq %r13, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbp, %r9
callq 0x1a5c0
movl 0x20(%rsp), %esi
movl 0x18(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0x8(%rsp), %r8d
movss (%rbx,%r15,4), %xmm0
movq %r14, %rdi
callq 0x1a380
incq %r15
cmpq %r15, %r12
jne 0x20b75
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZL24convert_weights_ak_to_ggP11ggml_tensorPKf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
call _ggml_n_dims
mov ebp, 1
test eax, eax
jle short loc_20B67
xor r15d, r15d
loc_20B4B:
imul ebp, [r14+r15*8+10h]
inc r15
mov rdi, r14
call _ggml_n_dims
cdqe
cmp r15, rax
jl short loc_20B4B
test ebp, ebp
jle short loc_20BCD
loc_20B67:
mov r12d, ebp
xor r13d, r13d
lea rbp, [rsp+58h+var_50]
xor r15d, r15d
loc_20B75:
mov [rsp+58h+var_38], r13
mov [rsp+58h+var_40], r13
mov [rsp+58h+var_48], r13
mov [rsp+58h+var_50], r13
mov rdi, r14
mov rsi, r15
lea rdx, [rsp+58h+var_38]
lea rcx, [rsp+58h+var_40]
lea r8, [rsp+58h+var_48]
mov r9, rbp
call _ggml_unravel_index
mov esi, dword ptr [rsp+58h+var_38]
mov edx, dword ptr [rsp+58h+var_40]
mov ecx, dword ptr [rsp+58h+var_48]
mov r8d, dword ptr [rsp+58h+var_50]
movss xmm0, dword ptr [rbx+r15*4]
mov rdi, r14
call _ggml_set_f32_nd
inc r15
cmp r12, r15
jnz short loc_20B75
loc_20BCD:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long convert_weights_ak_to_gg(long long a1, long long a2)
{
int v2; // ebp
long long v3; // r15
long long result; // rax
long long i; // r15
long long v6; // [rsp+8h] [rbp-50h] BYREF
long long v7; // [rsp+10h] [rbp-48h] BYREF
long long v8; // [rsp+18h] [rbp-40h] BYREF
_QWORD v9[7]; // [rsp+20h] [rbp-38h] BYREF
v2 = 1;
if ( (int)ggml_n_dims(a1) <= 0 )
goto LABEL_5;
v3 = 0LL;
do
{
v2 *= *(_DWORD *)(a1 + 8 * v3++ + 16);
result = (int)ggml_n_dims(a1);
}
while ( v3 < (int)result );
if ( v2 > 0 )
{
LABEL_5:
for ( i = 0LL;
i != v2;
result = ggml_set_f32_nd(
a1,
LODWORD(v9[0]),
(unsigned int)v8,
(unsigned int)v7,
(unsigned int)v6,
*(float *)(a2 + 4 * i++)) )
{
v9[0] = 0LL;
v8 = 0LL;
v7 = 0LL;
v6 = 0LL;
ggml_unravel_index(a1, i, v9, &v8, &v7, &v6);
}
}
return result;
}
|
convert_weights_ak_to_gg:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
CALL 0x0011a0e0
MOV EBP,0x1
TEST EAX,EAX
JLE 0x00120b67
XOR R15D,R15D
LAB_00120b4b:
IMUL EBP,dword ptr [R14 + R15*0x8 + 0x10]
INC R15
MOV RDI,R14
CALL 0x0011a0e0
CDQE
CMP R15,RAX
JL 0x00120b4b
TEST EBP,EBP
JLE 0x00120bcd
LAB_00120b67:
MOV R12D,EBP
XOR R13D,R13D
LEA RBP,[RSP + 0x8]
XOR R15D,R15D
LAB_00120b75:
MOV qword ptr [RSP + 0x20],R13
MOV qword ptr [RSP + 0x18],R13
MOV qword ptr [RSP + 0x10],R13
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R14
MOV RSI,R15
LEA RDX,[RSP + 0x20]
LEA RCX,[RSP + 0x18]
LEA R8,[RSP + 0x10]
MOV R9,RBP
CALL 0x0011a5c0
MOV ESI,dword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0x18]
MOV ECX,dword ptr [RSP + 0x10]
MOV R8D,dword ptr [RSP + 0x8]
MOVSS XMM0,dword ptr [RBX + R15*0x4]
MOV RDI,R14
CALL 0x0011a380
INC R15
CMP R12,R15
JNZ 0x00120b75
LAB_00120bcd:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* convert_weights_ak_to_gg(ggml_tensor*, float const*) */
void convert_weights_ak_to_gg(ggml_tensor *param_1,float *param_2)
{
int iVar1;
uint uVar2;
long lVar3;
ulong uVar4;
ulong local_50;
ulong local_48;
ulong local_40;
ulong local_38;
iVar1 = ggml_n_dims();
uVar2 = 1;
if (0 < iVar1) {
lVar3 = 0;
do {
uVar2 = uVar2 * *(int *)(param_1 + lVar3 * 8 + 0x10);
lVar3 = lVar3 + 1;
iVar1 = ggml_n_dims(param_1);
} while (lVar3 < iVar1);
if ((int)uVar2 < 1) {
return;
}
}
uVar4 = 0;
do {
local_38 = 0;
local_40 = 0;
local_48 = 0;
local_50 = 0;
ggml_unravel_index(param_1,uVar4,&local_38,&local_40,&local_48,&local_50);
ggml_set_f32_nd(param_2[uVar4],param_1,local_38 & 0xffffffff,local_40 & 0xffffffff,
local_48 & 0xffffffff,local_50 & 0xffffffff);
uVar4 = uVar4 + 1;
} while (uVar2 != uVar4);
return;
}
|
|
9,623 |
minja::Value::empty() const
|
llama.cpp/common/minja/minja.hpp
|
bool empty() const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_string()) return primitive_.empty();
if (is_array()) return array_->empty();
if (is_object()) return object_->empty();
return false;
}
|
O3
|
cpp
|
minja::Value::empty() const:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movb 0x40(%rdi), %sil
testq %rcx, %rcx
jne 0x6462e
testq %rdx, %rdx
jne 0x6462e
testb %sil, %sil
jne 0x6462e
cmpq $0x0, 0x30(%rdi)
je 0x6465e
movq %rdx, %rax
orq %rcx, %rax
sete %dil
xorl %eax, %eax
cmpb $0x3, %sil
je 0x64656
testb %dil, %dil
jne 0x64656
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1d520
movq %rax, %rbx
leaq 0x6e2b4(%rip), %rsi # 0xd2926
movq %rax, %rdi
callq 0x1d330
movq 0xa6937(%rip), %rsi # 0x10afb8
movq 0xa68e8(%rip), %rdx # 0x10af70
movq %rbx, %rdi
callq 0x1d890
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dc90
movq %r14, %rdi
callq 0x1d8e0
|
_ZNK5minja5Value5emptyEv:
push r14
push rbx
push rax
mov rdx, [rdi+10h]
mov rcx, [rdi+20h]
mov sil, [rdi+40h]
test rcx, rcx
jnz short loc_6462E
test rdx, rdx
jnz short loc_6462E
test sil, sil
jnz short loc_6462E
cmp qword ptr [rdi+30h], 0
jz short loc_6465E
loc_6462E:
mov rax, rdx
or rax, rcx
setz dil
xor eax, eax
cmp sil, 3
jz short loc_64656
test dil, dil
jnz short loc_64656
test rdx, rdx
cmovnz rcx, rdx
mov rax, [rcx]
cmp rax, [rcx+8]
setz al
loc_64656:
add rsp, 8
pop rbx
pop r14
retn
loc_6465E:
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:_ZNSt13runtime_errorD1Ev_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
|
bool minja::Value::empty(minja::Value *this)
{
unsigned long long v1; // rdx
_QWORD *v2; // rcx
char v3; // si
bool result; // al
std::runtime_error *exception; // rbx
v1 = *((_QWORD *)this + 2);
v2 = (_QWORD *)*((_QWORD *)this + 4);
v3 = *((_BYTE *)this + 64);
if ( __PAIR128__((unsigned long long)v2, v1) == 0 && !v3 && !*((_QWORD *)this + 6) )
{
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);
}
result = 0;
if ( v3 != 3 && __PAIR128__((unsigned long long)v2, v1) != 0 )
{
if ( v1 )
v2 = (_QWORD *)*((_QWORD *)this + 2);
return *v2 == v2[1];
}
return result;
}
|
empty:
PUSH R14
PUSH RBX
PUSH RAX
MOV RDX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RDI + 0x20]
MOV SIL,byte ptr [RDI + 0x40]
TEST RCX,RCX
JNZ 0x0016462e
TEST RDX,RDX
JNZ 0x0016462e
TEST SIL,SIL
JNZ 0x0016462e
CMP qword ptr [RDI + 0x30],0x0
JZ 0x0016465e
LAB_0016462e:
MOV RAX,RDX
OR RAX,RCX
SETZ DIL
XOR EAX,EAX
CMP SIL,0x3
JZ 0x00164656
TEST DIL,DIL
JNZ 0x00164656
TEST RDX,RDX
CMOVNZ RCX,RDX
MOV RAX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x8]
SETZ AL
LAB_00164656:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0016465e:
MOV EDI,0x10
CALL 0x0011d520
MOV RBX,RAX
LAB_0016466b:
LEA RSI,[0x1d2926]
MOV RDI,RAX
CALL 0x0011d330
LAB_0016467a:
MOV RSI,qword ptr [0x0020afb8]
MOV RDX,qword ptr [0x0020af70]
MOV RDI,RBX
CALL 0x0011d890
|
/* minja::Value::empty() const */
int8 __thiscall minja::Value::empty(Value *this)
{
long *plVar1;
int8 uVar2;
runtime_error *this_00;
long *plVar3;
plVar1 = *(long **)(this + 0x10);
plVar3 = *(long **)(this + 0x20);
if ((((plVar3 == (long *)0x0) && (plVar1 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016466b to 00164679 has its CatchHandler @ 00164690 */
std::runtime_error::runtime_error(this_00,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0020afb8,PTR__runtime_error_0020af70);
}
uVar2 = 0;
if ((this[0x40] != (Value)0x3) && (plVar1 != (long *)0x0 || plVar3 != (long *)0x0)) {
if (plVar1 != (long *)0x0) {
plVar3 = plVar1;
}
uVar2 = CONCAT71((int7)((ulong)*plVar3 >> 8),*plVar3 == plVar3[1]);
}
return uVar2;
}
|
|
9,624 |
r3d_textures_unload
|
r3d/src/r3d_state.c
|
void r3d_textures_unload(void)
{
rlUnloadTexture(R3D.texture.white);
rlUnloadTexture(R3D.texture.black);
rlUnloadTexture(R3D.texture.normal);
rlUnloadTexture(R3D.texture.randNoise);
rlUnloadTexture(R3D.texture.iblBrdfLut);
if (R3D.texture.ssaoKernel != 0) {
rlUnloadTexture(R3D.texture.ssaoKernel);
}
}
|
O3
|
c
|
r3d_textures_unload:
pushq %rbp
movq %rsp, %rbp
movl 0xf0d3f(%rip), %edi # 0x1b14e0
callq 0x1ddb7
movl 0xf0d38(%rip), %edi # 0x1b14e4
callq 0x1ddb7
movl 0xf0d31(%rip), %edi # 0x1b14e8
callq 0x1ddb7
movl 0xf0d2a(%rip), %edi # 0x1b14ec
callq 0x1ddb7
movl 0xf0d27(%rip), %edi # 0x1b14f4
callq 0x1ddb7
movl 0xf0d18(%rip), %edi # 0x1b14f0
testl %edi, %edi
je 0xc07e2
popq %rbp
jmp 0x1ddb7
popq %rbp
retq
|
r3d_textures_unload:
push rbp
mov rbp, rsp
mov edi, cs:dword_1B14E0
call rlUnloadTexture
mov edi, cs:dword_1B14E4
call rlUnloadTexture
mov edi, cs:dword_1B14E8
call rlUnloadTexture
mov edi, cs:dword_1B14EC
call rlUnloadTexture
mov edi, cs:dword_1B14F4
call rlUnloadTexture
mov edi, cs:dword_1B14F0
test edi, edi
jz short loc_C07E2
pop rbp
jmp rlUnloadTexture
loc_C07E2:
pop rbp
retn
|
long long r3d_textures_unload()
{
long long result; // rax
rlUnloadTexture(dword_1B14E0);
rlUnloadTexture(dword_1B14E4);
rlUnloadTexture(dword_1B14E8);
rlUnloadTexture(dword_1B14EC);
result = rlUnloadTexture(dword_1B14F4);
if ( dword_1B14F0 )
return rlUnloadTexture(dword_1B14F0);
return result;
}
|
r3d_textures_unload:
PUSH RBP
MOV RBP,RSP
MOV EDI,dword ptr [0x002b14e0]
CALL 0x0011ddb7
MOV EDI,dword ptr [0x002b14e4]
CALL 0x0011ddb7
MOV EDI,dword ptr [0x002b14e8]
CALL 0x0011ddb7
MOV EDI,dword ptr [0x002b14ec]
CALL 0x0011ddb7
MOV EDI,dword ptr [0x002b14f4]
CALL 0x0011ddb7
MOV EDI,dword ptr [0x002b14f0]
TEST EDI,EDI
JZ 0x001c07e2
POP RBP
JMP 0x0011ddb7
LAB_001c07e2:
POP RBP
RET
|
void r3d_textures_unload(void)
{
rlUnloadTexture(DAT_002b14e0);
rlUnloadTexture(DAT_002b14e4);
rlUnloadTexture(DAT_002b14e8);
rlUnloadTexture(DAT_002b14ec);
rlUnloadTexture(DAT_002b14f4);
if (DAT_002b14f0 != 0) {
rlUnloadTexture();
return;
}
return;
}
|
|
9,625 |
ggml_fp32_to_fp16_row
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int64_t n) {
int64_t i = 0;
#if defined(__F16C__)
//if (ggml_cpu_has_f16c()) {
for (; i + 7 < n; i += 8) {
__m256 x_vec = _mm256_loadu_ps(x + i);
__m128i y_vec = _mm256_cvtps_ph(x_vec, _MM_FROUND_TO_NEAREST_INT);
_mm_storeu_si128((__m128i *)(y + i), y_vec);
}
for(; i + 3 < n; i += 4) {
__m128 x_vec = _mm_loadu_ps(x + i);
__m128i y_vec = _mm_cvtps_ph(x_vec, _MM_FROUND_TO_NEAREST_INT);
_mm_storel_epi64((__m128i *)(y + i), y_vec);
}
//}
#endif
for (; i < n; i++) {
y[i] = GGML_FP32_TO_FP16(x[i]);
}
}
|
O1
|
c
|
ggml_fp32_to_fp16_row:
testq %rdx, %rdx
jle 0x1aea3
pushq %rbx
xorl %eax, %eax
movdqa 0x31219(%rip), %xmm0 # 0x4c020
movss 0x31239(%rip), %xmm1 # 0x4c048
movss 0x31235(%rip), %xmm2 # 0x4c04c
movl $0x40000000, %ecx # imm = 0x40000000
movl $0x7e00, %r8d # imm = 0x7E00
movd (%rdi,%rax,4), %xmm3
movd %xmm3, %r9d
pand %xmm0, %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm3
leal (%r9,%r9), %r10d
movl %r9d, %r11d
andl $0x7f800000, %r11d # imm = 0x7F800000
addl $0x7800000, %r11d # imm = 0x7800000
cmpl $0x71000000, %r10d # imm = 0x71000000
cmovbl %ecx, %r11d
movd %r11d, %xmm4
addss %xmm3, %xmm4
movd %xmm4, %r11d
movl %r11d, %ebx
shrl $0xd, %ebx
andl $0x7c00, %ebx # imm = 0x7C00
andl $0xfff, %r11d # imm = 0xFFF
addl %ebx, %r11d
shrl $0x10, %r9d
andl $0x8000, %r9d # imm = 0x8000
cmpl $0xff000001, %r10d # imm = 0xFF000001
cmovael %r8d, %r11d
orl %r9d, %r11d
movw %r11w, (%rsi,%rax,2)
incq %rax
cmpq %rax, %rdx
jne 0x1ae22
popq %rbx
retq
|
ggml_fp32_to_fp16_row:
test rdx, rdx
jle locret_1AEA3
push rbx
xor eax, eax
movdqa xmm0, cs:xmmword_4C020
movss xmm1, cs:dword_4C048
movss xmm2, cs:dword_4C04C
mov ecx, 40000000h
mov r8d, 7E00h
loc_1AE22:
movd xmm3, dword ptr [rdi+rax*4]
movd r9d, xmm3
pand xmm3, xmm0
mulss xmm3, xmm1
mulss xmm3, xmm2
lea r10d, [r9+r9]
mov r11d, r9d
and r11d, 7F800000h
add r11d, 7800000h
cmp r10d, 71000000h
cmovb r11d, ecx
movd xmm4, r11d
addss xmm4, xmm3
movd r11d, xmm4
mov ebx, r11d
shr ebx, 0Dh
and ebx, 7C00h
and r11d, 0FFFh
add r11d, ebx
shr r9d, 10h
and r9d, 8000h
cmp r10d, 0FF000001h
cmovnb r11d, r8d
or r11d, r9d
mov [rsi+rax*2], r11w
inc rax
cmp rdx, rax
jnz short loc_1AE22
pop rbx
locret_1AEA3:
retn
|
void ggml_fp32_to_fp16_row(long long a1, long long a2, long long a3)
{
long long v3; // rax
__m128i si128; // xmm0
__m128i v5; // xmm3
unsigned int v6; // r9d
float v7; // xmm3_4
unsigned int v8; // r10d
unsigned int v9; // r11d
__m128i v10; // xmm4
unsigned int v11; // r11d
int v12; // r11d
int v13; // r9d
if ( a3 > 0 )
{
v3 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_4C020);
do
{
v5 = _mm_cvtsi32_si128(*(_DWORD *)(a1 + 4 * v3));
v6 = _mm_cvtsi128_si32(v5);
v7 = (float)(*(float *)_mm_and_si128(v5, si128).m128i_i32 * 5.1922969e33) * 7.7037198e-34;
v8 = 2 * v6;
v9 = (v6 & 0x7F800000) + 125829120;
if ( 2 * v6 < 0x71000000 )
v9 = 0x40000000;
v10 = _mm_cvtsi32_si128(v9);
*(float *)v10.m128i_i32 = *(float *)v10.m128i_i32 + v7;
v11 = _mm_cvtsi128_si32(v10);
v12 = ((v11 >> 13) & 0x7C00) + (v11 & 0xFFF);
v13 = HIWORD(v6) & 0x8000;
if ( v8 >= 0xFF000001 )
LOWORD(v12) = 32256;
*(_WORD *)(a2 + 2 * v3++) = v13 | v12;
}
while ( a3 != v3 );
}
}
|
ggml_fp32_to_fp16_row:
TEST RDX,RDX
JLE 0x0011aea3
PUSH RBX
XOR EAX,EAX
MOVDQA XMM0,xmmword ptr [0x0014c020]
MOVSS XMM1,dword ptr [0x0014c048]
MOVSS XMM2,dword ptr [0x0014c04c]
MOV ECX,0x40000000
MOV R8D,0x7e00
LAB_0011ae22:
MOVD XMM3,dword ptr [RDI + RAX*0x4]
MOVD R9D,XMM3
PAND XMM3,XMM0
MULSS XMM3,XMM1
MULSS XMM3,XMM2
LEA R10D,[R9 + R9*0x1]
MOV R11D,R9D
AND R11D,0x7f800000
ADD R11D,0x7800000
CMP R10D,0x71000000
CMOVC R11D,ECX
MOVD XMM4,R11D
ADDSS XMM4,XMM3
MOVD R11D,XMM4
MOV EBX,R11D
SHR EBX,0xd
AND EBX,0x7c00
AND R11D,0xfff
ADD R11D,EBX
SHR R9D,0x10
AND R9D,0x8000
CMP R10D,0xff000001
CMOVNC R11D,R8D
OR R11D,R9D
MOV word ptr [RSI + RAX*0x2],R11W
INC RAX
CMP RDX,RAX
JNZ 0x0011ae22
POP RBX
LAB_0011aea3:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_fp32_to_fp16_row(long param_1,long param_2,long param_3)
{
uint uVar1;
uint uVar2;
float fVar3;
float fVar4;
long lVar5;
ushort uVar6;
float fVar7;
fVar4 = DAT_0014c04c;
fVar3 = DAT_0014c048;
uVar2 = _DAT_0014c020;
if (0 < param_3) {
lVar5 = 0;
do {
uVar1 = *(uint *)(param_1 + lVar5 * 4);
fVar7 = (float)((uVar1 & 0x7f800000) + 0x7800000);
if (uVar1 * 2 < 0x71000000) {
fVar7 = 2.0;
}
fVar7 = fVar7 + (float)(uVar1 & uVar2) * fVar3 * fVar4;
uVar6 = (SUB42(fVar7,0) & 0xfff) + ((ushort)((uint)fVar7 >> 0xd) & 0x7c00);
if (0xff000000 < uVar1 * 2) {
uVar6 = 0x7e00;
}
*(ushort *)(param_2 + lVar5 * 2) = uVar6 | (ushort)(uVar1 >> 0x10) & 0x8000;
lVar5 = lVar5 + 1;
} while (param_3 != lVar5);
}
return;
}
|
|
9,626 |
ggml_fp32_to_fp16_row
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
void ggml_fp32_to_fp16_row(const float * x, ggml_fp16_t * y, int64_t n) {
int64_t i = 0;
#if defined(__F16C__)
//if (ggml_cpu_has_f16c()) {
for (; i + 7 < n; i += 8) {
__m256 x_vec = _mm256_loadu_ps(x + i);
__m128i y_vec = _mm256_cvtps_ph(x_vec, _MM_FROUND_TO_NEAREST_INT);
_mm_storeu_si128((__m128i *)(y + i), y_vec);
}
for(; i + 3 < n; i += 4) {
__m128 x_vec = _mm_loadu_ps(x + i);
__m128i y_vec = _mm_cvtps_ph(x_vec, _MM_FROUND_TO_NEAREST_INT);
_mm_storel_epi64((__m128i *)(y + i), y_vec);
}
//}
#endif
for (; i < n; i++) {
y[i] = GGML_FP32_TO_FP16(x[i]);
}
}
|
O3
|
c
|
ggml_fp32_to_fp16_row:
testq %rdx, %rdx
jle 0x19b73
pushq %rbx
xorl %eax, %eax
movdqa 0x32549(%rip), %xmm0 # 0x4c020
movss 0x32609(%rip), %xmm1 # 0x4c0e8
movss 0x32605(%rip), %xmm2 # 0x4c0ec
movl $0x40000000, %ecx # imm = 0x40000000
movl $0x7e00, %r8d # imm = 0x7E00
movd (%rdi,%rax,4), %xmm3
movd %xmm3, %r9d
pand %xmm0, %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm3
leal (%r9,%r9), %r10d
movl %r9d, %r11d
andl $0x7f800000, %r11d # imm = 0x7F800000
addl $0x7800000, %r11d # imm = 0x7800000
cmpl $0x71000000, %r10d # imm = 0x71000000
cmovbl %ecx, %r11d
movd %r11d, %xmm4
addss %xmm3, %xmm4
movd %xmm4, %r11d
movl %r11d, %ebx
shrl $0xd, %ebx
andl $0x7c00, %ebx # imm = 0x7C00
andl $0xfff, %r11d # imm = 0xFFF
addl %ebx, %r11d
shrl $0x10, %r9d
andl $0x8000, %r9d # imm = 0x8000
cmpl $0xff000001, %r10d # imm = 0xFF000001
cmovael %r8d, %r11d
orl %r9d, %r11d
movw %r11w, (%rsi,%rax,2)
incq %rax
cmpq %rax, %rdx
jne 0x19af2
popq %rbx
retq
|
ggml_fp32_to_fp16_row:
test rdx, rdx
jle locret_19B73
push rbx
xor eax, eax
movdqa xmm0, cs:xmmword_4C020
movss xmm1, cs:dword_4C0E8
movss xmm2, cs:dword_4C0EC
mov ecx, 40000000h
mov r8d, 7E00h
loc_19AF2:
movd xmm3, dword ptr [rdi+rax*4]
movd r9d, xmm3
pand xmm3, xmm0
mulss xmm3, xmm1
mulss xmm3, xmm2
lea r10d, [r9+r9]
mov r11d, r9d
and r11d, 7F800000h
add r11d, 7800000h
cmp r10d, 71000000h
cmovb r11d, ecx
movd xmm4, r11d
addss xmm4, xmm3
movd r11d, xmm4
mov ebx, r11d
shr ebx, 0Dh
and ebx, 7C00h
and r11d, 0FFFh
add r11d, ebx
shr r9d, 10h
and r9d, 8000h
cmp r10d, 0FF000001h
cmovnb r11d, r8d
or r11d, r9d
mov [rsi+rax*2], r11w
inc rax
cmp rdx, rax
jnz short loc_19AF2
pop rbx
locret_19B73:
retn
|
void ggml_fp32_to_fp16_row(long long a1, long long a2, long long a3)
{
long long v3; // rax
__m128i si128; // xmm0
__m128i v5; // xmm3
unsigned int v6; // r9d
float v7; // xmm3_4
unsigned int v8; // r10d
unsigned int v9; // r11d
__m128i v10; // xmm4
unsigned int v11; // r11d
int v12; // r11d
int v13; // r9d
if ( a3 > 0 )
{
v3 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_4C020);
do
{
v5 = _mm_cvtsi32_si128(*(_DWORD *)(a1 + 4 * v3));
v6 = _mm_cvtsi128_si32(v5);
v7 = (float)(*(float *)_mm_and_si128(v5, si128).m128i_i32 * 5.1922969e33) * 7.7037198e-34;
v8 = 2 * v6;
v9 = (v6 & 0x7F800000) + 125829120;
if ( 2 * v6 < 0x71000000 )
v9 = 0x40000000;
v10 = _mm_cvtsi32_si128(v9);
*(float *)v10.m128i_i32 = *(float *)v10.m128i_i32 + v7;
v11 = _mm_cvtsi128_si32(v10);
v12 = ((v11 >> 13) & 0x7C00) + (v11 & 0xFFF);
v13 = HIWORD(v6) & 0x8000;
if ( v8 >= 0xFF000001 )
LOWORD(v12) = 32256;
*(_WORD *)(a2 + 2 * v3++) = v13 | v12;
}
while ( a3 != v3 );
}
}
|
ggml_fp32_to_fp16_row:
TEST RDX,RDX
JLE 0x00119b73
PUSH RBX
XOR EAX,EAX
MOVDQA XMM0,xmmword ptr [0x0014c020]
MOVSS XMM1,dword ptr [0x0014c0e8]
MOVSS XMM2,dword ptr [0x0014c0ec]
MOV ECX,0x40000000
MOV R8D,0x7e00
LAB_00119af2:
MOVD XMM3,dword ptr [RDI + RAX*0x4]
MOVD R9D,XMM3
PAND XMM3,XMM0
MULSS XMM3,XMM1
MULSS XMM3,XMM2
LEA R10D,[R9 + R9*0x1]
MOV R11D,R9D
AND R11D,0x7f800000
ADD R11D,0x7800000
CMP R10D,0x71000000
CMOVC R11D,ECX
MOVD XMM4,R11D
ADDSS XMM4,XMM3
MOVD R11D,XMM4
MOV EBX,R11D
SHR EBX,0xd
AND EBX,0x7c00
AND R11D,0xfff
ADD R11D,EBX
SHR R9D,0x10
AND R9D,0x8000
CMP R10D,0xff000001
CMOVNC R11D,R8D
OR R11D,R9D
MOV word ptr [RSI + RAX*0x2],R11W
INC RAX
CMP RDX,RAX
JNZ 0x00119af2
POP RBX
LAB_00119b73:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_fp32_to_fp16_row(long param_1,long param_2,long param_3)
{
uint uVar1;
uint uVar2;
float fVar3;
float fVar4;
long lVar5;
ushort uVar6;
float fVar7;
fVar4 = DAT_0014c0ec;
fVar3 = DAT_0014c0e8;
uVar2 = _DAT_0014c020;
if (0 < param_3) {
lVar5 = 0;
do {
uVar1 = *(uint *)(param_1 + lVar5 * 4);
fVar7 = (float)((uVar1 & 0x7f800000) + 0x7800000);
if (uVar1 * 2 < 0x71000000) {
fVar7 = 2.0;
}
fVar7 = fVar7 + (float)(uVar1 & uVar2) * fVar3 * fVar4;
uVar6 = (SUB42(fVar7,0) & 0xfff) + ((ushort)((uint)fVar7 >> 0xd) & 0x7c00);
if (0xff000000 < uVar1 * 2) {
uVar6 = 0x7e00;
}
*(ushort *)(param_2 + lVar5 * 2) = uVar6 | (ushort)(uVar1 >> 0x10) & 0x8000;
lVar5 = lVar5 + 1;
} while (param_3 != lVar5);
}
return;
}
|
|
9,627 |
my_utf16le_uni
|
eloqsql/strings/ctype-ucs2.c
|
static int
my_utf16le_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
my_wc_t lo;
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if ((*pwc= uint2korr(s)) < MY_UTF16_SURROGATE_HIGH_FIRST ||
(*pwc > MY_UTF16_SURROGATE_LOW_LAST))
return 2; /* [0000-D7FF,E000-FFFF] */
if (*pwc >= MY_UTF16_SURROGATE_LOW_FIRST)
return MY_CS_ILSEQ; /* [DC00-DFFF] Low surrogate part without high part */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
s+= 2;
if ((lo= uint2korr(s)) < MY_UTF16_SURROGATE_LOW_FIRST ||
lo > MY_UTF16_SURROGATE_LOW_LAST)
return MY_CS_ILSEQ; /* Expected low surrogate part, got something else */
*pwc= 0x10000 + (((*pwc & 0x3FF) << 10) | (lo & 0x3FF));
return 4;
}
|
O3
|
c
|
my_utf16le_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xe6611
movzwl (%rdx), %edi
movq %rdi, (%rsi)
leal 0x2000(%rdi), %eax
movzwl %ax, %r9d
movl $0x2, %eax
cmpl $0xf800, %r9d # imm = 0xF800
jb 0xe6611
xorl %eax, %eax
cmpl $0xdbff, %edi # imm = 0xDBFF
ja 0xe6611
addq $0x4, %rdx
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdx
ja 0xe6611
movzwl (%r8), %ecx
leal 0x2000(%rcx), %eax
movzwl %ax, %edx
movl $0x0, %eax
cmpl $0xfc00, %edx # imm = 0xFC00
jb 0xe6611
shll $0xa, %edi
andl $0xffc00, %edi # imm = 0xFFC00
andl $0x3ff, %ecx # imm = 0x3FF
leaq (%rdi,%rcx), %rax
addq $0x10000, %rax # imm = 0x10000
movq %rax, (%rsi)
movl $0x4, %eax
popq %rbp
retq
|
my_utf16le_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_E6611
movzx edi, word ptr [rdx]
mov [rsi], rdi
lea eax, [rdi+2000h]
movzx r9d, ax
mov eax, 2
cmp r9d, 0F800h
jb short loc_E6611
xor eax, eax
cmp edi, 0DBFFh
ja short loc_E6611
add rdx, 4
mov eax, 0FFFFFF98h
cmp rdx, rcx
ja short loc_E6611
movzx ecx, word ptr [r8]
lea eax, [rcx+2000h]
movzx edx, ax
mov eax, 0
cmp edx, 0FC00h
jb short loc_E6611
shl edi, 0Ah
and edi, 0FFC00h
and ecx, 3FFh
lea rax, [rdi+rcx]
add rax, 10000h
mov [rsi], rax
mov eax, 4
loc_E6611:
pop rbp
retn
|
long long my_utf16le_uni(long long a1, _QWORD *a2, unsigned __int16 *a3, unsigned long long a4)
{
_WORD *v4; // r8
long long result; // rax
long long v6; // rdi
v4 = a3 + 1;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
v6 = *a3;
*a2 = v6;
result = 2LL;
if ( (unsigned __int16)(v6 + 0x2000) >= 0xF800u )
{
result = 0LL;
if ( (unsigned int)v6 <= 0xDBFF )
{
result = 4294967192LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int16)(*v4 + 0x2000) >= 0xFC00u )
{
*a2 = (((_DWORD)v6 << 10) & 0xFFC00) + (unsigned long long)(*v4 & 0x3FF) + 0x10000;
return 4LL;
}
}
}
}
}
return result;
}
|
my_utf16le_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001e6611
MOVZX EDI,word ptr [RDX]
MOV qword ptr [RSI],RDI
LEA EAX,[RDI + 0x2000]
MOVZX R9D,AX
MOV EAX,0x2
CMP R9D,0xf800
JC 0x001e6611
XOR EAX,EAX
CMP EDI,0xdbff
JA 0x001e6611
ADD RDX,0x4
MOV EAX,0xffffff98
CMP RDX,RCX
JA 0x001e6611
MOVZX ECX,word ptr [R8]
LEA EAX,[RCX + 0x2000]
MOVZX EDX,AX
MOV EAX,0x0
CMP EDX,0xfc00
JC 0x001e6611
SHL EDI,0xa
AND EDI,0xffc00
AND ECX,0x3ff
LEA RAX,[RDI + RCX*0x1]
ADD RAX,0x10000
MOV qword ptr [RSI],RAX
MOV EAX,0x4
LAB_001e6611:
POP RBP
RET
|
int8 my_utf16le_uni(int8 param_1,ulong *param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
ushort uVar2;
int8 uVar3;
uVar3 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
uVar1 = *param_3;
*param_2 = (ulong)uVar1;
uVar3 = 2;
if (((0xf7ff < (ushort)(uVar1 + 0x2000)) && (uVar3 = 0, uVar1 < 0xdc00)) &&
(uVar3 = 0xffffff98, param_3 + 2 <= param_4)) {
uVar2 = param_3[1];
uVar3 = 0;
if (0xfbff < (ushort)(uVar2 + 0x2000)) {
*param_2 = (ulong)((uVar1 & 0x3ff) << 10) + (ulong)(uVar2 & 0x3ff) + 0x10000;
uVar3 = 4;
}
}
}
return uVar3;
}
|
|
9,628 |
mysql_stat
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
char * STDCALL
mysql_stat(MYSQL *mysql)
{
if (ma_simple_command(mysql, COM_STATISTICS,0,0,0,0))
return mysql->net.last_error;
mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
if (!mysql->net.read_pos[0])
{
SET_CLIENT_ERROR(mysql, CR_WRONG_HOST_INFO , SQLSTATE_UNKNOWN, 0);
return mysql->net.last_error;
}
return((char*) mysql->net.read_pos);
}
|
O3
|
c
|
mysql_stat:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4d0(%rdi), %rax
movl $0x9, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x10(%rax)
testl %eax, %eax
je 0x20541
addq $0x97, %rbx
movq %rbx, %r14
jmp 0x205af
movq 0x20(%rbx), %rax
movq 0x358(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rbx), %r14
cmpb $0x0, (%r14)
jne 0x205af
movl $0x7d9, 0x90(%rbx) # imm = 0x7D9
leaq 0x297(%rbx), %rdi
leaq 0x2fa8e(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %r15d, %r15d
movb %r15b, 0x29c(%rbx)
leaq 0x97(%rbx), %r14
leaq 0x2fa79(%rip), %rax # 0x50010
movq 0x48(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rdi
callq 0x13230
movb %r15b, 0x296(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_stat:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+4D0h]
mov esi, 9
xor edx, edx
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
call qword ptr [rax+10h]
test eax, eax
jz short loc_20541
add rbx, 97h
mov r14, rbx
jmp short loc_205AF
loc_20541:
mov rax, [rbx+20h]
mov rcx, [rbx+358h]
mov byte ptr [rax+rcx], 0
mov r14, [rbx+20h]
cmp byte ptr [r14], 0
jnz short loc_205AF
mov dword ptr [rbx+90h], 7D9h
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [rbx+29Ch], r15b
lea r14, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+48h]
mov edx, 1FFh
mov rdi, r14
call _strncpy
mov [rbx+296h], r15b
loc_205AF:
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_BYTE * mysql_stat(long long a1)
{
long long v1; // rax
_BYTE *v2; // r14
if ( (*(unsigned int ( **)(long long, long long, _QWORD, _QWORD, _QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 1232)
+ 16LL))(
a1,
9LL,
0LL,
0LL,
0LL,
0LL,
v1) )
{
return (_BYTE *)(a1 + 151);
}
*(_BYTE *)(*(_QWORD *)(a1 + 32) + *(_QWORD *)(a1 + 856)) = 0;
v2 = *(_BYTE **)(a1 + 32);
if ( !*v2 )
{
*(_DWORD *)(a1 + 144) = 2009;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
v2 = (_BYTE *)(a1 + 151);
strncpy(a1 + 151, client_errors[9], 511LL);
*(_BYTE *)(a1 + 662) = 0;
}
return v2;
}
|
mysql_stat:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ESI,0x9
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x00120541
ADD RBX,0x97
MOV R14,RBX
JMP 0x001205af
LAB_00120541:
MOV RAX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x358]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV R14,qword ptr [RBX + 0x20]
CMP byte ptr [R14],0x0
JNZ 0x001205af
MOV dword ptr [RBX + 0x90],0x7d9
LEA RDI,[RBX + 0x297]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR R15D,R15D
MOV byte ptr [RBX + 0x29c],R15B
LEA R14,[RBX + 0x97]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x48]
MOV EDX,0x1ff
MOV RDI,R14
CALL 0x00113230
MOV byte ptr [RBX + 0x296],R15B
LAB_001205af:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * mysql_stat(long param_1)
{
int iVar1;
char *__dest;
iVar1 = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x10))(param_1,9,0,0,0,0);
if (iVar1 == 0) {
*(int1 *)(*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x358)) = 0;
__dest = *(char **)(param_1 + 0x20);
if (*__dest == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7d9;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
__dest = (char *)(param_1 + 0x97);
strncpy(__dest,PTR_s_Wrong_host_info_00150058,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
}
}
else {
__dest = (char *)(param_1 + 0x97);
}
return __dest;
}
|
|
9,629 |
sqrt_align_fp2
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/sqrt.c
|
static bool_t sqrt_align_fp2(vec384x out, const vec384x ret,
const vec384x sqrt, const vec384x inp)
{
static const vec384x sqrt_minus_1 = { { 0 }, { ONE_MONT_P } };
static const vec384x sqrt_sqrt_minus_1 = {
/*
* "magic" number is ±2^((p-3)/4)%p, which is "1/sqrt(2)",
* in quotes because 2*"1/sqrt(2)"^2 == -1 mod p, not 1,
* but it pivots into "complex" plane nevertheless...
*/
{ TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),
TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),
TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }
};
static const vec384x sqrt_minus_sqrt_minus_1 = {
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },
{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }
};
vec384x coeff, t0, t1;
bool_t is_sqrt, flag;
/*
* Instead of multiple trial squarings we can perform just one
* and see if the result is "rotated by multiple of 90°" in
* relation to |inp|, and "rotate" |ret| accordingly.
*/
sqr_fp2(t0, sqrt);
/* "sqrt(|inp|)"^2 = (a + b*i)^2 = (a^2-b^2) + 2ab*i */
/* (a^2-b^2) + 2ab*i == |inp| ? |ret| is spot on */
sub_fp2(t1, t0, inp);
is_sqrt = vec_is_zero(t1, sizeof(t1));
vec_copy(coeff, BLS12_381_Rx.p2, sizeof(coeff));
/* -(a^2-b^2) - 2ab*i == |inp| ? "rotate |ret| by 90°" */
add_fp2(t1, t0, inp);
vec_select(coeff, sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* 2ab - (a^2-b^2)*i == |inp| ? "rotate |ret| by 135°" */
sub_fp(t1[0], t0[0], inp[1]);
add_fp(t1[1], t0[1], inp[0]);
vec_select(coeff, sqrt_sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* -2ab + (a^2-b^2)*i == |inp| ? "rotate |ret| by 45°" */
add_fp(t1[0], t0[0], inp[1]);
sub_fp(t1[1], t0[1], inp[0]);
vec_select(coeff, sqrt_minus_sqrt_minus_1, coeff, sizeof(coeff),
flag = vec_is_zero(t1, sizeof(t1)));
is_sqrt |= flag;
/* actual "rotation" */
mul_fp2(out, ret, coeff);
return is_sqrt;
}
|
O0
|
c
|
sqrt_align_fp2:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb6750
leaq -0x140(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb6520
leaq -0x140(%rbp), %rdi
movl $0x60, %esi
callq 0xa8cd0
movq %rax, -0x148(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x2b273(%rip), %rsi # 0xe84a8
movl $0x60, %edx
callq 0xa8ad0
leaq -0x140(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb64b0
leaq -0x80(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x140(%rbp), %rdi
movl $0x60, %esi
callq 0xa8cd0
movq -0x180(%rbp), %rdi
movq -0x178(%rbp), %rdx
movq %rax, %r8
movq %r8, -0x150(%rbp)
leaq 0x2c474(%rip), %rsi # 0xe9710
movl $0x60, %ecx
callq 0xa8b40
movq -0x150(%rbp), %rax
orq -0x148(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x140(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0xb5ee0
leaq -0x140(%rbp), %rdi
addq $0x30, %rdi
leaq -0xe0(%rbp), %rsi
addq $0x30, %rsi
movq -0x20(%rbp), %rdx
callq 0xafde0
leaq -0x80(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x140(%rbp), %rdi
movl $0x60, %esi
callq 0xa8cd0
movq -0x170(%rbp), %rdi
movq -0x168(%rbp), %rdx
movq %rax, %r8
movq %r8, -0x150(%rbp)
leaq 0x2c435(%rip), %rsi # 0xe9770
movl $0x60, %ecx
callq 0xa8b40
movq -0x150(%rbp), %rax
orq -0x148(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x140(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0xafde0
leaq -0x140(%rbp), %rdi
addq $0x30, %rdi
leaq -0xe0(%rbp), %rsi
addq $0x30, %rsi
movq -0x20(%rbp), %rdx
callq 0xb5ee0
leaq -0x80(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x140(%rbp), %rdi
movl $0x60, %esi
callq 0xa8cd0
movq -0x160(%rbp), %rdi
movq -0x158(%rbp), %rdx
movq %rax, %r8
movq %r8, -0x150(%rbp)
leaq 0x2c3f6(%rip), %rsi # 0xe97d0
movl $0x60, %ecx
callq 0xa8b40
movq -0x150(%rbp), %rax
orq -0x148(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0xb66e0
movq -0x148(%rbp), %rax
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
nopw (%rax,%rax)
|
sqrt_align_fp2:
push rbp
mov rbp, rsp
sub rsp, 180h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
lea rdi, [rbp+var_E0]
mov rsi, [rbp+var_18]
call sqr_fp2
lea rdi, [rbp+var_140]
lea rsi, [rbp+var_E0]
mov rdx, [rbp+var_20]
call _sub_fp2
lea rdi, [rbp+var_140]
mov esi, 60h ; '`'
call vec_is_zero
mov [rbp+var_148], rax
lea rdi, [rbp+var_80]
lea rsi, BLS12_381_Rx
mov edx, 60h ; '`'
call vec_copy
lea rdi, [rbp+var_140]
lea rsi, [rbp+var_E0]
mov rdx, [rbp+var_20]
call add_fp2
lea rax, [rbp+var_80]
mov [rbp+var_180], rax
lea rax, [rbp+var_80]
mov [rbp+var_178], rax
lea rdi, [rbp+var_140]
mov esi, 60h ; '`'
call vec_is_zero
mov rdi, [rbp+var_180]
mov rdx, [rbp+var_178]
mov r8, rax
mov [rbp+var_150], r8
lea rsi, sqrt_align_fp2_sqrt_minus_1
mov ecx, 60h ; '`'
call vec_select
mov rax, [rbp+var_150]
or rax, [rbp+var_148]
mov [rbp+var_148], rax
lea rdi, [rbp+var_140]
lea rsi, [rbp+var_E0]
mov rdx, [rbp+var_20]
add rdx, 30h ; '0'
call _sub_fp
lea rdi, [rbp+var_140]
add rdi, 30h ; '0'
lea rsi, [rbp+var_E0]
add rsi, 30h ; '0'
mov rdx, [rbp+var_20]
call add_fp
lea rax, [rbp+var_80]
mov [rbp+var_170], rax
lea rax, [rbp+var_80]
mov [rbp+var_168], rax
lea rdi, [rbp+var_140]
mov esi, 60h ; '`'
call vec_is_zero
mov rdi, [rbp+var_170]
mov rdx, [rbp+var_168]
mov r8, rax
mov [rbp+var_150], r8
lea rsi, sqrt_align_fp2_sqrt_sqrt_minus_1
mov ecx, 60h ; '`'
call vec_select
mov rax, [rbp+var_150]
or rax, [rbp+var_148]
mov [rbp+var_148], rax
lea rdi, [rbp+var_140]
lea rsi, [rbp+var_E0]
mov rdx, [rbp+var_20]
add rdx, 30h ; '0'
call add_fp
lea rdi, [rbp+var_140]
add rdi, 30h ; '0'
lea rsi, [rbp+var_E0]
add rsi, 30h ; '0'
mov rdx, [rbp+var_20]
call _sub_fp
lea rax, [rbp+var_80]
mov [rbp+var_160], rax
lea rax, [rbp+var_80]
mov [rbp+var_158], rax
lea rdi, [rbp+var_140]
mov esi, 60h ; '`'
call vec_is_zero
mov rdi, [rbp+var_160]
mov rdx, [rbp+var_158]
mov r8, rax
mov [rbp+var_150], r8
lea rsi, sqrt_align_fp2_sqrt_minus_sqrt_minus_1
mov ecx, 60h ; '`'
call vec_select
mov rax, [rbp+var_150]
or rax, [rbp+var_148]
mov [rbp+var_148], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_80]
call mul_fp2
mov rax, [rbp+var_148]
add rsp, 180h
pop rbp
retn
|
unsigned long long sqrt_align_fp2(long long a1, long long a2, long long a3, long long a4)
{
unsigned long long v5; // [rsp+30h] [rbp-150h]
unsigned long long v6; // [rsp+30h] [rbp-150h]
unsigned long long v7; // [rsp+30h] [rbp-150h]
unsigned long long is_zero; // [rsp+38h] [rbp-148h]
unsigned long long v9; // [rsp+38h] [rbp-148h]
unsigned long long v10; // [rsp+38h] [rbp-148h]
_BYTE v11[48]; // [rsp+40h] [rbp-140h] BYREF
_BYTE v12[48]; // [rsp+70h] [rbp-110h] BYREF
_BYTE v13[48]; // [rsp+A0h] [rbp-E0h] BYREF
_BYTE v14[48]; // [rsp+D0h] [rbp-B0h] BYREF
_BYTE v15[96]; // [rsp+100h] [rbp-80h] BYREF
long long v16; // [rsp+160h] [rbp-20h]
long long v17; // [rsp+168h] [rbp-18h]
long long v18; // [rsp+170h] [rbp-10h]
long long v19; // [rsp+178h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
sqr_fp2((long long)v13, a3);
sub_fp2((long long)v11, (long long)v13, v16);
is_zero = vec_is_zero((long long)v11, 0x60uLL);
vec_copy((long long)v15, (long long)&BLS12_381_Rx, 0x60uLL);
add_fp2((long long)v11, (long long)v13, v16);
v5 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v15, (long long)&sqrt_align_fp2_sqrt_minus_1, (long long)v15, 0x60uLL, v5);
v9 = is_zero | v5;
sub_fp((long long)v11, (long long)v13, v16 + 48);
add_fp((long long)v12, (long long)v14, v16);
v6 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v15, (long long)&sqrt_align_fp2_sqrt_sqrt_minus_1, (long long)v15, 0x60uLL, v6);
v10 = v9 | v6;
add_fp((long long)v11, (long long)v13, v16 + 48);
sub_fp((long long)v12, (long long)v14, v16);
v7 = vec_is_zero((long long)v11, 0x60uLL);
vec_select((long long)v15, (long long)&sqrt_align_fp2_sqrt_minus_sqrt_minus_1, (long long)v15, 0x60uLL, v7);
mul_fp2(v19, v18, (long long)v15);
return v10 | v7;
}
|
sqrt_align_fp2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
LEA RDI,[RBP + -0xe0]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001b6750
LEA RDI,[RBP + -0x140]
LEA RSI,[RBP + -0xe0]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b6520
LEA RDI,[RBP + -0x140]
MOV ESI,0x60
CALL 0x001a8cd0
MOV qword ptr [RBP + -0x148],RAX
LEA RDI,[RBP + -0x80]
LEA RSI,[0x1e84a8]
MOV EDX,0x60
CALL 0x001a8ad0
LEA RDI,[RBP + -0x140]
LEA RSI,[RBP + -0xe0]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b64b0
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x180],RAX
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x178],RAX
LEA RDI,[RBP + -0x140]
MOV ESI,0x60
CALL 0x001a8cd0
MOV RDI,qword ptr [RBP + -0x180]
MOV RDX,qword ptr [RBP + -0x178]
MOV R8,RAX
MOV qword ptr [RBP + -0x150],R8
LEA RSI,[0x1e9710]
MOV ECX,0x60
CALL 0x001a8b40
MOV RAX,qword ptr [RBP + -0x150]
OR RAX,qword ptr [RBP + -0x148]
MOV qword ptr [RBP + -0x148],RAX
LEA RDI,[RBP + -0x140]
LEA RSI,[RBP + -0xe0]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,0x30
CALL 0x001b5ee0
LEA RDI,[RBP + -0x140]
ADD RDI,0x30
LEA RSI,[RBP + -0xe0]
ADD RSI,0x30
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001afde0
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x170],RAX
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x168],RAX
LEA RDI,[RBP + -0x140]
MOV ESI,0x60
CALL 0x001a8cd0
MOV RDI,qword ptr [RBP + -0x170]
MOV RDX,qword ptr [RBP + -0x168]
MOV R8,RAX
MOV qword ptr [RBP + -0x150],R8
LEA RSI,[0x1e9770]
MOV ECX,0x60
CALL 0x001a8b40
MOV RAX,qword ptr [RBP + -0x150]
OR RAX,qword ptr [RBP + -0x148]
MOV qword ptr [RBP + -0x148],RAX
LEA RDI,[RBP + -0x140]
LEA RSI,[RBP + -0xe0]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,0x30
CALL 0x001afde0
LEA RDI,[RBP + -0x140]
ADD RDI,0x30
LEA RSI,[RBP + -0xe0]
ADD RSI,0x30
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b5ee0
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x160],RAX
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x158],RAX
LEA RDI,[RBP + -0x140]
MOV ESI,0x60
CALL 0x001a8cd0
MOV RDI,qword ptr [RBP + -0x160]
MOV RDX,qword ptr [RBP + -0x158]
MOV R8,RAX
MOV qword ptr [RBP + -0x150],R8
LEA RSI,[0x1e97d0]
MOV ECX,0x60
CALL 0x001a8b40
MOV RAX,qword ptr [RBP + -0x150]
OR RAX,qword ptr [RBP + -0x148]
MOV qword ptr [RBP + -0x148],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x80]
CALL 0x001b66e0
MOV RAX,qword ptr [RBP + -0x148]
ADD RSP,0x180
POP RBP
RET
|
ulong sqrt_align_fp2(int8 param_1,int8 param_2,int8 param_3,long param_4)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int1 local_148 [48];
int1 auStack_118 [48];
int1 local_e8 [48];
int1 auStack_b8 [48];
int1 local_88 [96];
long local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
sqr_fp2(local_e8,param_3);
sub_fp2(local_148,local_e8,local_28);
uVar1 = vec_is_zero(local_148,0x60);
vec_copy(local_88,BLS12_381_Rx,0x60);
add_fp2(local_148,local_e8,local_28);
uVar2 = vec_is_zero(local_148,0x60);
vec_select(local_88,sqrt_align_fp2_sqrt_minus_1,local_88,0x60);
sub_fp(local_148,local_e8,local_28 + 0x30);
add_fp(auStack_118,auStack_b8,local_28);
uVar3 = vec_is_zero(local_148,0x60);
vec_select(local_88,sqrt_align_fp2_sqrt_sqrt_minus_1,local_88,0x60);
add_fp(local_148,local_e8,local_28 + 0x30);
sub_fp(auStack_118,auStack_b8,local_28);
uVar4 = vec_is_zero(local_148,0x60);
vec_select(local_88,sqrt_align_fp2_sqrt_minus_sqrt_minus_1,local_88,0x60);
mul_fp2(local_10,local_18,local_88);
return uVar4 | uVar3 | uVar2 | uVar1;
}
|
|
9,630 |
insert_at
|
eloqsql/mysys/queues.c
|
static void insert_at(QUEUE *queue, uchar *element, uint idx)
{
uint next_index, offset_to_key= queue->offset_to_key;
uint offset_to_queue_pos= queue->offset_to_queue_pos;
/* max_at_top swaps the comparison if we want to order by desc */
while ((next_index= idx >> 1) > 0 &&
queue->compare(queue->first_cmp_arg,
element + offset_to_key,
queue->root[next_index] + offset_to_key) *
queue->max_at_top < 0)
{
queue->root[idx]= queue->root[next_index];
if (offset_to_queue_pos)
(*(uint*) (queue->root[idx] + offset_to_queue_pos-1))= idx;
idx= next_index;
}
queue->root[idx]= element;
if (offset_to_queue_pos)
(*(uint*) (element + offset_to_queue_pos-1))= idx;
}
|
O0
|
c
|
insert_at:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jbe 0x13289da
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
addq %rcx, %rsi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x18(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movl -0x1c(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x13289e3
jmp 0x1328a28
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0x1328a1d
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1328987
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0x1328a4e
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
insert_at:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov eax, [rax+18h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_20], eax
loc_1328987:
mov ecx, [rbp+var_14]
shr ecx, 1
mov [rbp+var_18], ecx
xor eax, eax
cmp ecx, 0
mov [rbp+var_21], al
jbe short loc_13289DA
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov rsi, [rbp+var_10]
mov ecx, [rbp+var_1C]
add rsi, rcx
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_18]
mov rdx, [rcx+rdx*8]
mov ecx, [rbp+var_1C]
add rdx, rcx
call rax
mov rcx, [rbp+var_8]
imul eax, [rcx+24h]
cmp eax, 0
setl al
mov [rbp+var_21], al
loc_13289DA:
mov al, [rbp+var_21]
test al, 1
jnz short loc_13289E3
jmp short loc_1328A28
loc_13289E3:
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_18]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_1328A1D
mov edx, [rbp+var_14]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_1328A1D:
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
jmp loc_1328987
loc_1328A28:
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_1328A4E
mov edx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_1328A4E:
add rsp, 30h
pop rbp
retn
|
long long insert_at(long long *a1, long long a2, unsigned int a3)
{
long long result; // rax
bool v4; // [rsp+Fh] [rbp-21h]
unsigned int v5; // [rsp+10h] [rbp-20h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
unsigned int v7; // [rsp+18h] [rbp-18h]
v6 = *((_DWORD *)a1 + 6);
v5 = *((_DWORD *)a1 + 7);
while ( 1 )
{
v7 = a3 >> 1;
v4 = 0;
if ( a3 >> 1 )
v4 = (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, long long, _QWORD))a1[5])(
a1[1],
v6 + a2,
v6 + *(_QWORD *)(*a1 + 8LL * v7))) < 0;
if ( !v4 )
break;
*(_QWORD *)(*a1 + 8LL * a3) = *(_QWORD *)(*a1 + 8LL * v7);
if ( v5 )
*(_DWORD *)(*(_QWORD *)(*a1 + 8LL * a3) + v5 - 1LL) = a3;
a3 >>= 1;
}
result = *a1;
*(_QWORD *)(*a1 + 8LL * a3) = a2;
if ( v5 )
{
result = a2;
*(_DWORD *)(a2 + v5 - 1) = a3;
}
return result;
}
|
trx_rsegf_undo_find_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x26dce50]
MOV RAX,qword ptr [RAX]
SHR RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_01328986:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x013289bc
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x01317590
CMP EAX,-0x1
JNZ 0x013289ac
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x013289c4
LAB_013289ac:
JMP 0x013289ae
LAB_013289ae:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x01328986
LAB_013289bc:
MOV qword ptr [RBP + -0x8],-0x1
LAB_013289c4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
/* trx_rsegf_undo_find_free(buf_block_t const*) */
ulong trx_rsegf_undo_find_free(buf_block_t *param_1)
{
int iVar1;
ulong uVar2;
ulong local_28;
uVar2 = srv_page_size >> 4;
local_28 = 0;
while( true ) {
if (uVar2 <= local_28) {
return 0xffffffffffffffff;
}
iVar1 = trx_rsegf_get_nth_undo(param_1,local_28);
if (iVar1 == -1) break;
local_28 = local_28 + 1;
}
return local_28;
}
|
|
9,631 |
JS_ThrowError2
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowError2(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap, BOOL add_backtrace)
{
char buf[256];
JSValue obj;
vsnprintf(buf, sizeof(buf), fmt, ap);
obj = JS_MakeError(ctx, error_num, buf, add_backtrace);
if (unlikely(JS_IsException(obj))) {
/* out of memory: throw JS_NULL to avoid recursing */
obj = JS_NULL;
}
return JS_Throw(ctx, obj);
}
|
O1
|
c
|
JS_ThrowError2:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %rsp, %r15
movl $0x100, %esi # imm = 0x100
movq %r15, %rdi
callq 0xe190
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x431ce
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x2fe67
movq %rax, %r15
movq 0x18(%rbx), %rbx
movq 0xf0(%rbx), %rsi
movq 0xf8(%rbx), %rdx
movq %rbx, %rdi
callq 0x1d8c6
movq %r15, 0xf0(%rbx)
movq %r14, 0xf8(%rbx)
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %r14d
xorl %r15d, %r15d
jmp 0x2fe31
|
JS_ThrowError2:
push rbp
push r15
push r14
push rbx
sub rsp, 108h
mov ebp, r8d
mov r14d, esi
mov rbx, rdi
mov r15, rsp
mov esi, 100h
mov rdi, r15
call _vsnprintf
mov rdi, rbx
mov esi, r14d
mov rdx, r15
mov ecx, ebp
call JS_MakeError
mov r14, rdx
cmp r14d, 6
jz short loc_2FE67
mov r15, rax
loc_2FE31:
mov rbx, [rbx+18h]
mov rsi, [rbx+0F0h]
mov rdx, [rbx+0F8h]
mov rdi, rbx
call JS_FreeValueRT
mov [rbx+0F0h], r15
mov [rbx+0F8h], r14
add rsp, 108h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2FE67:
mov r14d, 2
xor r15d, r15d
jmp short loc_2FE31
|
long long JS_ThrowError2(long long a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
unsigned int v6; // ebp
long long Error; // rax
long long v8; // rdx
long long v9; // r14
long long v10; // r15
long long v11; // rbx
long long result; // rax
_BYTE v13[296]; // [rsp+0h] [rbp-128h] BYREF
v6 = a5;
((void ( *)(_BYTE *, long long, long long, long long, long long, long long))vsnprintf)(v13, 256LL, a3, a4, a5, a6);
Error = JS_MakeError(a1, a2, v13, v6);
v9 = v8;
if ( (_DWORD)v8 == 6 )
{
v9 = 2LL;
v10 = 0LL;
}
else
{
v10 = Error;
}
v11 = *(_QWORD *)(a1 + 24);
result = JS_FreeValueRT(v11, *(_DWORD **)(v11 + 240), *(_QWORD *)(v11 + 248));
*(_QWORD *)(v11 + 240) = v10;
*(_QWORD *)(v11 + 248) = v9;
return result;
}
| |||
9,632 |
JS_ThrowError2
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowError2(JSContext *ctx, JSErrorEnum error_num,
const char *fmt, va_list ap, BOOL add_backtrace)
{
char buf[256];
JSValue obj;
vsnprintf(buf, sizeof(buf), fmt, ap);
obj = JS_MakeError(ctx, error_num, buf, add_backtrace);
if (unlikely(JS_IsException(obj))) {
/* out of memory: throw JS_NULL to avoid recursing */
obj = JS_NULL;
}
return JS_Throw(ctx, obj);
}
|
O2
|
c
|
JS_ThrowError2:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq %rsp, %r15
movl $0x100, %esi # imm = 0x100
movq %r15, %rdi
callq 0xe1a0
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x3ae25
cmpl $0x6, %edx
je 0x285ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c446
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
popq %rdx
xorl %eax, %eax
jmp 0x28592
|
JS_ThrowError2:
push rbp
push r15
push r14
push rbx
sub rsp, 108h
mov ebp, r8d
mov r14d, esi
mov rbx, rdi
mov r15, rsp
mov esi, 100h
mov rdi, r15
call _vsnprintf
mov rdi, rbx
mov esi, r14d
mov rdx, r15
mov ecx, ebp
call JS_MakeError
cmp edx, 6
jz short loc_285AB
loc_28592:
mov rdi, rbx
mov rsi, rax
call JS_Throw
add rsp, 108h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_285AB:
push 2
pop rdx
xor eax, eax
jmp short loc_28592
|
long long JS_ThrowError2(long long a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
unsigned int v6; // ebp
long long Error; // rax
long long v8; // rdx
_BYTE v10[296]; // [rsp+0h] [rbp-128h] BYREF
v6 = a5;
((void ( *)(_BYTE *, long long, long long, long long, long long, long long))vsnprintf)(v10, 256LL, a3, a4, a5, a6);
Error = JS_MakeError(a1, a2, v10, v6);
if ( (_DWORD)v8 == 6 )
{
v8 = 2LL;
Error = 0LL;
}
return JS_Throw(a1, Error, v8);
}
|
JS_ThrowError2:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x108
MOV EBP,R8D
MOV R14D,ESI
MOV RBX,RDI
MOV R15,RSP
MOV ESI,0x100
MOV RDI,R15
CALL 0x0010e1a0
MOV RDI,RBX
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EBP
CALL 0x0013ae25
CMP EDX,0x6
JZ 0x001285ab
LAB_00128592:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011c446
ADD RSP,0x108
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001285ab:
PUSH 0x2
POP RDX
XOR EAX,EAX
JMP 0x00128592
|
void JS_ThrowError2(int8 param_1,int4 param_2,char *param_3,__gnuc_va_list param_4,
int4 param_5)
{
int1 auVar1 [16];
char acStack_128 [264];
vsnprintf(acStack_128,0x100,param_3,param_4);
auVar1 = JS_MakeError(param_1,param_2,acStack_128,param_5);
if (auVar1._8_4_ == 6) {
auVar1 = ZEXT816(2) << 0x40;
}
JS_Throw(param_1,auVar1._0_8_,auVar1._8_8_);
return;
}
|
|
9,633 |
my_open
|
eloqsql/mysys/my_open.c
|
File my_open(const char *FileName, int Flags, myf MyFlags)
/* Path-name of file */
/* Read | write .. */
/* Special flags */
{
File fd;
DBUG_ENTER("my_open");
DBUG_PRINT("my",("Name: '%s' Flags: %d MyFlags: %lu",
FileName, Flags, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FFNF)))
MyFlags|= my_global_flags;
#if defined(_WIN32)
fd= my_win_open(FileName, Flags);
#else
if (MyFlags & MY_NOSYMLINKS)
fd = open_nosymlinks(FileName, Flags | O_CLOEXEC, my_umask);
else
fd = open(FileName, Flags | O_CLOEXEC, my_umask);
#endif
fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
EE_FILENOTFOUND, MyFlags);
DBUG_RETURN(fd);
}
|
O0
|
c
|
my_open:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2fa25
movq -0x18(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
jne 0x2fa45
leaq 0x3562fe(%rip), %rax # 0x385d38
movq (%rax), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0x2fa75
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x19e98f(%rip), %rax # 0x1ce3f8
movl (%rax), %edx
callq 0x2fad0
movl %eax, -0x1c(%rbp)
jmp 0x2fa95
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x19e96f(%rip), %rax # 0x1ce3f8
movl (%rax), %edx
movb $0x0, %al
callq 0x24630
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x1, %edx
movl $0x1d, %ecx
callq 0x2fb40
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_open:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_2FA25:
mov rax, [rbp+var_18]
and rax, 19h
cmp rax, 0
jnz short loc_2FA45
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_18]
mov [rbp+var_18], rax
loc_2FA45:
mov rax, [rbp+var_18]
and rax, 200h
cmp rax, 0
jz short loc_2FA75
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
call open_nosymlinks
mov [rbp+var_1C], eax
jmp short loc_2FA95
loc_2FA75:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
mov al, 0
call _open64
mov [rbp+var_1C], eax
loc_2FA95:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_8]
mov r8, [rbp+var_18]
mov edx, 1
mov ecx, 1Dh
call my_register_filename
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long my_open(long long a1, int a2, long long a3)
{
unsigned int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = a3;
if ( (a3 & 0x19) == 0 )
v5 = a3 | my_global_flags;
if ( (v5 & 0x200) != 0 )
v4 = open_nosymlinks(a1, a2 | 0x80000u, my_umask);
else
v4 = open64(a1, a2 | 0x80000u, my_umask);
return (unsigned int)my_register_filename(v4, a1, 1LL, 29LL, v5);
}
|
my_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x0012fa25
LAB_0012fa25:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x19
CMP RAX,0x0
JNZ 0x0012fa45
LEA RAX,[0x485d38]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
LAB_0012fa45:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x200
CMP RAX,0x0
JZ 0x0012fa75
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x2ce3f8]
MOV EDX,dword ptr [RAX]
CALL 0x0012fad0
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0012fa95
LAB_0012fa75:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x2ce3f8]
MOV EDX,dword ptr [RAX]
MOV AL,0x0
CALL 0x00124630
MOV dword ptr [RBP + -0x1c],EAX
LAB_0012fa95:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x18]
MOV EDX,0x1
MOV ECX,0x1d
CALL 0x0012fb40
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int4 my_open(char *param_1,uint param_2,ulong param_3)
{
int4 uVar1;
int4 local_24;
int8 local_20;
local_20 = param_3;
if ((param_3 & 0x19) == 0) {
local_20 = my_global_flags | param_3;
}
if ((local_20 & 0x200) == 0) {
local_24 = open64(param_1,param_2 | 0x80000,(ulong)my_umask);
}
else {
local_24 = open_nosymlinks(param_1,param_2 | 0x80000,my_umask);
}
uVar1 = my_register_filename(local_24,param_1,1,0x1d,local_20);
return uVar1;
}
|
|
9,634 |
init_key_cache_internal
|
eloqsql/mysys/mf_keycache.c
|
static
int init_key_cache_internal(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size,
uint partitions,
my_bool use_op_lock)
{
void *keycache_cb;
int blocks;
if (keycache->key_cache_inited)
{
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
keycache_cb= keycache->keycache_cb;
}
else
{
if (partitions == 0)
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB),
MYF(0))))
return 0;
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= SIMPLE_KEY_CACHE;
keycache->interface_funcs= &simple_key_cache_funcs;
}
else
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(PARTITIONED_KEY_CACHE_CB),
MYF(0))))
return 0;
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= PARTITIONED_KEY_CACHE;
keycache->interface_funcs= &partitioned_key_cache_funcs;
}
/*
Initialize op_lock if it's not initialized before.
The mutex may have been initialized before if we are being called
from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_init(&keycache->op_lock, MY_MUTEX_INIT_FAST);
keycache->keycache_cb= keycache_cb;
keycache->key_cache_inited= 1;
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
}
if (partitions != 0)
{
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions= partitions;
}
keycache->can_be_used= 0;
blocks= keycache->interface_funcs->init(keycache_cb, key_cache_block_size,
use_mem, division_limit,
age_threshold, changed_blocks_hash_size);
keycache->partitions= partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions :
0;
DBUG_ASSERT(partitions <= MAX_KEY_CACHE_PARTITIONS);
keycache->key_cache_mem_size=
keycache->partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size :
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size;
if (blocks > 0)
keycache->can_be_used= 1;
if (use_op_lock)
pthread_mutex_unlock(&keycache->op_lock);
return blocks;
}
|
O0
|
c
|
init_key_cache_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe9632
cmpb $0x0, 0x18(%rbp)
je 0xe9621
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a200
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xe9717
cmpl $0x0, 0x10(%rbp)
jne 0xe9687
leaq 0xba8cf9(%rip), %rax # 0xc92338
movl (%rax), %edi
movl $0x170, %esi # imm = 0x170
xorl %eax, %eax
movl %eax, %edx
callq 0xfc090
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xe9665
movl $0x0, -0x4(%rbp)
jmp 0xe97d1
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1e3e9f(%rip), %rcx # 0x2cd520
movq %rcx, 0x10(%rax)
jmp 0xe96d4
leaq 0xba8caa(%rip), %rax # 0xc92338
movl (%rax), %edi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xfc090
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xe96b4
movl $0x0, -0x4(%rbp)
jmp 0xe97d1
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
leaq 0x1e3ea0(%rip), %rcx # 0x2cd570
movq %rcx, 0x10(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe96ee
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
leaq 0xba8fc7(%rip), %rsi # 0xc926b0
callq 0x2a320
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x48(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe9715
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a200
jmp 0xe9717
cmpl $0x0, 0x10(%rbp)
je 0xe9727
movl 0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x49(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0xe9767
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xe976e
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xe976e
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0xe977a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0xe9792
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe979e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpl $0x0, -0x3c(%rbp)
jle 0xe97b8
movq -0x10(%rbp), %rax
movb $0x1, 0x49(%rax)
cmpb $0x0, 0x18(%rbp)
je 0xe97cb
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1e0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
init_key_cache_internal:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_2C], r9d
mov rax, [rbp+var_10]
cmp byte ptr [rax+48h], 0
jz short loc_E9632
cmp [rbp+arg_8], 0
jz short loc_E9621
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
loc_E9621:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_38], rax
jmp loc_E9717
loc_E9632:
cmp [rbp+arg_0], 0
jnz short loc_E9687
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 170h
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_E9665
mov [rbp+var_4], 0
jmp loc_E97D1
loc_E9665:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
lea rcx, simple_key_cache_funcs
mov [rax+10h], rcx
jmp short loc_E96D4
loc_E9687:
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 20h ; ' '
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_E96B4
mov [rbp+var_4], 0
jmp loc_E97D1
loc_E96B4:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov rax, [rbp+var_10]
lea rcx, partitioned_key_cache_funcs
mov [rax+10h], rcx
loc_E96D4:
cmp [rbp+arg_8], 0
jz short loc_E96EE
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
loc_E96EE:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov byte ptr [rax+48h], 1
cmp [rbp+arg_8], 0
jz short loc_E9715
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
loc_E9715:
jmp short $+2
loc_E9717:
cmp [rbp+arg_0], 0
jz short loc_E9727
mov ecx, [rbp+arg_0]
mov rax, [rbp+var_38]
mov [rax+1Ch], ecx
loc_E9727:
mov rax, [rbp+var_10]
mov byte ptr [rax+49h], 0
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rax, [rax]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8d, [rbp+var_28]
mov r9d, [rbp+var_2C]
call rax
mov [rbp+var_3C], eax
cmp [rbp+arg_0], 0
jz short loc_E9767
mov rax, [rbp+var_38]
mov eax, [rax+1Ch]
mov [rbp+var_40], eax
jmp short loc_E976E
loc_E9767:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_E976E:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+4Ch], ecx
jmp short $+2
loc_E977A:
mov rax, [rbp+var_10]
cmp dword ptr [rax+4Ch], 0
jz short loc_E9792
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov [rbp+var_48], rax
jmp short loc_E979E
loc_E9792:
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_48], rax
loc_E979E:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax+50h], rcx
cmp [rbp+var_3C], 0
jle short loc_E97B8
mov rax, [rbp+var_10]
mov byte ptr [rax+49h], 1
loc_E97B8:
cmp [rbp+arg_8], 0
jz short loc_E97CB
mov rdi, [rbp+var_10]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_E97CB:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_E97D1:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long init_key_cache_internal(
long long a1,
unsigned int a2,
long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6,
int a7,
char a8)
{
long long v9; // [rsp+8h] [rbp-48h]
int v10; // [rsp+10h] [rbp-40h]
int v11; // [rsp+14h] [rbp-3Ch]
long long v12; // [rsp+18h] [rbp-38h]
if ( *(_BYTE *)(a1 + 72) )
{
if ( a8 )
pthread_mutex_lock(a1 + 88);
v12 = *(_QWORD *)(a1 + 8);
}
else
{
if ( a7 )
{
v12 = my_malloc(key_memory_KEY_CACHE, 32LL, 0LL);
if ( !v12 )
return 0;
*(_BYTE *)v12 = 0;
*(_DWORD *)a1 = 1;
*(_QWORD *)(a1 + 16) = partitioned_key_cache_funcs;
}
else
{
v12 = my_malloc(key_memory_KEY_CACHE, 368LL, 0LL);
if ( !v12 )
return 0;
*(_BYTE *)v12 = 0;
*(_DWORD *)a1 = 0;
*(_QWORD *)(a1 + 16) = simple_key_cache_funcs;
}
if ( a8 )
pthread_mutex_init(a1 + 88, &my_fast_mutexattr);
*(_QWORD *)(a1 + 8) = v12;
*(_BYTE *)(a1 + 72) = 1;
if ( a8 )
pthread_mutex_lock(a1 + 88);
}
if ( a7 )
*(_DWORD *)(v12 + 28) = a7;
*(_BYTE *)(a1 + 73) = 0;
v11 = (**(long long ( ***)(long long, _QWORD, long long, _QWORD, _QWORD, _QWORD))(a1 + 16))(
v12,
a2,
a3,
a4,
a5,
a6);
if ( a7 )
v10 = *(_DWORD *)(v12 + 28);
else
v10 = 0;
*(_DWORD *)(a1 + 76) = v10;
if ( *(_DWORD *)(a1 + 76) )
v9 = *(_QWORD *)(v12 + 16);
else
v9 = *(_QWORD *)(v12 + 8);
*(_QWORD *)(a1 + 80) = v9;
if ( v11 > 0 )
*(_BYTE *)(a1 + 73) = 1;
if ( a8 )
pthread_mutex_unlock(a1 + 88);
return (unsigned int)v11;
}
|
init_key_cache_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,byte ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV dword ptr [RBP + -0x2c],R9D
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e9632
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e9621
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a200
LAB_001e9621:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001e9717
LAB_001e9632:
CMP dword ptr [RBP + 0x10],0x0
JNZ 0x001e9687
LEA RAX,[0xd92338]
MOV EDI,dword ptr [RAX]
MOV ESI,0x170
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001fc090
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001e9665
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e97d1
LAB_001e9665:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3cd520]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e96d4
LAB_001e9687:
LEA RAX,[0xd92338]
MOV EDI,dword ptr [RAX]
MOV ESI,0x20
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001fc090
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001e96b4
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e97d1
LAB_001e96b4:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3cd570]
MOV qword ptr [RAX + 0x10],RCX
LAB_001e96d4:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e96ee
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
LEA RSI,[0xd926b0]
CALL 0x0012a320
LAB_001e96ee:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x48],0x1
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e9715
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a200
LAB_001e9715:
JMP 0x001e9717
LAB_001e9717:
CMP dword ptr [RBP + 0x10],0x0
JZ 0x001e9727
MOV ECX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x1c],ECX
LAB_001e9727:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x49],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8D,dword ptr [RBP + -0x28]
MOV R9D,dword ptr [RBP + -0x2c]
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + 0x10],0x0
JZ 0x001e9767
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001e976e
LAB_001e9767:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001e976e
LAB_001e976e:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4c],ECX
JMP 0x001e977a
LAB_001e977a:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4c],0x0
JZ 0x001e9792
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e979e
LAB_001e9792:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x48],RAX
LAB_001e979e:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x50],RCX
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x001e97b8
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x49],0x1
LAB_001e97b8:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001e97cb
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x58
CALL 0x0012a1e0
LAB_001e97cb:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e97d1:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int init_key_cache_internal
(int4 *param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6,int param_7,char param_8)
{
int iVar1;
int8 local_50;
int4 local_48;
int1 *local_40;
if (*(char *)(param_1 + 0x12) == '\0') {
if (param_7 == 0) {
local_40 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x170,0);
if (local_40 == (int1 *)0x0) {
return 0;
}
*local_40 = 0;
*param_1 = 0;
*(int1 **)(param_1 + 4) = simple_key_cache_funcs;
}
else {
local_40 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x20,0);
if (local_40 == (int1 *)0x0) {
return 0;
}
*local_40 = 0;
*param_1 = 1;
*(int1 **)(param_1 + 4) = partitioned_key_cache_funcs;
}
if (param_8 != '\0') {
pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x16),
(pthread_mutexattr_t *)&my_fast_mutexattr);
}
*(int1 **)(param_1 + 2) = local_40;
*(int1 *)(param_1 + 0x12) = 1;
if (param_8 != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
}
else {
if (param_8 != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
local_40 = *(int1 **)(param_1 + 2);
}
if (param_7 != 0) {
*(int *)(local_40 + 0x1c) = param_7;
}
*(int1 *)((long)param_1 + 0x49) = 0;
iVar1 = (*(code *)**(int8 **)(param_1 + 4))
(local_40,param_2,param_3,param_4,param_5,param_6);
if (param_7 == 0) {
local_48 = 0;
}
else {
local_48 = *(int4 *)(local_40 + 0x1c);
}
param_1[0x13] = local_48;
if (param_1[0x13] == 0) {
local_50 = *(int8 *)(local_40 + 8);
}
else {
local_50 = *(int8 *)(local_40 + 0x10);
}
*(int8 *)(param_1 + 0x14) = local_50;
if (0 < iVar1) {
*(int1 *)((long)param_1 + 0x49) = 1;
}
if (param_8 != '\0') {
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x16));
}
return iVar1;
}
|
|
9,635 |
init_key_cache_internal
|
eloqsql/mysys/mf_keycache.c
|
static
int init_key_cache_internal(KEY_CACHE *keycache, uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size,
uint partitions,
my_bool use_op_lock)
{
void *keycache_cb;
int blocks;
if (keycache->key_cache_inited)
{
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
keycache_cb= keycache->keycache_cb;
}
else
{
if (partitions == 0)
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB),
MYF(0))))
return 0;
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= SIMPLE_KEY_CACHE;
keycache->interface_funcs= &simple_key_cache_funcs;
}
else
{
if (!(keycache_cb= (void *) my_malloc(key_memory_KEY_CACHE,
sizeof(PARTITIONED_KEY_CACHE_CB),
MYF(0))))
return 0;
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_inited= 0;
keycache->key_cache_type= PARTITIONED_KEY_CACHE;
keycache->interface_funcs= &partitioned_key_cache_funcs;
}
/*
Initialize op_lock if it's not initialized before.
The mutex may have been initialized before if we are being called
from repartition_key_cache_internal().
*/
if (use_op_lock)
pthread_mutex_init(&keycache->op_lock, MY_MUTEX_INIT_FAST);
keycache->keycache_cb= keycache_cb;
keycache->key_cache_inited= 1;
if (use_op_lock)
pthread_mutex_lock(&keycache->op_lock);
}
if (partitions != 0)
{
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions= partitions;
}
keycache->can_be_used= 0;
blocks= keycache->interface_funcs->init(keycache_cb, key_cache_block_size,
use_mem, division_limit,
age_threshold, changed_blocks_hash_size);
keycache->partitions= partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->partitions :
0;
DBUG_ASSERT(partitions <= MAX_KEY_CACHE_PARTITIONS);
keycache->key_cache_mem_size=
keycache->partitions ?
((PARTITIONED_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size :
((SIMPLE_KEY_CACHE_CB *) keycache_cb)->key_cache_mem_size;
if (blocks > 0)
keycache->can_be_used= 1;
if (use_op_lock)
pthread_mutex_unlock(&keycache->op_lock);
return blocks;
}
|
O3
|
c
|
init_key_cache_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movl %ecx, %r13d
movq %rdx, %r14
movq %rdi, %rbx
movl 0x10(%rbp), %ecx
cmpb $0x0, 0x48(%rdi)
je 0x9d0d0
cmpb $0x0, 0x18(%rbp)
je 0x9d0c7
leaq 0x58(%rbx), %rdi
movl %r8d, %r15d
movl %r13d, -0x2c(%rbp)
movl %esi, %r13d
callq 0x2a1f0
movl %r13d, %esi
movl 0x10(%rbp), %ecx
movl -0x2c(%rbp), %r13d
movl %r15d, %r8d
movq 0x8(%rbx), %r15
jmp 0x9d17d
movl %esi, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movl %r12d, -0x2c(%rbp)
leaq 0xb776e6(%rip), %rax # 0xc147c8
movl (%rax), %edi
xorl %r12d, %r12d
testl %ecx, %ecx
je 0x9d112
movl $0x20, %esi
xorl %edx, %edx
callq 0xa6f99
testq %rax, %rax
je 0x9d1e8
movq %rax, %r15
leaq 0x2f34a6(%rip), %rax # 0x3905b0
movl $0x1, %r12d
jmp 0x9d131
movl $0x170, %esi # imm = 0x170
xorl %edx, %edx
callq 0xa6f99
testq %rax, %rax
je 0x9d1e8
movq %rax, %r15
leaq 0x2f342f(%rip), %rax # 0x390560
movb $0x0, (%r15)
movl %r12d, (%rbx)
movq %rax, 0x10(%rbx)
cmpb $0x0, 0x18(%rbp)
je 0x9d167
leaq 0x58(%rbx), %r12
leaq 0xb779f3(%rip), %rsi # 0xc14b40
movq %r12, %rdi
callq 0x2a310
movq %r15, 0x8(%rbx)
movb $0x1, 0x48(%rbx)
movq %r12, %rdi
callq 0x2a1f0
jmp 0x9d16f
movq %r15, 0x8(%rbx)
movb $0x1, 0x48(%rbx)
movl -0x2c(%rbp), %r12d
movl -0x34(%rbp), %r8d
movl 0x10(%rbp), %ecx
movl -0x30(%rbp), %esi
testl %ecx, %ecx
je 0x9d185
movl %ecx, 0x1c(%r15)
movb $0x0, 0x49(%rbx)
movq 0x10(%rbx), %rax
movq %r15, %rdi
movq %r14, %rdx
movl %ecx, %r14d
movl %r13d, %ecx
movl %r12d, %r9d
callq *(%rax)
movl %eax, %r12d
testl %r14d, %r14d
je 0x9d1bb
movl 0x1c(%r15), %eax
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq 0x8(,%rcx,8), %rcx
jmp 0x9d1c2
xorl %eax, %eax
movl $0x8, %ecx
movl %eax, 0x4c(%rbx)
movq (%r15,%rcx), %rax
movq %rax, 0x50(%rbx)
testl %r12d, %r12d
jle 0x9d1d6
movb $0x1, 0x49(%rbx)
cmpb $0x0, 0x18(%rbp)
je 0x9d1e8
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x2a1c0
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
init_key_cache_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12d, r9d
mov r13d, ecx
mov r14, rdx
mov rbx, rdi
mov ecx, [rbp+arg_0]
cmp byte ptr [rdi+48h], 0
jz short loc_9D0D0
cmp [rbp+arg_8], 0
jz short loc_9D0C7
lea rdi, [rbx+58h]
mov r15d, r8d
mov [rbp+var_2C], r13d
mov r13d, esi
call _pthread_mutex_lock
mov esi, r13d
mov ecx, [rbp+arg_0]
mov r13d, [rbp+var_2C]
mov r8d, r15d
loc_9D0C7:
mov r15, [rbx+8]
jmp loc_9D17D
loc_9D0D0:
mov [rbp+var_30], esi
mov [rbp+var_34], r8d
mov [rbp+var_2C], r12d
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
xor r12d, r12d
test ecx, ecx
jz short loc_9D112
mov esi, 20h ; ' '
xor edx, edx
call my_malloc
test rax, rax
jz loc_9D1E8
mov r15, rax
lea rax, partitioned_key_cache_funcs
mov r12d, 1
jmp short loc_9D131
loc_9D112:
mov esi, 170h
xor edx, edx
call my_malloc
test rax, rax
jz loc_9D1E8
mov r15, rax
lea rax, simple_key_cache_funcs
loc_9D131:
mov byte ptr [r15], 0
mov [rbx], r12d
mov [rbx+10h], rax
cmp [rbp+arg_8], 0
jz short loc_9D167
lea r12, [rbx+58h]
lea rsi, my_fast_mutexattr
mov rdi, r12
call _pthread_mutex_init
mov [rbx+8], r15
mov byte ptr [rbx+48h], 1
mov rdi, r12
call _pthread_mutex_lock
jmp short loc_9D16F
loc_9D167:
mov [rbx+8], r15
mov byte ptr [rbx+48h], 1
loc_9D16F:
mov r12d, [rbp+var_2C]
mov r8d, [rbp+var_34]
mov ecx, [rbp+arg_0]
mov esi, [rbp+var_30]
loc_9D17D:
test ecx, ecx
jz short loc_9D185
mov [r15+1Ch], ecx
loc_9D185:
mov byte ptr [rbx+49h], 0
mov rax, [rbx+10h]
mov rdi, r15
mov rdx, r14
mov r14d, ecx
mov ecx, r13d
mov r9d, r12d
call qword ptr [rax]
mov r12d, eax
test r14d, r14d
jz short loc_9D1BB
mov eax, [r15+1Ch]
xor ecx, ecx
test eax, eax
setnz cl
lea rcx, ds:8[rcx*8]
jmp short loc_9D1C2
loc_9D1BB:
xor eax, eax
mov ecx, 8
loc_9D1C2:
mov [rbx+4Ch], eax
mov rax, [r15+rcx]
mov [rbx+50h], rax
test r12d, r12d
jle short loc_9D1D6
mov byte ptr [rbx+49h], 1
loc_9D1D6:
cmp [rbp+arg_8], 0
jz short loc_9D1E8
add rbx, 58h ; 'X'
mov rdi, rbx
call _pthread_mutex_unlock
loc_9D1E8:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long init_key_cache_internal(
long long a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
unsigned int a6,
int a7,
char a8)
{
unsigned int v8; // r12d
int v11; // ecx
unsigned int v12; // r15d
long long v13; // r15
unsigned int v14; // r12d
long long v15; // rax
long long ( **v16)(); // rax
long long v17; // rax
long long v18; // rdx
int v19; // r14d
int v20; // eax
long long v21; // rcx
unsigned int v23; // [rsp+Ch] [rbp-34h]
v8 = a6;
v11 = a7;
if ( *(_BYTE *)(a1 + 72) )
{
if ( a8 )
{
v12 = a5;
pthread_mutex_lock(a1 + 88);
a2 = (unsigned int)a2;
v11 = a7;
a5 = v12;
}
v13 = *(_QWORD *)(a1 + 8);
}
else
{
v23 = a5;
v14 = 0;
if ( a7 )
{
v15 = my_malloc(key_memory_KEY_CACHE, 32LL, 0LL);
if ( !v15 )
return v14;
v13 = v15;
v16 = partitioned_key_cache_funcs;
v14 = 1;
}
else
{
v17 = my_malloc(key_memory_KEY_CACHE, 368LL, 0LL);
if ( !v17 )
return v14;
v13 = v17;
v16 = simple_key_cache_funcs;
}
*(_BYTE *)v13 = 0;
*(_DWORD *)a1 = v14;
*(_QWORD *)(a1 + 16) = v16;
if ( a8 )
{
pthread_mutex_init(a1 + 88, &my_fast_mutexattr);
*(_QWORD *)(a1 + 8) = v13;
*(_BYTE *)(a1 + 72) = 1;
pthread_mutex_lock(a1 + 88);
}
else
{
*(_QWORD *)(a1 + 8) = v13;
*(_BYTE *)(a1 + 72) = 1;
}
v8 = a6;
a5 = v23;
v11 = a7;
a2 = (unsigned int)a2;
}
if ( v11 )
*(_DWORD *)(v13 + 28) = v11;
*(_BYTE *)(a1 + 73) = 0;
v18 = a3;
v19 = v11;
v14 = (**(long long ( ***)(long long, long long, long long, _QWORD, long long, _QWORD))(a1 + 16))(
v13,
a2,
v18,
a4,
a5,
v8);
if ( v19 )
{
v20 = *(_DWORD *)(v13 + 28);
v21 = 8LL * (v20 != 0) + 8;
}
else
{
v20 = 0;
v21 = 8LL;
}
*(_DWORD *)(a1 + 76) = v20;
*(_QWORD *)(a1 + 80) = *(_QWORD *)(v13 + v21);
if ( (int)v14 > 0 )
*(_BYTE *)(a1 + 73) = 1;
if ( a8 )
pthread_mutex_unlock(a1 + 88);
return v14;
}
|
init_key_cache_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12D,R9D
MOV R13D,ECX
MOV R14,RDX
MOV RBX,RDI
MOV ECX,dword ptr [RBP + 0x10]
CMP byte ptr [RDI + 0x48],0x0
JZ 0x0019d0d0
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0019d0c7
LEA RDI,[RBX + 0x58]
MOV R15D,R8D
MOV dword ptr [RBP + -0x2c],R13D
MOV R13D,ESI
CALL 0x0012a1f0
MOV ESI,R13D
MOV ECX,dword ptr [RBP + 0x10]
MOV R13D,dword ptr [RBP + -0x2c]
MOV R8D,R15D
LAB_0019d0c7:
MOV R15,qword ptr [RBX + 0x8]
JMP 0x0019d17d
LAB_0019d0d0:
MOV dword ptr [RBP + -0x30],ESI
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBP + -0x2c],R12D
LEA RAX,[0xd147c8]
MOV EDI,dword ptr [RAX]
XOR R12D,R12D
TEST ECX,ECX
JZ 0x0019d112
MOV ESI,0x20
XOR EDX,EDX
CALL 0x001a6f99
TEST RAX,RAX
JZ 0x0019d1e8
MOV R15,RAX
LEA RAX,[0x4905b0]
MOV R12D,0x1
JMP 0x0019d131
LAB_0019d112:
MOV ESI,0x170
XOR EDX,EDX
CALL 0x001a6f99
TEST RAX,RAX
JZ 0x0019d1e8
MOV R15,RAX
LEA RAX,[0x490560]
LAB_0019d131:
MOV byte ptr [R15],0x0
MOV dword ptr [RBX],R12D
MOV qword ptr [RBX + 0x10],RAX
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0019d167
LEA R12,[RBX + 0x58]
LEA RSI,[0xd14b40]
MOV RDI,R12
CALL 0x0012a310
MOV qword ptr [RBX + 0x8],R15
MOV byte ptr [RBX + 0x48],0x1
MOV RDI,R12
CALL 0x0012a1f0
JMP 0x0019d16f
LAB_0019d167:
MOV qword ptr [RBX + 0x8],R15
MOV byte ptr [RBX + 0x48],0x1
LAB_0019d16f:
MOV R12D,dword ptr [RBP + -0x2c]
MOV R8D,dword ptr [RBP + -0x34]
MOV ECX,dword ptr [RBP + 0x10]
MOV ESI,dword ptr [RBP + -0x30]
LAB_0019d17d:
TEST ECX,ECX
JZ 0x0019d185
MOV dword ptr [R15 + 0x1c],ECX
LAB_0019d185:
MOV byte ptr [RBX + 0x49],0x0
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,R15
MOV RDX,R14
MOV R14D,ECX
MOV ECX,R13D
MOV R9D,R12D
CALL qword ptr [RAX]
MOV R12D,EAX
TEST R14D,R14D
JZ 0x0019d1bb
MOV EAX,dword ptr [R15 + 0x1c]
XOR ECX,ECX
TEST EAX,EAX
SETNZ CL
LEA RCX,[0x8 + RCX*0x8]
JMP 0x0019d1c2
LAB_0019d1bb:
XOR EAX,EAX
MOV ECX,0x8
LAB_0019d1c2:
MOV dword ptr [RBX + 0x4c],EAX
MOV RAX,qword ptr [R15 + RCX*0x1]
MOV qword ptr [RBX + 0x50],RAX
TEST R12D,R12D
JLE 0x0019d1d6
MOV byte ptr [RBX + 0x49],0x1
LAB_0019d1d6:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0019d1e8
ADD RBX,0x58
MOV RDI,RBX
CALL 0x0012a1c0
LAB_0019d1e8:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int init_key_cache_internal
(int4 *param_1,ulong param_2,int8 param_3,int4 param_4,ulong param_5
,int4 param_6,int param_7,char param_8)
{
int iVar1;
int iVar2;
int1 *puVar3;
int1 *puVar4;
long lVar5;
int4 uVar6;
if (*(char *)(param_1 + 0x12) == '\0') {
uVar6 = 0;
if (param_7 == 0) {
puVar3 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x170,0);
if (puVar3 == (int1 *)0x0) {
return 0;
}
puVar4 = simple_key_cache_funcs;
}
else {
puVar3 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x20,0);
if (puVar3 == (int1 *)0x0) {
return 0;
}
puVar4 = partitioned_key_cache_funcs;
uVar6 = 1;
}
*puVar3 = 0;
*param_1 = uVar6;
*(int1 **)(param_1 + 4) = puVar4;
if (param_8 == '\0') {
*(int1 **)(param_1 + 2) = puVar3;
*(int1 *)(param_1 + 0x12) = 1;
}
else {
pthread_mutex_init((pthread_mutex_t *)(param_1 + 0x16),
(pthread_mutexattr_t *)&my_fast_mutexattr);
*(int1 **)(param_1 + 2) = puVar3;
*(int1 *)(param_1 + 0x12) = 1;
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
param_5 = param_5 & 0xffffffff;
param_2 = param_2 & 0xffffffff;
}
else {
if (param_8 != '\0') {
param_5 = param_5 & 0xffffffff;
param_2 = param_2 & 0xffffffff;
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x16));
}
puVar3 = *(int1 **)(param_1 + 2);
}
if (param_7 != 0) {
*(int *)(puVar3 + 0x1c) = param_7;
}
*(int1 *)((long)param_1 + 0x49) = 0;
iVar1 = (*(code *)**(int8 **)(param_1 + 4))(puVar3,param_2,param_3,param_4,param_5,param_6);
if (param_7 == 0) {
iVar2 = 0;
lVar5 = 8;
}
else {
iVar2 = *(int *)(puVar3 + 0x1c);
lVar5 = (ulong)(iVar2 != 0) * 8 + 8;
}
param_1[0x13] = iVar2;
*(int8 *)(param_1 + 0x14) = *(int8 *)(puVar3 + lVar5);
if (0 < iVar1) {
*(int1 *)((long)param_1 + 0x49) = 1;
}
if (param_8 != '\0') {
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x16));
}
return iVar1;
}
|
|
9,636 |
ma_dynmap_file
|
eloqsql/storage/maria/ma_dynrec.c
|
my_bool _ma_dynmap_file(MARIA_HA *info, my_off_t size)
{
DBUG_ENTER("_ma_dynmap_file");
if (size > (my_off_t) (~((size_t) 0)) - MEMMAP_EXTRA_MARGIN)
{
DBUG_PRINT("warning", ("File is too large for mmap"));
DBUG_RETURN(1);
}
/*
Ingo wonders if it is good to use MAP_NORESERVE. From the Linux man page:
MAP_NORESERVE
Do not reserve swap space for this mapping. When swap space is
reserved, one has the guarantee that it is possible to modify the
mapping. When swap space is not reserved one might get SIGSEGV
upon a write if no physical memory is available.
*/
info->s->file_map= (uchar*)
my_mmap(0, (size_t)(size + MEMMAP_EXTRA_MARGIN),
info->s->mode==O_RDONLY ? PROT_READ :
PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_NORESERVE,
info->dfile.file, 0L);
if (info->s->file_map == (uchar*) MAP_FAILED)
{
info->s->file_map= NULL;
DBUG_RETURN(1);
}
#if defined(HAVE_MADVISE)
madvise((char*) info->s->file_map, size, MADV_RANDOM);
#endif
info->s->mmaped_length= size;
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_dynmap_file:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $-0x8, -0x18(%rbp)
jbe 0x3c746
jmp 0x3c739
jmp 0x3c73b
jmp 0x3c73d
movb $0x1, -0x1(%rbp)
jmp 0x3c7fa
movq -0x18(%rbp), %rsi
addq $0x7, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x7a4(%rax), %ecx
movl $0x3, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
movq -0x10(%rbp), %rax
movl 0x480(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x4001, %ecx # imm = 0x4001
movq %r9, %rdi
callq 0x2a5b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x5f0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $-0x1, %rcx
cmpq %rcx, 0x5f0(%rax)
jne 0x3c7c8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x5f0(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3c7fa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x5f0(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x2a460
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xa00(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_dynmap_file:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0FFFFFFFFFFFFFFF8h
jbe short loc_3C746
jmp short $+2
loc_3C739:
jmp short $+2
loc_3C73B:
jmp short $+2
loc_3C73D:
mov [rbp+var_1], 1
jmp loc_3C7FA
loc_3C746:
mov rsi, [rbp+var_18]
add rsi, 7
mov rax, [rbp+var_10]
mov rax, [rax]
mov ecx, [rax+7A4h]
mov edx, 3
mov eax, 1
cmp ecx, 0
cmovz edx, eax
mov rax, [rbp+var_10]
mov r8d, [rax+480h]
xor eax, eax
mov r9d, eax
mov ecx, 4001h
mov rdi, r9
call _mmap64
mov rcx, rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+5F0h], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, 0FFFFFFFFFFFFFFFFh
cmp [rax+5F0h], rcx
jnz short loc_3C7C8
mov rax, [rbp+var_10]
mov rax, [rax]
mov qword ptr [rax+5F0h], 0
mov [rbp+var_1], 1
jmp short loc_3C7FA
loc_3C7C8:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+5F0h]
mov rsi, [rbp+var_18]
mov edx, 1
call _madvise
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+0A00h], rcx
mov [rbp+var_1], 0
loc_3C7FA:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char ma_dynmap_file(unsigned int *a1, unsigned long long a2)
{
long long v2; // rdx
if ( a2 > 0xFFFFFFFFFFFFFFF8LL )
return 1;
v2 = 3LL;
if ( !*(_DWORD *)(*(_QWORD *)a1 + 1956LL) )
v2 = 1LL;
*(_QWORD *)(*(_QWORD *)a1 + 1520LL) = mmap64(0LL, a2 + 7, v2, 16385LL, a1[288]);
if ( *(_QWORD *)(*(_QWORD *)a1 + 1520LL) == -1LL )
{
*(_QWORD *)(*(_QWORD *)a1 + 1520LL) = 0LL;
return 1;
}
else
{
madvise(*(_QWORD *)(*(_QWORD *)a1 + 1520LL), a2, 1LL);
*(_QWORD *)(*(_QWORD *)a1 + 2560LL) = a2;
return 0;
}
}
|
_ma_dynmap_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],-0x8
JBE 0x0013c746
JMP 0x0013c739
LAB_0013c739:
JMP 0x0013c73b
LAB_0013c73b:
JMP 0x0013c73d
LAB_0013c73d:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013c7fa
LAB_0013c746:
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x7a4]
MOV EDX,0x3
MOV EAX,0x1
CMP ECX,0x0
CMOVZ EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0x480]
XOR EAX,EAX
MOV R9D,EAX
MOV ECX,0x4001
MOV RDI,R9
CALL 0x0012a5b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x5f0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,-0x1
CMP qword ptr [RAX + 0x5f0],RCX
JNZ 0x0013c7c8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x5f0],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013c7fa
LAB_0013c7c8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x5f0]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x1
CALL 0x0012a460
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0xa00],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_0013c7fa:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_dynmap_file(long *param_1,ulong param_2)
{
void *pvVar1;
int __prot;
int1 local_9;
if (param_2 < 0xfffffffffffffff9) {
__prot = 3;
if (*(int *)(*param_1 + 0x7a4) == 0) {
__prot = 1;
}
pvVar1 = mmap64((void *)0x0,param_2 + 7,__prot,0x4001,(int)param_1[0x90],0);
*(void **)(*param_1 + 0x5f0) = pvVar1;
if (*(long *)(*param_1 + 0x5f0) == -1) {
*(int8 *)(*param_1 + 0x5f0) = 0;
local_9 = 1;
}
else {
madvise(*(void **)(*param_1 + 0x5f0),param_2,1);
*(ulong *)(*param_1 + 0xa00) = param_2;
local_9 = 0;
}
}
else {
local_9 = 1;
}
return local_9;
}
|
|
9,637 |
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 0x341b56(%rip), %rax # 0x37a110
movq (%rax), %rax
testq %rax, %rax
je 0x385ed
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 0x386f9
movl 0x10(%rbp), %r11d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r13, %rbx
je 0x386ef
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %dil
cmpl %r15d, %ecx
sete %dl
orb %dl, %dil
je 0x38660
testb %dl, %dl
je 0x38656
incq %rbx
movq %rbx, %rax
cmpq %rsi, %r12
je 0x386f9
movq %r12, %rcx
movq %rax, %rbx
cmpq %r13, %rax
jae 0x38645
leaq 0x1(%rcx), %r12
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rax
cmpl %r15d, %edx
je 0x38621
incq %rcx
cmpq %r13, %rbx
je 0x386ec
movb (%rbx), %al
movq %rcx, %r12
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x385f7
jmp 0x386b2
movl $0x1, %r14d
cmpq %rsi, %r12
je 0x386f9
leaq 0x1(%rbx), %rax
cmpq %r13, %rax
cmoveq %rbx, %rax
cmpl %r8d, %ecx
cmoveq %rax, %rbx
movb (%rbx), %al
cmpb (%r12), %al
jne 0x386f9
incq %r12
incq %rbx
cmpq %r13, %rbx
je 0x386ef
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r15d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x38617
cmpl %r15d, %ecx
jne 0x38660
jmp 0x38617
leaq 0x1(%rbx), %rax
xorl %r14d, %r14d
cmpq %r13, %rax
je 0x386f9
addq $0x2, %rbx
movb -0x1(%rbx), %cl
movsbl %cl, %eax
cmpl %r11d, %eax
je 0x386de
cmpl %r15d, %eax
jne 0x3870b
cmpq %rsi, %r12
je 0x38791
incq %r12
leaq 0x1(%rbx), %rax
cmpq %r13, %rbx
movq %rax, %rbx
jne 0x386c2
jmp 0x386f9
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 0x386f9
movzbl %cl, %eax
leaq -0x1(%rbx), %rdx
cmpl %r8d, %eax
jne 0x3872c
cmpq %r13, %rbx
je 0x3872c
movb (%rbx), %cl
movq %rbx, %rdx
incq %rdx
incl %r10d
cmpq %rsi, %r12
je 0x386f9
cmpb %cl, (%r12)
je 0x38742
incq %r12
jmp 0x38732
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 0x38592
addq $0x10, %rsp
testl %eax, %eax
jle 0x3879c
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 0x38732
jmp 0x386f9
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x386f9
movl %eax, %r14d
jmp 0x386f9
|
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_385ED
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_386F9
loc_385ED:
mov r11d, [rbp+arg_0]
mov r14d, 0FFFFFFFFh
loc_385F7:
cmp rbx, r13
jz loc_386EF
mov al, [rbx]
movsx ecx, al
cmp ecx, r11d
setz dil
cmp ecx, r15d
setz dl
or dil, dl
jz short loc_38660
loc_38617:
test dl, dl
jz short loc_38656
inc rbx
mov rax, rbx
loc_38621:
cmp r12, rsi
jz loc_386F9
mov rcx, r12
mov rbx, rax
cmp rax, r13
jnb short loc_38645
lea r12, [rcx+1]
movsx edx, byte ptr [rbx]
lea rax, [rbx+1]
cmp edx, r15d
jz short loc_38621
loc_38645:
inc rcx
cmp rbx, r13
jz loc_386EC
mov al, [rbx]
mov r12, rcx
loc_38656:
movsx eax, al
cmp eax, r11d
jnz short loc_385F7
jmp short loc_386B2
loc_38660:
mov r14d, 1
cmp r12, rsi
jz loc_386F9
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_386F9
inc r12
inc rbx
cmp rbx, r13
jz short loc_386EF
mov al, [rbx]
movsx ecx, al
cmp ecx, r15d
setz dl
cmp ecx, r11d
jz loc_38617
cmp ecx, r15d
jnz short loc_38660
jmp loc_38617
loc_386B2:
lea rax, [rbx+1]
xor r14d, r14d
cmp rax, r13
jz short loc_386F9
add rbx, 2
loc_386C2:
mov cl, [rbx-1]
movsx eax, cl
cmp eax, r11d
jz short loc_386DE
cmp eax, r15d
jnz short loc_3870B
cmp r12, rsi
jz loc_38791
inc r12
loc_386DE:
lea rax, [rbx+1]
cmp rbx, r13
mov rbx, rax
jnz short loc_386C2
jmp short loc_386F9
loc_386EC:
mov r12, rcx
loc_386EF:
xor r14d, r14d
cmp r12, rsi
setnz r14b
loc_386F9:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3870B:
mov r14d, 0FFFFFFFFh
cmp r12, rsi
jz short loc_386F9
movzx eax, cl
lea rdx, [rbx-1]
cmp eax, r8d
jnz short loc_3872C
cmp rbx, r13
jz short loc_3872C
mov cl, [rbx]
mov rdx, rbx
loc_3872C:
inc rdx
inc r10d
loc_38732:
cmp r12, rsi
jz short loc_386F9
cmp [r12], cl
jz short loc_38742
inc r12
jmp short loc_38732
loc_38742:
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_3879C
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_38732
jmp loc_386F9
loc_38791:
mov r14d, 0FFFFFFFFh
jmp loc_386F9
loc_3879C:
mov r14d, eax
jmp loc_386F9
|
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,[0x47a110]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001385ed
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 0x001386f9
LAB_001385ed:
MOV R11D,dword ptr [RBP + 0x10]
MOV R14D,0xffffffff
LAB_001385f7:
CMP RBX,R13
JZ 0x001386ef
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R11D
SETZ DIL
CMP ECX,R15D
SETZ DL
OR DIL,DL
JZ 0x00138660
LAB_00138617:
TEST DL,DL
JZ 0x00138656
INC RBX
MOV RAX,RBX
LAB_00138621:
CMP R12,RSI
JZ 0x001386f9
MOV RCX,R12
MOV RBX,RAX
CMP RAX,R13
JNC 0x00138645
LEA R12,[RCX + 0x1]
MOVSX EDX,byte ptr [RBX]
LEA RAX,[RBX + 0x1]
CMP EDX,R15D
JZ 0x00138621
LAB_00138645:
INC RCX
CMP RBX,R13
JZ 0x001386ec
MOV AL,byte ptr [RBX]
MOV R12,RCX
LAB_00138656:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x001385f7
JMP 0x001386b2
LAB_00138660:
MOV R14D,0x1
CMP R12,RSI
JZ 0x001386f9
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 0x001386f9
INC R12
INC RBX
CMP RBX,R13
JZ 0x001386ef
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R15D
SETZ DL
CMP ECX,R11D
JZ 0x00138617
CMP ECX,R15D
JNZ 0x00138660
JMP 0x00138617
LAB_001386b2:
LEA RAX,[RBX + 0x1]
XOR R14D,R14D
CMP RAX,R13
JZ 0x001386f9
ADD RBX,0x2
LAB_001386c2:
MOV CL,byte ptr [RBX + -0x1]
MOVSX EAX,CL
CMP EAX,R11D
JZ 0x001386de
CMP EAX,R15D
JNZ 0x0013870b
CMP R12,RSI
JZ 0x00138791
INC R12
LAB_001386de:
LEA RAX,[RBX + 0x1]
CMP RBX,R13
MOV RBX,RAX
JNZ 0x001386c2
JMP 0x001386f9
LAB_001386ec:
MOV R12,RCX
LAB_001386ef:
XOR R14D,R14D
CMP R12,RSI
SETNZ R14B
LAB_001386f9:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013870b:
MOV R14D,0xffffffff
CMP R12,RSI
JZ 0x001386f9
MOVZX EAX,CL
LEA RDX,[RBX + -0x1]
CMP EAX,R8D
JNZ 0x0013872c
CMP RBX,R13
JZ 0x0013872c
MOV CL,byte ptr [RBX]
MOV RDX,RBX
LAB_0013872c:
INC RDX
INC R10D
LAB_00138732:
CMP R12,RSI
JZ 0x001386f9
CMP byte ptr [R12],CL
JZ 0x00138742
INC R12
JMP 0x00138732
LAB_00138742:
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 0x00138592
ADD RSP,0x10
TEST EAX,EAX
JLE 0x0013879c
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 0x00138732
JMP 0x001386f9
LAB_00138791:
MOV R14D,0xffffffff
JMP 0x001386f9
LAB_0013879c:
MOV R14D,EAX
JMP 0x001386f9
|
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_001386ef;
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_001386ef:
return (uint)(param_1 != param_2);
}
|
|
9,638 |
mi_pack_rec_unpack
|
eloqsql/storage/myisam/mi_packrec.c
|
int _mi_pack_rec_unpack(register MI_INFO *info, MI_BIT_BUFF *bit_buff,
register uchar *to, uchar *from, ulong reclength)
{
uchar *end_field;
reg3 MI_COLUMNDEF *end;
MI_COLUMNDEF *current_field;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_pack_rec_unpack");
init_bit_buffer(bit_buff, (uchar*) from, reclength);
for (current_field=share->rec, end=current_field+share->base.fields ;
current_field < end ;
current_field++,to=end_field)
{
end_field=to+current_field->length;
(*current_field->unpack)(current_field, bit_buff, (uchar*) to,
(uchar*) end_field);
}
if (!bit_buff->error &&
bit_buff->pos - bit_buff->bits / 8 == bit_buff->end)
DBUG_RETURN(0);
info->update&= ~HA_STATE_AKTIV;
DBUG_RETURN(my_errno=HA_ERR_WRONG_IN_RECORD);
}
|
O3
|
c
|
mi_pack_rec_unpack:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq %rcx, 0x8(%rsi)
movl %r8d, %esi
addq %rcx, %rsi
movq %rsi, 0x10(%r14)
movl $0x0, 0x28(%r14)
movq $0x0, (%r14)
movq 0x168(%rax), %rcx
testq %rcx, %rcx
jle 0x823f1
movq 0x230(%rax), %r15
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
addq %r15, %r13
movzwl 0x4(%r15), %r12d
addq %rdx, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%r15)
addq $0x30, %r15
movq %r12, %rdx
cmpq %r13, %r15
jb 0x823c9
cmpl $0x0, 0x28(%r14)
jne 0x82405
movq 0x8(%r14), %rax
movl 0x4(%r14), %ecx
shrl $0x3, %ecx
subq %rcx, %rax
cmpq 0x10(%r14), %rax
je 0x8241e
andb $-0x3, 0x1d0(%rbx)
callq 0xa2412
movl $0x7f, (%rax)
movl $0x7f, %eax
jmp 0x82420
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_pack_rec_unpack:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov [rsi+8], rcx
mov esi, r8d
add rsi, rcx
mov [r14+10h], rsi
mov dword ptr [r14+28h], 0
mov qword ptr [r14], 0
mov rcx, [rax+168h]
test rcx, rcx
jle short loc_823F1
mov r15, [rax+230h]
lea r13, [rcx+rcx*2]
shl r13, 4
add r13, r15
loc_823C9:
movzx r12d, word ptr [r15+4]
add r12, rdx
mov rdi, r15
mov rsi, r14
mov rcx, r12
call qword ptr [r15+10h]
add r15, 30h ; '0'
mov rdx, r12
cmp r15, r13
jb short loc_823C9
cmp dword ptr [r14+28h], 0
jnz short loc_82405
loc_823F1:
mov rax, [r14+8]
mov ecx, [r14+4]
shr ecx, 3
sub rax, rcx
cmp rax, [r14+10h]
jz short loc_8241E
loc_82405:
and byte ptr [rbx+1D0h], 0FDh
call _my_thread_var
mov dword ptr [rax], 7Fh
mov eax, 7Fh
jmp short loc_82420
loc_8241E:
xor eax, eax
loc_82420:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mi_pack_rec_unpack(_QWORD *a1, long long a2, long long a3, long long a4, unsigned int a5)
{
_QWORD *v5; // rbx
long long v6; // rax
long long v7; // rcx
unsigned long long v8; // r15
unsigned long long v9; // r13
long long v10; // r12
v5 = a1;
v6 = *a1;
*(_QWORD *)(a2 + 8) = a4;
*(_QWORD *)(a2 + 16) = a4 + a5;
*(_DWORD *)(a2 + 40) = 0;
*(_QWORD *)a2 = 0LL;
v7 = *(_QWORD *)(v6 + 360);
if ( v7 <= 0 )
goto LABEL_5;
v8 = *(_QWORD *)(v6 + 560);
v9 = v8 + 48 * v7;
do
{
v10 = a3 + *(unsigned __int16 *)(v8 + 4);
a1 = (_QWORD *)v8;
(*(void ( **)(unsigned long long, long long, long long, long long))(v8 + 16))(v8, a2, a3, v10);
v8 += 48LL;
a3 = v10;
}
while ( v8 < v9 );
if ( !*(_DWORD *)(a2 + 40) )
{
LABEL_5:
if ( *(_QWORD *)(a2 + 8) - (*(_DWORD *)(a2 + 4) >> 3) == *(_QWORD *)(a2 + 16) )
return 0LL;
}
*((_BYTE *)v5 + 464) &= ~2u;
*(_DWORD *)my_thread_var(a1) = 127;
return 127LL;
}
|
_mi_pack_rec_unpack:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSI + 0x8],RCX
MOV ESI,R8D
ADD RSI,RCX
MOV qword ptr [R14 + 0x10],RSI
MOV dword ptr [R14 + 0x28],0x0
MOV qword ptr [R14],0x0
MOV RCX,qword ptr [RAX + 0x168]
TEST RCX,RCX
JLE 0x001823f1
MOV R15,qword ptr [RAX + 0x230]
LEA R13,[RCX + RCX*0x2]
SHL R13,0x4
ADD R13,R15
LAB_001823c9:
MOVZX R12D,word ptr [R15 + 0x4]
ADD R12,RDX
MOV RDI,R15
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [R15 + 0x10]
ADD R15,0x30
MOV RDX,R12
CMP R15,R13
JC 0x001823c9
CMP dword ptr [R14 + 0x28],0x0
JNZ 0x00182405
LAB_001823f1:
MOV RAX,qword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x4]
SHR ECX,0x3
SUB RAX,RCX
CMP RAX,qword ptr [R14 + 0x10]
JZ 0x0018241e
LAB_00182405:
AND byte ptr [RBX + 0x1d0],0xfd
CALL 0x001a2412
MOV dword ptr [RAX],0x7f
MOV EAX,0x7f
JMP 0x00182420
LAB_0018241e:
XOR EAX,EAX
LAB_00182420:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_mi_pack_rec_unpack(long *param_1,int8 *param_2,long param_3,long param_4,uint param_5)
{
long lVar1;
int4 *puVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
lVar3 = *param_1;
param_2[1] = param_4;
param_2[2] = (ulong)param_5 + param_4;
*(int4 *)(param_2 + 5) = 0;
*param_2 = 0;
lVar1 = *(long *)(lVar3 + 0x168);
if (0 < lVar1) {
uVar5 = *(ulong *)(lVar3 + 0x230);
uVar4 = lVar1 * 0x30 + uVar5;
do {
lVar3 = (ulong)*(ushort *)(uVar5 + 4) + param_3;
(**(code **)(uVar5 + 0x10))(uVar5,param_2,param_3,lVar3);
uVar5 = uVar5 + 0x30;
param_3 = lVar3;
} while (uVar5 < uVar4);
if (*(int *)(param_2 + 5) != 0) goto LAB_00182405;
}
if (param_2[1] - (ulong)(*(uint *)((long)param_2 + 4) >> 3) == param_2[2]) {
return 0;
}
LAB_00182405:
*(byte *)(param_1 + 0x3a) = *(byte *)(param_1 + 0x3a) & 0xfd;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7f;
return 0x7f;
}
|
|
9,639 |
ggml_fp32_to_fp16
|
ngxson[P]ggml-easy/ggml/src/ggml-impl.h
|
static inline uint32_t fp32_to_bits(float f) {
union {
float as_value;
uint32_t as_bits;
} fp32;
fp32.as_value = f;
return fp32.as_bits;
}
|
O3
|
c
|
ggml_fp32_to_fp16:
movd %xmm0, %ecx
pand 0x30f9c(%rip), %xmm0 # 0x4a020
mulss 0x3105c(%rip), %xmm0 # 0x4a0e8
mulss 0x31058(%rip), %xmm0 # 0x4a0ec
leal (%rcx,%rcx), %eax
movl %ecx, %edx
andl $0x7f800000, %edx # imm = 0x7F800000
addl $0x7800000, %edx # imm = 0x7800000
cmpl $0x71000000, %eax # imm = 0x71000000
movl $0x40000000, %esi # imm = 0x40000000
cmovael %edx, %esi
movd %esi, %xmm1
addss %xmm0, %xmm1
movd %xmm1, %edx
movl %edx, %esi
shrl $0xd, %esi
andl $0x7c00, %esi # imm = 0x7C00
andl $0xfff, %edx # imm = 0xFFF
addl %esi, %edx
shrl $0x10, %ecx
andl $0x8000, %ecx # imm = 0x8000
cmpl $0xff000001, %eax # imm = 0xFF000001
movl $0x7e00, %eax # imm = 0x7E00
cmovbl %edx, %eax
orl %ecx, %eax
retq
|
ggml_fp32_to_fp16:
movd ecx, xmm0
pand xmm0, cs:xmmword_4A020
mulss xmm0, cs:dword_4A0E8
mulss xmm0, cs:dword_4A0EC
lea eax, [rcx+rcx]
mov edx, ecx
and edx, 7F800000h
add edx, 7800000h
cmp eax, 71000000h
mov esi, 40000000h
cmovnb esi, edx
movd xmm1, esi
addss xmm1, xmm0
movd edx, xmm1
mov esi, edx
shr esi, 0Dh
and esi, 7C00h
and edx, 0FFFh
add edx, esi
shr ecx, 10h
and ecx, 8000h
cmp eax, 0FF000001h
mov eax, 7E00h
cmovb eax, edx
or eax, ecx
retn
|
long long ggml_fp32_to_fp16(__m128i a1)
{
unsigned int v1; // ecx
float v2; // xmm0_4
unsigned int v3; // eax
unsigned int v4; // esi
__m128i v5; // xmm1
unsigned int v6; // edx
int v7; // edx
int v8; // ecx
bool v9; // cf
int v10; // eax
v1 = _mm_cvtsi128_si32(a1);
v2 = (float)(*(float *)_mm_and_si128(a1, (__m128i)xmmword_4A020).m128i_i32 * 5.1922969e33) * 7.7037198e-34;
v3 = 2 * v1;
v4 = 0x40000000;
if ( 2 * v1 >= 0x71000000 )
v4 = (v1 & 0x7F800000) + 125829120;
v5 = _mm_cvtsi32_si128(v4);
*(float *)v5.m128i_i32 = *(float *)v5.m128i_i32 + v2;
v6 = _mm_cvtsi128_si32(v5);
v7 = ((v6 >> 13) & 0x7C00) + (v6 & 0xFFF);
v8 = HIWORD(v1) & 0x8000;
v9 = v3 < 0xFF000001;
v10 = 32256;
if ( v9 )
v10 = v7;
return v8 | (unsigned int)v10;
}
|
ggml_fp32_to_fp16:
MOVD ECX,XMM0
PAND XMM0,xmmword ptr [0x0014a020]
MULSS XMM0,dword ptr [0x0014a0e8]
MULSS XMM0,dword ptr [0x0014a0ec]
LEA EAX,[RCX + RCX*0x1]
MOV EDX,ECX
AND EDX,0x7f800000
ADD EDX,0x7800000
CMP EAX,0x71000000
MOV ESI,0x40000000
CMOVNC ESI,EDX
MOVD XMM1,ESI
ADDSS XMM1,XMM0
MOVD EDX,XMM1
MOV ESI,EDX
SHR ESI,0xd
AND ESI,0x7c00
AND EDX,0xfff
ADD EDX,ESI
SHR ECX,0x10
AND ECX,0x8000
CMP EAX,0xff000001
MOV EAX,0x7e00
CMOVC EAX,EDX
OR EAX,ECX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint ggml_fp32_to_fp16(uint param_1)
{
uint uVar1;
float fVar2;
fVar2 = 2.0;
if (0x70ffffff < param_1 * 2) {
fVar2 = (float)((param_1 & 0x7f800000) + 0x7800000);
}
fVar2 = fVar2 + (float)(param_1 & SUB164(_DAT_0014a020,0)) * DAT_0014a0e8 * DAT_0014a0ec;
uVar1 = 0x7e00;
if (param_1 * 2 < 0xff000001) {
uVar1 = ((uint)fVar2 & 0xfff) + ((uint)fVar2 >> 0xd & 0x7c00);
}
return uVar1 | param_1 >> 0x10 & 0x8000;
}
|
|
9,640 |
write_dynamic_record
|
eloqsql/storage/myisam/mi_dynrec.c
|
static int write_dynamic_record(MI_INFO *info, const uchar *record,
ulong reclength)
{
int flag;
ulong length;
my_off_t filepos;
DBUG_ENTER("write_dynamic_record");
flag=0;
/*
Check if we have enough room for the new record.
First we do simplified check to make usual case faster.
Then we do more precise check for the space left.
Though it still is not absolutely precise, as
we always use MI_MAX_DYN_BLOCK_HEADER while it can be
less in the most of the cases.
*/
if (unlikely(info->s->base.max_data_file_length -
info->state->data_file_length <
reclength + MI_MAX_DYN_BLOCK_HEADER))
{
if (info->s->base.max_data_file_length - info->state->data_file_length +
info->state->empty - info->state->del * MI_MAX_DYN_BLOCK_HEADER <
reclength + MI_MAX_DYN_BLOCK_HEADER)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(1);
}
}
do
{
if (_mi_find_writepos(info,reclength,&filepos,&length))
goto err;
if (_mi_write_part_record(info,filepos,length,
(info->append_insert_at_end ?
HA_OFFSET_ERROR : info->s->state.dellink),
(uchar**) &record,&reclength,&flag))
goto err;
} while (reclength);
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
}
|
O3
|
c
|
write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, -0x50(%rbp)
movq %rdx, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x110(%rax), %rax
subq 0x28(%rsi), %rax
leaq 0x14(%rdx), %rcx
cmpq %rcx, %rax
jb 0x7730d
leaq -0x48(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x38(%rbp), %r13
movl $0x1, %r14d
movq %rbx, %rdi
movq %rdx, %rsi
leaq -0x40(%rbp), %rdx
movq %r15, %rcx
callq 0x79c51
testl %eax, %eax
jne 0x772fb
movq $-0x1, %rcx
cmpb $0x0, 0x33a(%rbx)
jne 0x772cd
movq (%rbx), %rax
movq 0x58(%rax), %rcx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x2c(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %r8
movq %r13, %r9
callq 0x77b18
testl %eax, %eax
jne 0x772fb
movq -0x38(%rbp), %rdx
testq %rdx, %rdx
jne 0x772a0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq 0x10(%rsi), %rax
movq 0x8(%rsi), %rsi
shlq $0x2, %rsi
leaq (%rsi,%rsi,4), %rsi
subq %rsi, %rax
cmpq %rcx, %rax
jae 0x7728e
callq 0xa1ab2
movl $0x87, (%rax)
movl $0x1, %r14d
jmp 0x772fb
|
write_dynamic_record_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rbp+var_50], rsi
mov [rbp+var_38], rdx
mov [rbp+var_2C], 0
mov rax, [rdi]
mov rsi, [rdi+8]
mov rax, [rax+110h]
sub rax, [rsi+28h]
lea rcx, [rdx+14h]
cmp rax, rcx
jb short loc_7730D
loc_7728E:
lea r15, [rbp+var_48]
lea r12, [rbp+var_50]
lea r13, [rbp+var_38]
mov r14d, 1
loc_772A0:
mov rdi, rbx
mov rsi, rdx
lea rdx, [rbp+var_40]
mov rcx, r15
call _mi_find_writepos
test eax, eax
jnz short loc_772FB
mov rcx, 0FFFFFFFFFFFFFFFFh
cmp byte ptr [rbx+33Ah], 0
jnz short loc_772CD
mov rax, [rbx]
mov rcx, [rax+58h]
loc_772CD:
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_48]
lea rax, [rbp+var_2C]
mov [rsp+60h+var_60], rax
mov rdi, rbx
mov r8, r12
mov r9, r13
call _mi_write_part_record
test eax, eax
jnz short loc_772FB
mov rdx, [rbp+var_38]
test rdx, rdx
jnz short loc_772A0
xor r14d, r14d
loc_772FB:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7730D:
add rax, [rsi+10h]
mov rsi, [rsi+8]
shl rsi, 2
lea rsi, [rsi+rsi*4]
sub rax, rsi
cmp rax, rcx
jnb loc_7728E
call _my_thread_var
mov dword ptr [rax], 87h
mov r14d, 1
jmp short loc_772FB
|
long long write_dynamic_record_0(_BYTE *a1, long long a2, long long a3)
{
_QWORD *v3; // rsi
unsigned long long v4; // rax
unsigned int v5; // r14d
long long v6; // rcx
long long v8; // [rsp+10h] [rbp-50h] BYREF
long long v9; // [rsp+18h] [rbp-48h] BYREF
long long v10; // [rsp+20h] [rbp-40h] BYREF
long long v11; // [rsp+28h] [rbp-38h] BYREF
_DWORD v12[11]; // [rsp+34h] [rbp-2Ch] BYREF
v8 = a2;
v11 = a3;
v12[0] = 0;
v3 = (_QWORD *)*((_QWORD *)a1 + 1);
v4 = *(_QWORD *)(*(_QWORD *)a1 + 272LL) - v3[5];
if ( v4 >= a3 + 20 || v3[2] + v4 - 20LL * v3[1] >= a3 + 20 )
{
v5 = 1;
while ( !(unsigned int)mi_find_writepos(a1, a3, &v10, &v9) )
{
LODWORD(v6) = -1;
if ( !a1[826] )
v6 = *(_QWORD *)(*(_QWORD *)a1 + 88LL);
if ( (unsigned int)mi_write_part_record(
(_DWORD)a1,
v10,
v9,
v6,
(unsigned int)&v8,
(unsigned int)&v11,
(long long)v12) )
break;
a3 = v11;
if ( !v11 )
return 0;
}
}
else
{
*(_DWORD *)my_thread_var(a1) = 135;
return 1;
}
return v5;
}
|
write_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV dword ptr [RBP + -0x2c],0x0
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RAX + 0x110]
SUB RAX,qword ptr [RSI + 0x28]
LEA RCX,[RDX + 0x14]
CMP RAX,RCX
JC 0x0017730d
LAB_0017728e:
LEA R15,[RBP + -0x48]
LEA R12,[RBP + -0x50]
LEA R13,[RBP + -0x38]
MOV R14D,0x1
LAB_001772a0:
MOV RDI,RBX
MOV RSI,RDX
LEA RDX,[RBP + -0x40]
MOV RCX,R15
CALL 0x00179c51
TEST EAX,EAX
JNZ 0x001772fb
MOV RCX,-0x1
CMP byte ptr [RBX + 0x33a],0x0
JNZ 0x001772cd
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + 0x58]
LAB_001772cd:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
LEA RAX,[RBP + -0x2c]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV R8,R12
MOV R9,R13
CALL 0x00177b18
TEST EAX,EAX
JNZ 0x001772fb
MOV RDX,qword ptr [RBP + -0x38]
TEST RDX,RDX
JNZ 0x001772a0
XOR R14D,R14D
LAB_001772fb:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017730d:
ADD RAX,qword ptr [RSI + 0x10]
MOV RSI,qword ptr [RSI + 0x8]
SHL RSI,0x2
LEA RSI,[RSI + RSI*0x4]
SUB RAX,RSI
CMP RAX,RCX
JNC 0x0017728e
CALL 0x001a1ab2
MOV dword ptr [RAX],0x87
MOV R14D,0x1
JMP 0x001772fb
|
int8 write_dynamic_record(long *param_1,int8 param_2,long param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
int4 *puVar4;
int8 uVar5;
int8 local_58;
int8 local_50;
int8 local_48;
long local_40;
int4 local_34;
local_34 = 0;
lVar1 = param_1[1];
uVar3 = *(long *)(*param_1 + 0x110) - *(long *)(lVar1 + 0x28);
local_58 = param_2;
local_40 = param_3;
if ((uVar3 < param_3 + 0x14U) &&
(uVar3 + *(long *)(lVar1 + 0x10) + *(long *)(lVar1 + 8) * -0x14 < param_3 + 0x14U)) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x87;
uVar5 = 1;
}
else {
do {
iVar2 = _mi_find_writepos(param_1,local_40,&local_48,&local_50);
if (iVar2 != 0) {
return 1;
}
uVar5 = 0xffffffffffffffff;
if (*(char *)((long)param_1 + 0x33a) == '\0') {
uVar5 = *(int8 *)(*param_1 + 0x58);
}
iVar2 = _mi_write_part_record(param_1,local_48,local_50,uVar5,&local_58,&local_40,&local_34);
if (iVar2 != 0) {
return 1;
}
} while (local_40 != 0);
uVar5 = 0;
}
return uVar5;
}
|
|
9,641 |
delete_tails
|
eloqsql/storage/maria/ma_blockrec.c
|
static my_bool delete_tails(MARIA_HA *info, MARIA_RECORD_POS *tails)
{
my_bool res= 0;
DBUG_ENTER("delete_tails");
for (; *tails; tails++)
{
if (delete_head_or_tail(info,
ma_recordpos_to_page(*tails),
ma_recordpos_to_dir_entry(*tails), 0, 1))
res= 1;
}
DBUG_RETURN(res);
}
|
O0
|
c
|
delete_tails:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x76b21
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x75e50
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x75e70
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x75ab0
cmpb $0x0, %al
je 0x76b11
movb $0x1, -0x11(%rbp)
jmp 0x76b13
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x76ac4
jmp 0x76b23
movb -0x11(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
delete_tails:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], 0
loc_76AC4:
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_76B21
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call ma_recordpos_to_page
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call ma_recordpos_to_dir_entry
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
mov edx, eax
xor ecx, ecx
mov r8d, 1
call delete_head_or_tail
cmp al, 0
jz short loc_76B11
mov [rbp+var_11], 1
loc_76B11:
jmp short $+2
loc_76B13:
mov rax, [rbp+var_10]
add rax, 8
mov [rbp+var_10], rax
jmp short loc_76AC4
loc_76B21:
jmp short $+2
loc_76B23:
mov al, [rbp+var_11]
mov [rbp+var_29], al
mov al, [rbp+var_29]
add rsp, 30h
pop rbp
retn
|
char delete_tails(long long *a1, unsigned long long *a2)
{
unsigned int v2; // eax
unsigned long long v4; // [rsp+10h] [rbp-20h]
char v5; // [rsp+1Fh] [rbp-11h]
v5 = 0;
while ( *a2 )
{
v4 = ma_recordpos_to_page(*a2);
v2 = ma_recordpos_to_dir_entry(*a2);
if ( delete_head_or_tail(a1, v4, v2, 0, 1) )
v5 = 1;
++a2;
}
return v5;
}
|
delete_tails:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],0x0
LAB_00176ac4:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x00176b21
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00175e50
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00175e70
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,EAX
XOR ECX,ECX
MOV R8D,0x1
CALL 0x00175ab0
CMP AL,0x0
JZ 0x00176b11
MOV byte ptr [RBP + -0x11],0x1
LAB_00176b11:
JMP 0x00176b13
LAB_00176b13:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00176ac4
LAB_00176b21:
JMP 0x00176b23
LAB_00176b23:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x29],AL
MOV AL,byte ptr [RBP + -0x29]
ADD RSP,0x30
POP RBP
RET
|
int1 delete_tails(int8 param_1,long *param_2)
{
char cVar1;
int4 uVar2;
int8 uVar3;
int1 local_19;
long *local_18;
local_19 = 0;
for (local_18 = param_2; *local_18 != 0; local_18 = local_18 + 1) {
uVar3 = ma_recordpos_to_page(*local_18);
uVar2 = ma_recordpos_to_dir_entry(*local_18);
cVar1 = delete_head_or_tail(param_1,uVar3,uVar2,0,1);
if (cVar1 != '\0') {
local_19 = 1;
}
}
return local_19;
}
|
|
9,642 |
fmt::v11::basic_appender<char> fmt::v11::detail::write_int_noinline<char, fmt::v11::basic_appender<char>, unsigned int>(fmt::v11::basic_appender<char>, fmt::v11::detail::write_int_arg<unsigned int>, fmt::v11::format_specs const&)
|
zkingston[P]unknot/build_O1/_deps/fmt-src/include/fmt/format.h
|
FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out,
write_int_arg<T> arg,
const format_specs& specs)
-> OutputIt {
return write_int<Char>(out, arg, specs);
}
|
O1
|
c
|
fmt::v11::basic_appender<char> fmt::v11::detail::write_int_noinline<char, fmt::v11::basic_appender<char>, unsigned int>(fmt::v11::basic_appender<char>, fmt::v11::detail::write_int_arg<unsigned int>, fmt::v11::format_specs const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, %r13
shrq $0x20, %r13
leaq 0x40(%rsp), %r14
movl (%rdx), %eax
movl %eax, %ecx
andl $0x7, %ecx
leal -0x4(%rcx), %edx
cmpl $0x3, %edx
ja 0x4078f
leaq 0x253050(%rip), %rdi # 0x2936a0
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
btl $0xc, %eax
leaq 0x2532ba(%rip), %rdx # 0x29391e
leaq 0x24fde5(%rip), %rcx # 0x290450
cmovaeq %rdx, %rcx
movq %r14, %r12
movl %esi, %edx
movl %esi, %edi
andl $0xf, %edi
movb (%rcx,%rdi), %dil
movb %dil, -0x1(%r12)
decq %r12
shrl $0x4, %edx
cmpl $0xf, %esi
movl %edx, %esi
ja 0x40674
btl $0xd, %eax
jae 0x407a1
xorl %ecx, %ecx
btl $0xc, %eax
setae %cl
shll $0xd, %ecx
orl $0x5830, %ecx # imm = 0x5830
jmp 0x406e7
movq %r14, %r12
movl %esi, %ecx
movl %esi, %edx
andb $0x1, %dl
orb $0x30, %dl
movb %dl, -0x1(%r12)
decq %r12
shrl %ecx
cmpl $0x1, %esi
movl %ecx, %esi
ja 0x406b2
btl $0xd, %eax
jae 0x407a1
xorl %ecx, %ecx
btl $0xc, %eax
setae %cl
shll $0xd, %ecx
orl $0x4230, %ecx # imm = 0x4230
movl %ecx, %eax
shll $0x8, %eax
testq %r13, %r13
cmovel %ecx, %eax
orl %r13d, %eax
addl $0x2000000, %eax # imm = 0x2000000
movl %eax, %r13d
jmp 0x407a1
cmpl $0x1, %ecx
leaq 0x8(%rsp), %r8
sete (%r8)
movb %sil, 0x1(%r8)
movl $0x1, %edx
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4088a
jmp 0x40876
xorl %ecx, %ecx
movl %esi, %edi
movq %r14, %r12
movl %esi, %edx
movl %edi, %r8d
andb $0x7, %r8b
orb $0x30, %r8b
movb %r8b, -0x1(%r12)
decq %r12
shrl $0x3, %edx
incq %rcx
cmpl $0x7, %edi
movl %edx, %edi
ja 0x40735
btl $0xd, %eax
jae 0x407a1
movslq 0xc(%r15), %rax
cmpq %rax, %rcx
setge %al
testl %esi, %esi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x407a1
testq %r13, %r13
movl $0x30, %eax
movl $0x3000, %ecx # imm = 0x3000
cmovel %eax, %ecx
orl %r13d, %ecx
addl $0x1000000, %ecx # imm = 0x1000000
movl %ecx, %r13d
jmp 0x407a1
leaq 0x20(%rsp), %rdi
movl $0x20, %edx
callq 0x3ff74
movq %rax, %r12
movl %r14d, %edi
subl %r12d, %edi
movl 0x8(%r15), %edx
movl 0xc(%r15), %ecx
leal 0x1(%rcx), %r8d
movl %r13d, %esi
shrl $0x18, %esi
leal (%rsi,%rdi), %eax
orl %edx, %r8d
je 0x407df
movl (%r15), %r8d
andl $0x38, %r8d
cmpl $0x20, %r8d
jne 0x40842
xorl %ecx, %ecx
movl %edx, %r9d
subl %eax, %r9d
cmovbl %ecx, %r9d
cmoval %edx, %eax
jmp 0x40852
movl %eax, %esi
addq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jae 0x407f1
movq %rbx, %rdi
callq *0x18(%rbx)
andl $0xffffff, %r13d # imm = 0xFFFFFF
je 0x40832
movq 0x8(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x10(%rbx)
jae 0x4080d
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb %r13b, (%rax,%rcx)
movl %r13d, %eax
shrl $0x8, %eax
cmpl $0x100, %r13d # imm = 0x100
movl %eax, %r13d
jae 0x407fa
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3f992
jmp 0x40879
xorl %r9d, %r9d
movl %ecx, %edx
subl %edi, %edx
jle 0x40852
addl %esi, %ecx
movl %edx, %r9d
movl %ecx, %eax
movl %eax, %ecx
leaq 0x8(%rsp), %r8
movl %r13d, (%r8)
movl %r9d, 0x4(%r8)
movq %r12, 0x8(%r8)
movq %r14, 0x10(%r8)
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x40e7a
movq %rax, %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN3fmt3v116detail18write_int_noinlineIcNS0_14basic_appenderIcEEjEET0_S5_NS1_13write_int_argIT1_EERKNS0_12format_specsE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov r15, rdx
mov rbx, rdi
mov r13, rsi
shr r13, 20h
lea r14, [rsp+68h+var_28]
mov eax, [rdx]
mov ecx, eax
and ecx, 7
lea edx, [rcx-4]; switch 4 cases
cmp edx, 3
ja def_40657; jumptable 0000000000040657 default case
lea rdi, jpt_40657
movsxd rdx, ds:(jpt_40657 - 2936A0h)[rdi+rdx*4]
add rdx, rdi
jmp rdx; switch jump
loc_40659:
bt eax, 0Ch; jumptable 0000000000040657 case 4
lea rdx, a0123456789abcd_0; "0123456789abcdef"
lea rcx, a0123456789abcd; "0123456789ABCDEF"
cmovnb rcx, rdx
mov r12, r14
mov edx, esi
loc_40674:
mov edi, esi
and edi, 0Fh
mov dil, [rcx+rdi]
mov [r12-1], dil
dec r12
shr edx, 4
cmp esi, 0Fh
mov esi, edx
ja short loc_40674
bt eax, 0Dh
jnb loc_407A1
xor ecx, ecx
bt eax, 0Ch
setnb cl
shl ecx, 0Dh
or ecx, 5830h
jmp short loc_406E7
loc_406AD:
mov r12, r14; jumptable 0000000000040657 case 6
mov ecx, esi
loc_406B2:
mov edx, esi
and dl, 1
or dl, 30h
mov [r12-1], dl
dec r12
shr ecx, 1
cmp esi, 1
mov esi, ecx
ja short loc_406B2
bt eax, 0Dh
jnb loc_407A1
xor ecx, ecx
bt eax, 0Ch
setnb cl
shl ecx, 0Dh
or ecx, 4230h
loc_406E7:
mov eax, ecx
shl eax, 8
test r13, r13
cmovz eax, ecx
or eax, r13d
add eax, 2000000h
mov r13d, eax
jmp loc_407A1
loc_40702:
cmp ecx, 1; jumptable 0000000000040657 case 7
lea r8, [rsp+68h+var_60]
setz byte ptr [r8]
mov [r8+1], sil
mov edx, 1
mov ecx, 1
mov rdi, rbx
mov rsi, r15
call _ZN3fmt3v116detail12write_paddedIcLNS0_5alignE1ENS0_14basic_appenderIcEERZNS1_10write_charIcS5_EET0_S7_T_RKNS0_12format_specsEEUlS5_E_EET1_SE_SB_mmOT2_; fmt::v11::detail::write_padded<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>,fmt::v11::detail::write_char<char,fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>,char,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &>(fmt::v11::basic_appender<char>,fmt::v11::format_specs const&,ulong,ulong,fmt::v11::detail::write_char<char,fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>,char,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &)
jmp loc_40876
loc_4072C:
xor ecx, ecx; jumptable 0000000000040657 case 5
mov edi, esi
mov r12, r14
mov edx, esi
loc_40735:
mov r8d, edi
and r8b, 7
or r8b, 30h
mov [r12-1], r8b
dec r12
shr edx, 3
inc rcx
cmp edi, 7
mov edi, edx
ja short loc_40735
bt eax, 0Dh
jnb short loc_407A1
movsxd rax, dword ptr [r15+0Ch]
cmp rcx, rax
setnl al
test esi, esi
setnz cl
and cl, al
cmp cl, 1
jnz short loc_407A1
test r13, r13
mov eax, 30h ; '0'
mov ecx, 3000h
cmovz ecx, eax
or ecx, r13d
add ecx, 1000000h
mov r13d, ecx
jmp short loc_407A1
def_40657:
lea rdi, [rsp+68h+var_48]; jumptable 0000000000040657 default case
mov edx, 20h ; ' '
call _ZN3fmt3v116detail17do_format_decimalIcjEEPT_S4_T0_i; fmt::v11::detail::do_format_decimal<char,uint>(char *,uint,int)
mov r12, rax
loc_407A1:
mov edi, r14d
sub edi, r12d
mov edx, [r15+8]
mov ecx, [r15+0Ch]
lea r8d, [rcx+1]
mov esi, r13d
shr esi, 18h
lea eax, [rsi+rdi]
or r8d, edx
jz short loc_407DF
mov r8d, [r15]
and r8d, 38h
cmp r8d, 20h ; ' '
jnz short loc_40842
xor ecx, ecx
mov r9d, edx
sub r9d, eax
cmovb r9d, ecx
cmova eax, edx
jmp short loc_40852
loc_407DF:
mov esi, eax
add rsi, [rbx+8]
cmp [rbx+10h], rsi
jnb short loc_407F1
mov rdi, rbx
call qword ptr [rbx+18h]
loc_407F1:
and r13d, 0FFFFFFh
jz short loc_40832
loc_407FA:
mov rsi, [rbx+8]
inc rsi
cmp [rbx+10h], rsi
jnb short loc_4080D
mov rdi, rbx
call qword ptr [rbx+18h]
loc_4080D:
mov rax, [rbx]
mov rcx, [rbx+8]
lea rdx, [rcx+1]
mov [rbx+8], rdx
mov [rax+rcx], r13b
mov eax, r13d
shr eax, 8
cmp r13d, 100h
mov r13d, eax
jnb short loc_407FA
loc_40832:
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _ZN3fmt3v116detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v11::detail::buffer<char>::append<char>(char const*,char const*)
jmp short loc_40879
loc_40842:
xor r9d, r9d
mov edx, ecx
sub edx, edi
jle short loc_40852
add ecx, esi
mov r9d, edx
mov eax, ecx
loc_40852:
mov ecx, eax
lea r8, [rsp+68h+var_60]
mov [r8], r13d
mov [r8+4], r9d
mov [r8+8], r12
mov [r8+10h], r14
mov rdi, rbx
mov rsi, r15
mov rdx, rcx
call _ZN3fmt3v116detail12write_paddedIcLNS0_5alignE2ENS0_14basic_appenderIcEERZNS1_9write_intIcS5_jEET0_S7_NS1_13write_int_argIT1_EERKNS0_12format_specsEEUlS5_E_EES9_S9_SD_mmOT2_; fmt::v11::detail::write_padded<char,(fmt::v11::align)2,fmt::v11::basic_appender<char>,fmt::v11::detail::write_int<char,fmt::v11::basic_appender<char>,uint>(fmt::v11::basic_appender<char>,fmt::v11::detail::write_int_arg<uint>,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &>(uint,fmt::v11::format_specs const&,ulong,ulong,fmt::v11::detail::write_int<char,fmt::v11::basic_appender<char>,uint>(fmt::v11::basic_appender<char>,fmt::v11::detail::write_int_arg<uint>,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &)
loc_40876:
mov rbx, rax
loc_40879:
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long fmt::v11::detail::write_int_noinline<char,fmt::v11::basic_appender<char>,unsigned int>(
long long a1,
unsigned long long a2,
int *a3)
{
long long v4; // rbx
unsigned long long v5; // r13
int v6; // eax
const char *v7; // rcx
_BYTE *v8; // r12
unsigned int v9; // edx
bool v10; // cc
int v11; // ecx
unsigned int v12; // ecx
int v13; // eax
long long v15; // rcx
unsigned int v16; // edi
unsigned int v17; // edx
int v18; // ecx
signed int v19; // edi
unsigned int v20; // edx
signed int v21; // ecx
unsigned int v22; // eax
unsigned int v23; // r13d
long long v24; // rax
long long v25; // rcx
bool v26; // cf
char v28[32]; // [rsp+20h] [rbp-48h] BYREF
_BYTE v29[40]; // [rsp+40h] [rbp-28h] BYREF
v4 = a1;
v5 = HIDWORD(a2);
v6 = *a3;
switch ( *a3 & 7 )
{
case 4:
v7 = "0123456789ABCDEF";
if ( (v6 & 0x1000) == 0 )
v7 = "0123456789abcdef";
v8 = v29;
v9 = a2;
do
{
*--v8 = v7[a2 & 0xF];
v9 >>= 4;
v10 = (unsigned int)a2 <= 0xF;
LODWORD(a2) = v9;
}
while ( !v10 );
if ( (v6 & 0x2000) == 0 )
goto LABEL_24;
v11 = (((v6 & 0x1000) == 0) << 13) | 0x5830;
goto LABEL_12;
case 5:
v15 = 0LL;
v16 = a2;
v8 = v29;
v17 = a2;
do
{
*--v8 = v16 & 7 | 0x30;
v17 >>= 3;
++v15;
v10 = v16 <= 7;
v16 = v17;
}
while ( !v10 );
if ( (v6 & 0x2000) != 0 && v15 >= a3[3] && (_DWORD)a2 != 0 )
{
v18 = 12288;
if ( !v5 )
v18 = 48;
LODWORD(v5) = (HIDWORD(a2) | v18) + 0x1000000;
}
goto LABEL_24;
case 6:
v8 = v29;
v12 = a2;
do
{
*--v8 = a2 & 1 | 0x30;
v12 >>= 1;
v10 = (unsigned int)a2 <= 1;
LODWORD(a2) = v12;
}
while ( !v10 );
if ( (v6 & 0x2000) != 0 )
{
v11 = (((v6 & 0x1000) == 0) << 13) | 0x4230;
LABEL_12:
v13 = v11 << 8;
if ( !v5 )
v13 = v11;
LODWORD(v5) = (v5 | v13) + 0x2000000;
}
goto LABEL_24;
case 7:
return fmt::v11::detail::write_padded<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>,fmt::v11::basic_appender<char> fmt::v11::detail::write_char<char,fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>,char,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &>(
a1,
a3,
1LL,
1LL);
default:
v8 = (_BYTE *)fmt::v11::detail::do_format_decimal<char,unsigned int>((long long)v28, a2, 32LL);
LABEL_24:
v19 = (unsigned int)v29 - (_DWORD)v8;
v20 = a3[2];
v21 = a3[3];
v22 = BYTE3(v5) + v19;
if ( v20 | (v21 + 1) )
{
if ( (*a3 & 0x38) == 0x20 )
{
if ( v20 > v22 )
v22 = a3[2];
}
else if ( v21 > v19 )
{
v22 = BYTE3(v5) + v21;
}
return fmt::v11::detail::write_padded<char,(fmt::v11::align)2,fmt::v11::basic_appender<char>,fmt::v11::basic_appender<char> fmt::v11::detail::write_int<char,fmt::v11::basic_appender<char>,unsigned int>(fmt::v11::basic_appender<char>,fmt::v11::detail::write_int_arg<unsigned int>,fmt::v11::format_specs const&)::{lambda(fmt::v11::basic_appender<char>)#1} &>(
v4,
a3,
v22);
}
else
{
if ( *(_QWORD *)(v4 + 16) < *(_QWORD *)(v4 + 8) + (unsigned long long)v22 )
(*(void ( **)(long long))(v4 + 24))(v4);
v23 = v5 & 0xFFFFFF;
if ( v23 )
{
do
{
if ( *(_QWORD *)(v4 + 16) < (unsigned long long)(*(_QWORD *)(v4 + 8) + 1LL) )
(*(void ( **)(long long))(v4 + 24))(v4);
v24 = *(_QWORD *)v4;
v25 = *(_QWORD *)(v4 + 8);
*(_QWORD *)(v4 + 8) = v25 + 1;
*(_BYTE *)(v24 + v25) = v23;
v26 = v23 < 0x100;
v23 >>= 8;
}
while ( !v26 );
}
fmt::v11::detail::buffer<char>::append<char>(v4, (long long)v8, (long long)v29);
}
return v4;
}
}
|
write_int_noinline<char,fmt::v11::basic_appender<char>,unsigned_int>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R15,RDX
MOV RBX,RDI
MOV R13,RSI
SHR R13,0x20
LEA R14,[RSP + 0x40]
MOV EAX,dword ptr [RDX]
MOV ECX,EAX
AND ECX,0x7
LEA EDX,[RCX + -0x4]
CMP EDX,0x3
JA 0x0014078f
LEA RDI,[0x3936a0]
MOVSXD RDX,dword ptr [RDI + RDX*0x4]
ADD RDX,RDI
switchD:
JMP RDX
caseD_4:
BT EAX,0xc
LEA RDX,[0x39391e]
LEA RCX,[0x390450]
CMOVNC RCX,RDX
MOV R12,R14
MOV EDX,ESI
LAB_00140674:
MOV EDI,ESI
AND EDI,0xf
MOV DIL,byte ptr [RCX + RDI*0x1]
MOV byte ptr [R12 + -0x1],DIL
DEC R12
SHR EDX,0x4
CMP ESI,0xf
MOV ESI,EDX
JA 0x00140674
BT EAX,0xd
JNC 0x001407a1
XOR ECX,ECX
BT EAX,0xc
SETNC CL
SHL ECX,0xd
OR ECX,0x5830
JMP 0x001406e7
caseD_6:
MOV R12,R14
MOV ECX,ESI
LAB_001406b2:
MOV EDX,ESI
AND DL,0x1
OR DL,0x30
MOV byte ptr [R12 + -0x1],DL
DEC R12
SHR ECX,0x1
CMP ESI,0x1
MOV ESI,ECX
JA 0x001406b2
BT EAX,0xd
JNC 0x001407a1
XOR ECX,ECX
BT EAX,0xc
SETNC CL
SHL ECX,0xd
OR ECX,0x4230
LAB_001406e7:
MOV EAX,ECX
SHL EAX,0x8
TEST R13,R13
CMOVZ EAX,ECX
OR EAX,R13D
ADD EAX,0x2000000
MOV R13D,EAX
JMP 0x001407a1
caseD_7:
CMP ECX,0x1
LEA R8,[RSP + 0x8]
SETZ byte ptr [R8]
MOV byte ptr [R8 + 0x1],SIL
MOV EDX,0x1
MOV ECX,0x1
MOV RDI,RBX
MOV RSI,R15
CALL 0x0014088a
JMP 0x00140876
caseD_5:
XOR ECX,ECX
MOV EDI,ESI
MOV R12,R14
MOV EDX,ESI
LAB_00140735:
MOV R8D,EDI
AND R8B,0x7
OR R8B,0x30
MOV byte ptr [R12 + -0x1],R8B
DEC R12
SHR EDX,0x3
INC RCX
CMP EDI,0x7
MOV EDI,EDX
JA 0x00140735
BT EAX,0xd
JNC 0x001407a1
MOVSXD RAX,dword ptr [R15 + 0xc]
CMP RCX,RAX
SETGE AL
TEST ESI,ESI
SETNZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x001407a1
TEST R13,R13
MOV EAX,0x30
MOV ECX,0x3000
CMOVZ ECX,EAX
OR ECX,R13D
ADD ECX,0x1000000
MOV R13D,ECX
JMP 0x001407a1
default:
LEA RDI,[RSP + 0x20]
MOV EDX,0x20
CALL 0x0013ff74
MOV R12,RAX
LAB_001407a1:
MOV EDI,R14D
SUB EDI,R12D
MOV EDX,dword ptr [R15 + 0x8]
MOV ECX,dword ptr [R15 + 0xc]
LEA R8D,[RCX + 0x1]
MOV ESI,R13D
SHR ESI,0x18
LEA EAX,[RSI + RDI*0x1]
OR R8D,EDX
JZ 0x001407df
MOV R8D,dword ptr [R15]
AND R8D,0x38
CMP R8D,0x20
JNZ 0x00140842
XOR ECX,ECX
MOV R9D,EDX
SUB R9D,EAX
CMOVC R9D,ECX
CMOVA EAX,EDX
JMP 0x00140852
LAB_001407df:
MOV ESI,EAX
ADD RSI,qword ptr [RBX + 0x8]
CMP qword ptr [RBX + 0x10],RSI
JNC 0x001407f1
MOV RDI,RBX
CALL qword ptr [RBX + 0x18]
LAB_001407f1:
AND R13D,0xffffff
JZ 0x00140832
LAB_001407fa:
MOV RSI,qword ptr [RBX + 0x8]
INC RSI
CMP qword ptr [RBX + 0x10],RSI
JNC 0x0014080d
MOV RDI,RBX
CALL qword ptr [RBX + 0x18]
LAB_0014080d:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RBX + 0x8],RDX
MOV byte ptr [RAX + RCX*0x1],R13B
MOV EAX,R13D
SHR EAX,0x8
CMP R13D,0x100
MOV R13D,EAX
JNC 0x001407fa
LAB_00140832:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x0013f992
JMP 0x00140879
LAB_00140842:
XOR R9D,R9D
MOV EDX,ECX
SUB EDX,EDI
JLE 0x00140852
ADD ECX,ESI
MOV R9D,EDX
MOV EAX,ECX
LAB_00140852:
MOV ECX,EAX
LEA R8,[RSP + 0x8]
MOV dword ptr [R8],R13D
MOV dword ptr [R8 + 0x4],R9D
MOV qword ptr [R8 + 0x8],R12
MOV qword ptr [R8 + 0x10],R14
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RCX
CALL 0x00140e7a
LAB_00140876:
MOV RBX,RAX
LAB_00140879:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* fmt::v11::basic_appender<char> fmt::v11::detail::write_int_noinline<char,
fmt::v11::basic_appender<char>, unsigned int>(fmt::v11::basic_appender<char>,
fmt::v11::detail::write_int_arg<unsigned int>, fmt::v11::format_specs const&) */
buffer<char> *
fmt::v11::detail::write_int_noinline<char,fmt::v11::basic_appender<char>,unsigned_int>
(buffer<char> *param_1,ulong param_2,uint *param_3)
{
buffer<char> *pbVar1;
char *pcVar2;
uint uVar3;
char *pcVar4;
ulong uVar5;
long lVar6;
uint uVar7;
uint uVar8;
int iVar9;
uint uVar10;
ulong uVar11;
bool bVar12;
char local_48 [31];
byte local_29;
pcVar2 = &stack0xffffffffffffffd8;
uVar11 = param_2 >> 0x20;
uVar3 = *param_3;
uVar10 = (uint)(param_2 >> 0x20);
switch(uVar3 & 7) {
case 4:
pcVar4 = "0123456789ABCDEF";
if ((uVar3 >> 0xc & 1) == 0) {
pcVar4 = "0123456789abcdef";
}
uVar5 = param_2 & 0xffffffff;
do {
uVar7 = (uint)param_2;
pcVar2[-1] = pcVar4[uVar7 & 0xf];
pcVar2 = pcVar2 + -1;
uVar5 = uVar5 >> 4;
param_2 = uVar5;
} while (0xf < uVar7);
if ((uVar3 >> 0xd & 1) == 0) goto LAB_001407a1;
uVar3 = (uint)((uVar3 >> 0xc & 1) == 0) << 0xd | 0x5830;
break;
case 5:
lVar6 = 0;
uVar5 = param_2 & 0xffffffff;
pcVar2 = &stack0xffffffffffffffd8;
do {
uVar7 = (uint)uVar5;
pcVar2[-1] = (byte)uVar5 & 7 | 0x30;
pcVar2 = pcVar2 + -1;
uVar5 = uVar5 >> 3;
lVar6 = lVar6 + 1;
} while (7 < uVar7);
if (((uVar3 >> 0xd & 1) != 0) && ((uint)param_2 != 0 && (int)param_3[3] <= lVar6)) {
uVar3 = 0x3000;
if (uVar11 == 0) {
uVar3 = 0x30;
}
uVar11 = (ulong)((uVar3 | uVar10) + 0x1000000);
}
goto LAB_001407a1;
case 6:
uVar5 = param_2 & 0xffffffff;
pcVar2 = &stack0xffffffffffffffd8;
do {
uVar7 = (uint)param_2;
pcVar2[-1] = (byte)param_2 & 1 | 0x30;
pcVar2 = pcVar2 + -1;
uVar5 = uVar5 >> 1;
param_2 = uVar5;
} while (1 < uVar7);
if ((uVar3 >> 0xd & 1) == 0) goto LAB_001407a1;
uVar3 = (uint)((uVar3 >> 0xc & 1) == 0) << 0xd | 0x4230;
break;
case 7:
pbVar1 = (buffer<char> *)
write_padded<char,(fmt::v11::align)1,fmt::v11::basic_appender<char>,fmt::v11::detail::write_char<char,fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>,char,fmt::v11::format_specs_const&)::_lambda(fmt::v11::basic_appender<char>)_1_&>
(param_1,param_3,1,1);
return pbVar1;
default:
pcVar2 = do_format_decimal<char,unsigned_int>(local_48,(uint)param_2,0x20);
goto LAB_001407a1;
}
uVar7 = uVar3 << 8;
if (uVar11 == 0) {
uVar7 = uVar3;
}
uVar11 = (ulong)((uVar7 | uVar10) + 0x2000000);
LAB_001407a1:
iVar9 = (int)&stack0xffffffffffffffd8 - (int)pcVar2;
uVar10 = param_3[2];
uVar7 = param_3[3];
uVar8 = (uint)uVar11 >> 0x18;
uVar3 = uVar8 + iVar9;
if (uVar7 == 0xffffffff && uVar10 == 0) {
if (*(ulong *)(param_1 + 0x10) < (ulong)uVar3 + *(long *)(param_1 + 8)) {
(**(code **)(param_1 + 0x18))(param_1);
}
uVar3 = (uint)uVar11 & 0xffffff;
if ((uVar11 & 0xffffff) != 0) {
do {
if (*(ulong *)(param_1 + 0x10) < *(long *)(param_1 + 8) + 1U) {
(**(code **)(param_1 + 0x18))(param_1);
}
lVar6 = *(long *)(param_1 + 8);
*(long *)(param_1 + 8) = lVar6 + 1;
*(char *)(*(long *)param_1 + lVar6) = (char)uVar3;
bVar12 = 0xff < uVar3;
uVar3 = uVar3 >> 8;
} while (bVar12);
}
buffer<char>::append<char>(param_1,pcVar2,&stack0xffffffffffffffd8);
}
else {
if ((*param_3 & 0x38) == 0x20) {
if (uVar3 < uVar10) {
uVar3 = uVar10;
}
}
else if (iVar9 < (int)uVar7) {
uVar3 = uVar7 + uVar8;
}
param_1 = (buffer<char> *)
write_padded<char,(fmt::v11::align)2,fmt::v11::basic_appender<char>,fmt::v11::detail::write_int<char,fmt::v11::basic_appender<char>,unsigned_int>(fmt::v11::basic_appender<char>,fmt::v11::detail::write_int_arg<unsigned_int>,fmt::v11::format_specs_const&)::_lambda(fmt::v11::basic_appender<char>)_1_&>
(param_1,param_3,uVar3);
}
return param_1;
}
|
|
9,643 |
inline_mysql_cond_signal
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_cond_signal(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(signal_cond)(that->m_psi);
#endif
result= pthread_cond_signal(&that->m_cond);
return result;
}
|
O0
|
c
|
inline_mysql_cond_signal:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9c93b
leaq 0x2315b9(%rip), %rax # 0x2cdee0
movq (%rax), %rax
movq 0x170(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2a570
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
|
inline_mysql_cond_signal_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9C93B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+170h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
loc_9C93B:
mov rdi, [rbp+var_8]
call _pthread_cond_signal
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long inline_mysql_cond_signal_0(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
((void ( *)(_QWORD))PSI_server[46])(*(_QWORD *)(a1 + 48));
return (unsigned int)pthread_cond_signal(a1);
}
|
inline_mysql_cond_signal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019c93b
LEA RAX,[0x3cdee0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x170]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
LAB_0019c93b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a570
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int inline_mysql_cond_signal(pthread_cond_t *param_1)
{
int iVar1;
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))(param_1[1].__align);
}
iVar1 = pthread_cond_signal(param_1);
return iVar1;
}
|
|
9,644 |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t)
|
monkey531[P]llama/common/./json.hpp
|
serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
, decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
{}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
movups (%rsi), %xmm0
movq %r15, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %r15, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
callq 0x20530
movq %rax, 0x50(%rbx)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x74af7
movb (%rcx), %r15b
movb %r15b, 0x58(%rbx)
movq (%rax), %rax
testq %rax, %rax
je 0x74b07
movb (%rax), %al
jmp 0x74b09
xorl %eax, %eax
movb %al, 0x59(%rbx)
leaq 0x5a(%rbx), %rdi
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x1f610
movb %r14b, 0x25a(%rbx)
leaq 0x260(%rbx), %rdi
leaq 0x270(%rbx), %rax
movq %rax, 0x260(%rbx)
movsbl %r14b, %edx
movl $0x200, %esi # imm = 0x200
callq 0x1fc80
movl %ebp, 0x280(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x74b68
callq 0x52cd2
movq %r14, %rdi
callq 0x20380
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt10shared_ptrINS1_23output_adapter_protocolIcEEEcNS1_15error_handler_tE:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
mov r14d, edx
mov rbx, rdi
xor r15d, r15d
mov [rdi+8], r15
movups xmm0, xmmword ptr [rsi]
mov [rsi+8], r15
movups xmmword ptr [rdi], xmm0
mov [rsi], r15
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
call _localeconv
mov [rbx+50h], rax
mov rcx, [rax+8]
test rcx, rcx
jz short loc_74AF7
mov r15b, [rcx]
loc_74AF7:
mov [rbx+58h], r15b
mov rax, [rax]
test rax, rax
jz short loc_74B07
mov al, [rax]
jmp short loc_74B09
loc_74B07:
xor eax, eax
loc_74B09:
mov [rbx+59h], al
lea rdi, [rbx+5Ah]
mov edx, 200h
xor esi, esi
call _memset
mov [rbx+25Ah], r14b
lea rdi, [rbx+260h]
lea rax, [rbx+270h]
mov [rbx+260h], rax
movsx edx, r14b
mov esi, 200h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov [rbx+280h], ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_74B68
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_74B68:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::serializer(
long long a1,
__int128 *a2,
char a3,
int a4)
{
char v6; // r15
__int128 v7; // xmm0
long long v8; // rax
char *v9; // rcx
char *v10; // rax
char v11; // al
long long result; // rax
v6 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
v7 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)a1 = v7;
*(_QWORD *)a2 = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
v8 = localeconv(a1);
*(_QWORD *)(a1 + 80) = v8;
v9 = *(char **)(v8 + 8);
if ( v9 )
v6 = *v9;
*(_BYTE *)(a1 + 88) = v6;
v10 = *(char **)v8;
if ( v10 )
v11 = *v10;
else
v11 = 0;
*(_BYTE *)(a1 + 89) = v11;
memset(a1 + 90, 0LL, 512LL);
*(_BYTE *)(a1 + 602) = a3;
*(_QWORD *)(a1 + 608) = a1 + 624;
result = std::string::_M_construct(a1 + 608, 512LL, (unsigned int)a3);
*(_DWORD *)(a1 + 640) = a4;
return result;
}
|
serializer:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV R14D,EDX
MOV RBX,RDI
XOR R15D,R15D
MOV qword ptr [RDI + 0x8],R15
MOVUPS XMM0,xmmword ptr [RSI]
MOV qword ptr [RSI + 0x8],R15
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSI],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x00120530
MOV qword ptr [RBX + 0x50],RAX
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x00174af7
MOV R15B,byte ptr [RCX]
LAB_00174af7:
MOV byte ptr [RBX + 0x58],R15B
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00174b07
MOV AL,byte ptr [RAX]
JMP 0x00174b09
LAB_00174b07:
XOR EAX,EAX
LAB_00174b09:
MOV byte ptr [RBX + 0x59],AL
LEA RDI,[RBX + 0x5a]
MOV EDX,0x200
XOR ESI,ESI
CALL 0x0011f610
MOV byte ptr [RBX + 0x25a],R14B
LEA RDI,[RBX + 0x260]
LEA RAX,[RBX + 0x270]
MOV qword ptr [RBX + 0x260],RAX
LAB_00174b38:
MOVSX EDX,R14B
MOV ESI,0x200
CALL 0x0011fc80
LAB_00174b46:
MOV dword ptr [RBX + 0x280],EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>
>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::serializer(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,int8 *param_2,
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
param_3,int4 param_4)
{
int8 uVar1;
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
sVar2;
lconv *plVar3;
sVar2 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
*(int8 *)(this + 8) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)this = *param_2;
*(int8 *)(this + 8) = uVar1;
*param_2 = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
plVar3 = localeconv();
*(lconv **)(this + 0x50) = plVar3;
if ((serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->thousands_sep !=
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar2 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->thousands_sep;
}
this[0x58] = sVar2;
if ((serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->decimal_point ==
(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar2 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
}
else {
sVar2 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->decimal_point;
}
this[0x59] = sVar2;
memset(this + 0x5a,0,0x200);
this[0x25a] = param_3;
*(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(this + 0x260) = this + 0x270;
/* try { // try from 00174b38 to 00174b45 has its CatchHandler @ 00174b57 */
std::__cxx11::string::_M_construct((ulong)(this + 0x260),'\0');
*(int4 *)(this + 0x280) = param_4;
return;
}
|
|
9,645 |
find_rh
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSOSRWHandler *find_rh(JSThreadState *ts, int fd)
{
JSOSRWHandler *rh;
struct list_head *el;
list_for_each(el, &ts->os_rw_handlers) {
rh = list_entry(el, JSOSRWHandler, link);
if (rh->fd == fd)
return rh;
}
return NULL;
}
|
O2
|
c
|
find_rh:
movq %rdi, %rax
movq 0x8(%rax), %rax
cmpq %rdi, %rax
je 0x15776
cmpl %esi, 0x10(%rax)
jne 0x15767
retq
xorl %eax, %eax
retq
|
find_rh:
mov rax, rdi
loc_15767:
mov rax, [rax+8]
cmp rax, rdi
jz short loc_15776
cmp [rax+10h], esi
jnz short loc_15767
retn
loc_15776:
xor eax, eax
retn
|
long long find_rh(long long a1, int a2)
{
long long result; // rax
result = a1;
while ( 1 )
{
result = *(_QWORD *)(result + 8);
if ( result == a1 )
break;
if ( *(_DWORD *)(result + 16) == a2 )
return result;
}
return 0LL;
}
|
find_rh:
MOV RAX,RDI
LAB_00115767:
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,RDI
JZ 0x00115776
CMP dword ptr [RAX + 0x10],ESI
JNZ 0x00115767
RET
LAB_00115776:
XOR EAX,EAX
RET
|
long find_rh(long param_1,int param_2)
{
long lVar1;
lVar1 = param_1;
do {
lVar1 = *(long *)(lVar1 + 8);
if (lVar1 == param_1) {
return 0;
}
} while (*(int *)(lVar1 + 0x10) != param_2);
return lVar1;
}
|
|
9,646 |
init_one_value
|
eloqsql/mysys/my_getopt.c
|
static void init_one_value(const struct my_option *option, void *variable,
longlong value)
{
DBUG_ENTER("init_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_BOOL:
*((my_bool*) variable)= (my_bool) value;
break;
case GET_INT:
*((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
break;
case GET_ENUM:
*((ulong*) variable)= (ulong) value;
break;
case GET_UINT:
*((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
break;
case GET_LONG:
*((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
break;
case GET_ULONG:
*((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
break;
case GET_LL:
*((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
break;
case GET_ULL:
*((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
break;
case GET_SET:
case GET_FLAGSET:
*((ulonglong*) variable)= (ulonglong) value;
break;
case GET_BIT:
{
ulonglong bit= (option->block_size >= 0 ?
option->block_size :
-option->block_size);
if (option->block_size < 0)
value= !value;
if (value)
(*(ulonglong*)variable)|= bit;
else
(*(ulonglong*)variable)&= ~bit;
break;
}
case GET_DOUBLE:
*((double*) variable)= getopt_ulonglong2double(value);
break;
case GET_STR:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
*((char**) variable)= (char*) (intptr) value;
break;
case GET_STR_ALLOC:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
{
char **pstr= (char **) variable;
my_free(*pstr);
*pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
}
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_one_value:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
andl $0x3f, %eax
addq $-0x2, %rax
cmpq $0xe, %rax
ja 0x28f53
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x3e350(%rip), %rcx # 0x671f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, (%rbx)
jmp 0x28f53
movq %r14, %rdi
xorl %edx, %edx
callq 0x2943f
jmp 0x28f50
movq %r14, %rdi
xorl %edx, %edx
callq 0x29560
jmp 0x28f50
movq 0x60(%rsi), %rcx
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
xorl %edx, %edx
testq %r14, %r14
sete %dl
testq %rcx, %rcx
cmovnsq %r14, %rdx
testq %rdx, %rdx
je 0x28f4a
orq (%rbx), %rax
jmp 0x28f50
movb %r14b, (%rbx)
jmp 0x28f53
movl %r14d, %edi
xorl %edx, %edx
callq 0x29560
jmp 0x28f3b
testq %r14, %r14
je 0x28f53
movq (%rbx), %rdi
callq 0x2afd2
leaq 0x344fb8(%rip), %rax # 0x36ded8
movl (%rax), %edi
movl $0x10, %edx
movq %r14, %rsi
callq 0x2b068
jmp 0x28f50
movslq %r14d, %rdi
xorl %edx, %edx
callq 0x2943f
movl %eax, (%rbx)
jmp 0x28f53
testq %r14, %r14
jne 0x28eb1
jmp 0x28f53
notq %rax
andq (%rbx), %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
init_one_value:
push rbp
mov rbp, rsp
push r14
push rbx
mov rax, [rdi+30h]
and eax, 3Fh
add rax, 0FFFFFFFFFFFFFFFEh; switch 15 cases
cmp rax, 0Eh
ja def_28EAF; jumptable 0000000000028EAF default case, case 11
mov r14, rdx
mov rbx, rsi
mov rsi, rdi
lea rcx, jpt_28EAF
movsxd rax, ds:(jpt_28EAF - 671F8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_28EB1:
mov [rbx], r14; jumptable 0000000000028EAF cases 12-15
jmp def_28EAF; jumptable 0000000000028EAF default case, case 11
loc_28EB9:
mov rdi, r14; jumptable 0000000000028EAF cases 5,7
xor edx, edx
call getopt_ll_limit_value
jmp loc_28F50
loc_28EC8:
mov rdi, r14; jumptable 0000000000028EAF cases 6,8
xor edx, edx
call getopt_ull_limit_value
jmp short loc_28F50
loc_28ED4:
mov rcx, [rsi+60h]; jumptable 0000000000028EAF case 16
mov rax, rcx
neg rax
cmovs rax, rcx
xor edx, edx
test r14, r14
setz dl
test rcx, rcx
cmovns rdx, r14
test rdx, rdx
jz short loc_28F4A
or rax, [rbx]
jmp short loc_28F50
loc_28EFB:
mov [rbx], r14b; jumptable 0000000000028EAF case 2
jmp short def_28EAF; jumptable 0000000000028EAF default case, case 11
loc_28F00:
mov edi, r14d; jumptable 0000000000028EAF case 4
xor edx, edx
call getopt_ull_limit_value
jmp short loc_28F3B
loc_28F0C:
test r14, r14; jumptable 0000000000028EAF case 10
jz short def_28EAF; jumptable 0000000000028EAF default case, case 11
mov rdi, [rbx]
call my_free
lea rax, key_memory_defaults
mov edi, [rax]
mov edx, 10h
mov rsi, r14
call my_strdup
jmp short loc_28F50
loc_28F31:
movsxd rdi, r14d; jumptable 0000000000028EAF case 3
xor edx, edx
call getopt_ll_limit_value
loc_28F3B:
mov [rbx], eax
jmp short def_28EAF; jumptable 0000000000028EAF default case, case 11
loc_28F3F:
test r14, r14; jumptable 0000000000028EAF case 9
jnz loc_28EB1; jumptable 0000000000028EAF cases 12-15
jmp short def_28EAF; jumptable 0000000000028EAF default case, case 11
loc_28F4A:
not rax
and rax, [rbx]
loc_28F50:
mov [rbx], rax
def_28EAF:
pop rbx; jumptable 0000000000028EAF default case, case 11
pop r14
pop rbp
retn
|
long long init_one_value(long long a1, long long *a2, _BOOL8 a3)
{
long long result; // rax
long long v5; // rax
_BOOL8 v6; // rdx
result = (*(_QWORD *)(a1 + 48) & 0x3FLL) - 2;
switch ( *(_QWORD *)(a1 + 48) & 0x3FLL )
{
case 2LL:
*(_BYTE *)a2 = a3;
return result;
case 3LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_16;
case 4LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
LABEL_16:
*(_DWORD *)a2 = result;
return result;
case 5LL:
case 7LL:
result = getopt_ll_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 6LL:
case 8LL:
result = getopt_ull_limit_value(a3, a1, 0LL);
goto LABEL_20;
case 9LL:
if ( !a3 )
return result;
goto LABEL_2;
case 0xALL:
if ( !a3 )
return result;
my_free(*a2);
result = my_strdup(key_memory_defaults, a3, 16LL);
goto LABEL_20;
case 0xCLL:
case 0xDLL:
case 0xELL:
case 0xFLL:
LABEL_2:
*a2 = a3;
return result;
case 0x10LL:
v5 = -*(_QWORD *)(a1 + 96);
if ( *(long long *)(a1 + 96) > 0 )
v5 = *(_QWORD *)(a1 + 96);
v6 = !a3;
if ( *(long long *)(a1 + 96) >= 0 )
v6 = a3;
if ( v6 )
result = *a2 | v5;
else
result = *a2 & ~v5;
LABEL_20:
*a2 = result;
break;
default:
return result;
}
return result;
}
|
init_one_value:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x30]
AND EAX,0x3f
ADD RAX,-0x2
CMP RAX,0xe
JA 0x00128f53
MOV R14,RDX
MOV RBX,RSI
MOV RSI,RDI
LEA RCX,[0x1671f8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_c:
MOV qword ptr [RBX],R14
JMP 0x00128f53
caseD_5:
MOV RDI,R14
XOR EDX,EDX
CALL 0x0012943f
JMP 0x00128f50
caseD_6:
MOV RDI,R14
XOR EDX,EDX
CALL 0x00129560
JMP 0x00128f50
caseD_10:
MOV RCX,qword ptr [RSI + 0x60]
MOV RAX,RCX
NEG RAX
CMOVS RAX,RCX
XOR EDX,EDX
TEST R14,R14
SETZ DL
TEST RCX,RCX
CMOVNS RDX,R14
TEST RDX,RDX
JZ 0x00128f4a
OR RAX,qword ptr [RBX]
JMP 0x00128f50
caseD_2:
MOV byte ptr [RBX],R14B
JMP 0x00128f53
caseD_4:
MOV EDI,R14D
XOR EDX,EDX
CALL 0x00129560
JMP 0x00128f3b
caseD_a:
TEST R14,R14
JZ 0x00128f53
MOV RDI,qword ptr [RBX]
CALL 0x0012afd2
LEA RAX,[0x46ded8]
MOV EDI,dword ptr [RAX]
MOV EDX,0x10
MOV RSI,R14
CALL 0x0012b068
JMP 0x00128f50
caseD_3:
MOVSXD RDI,R14D
XOR EDX,EDX
CALL 0x0012943f
LAB_00128f3b:
MOV dword ptr [RBX],EAX
JMP 0x00128f53
caseD_9:
TEST R14,R14
JNZ 0x00128eb1
JMP 0x00128f53
LAB_00128f4a:
NOT RAX
AND RAX,qword ptr [RBX]
LAB_00128f50:
MOV qword ptr [RBX],RAX
caseD_b:
POP RBX
POP R14
POP RBP
RET
|
void init_one_value(long param_1,ulong *param_2,ulong param_3)
{
ulong uVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
switch((uint)*(int8 *)(param_1 + 0x30) & 0x3f) {
case 2:
*(char *)param_2 = (char)param_3;
return;
case 3:
uVar2 = getopt_ll_limit_value((long)(int)param_3,param_1,0);
goto LAB_00128f3b;
case 4:
uVar2 = getopt_ull_limit_value(param_3 & 0xffffffff,param_1,0);
LAB_00128f3b:
*(int4 *)param_2 = uVar2;
return;
case 5:
case 7:
uVar3 = getopt_ll_limit_value(param_3,param_1,0);
break;
case 6:
case 8:
uVar3 = getopt_ull_limit_value(param_3,param_1,0);
break;
case 9:
if (param_3 == 0) {
return;
}
case 0xc:
case 0xd:
case 0xe:
case 0xf:
*param_2 = param_3;
return;
case 10:
if (param_3 == 0) {
return;
}
my_free(*param_2);
uVar3 = my_strdup(key_memory_defaults,param_3,0x10);
break;
default:
goto switchD_00128eaf_caseD_b;
case 0x10:
uVar1 = *(ulong *)(param_1 + 0x60);
uVar3 = -uVar1;
if (0 < (long)uVar1) {
uVar3 = uVar1;
}
uVar4 = (ulong)(param_3 == 0);
if (-1 < (long)uVar1) {
uVar4 = param_3;
}
if (uVar4 == 0) {
uVar3 = ~uVar3 & *param_2;
}
else {
uVar3 = uVar3 | *param_2;
}
}
*param_2 = uVar3;
switchD_00128eaf_caseD_b:
return;
}
|
|
9,647 |
uf_prespace
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
|
O3
|
c
|
uf_prespace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x832fc
subl %ecx, %r13d
leaq 0x5e62a(%rip), %rax # 0xe18f0
movq %rbx, -0x30(%rbp)
movl (%rax,%rcx,4), %ebx
andl (%r14), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
callq 0x81f1d
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %ebx, %eax
movq -0x30(%rbp), %rbx
jmp 0x83316
movl (%r14), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r14)
shrl %cl, %eax
movl 0x1c(%r15), %ecx
leaq 0x5e5dd(%rip), %rdx # 0xe18f0
andl (%rdx,%rcx,4), %eax
movl %eax, %edx
leaq (%r12,%rdx), %r13
cmpq %rbx, %r13
jbe 0x8332b
movl $0x1, 0x28(%r14)
jmp 0x8335c
movq %r12, %rdi
movl $0x20, %esi
callq 0x292c0
cmpq %rbx, %r13
je 0x8335c
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8280e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
uf_prespace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_832FC
sub r13d, ecx
lea rax, mask_0
mov [rbp+var_30], rbx
mov ebx, [rax+rcx*4]
and ebx, [r14]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, ebx
mov rbx, [rbp+var_30]
jmp short loc_83316
loc_832FC:
mov eax, [r14]
sub ecx, r13d
mov [r14+4], ecx
shr eax, cl
mov ecx, [r15+1Ch]
lea rdx, mask_0
and eax, [rdx+rcx*4]
loc_83316:
mov edx, eax
lea r13, [r12+rdx]
cmp r13, rbx
jbe short loc_8332B
mov dword ptr [r14+28h], 1
jmp short loc_8335C
loc_8332B:
mov rdi, r12
mov esi, 20h ; ' '
call _memset
cmp r13, rbx
jz short loc_8335C
mov rdi, r15
mov rsi, r14
mov rdx, r13
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
loc_8335C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long uf_prespace_0(long long a1, unsigned int *a2, long long a3, _BYTE *a4)
{
long long v6; // rcx
unsigned int v7; // r13d
int v8; // r13d
int v9; // ebx
long long result; // rax
unsigned int v11; // eax
unsigned int v12; // ecx
_BYTE *v13; // r13
_BYTE *v14; // [rsp+0h] [rbp-30h]
v6 = a2[1];
v7 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v6 >= v7 )
{
v11 = *a2;
v12 = v6 - v7;
a2[1] = v12;
result = mask_0[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v8 = v7 - v6;
v14 = a4;
v9 = (*a2 & mask_0[v6]) << v8;
fill_buffer_0((long long)a2);
a2[1] = 32 - v8;
result = v9 + (*a2 >> -(char)v8);
a4 = v14;
}
v13 = (_BYTE *)(a3 + (unsigned int)result);
if ( v13 <= a4 )
{
result = memset(a3, 32LL, (unsigned int)result);
if ( v13 != a4 )
return (long long)decode_bytes_0(a1, (long long)a2, v13, a4);
}
else
{
a2[10] = 1;
}
return result;
}
|
uf_prespace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x001832fc
SUB R13D,ECX
LEA RAX,[0x1e18f0]
MOV qword ptr [RBP + -0x30],RBX
MOV EBX,dword ptr [RAX + RCX*0x4]
AND EBX,dword ptr [R14]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
CALL 0x00181f1d
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,EBX
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00183316
LAB_001832fc:
MOV EAX,dword ptr [R14]
SUB ECX,R13D
MOV dword ptr [R14 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [R15 + 0x1c]
LEA RDX,[0x1e18f0]
AND EAX,dword ptr [RDX + RCX*0x4]
LAB_00183316:
MOV EDX,EAX
LEA R13,[R12 + RDX*0x1]
CMP R13,RBX
JBE 0x0018332b
MOV dword ptr [R14 + 0x28],0x1
JMP 0x0018335c
LAB_0018332b:
MOV RDI,R12
MOV ESI,0x20
CALL 0x001292c0
CMP R13,RBX
JZ 0x0018335c
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018280e
LAB_0018335c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
byte bVar6;
uVar5 = param_2[1];
uVar2 = *(uint *)(param_1 + 0x1c);
if (uVar5 < uVar2) {
uVar3 = (&mask)[uVar5];
uVar4 = *param_2;
bVar6 = (byte)(uVar2 - uVar5);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar5);
uVar5 = (*param_2 >> (-bVar6 & 0x1f)) + ((uVar3 & uVar4) << (bVar6 & 0x1f));
}
else {
param_2[1] = uVar5 - uVar2;
uVar5 = *param_2 >> ((byte)(uVar5 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar1 = (long)param_3 + (ulong)uVar5;
if (param_4 < uVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar5);
if (uVar1 != param_4) {
decode_bytes(param_1,param_2,uVar1,param_4);
return;
}
}
return;
}
|
|
9,648 |
my_fcvt
|
eloqsql/strings/dtoa.c
|
size_t my_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < DECIMAL_NOT_SPECIFIED && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MY_MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
}
|
O0
|
c
|
my_fcvt:
pushq %rbp
movq %rsp, %rbp
subq $0xee0, %rsp # imm = 0xEE0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movsd %xmm0, -0xe80(%rbp)
movl %edi, -0xe84(%rbp)
movq %rsi, -0xe90(%rbp)
movq %rdx, -0xe98(%rbp)
movq -0xe90(%rbp), %rax
movq %rax, -0xec8(%rbp)
jmp 0x146324
movsd -0xe80(%rbp), %xmm0
movl -0xe84(%rbp), %esi
leaq -0xe70(%rbp), %r9
movl $0x5, %edi
leaq -0xe9c(%rbp), %rdx
leaq -0xea0(%rbp), %rcx
leaq -0xec0(%rbp), %r8
movq $0xe60, (%rsp) # imm = 0xE60
callq 0x146690
movq %rax, -0xeb0(%rbp)
cmpl $0x270f, -0xe9c(%rbp) # imm = 0x270F
jne 0x1463d1
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x147ce0
movq -0xe90(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xe90(%rbp)
movb $0x30, (%rax)
movq -0xe90(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x1463c1
movq -0xe98(%rbp), %rax
movb $0x1, (%rax)
movq $0x1, -0xe78(%rbp)
jmp 0x146658
movq -0xeb0(%rbp), %rax
movq %rax, -0xeb8(%rbp)
movq -0xec0(%rbp), %rax
movq -0xeb8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xea4(%rbp)
cmpl $0x0, -0xea0(%rbp)
je 0x146417
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2d, (%rax)
cmpl $0x0, -0xe9c(%rbp)
jg 0x146490
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe9c(%rbp), %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jge 0x14648e
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x14645c
jmp 0x146490
movl $0x1, -0xea8(%rbp)
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jg 0x146520
movq -0xeb8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xeb8(%rbp)
movb (%rax), %cl
movq -0xec8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xec8(%rbp)
movb %cl, (%rax)
movl -0xea8(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jne 0x14650a
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jge 0x14650a
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
jmp 0x14650c
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x14649a
jmp 0x146522
movl -0xea8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xea8(%rbp)
cmpl -0xe9c(%rbp), %eax
jg 0x146555
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
jmp 0x146522
cmpl $0x0, -0xe84(%rbp)
jle 0x14660a
movl -0xea4(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jg 0x146588
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe84(%rbp), %eax
movl %eax, -0xecc(%rbp)
movl -0xea4(%rbp), %ecx
subl -0xe9c(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x1465b0
xorl %eax, %eax
movl %eax, -0xed0(%rbp)
jmp 0x1465c2
movl -0xea4(%rbp), %eax
subl -0xe9c(%rbp), %eax
movl %eax, -0xed0(%rbp)
movl -0xecc(%rbp), %eax
movl -0xed0(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jle 0x146608
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x1465d6
jmp 0x14660a
movq -0xec8(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x146628
movq -0xe98(%rbp), %rax
movb $0x0, (%rax)
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x147ce0
movq -0xec8(%rbp), %rax
movq -0xe90(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xe78(%rbp)
movq -0xe78(%rbp), %rax
movq %rax, -0xed8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x146688
movq -0xed8(%rbp), %rax
addq $0xee0, %rsp # imm = 0xEE0
popq %rbp
retq
callq 0x2a270
nopl (%rax)
|
my_fcvt:
push rbp
mov rbp, rsp
sub rsp, 0EE0h
mov rax, fs:28h
mov [rbp+var_8], rax
movsd [rbp+var_E80], xmm0
mov [rbp+var_E84], edi
mov [rbp+var_E90], rsi
mov [rbp+var_E98], rdx
mov rax, [rbp+var_E90]
mov [rbp+var_EC8], rax
jmp short $+2
loc_146324:
movsd xmm0, [rbp+var_E80]
mov esi, [rbp+var_E84]
lea r9, [rbp+var_E70]
mov edi, 5
lea rdx, [rbp+var_E9C]
lea rcx, [rbp+var_EA0]
lea r8, [rbp+var_EC0]
mov [rsp+0EE0h+var_EE0], 0E60h
call dtoa
mov [rbp+var_EB0], rax
cmp [rbp+var_E9C], 270Fh
jnz short loc_1463D1
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_E90]
mov rcx, rax
add rcx, 1
mov [rbp+var_E90], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_E90]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_1463C1
mov rax, [rbp+var_E98]
mov byte ptr [rax], 1
loc_1463C1:
mov [rbp+var_E78], 1
jmp loc_146658
loc_1463D1:
mov rax, [rbp+var_EB0]
mov [rbp+var_EB8], rax
mov rax, [rbp+var_EC0]
mov rcx, [rbp+var_EB8]
sub rax, rcx
mov [rbp+var_EA4], eax
cmp [rbp+var_EA0], 0
jz short loc_146417
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Dh ; '-'
loc_146417:
cmp [rbp+var_E9C], 0
jg short loc_146490
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_E9C]
mov [rbp+var_EA8], eax
loc_14645C:
cmp [rbp+var_EA8], 0
jge short loc_14648E
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp short loc_14645C
loc_14648E:
jmp short $+2
loc_146490:
mov [rbp+var_EA8], 1
loc_14649A:
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jg short loc_146520
mov rax, [rbp+var_EB8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EB8], rcx
mov cl, [rax]
mov rax, [rbp+var_EC8]
mov rdx, rax
add rdx, 1
mov [rbp+var_EC8], rdx
mov [rax], cl
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_E9C]
jnz short loc_14650A
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jge short loc_14650A
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_14650A:
jmp short $+2
loc_14650C:
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp loc_14649A
loc_146520:
jmp short $+2
loc_146522:
mov eax, [rbp+var_EA8]
mov ecx, eax
add ecx, 1
mov [rbp+var_EA8], ecx
cmp eax, [rbp+var_E9C]
jg short loc_146555
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
jmp short loc_146522
loc_146555:
cmp [rbp+var_E84], 0
jle loc_14660A
mov eax, [rbp+var_EA4]
cmp eax, [rbp+var_E9C]
jg short loc_146588
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_146588:
mov eax, [rbp+var_E84]
mov [rbp+var_ECC], eax
mov ecx, [rbp+var_EA4]
sub ecx, [rbp+var_E9C]
xor eax, eax
cmp eax, ecx
jle short loc_1465B0
xor eax, eax
mov [rbp+var_ED0], eax
jmp short loc_1465C2
loc_1465B0:
mov eax, [rbp+var_EA4]
sub eax, [rbp+var_E9C]
mov [rbp+var_ED0], eax
loc_1465C2:
mov eax, [rbp+var_ECC]
mov ecx, [rbp+var_ED0]
sub eax, ecx
mov [rbp+var_EA8], eax
loc_1465D6:
cmp [rbp+var_EA8], 0
jle short loc_146608
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 0FFFFFFFFh
mov [rbp+var_EA8], eax
jmp short loc_1465D6
loc_146608:
jmp short $+2
loc_14660A:
mov rax, [rbp+var_EC8]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_146628
mov rax, [rbp+var_E98]
mov byte ptr [rax], 0
loc_146628:
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_EC8]
mov rcx, [rbp+var_E90]
sub rax, rcx
mov [rbp+var_E78], rax
loc_146658:
mov rax, [rbp+var_E78]
mov [rbp+var_ED8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_146688
mov rax, [rbp+var_ED8]
add rsp, 0EE0h
pop rbp
retn
loc_146688:
call ___stack_chk_fail
|
long long my_fcvt(int a1, _BYTE *a2, _BYTE *a3, double a4)
{
_BYTE *v4; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
char *v7; // rax
char v8; // cl
_BYTE *v9; // rax
_BYTE *v10; // rax
int v11; // eax
_BYTE *v12; // rax
_BYTE *v13; // rax
_BYTE *v14; // rax
int v16; // [rsp+10h] [rbp-ED0h]
_BYTE *v17; // [rsp+18h] [rbp-EC8h]
long long v18; // [rsp+20h] [rbp-EC0h] BYREF
char *v19; // [rsp+28h] [rbp-EB8h]
long long v20; // [rsp+30h] [rbp-EB0h]
int i; // [rsp+38h] [rbp-EA8h]
int v22; // [rsp+3Ch] [rbp-EA4h]
int v23; // [rsp+40h] [rbp-EA0h] BYREF
int v24; // [rsp+44h] [rbp-E9Ch] BYREF
_BYTE *v25; // [rsp+48h] [rbp-E98h]
_BYTE *v26; // [rsp+50h] [rbp-E90h]
int v27; // [rsp+5Ch] [rbp-E84h]
double v28; // [rsp+60h] [rbp-E80h]
_BYTE v30[3688]; // [rsp+70h] [rbp-E70h] BYREF
unsigned long long v31; // [rsp+ED8h] [rbp-8h]
v31 = __readfsqword(0x28u);
v28 = a4;
v27 = a1;
v26 = a2;
v25 = a3;
v17 = a2;
v20 = dtoa(5, a1, (unsigned int)&v24, (unsigned int)&v23, (unsigned int)&v18, (unsigned int)v30, 3680LL);
if ( v24 == 9999 )
{
dtoa_free(v20, v30, 3680LL, a4);
v4 = v26++;
*v4 = 48;
*v26 = 0;
if ( v25 )
*v25 = 1;
return 1LL;
}
else
{
v19 = (char *)v20;
v22 = v18 - v20;
if ( v23 )
{
v17 = a2 + 1;
*a2 = 45;
}
if ( v24 <= 0 )
{
*v17 = 48;
v5 = v17 + 1;
v17 += 2;
*v5 = 46;
for ( i = v24; i < 0; ++i )
{
v6 = v17++;
*v6 = 48;
}
}
for ( i = 1; i <= v22; ++i )
{
v7 = v19++;
v8 = *v7;
v9 = v17++;
*v9 = v8;
if ( i == v24 && i < v22 )
{
v10 = v17++;
*v10 = 46;
}
}
while ( 1 )
{
v11 = i++;
if ( v11 > v24 )
break;
v12 = v17++;
*v12 = 48;
}
if ( v27 > 0 )
{
if ( v22 <= v24 )
{
v13 = v17++;
*v13 = 46;
}
if ( v22 - v24 >= 0 )
v16 = v22 - v24;
else
v16 = 0;
for ( i = v27 - v16; i > 0; --i )
{
v14 = v17++;
*v14 = 48;
}
}
*v17 = 0;
if ( v25 )
*v25 = 0;
dtoa_free(v20, v30, 3680LL, a4);
return v17 - v26;
}
}
| |||
9,649 |
my_fcvt
|
eloqsql/strings/dtoa.c
|
size_t my_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < DECIMAL_NOT_SPECIFIED && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MY_MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
}
|
O3
|
c
|
my_fcvt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe98, %rsp # imm = 0xE98
movq %rdx, -0xea8(%rbp)
movq %rsi, %r14
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xe94(%rbp), %r13
leaq -0xe9c(%rbp), %rcx
leaq -0xec0(%rbp), %r8
leaq -0xe90(%rbp), %rbx
movl $0x5, %edi
movl %esi, -0xe98(%rbp)
movq %r13, %rdx
movq %rbx, %r9
callq 0xd32b6
movq %rax, %r15
movl (%r13), %r12d
cmpl $0x270f, %r12d # imm = 0x270F
jne 0xd3123
cmpq %rbx, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0xd30ff
movq %r15, %rdi
callq 0x29160
movw $0x30, (%r14)
movl $0x1, %r13d
movq -0xea8(%rbp), %rax
testq %rax, %rax
je 0xd328d
movb $0x1, (%rax)
jmp 0xd328d
movq -0xec0(%rbp), %rbx
movq %r14, %rax
movl %ebx, %r14d
cmpl $0x0, -0xe9c(%rbp)
movq %rax, %r13
je 0xd3143
leaq 0x1(%rax), %r13
movb $0x2d, (%rax)
movq %rax, -0xeb8(%rbp)
subl %r15d, %r14d
testl %r12d, %r12d
movl -0xe98(%rbp), %r8d
jg 0xd319d
movw $0x2e30, (%r13) # imm = 0x2E30
leaq 0x2(%r13), %rdi
testl %r12d, %r12d
js 0xd316e
movq %rdi, %r13
jmp 0xd319d
movl %r12d, %eax
notl %eax
movq %rax, -0xeb0(%rbp)
leaq 0x1(%rax), %rdx
movl $0x30, %esi
callq 0x292c0
movl -0xe98(%rbp), %r8d
movq -0xeb0(%rbp), %rax
addq %rax, %r13
addq $0x3, %r13
testl %r14d, %r14d
jle 0xd31e4
subl %r15d, %ebx
incl %ebx
movl %r14d, %eax
xorl %ecx, %ecx
movq %r13, %rdx
leal 0x1(%rcx), %esi
movb (%r15,%rcx), %dil
incq %r13
movb %dil, (%rdx)
cmpl -0xe94(%rbp), %esi
jne 0xd31d4
cmpl %r14d, %esi
jge 0xd31d4
movb $0x2e, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %r13
incq %rcx
cmpl %ecx, %eax
jne 0xd31ac
movl -0xe94(%rbp), %r12d
jmp 0xd31e9
movl $0x1, %ebx
cmpl %r12d, %ebx
jg 0xd3206
decl %ebx
movb $0x30, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
incl %ebx
cmpl %r12d, %ebx
jl 0xd31f0
testl %r8d, %r8d
jle 0xd324c
cmpl %r14d, %r12d
jl 0xd321f
movb $0x2e, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
subl %r12d, %r14d
cmpl %r8d, %r14d
jge 0xd324c
xorl %ebx, %ebx
testl %r14d, %r14d
cmovgl %r14d, %ebx
notl %ebx
addl %r8d, %ebx
leaq 0x1(%rbx), %rdx
movq %r13, %rdi
movl $0x30, %esi
callq 0x292c0
addq %rbx, %r13
incq %r13
movb $0x0, (%r13)
movq -0xea8(%rbp), %rax
testq %rax, %rax
movq -0xeb8(%rbp), %rbx
je 0xd3267
movb $0x0, (%rax)
leaq -0xe90(%rbp), %rax
cmpq %rax, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0xd328a
movq %r15, %rdi
callq 0x29160
subq %rbx, %r13
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xd32b1
movq %r13, %rax
addq $0xe98, %rsp # imm = 0xE98
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
my_fcvt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E98h
mov [rbp+var_EA8], rdx
mov r14, rsi
mov esi, edi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_E94]
lea rcx, [rbp+var_E9C]
lea r8, [rbp+var_EC0]
lea rbx, [rbp+var_E90]
mov edi, 5
mov [rbp+var_E98], esi
mov rdx, r13
mov r9, rbx
call dtoa
mov r15, rax
mov r12d, [r13+0]
cmp r12d, 270Fh
jnz short loc_D3123
cmp r15, rbx
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_D30FF
mov rdi, r15
call _free
loc_D30FF:
mov word ptr [r14], 30h ; '0'
mov r13d, 1
mov rax, [rbp+var_EA8]
test rax, rax
jz loc_D328D
mov byte ptr [rax], 1
jmp loc_D328D
loc_D3123:
mov rbx, [rbp+var_EC0]
mov rax, r14
mov r14d, ebx
cmp [rbp+var_E9C], 0
mov r13, rax
jz short loc_D3143
lea r13, [rax+1]
mov byte ptr [rax], 2Dh ; '-'
loc_D3143:
mov [rbp+var_EB8], rax
sub r14d, r15d
test r12d, r12d
mov r8d, [rbp+var_E98]
jg short loc_D319D
mov word ptr [r13+0], 2E30h
lea rdi, [r13+2]
test r12d, r12d
js short loc_D316E
mov r13, rdi
jmp short loc_D319D
loc_D316E:
mov eax, r12d
not eax
mov [rbp+var_EB0], rax
lea rdx, [rax+1]
mov esi, 30h ; '0'
call _memset
mov r8d, [rbp+var_E98]
mov rax, [rbp+var_EB0]
add r13, rax
add r13, 3
loc_D319D:
test r14d, r14d
jle short loc_D31E4
sub ebx, r15d
inc ebx
mov eax, r14d
xor ecx, ecx
loc_D31AC:
mov rdx, r13
lea esi, [rcx+1]
mov dil, [r15+rcx]
inc r13
mov [rdx], dil
cmp esi, [rbp+var_E94]
jnz short loc_D31D4
cmp esi, r14d
jge short loc_D31D4
mov byte ptr [rdx+1], 2Eh ; '.'
add rdx, 2
mov r13, rdx
loc_D31D4:
inc rcx
cmp eax, ecx
jnz short loc_D31AC
mov r12d, [rbp+var_E94]
jmp short loc_D31E9
loc_D31E4:
mov ebx, 1
loc_D31E9:
cmp ebx, r12d
jg short loc_D3206
dec ebx
loc_D31F0:
mov byte ptr [r13+0], 30h ; '0'
inc r13
mov r12d, [rbp+var_E94]
inc ebx
cmp ebx, r12d
jl short loc_D31F0
loc_D3206:
test r8d, r8d
jle short loc_D324C
cmp r12d, r14d
jl short loc_D321F
mov byte ptr [r13+0], 2Eh ; '.'
inc r13
mov r12d, [rbp+var_E94]
loc_D321F:
sub r14d, r12d
cmp r14d, r8d
jge short loc_D324C
xor ebx, ebx
test r14d, r14d
cmovg ebx, r14d
not ebx
add ebx, r8d
lea rdx, [rbx+1]
mov rdi, r13
mov esi, 30h ; '0'
call _memset
add r13, rbx
inc r13
loc_D324C:
mov byte ptr [r13+0], 0
mov rax, [rbp+var_EA8]
test rax, rax
mov rbx, [rbp+var_EB8]
jz short loc_D3267
mov byte ptr [rax], 0
loc_D3267:
lea rax, [rbp+var_E90]
cmp r15, rax
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_D328A
mov rdi, r15
call _free
loc_D328A:
sub r13, rbx
loc_D328D:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_D32B1
mov rax, r13
add rsp, 0E98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D32B1:
call ___stack_chk_fail
|
_BYTE * my_fcvt(unsigned int a1, _WORD *a2, _BYTE *a3)
{
unsigned long long v3; // r15
int v4; // r12d
long long v5; // r13
int v6; // ebx
int v7; // r14d
_BYTE *v8; // r13
int v9; // r14d
int v10; // r8d
int v11; // ebx
long long v12; // rcx
_BYTE *v13; // rdx
int v14; // ebx
int v15; // r14d
int v16; // ebx
long long v17; // rbx
_WORD *v18; // rbx
long long v20; // [rsp+0h] [rbp-EC0h] BYREF
_WORD *v21; // [rsp+8h] [rbp-EB8h]
long long v22; // [rsp+10h] [rbp-EB0h]
_BYTE *v23; // [rsp+18h] [rbp-EA8h]
int v24; // [rsp+24h] [rbp-E9Ch] BYREF
int v25; // [rsp+28h] [rbp-E98h]
int v26; // [rsp+2Ch] [rbp-E94h] BYREF
_BYTE v27[3680]; // [rsp+30h] [rbp-E90h] BYREF
_QWORD v28[6]; // [rsp+E90h] [rbp-30h] BYREF
v23 = a3;
v28[0] = __readfsqword(0x28u);
v25 = a1;
v3 = dtoa(5LL, a1, &v26, &v24, &v20, v27);
v4 = v26;
if ( v26 == 9999 )
{
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
*a2 = 48;
v5 = 1LL;
if ( v23 )
*v23 = 1;
}
else
{
v6 = v20;
v7 = v20;
v8 = a2;
if ( v24 )
{
v8 = (char *)a2 + 1;
*(_BYTE *)a2 = 45;
}
v21 = a2;
v9 = v7 - v3;
v10 = v25;
if ( v4 <= 0 )
{
*(_WORD *)v8 = 11824;
if ( v4 < 0 )
{
v22 = (unsigned int)~v4;
memset(v8 + 2, 48LL, v22 + 1);
v10 = v25;
v8 += v22 + 3;
}
else
{
v8 += 2;
}
}
if ( v9 <= 0 )
{
v11 = 1;
}
else
{
v11 = v6 - v3 + 1;
v12 = 0LL;
do
{
v13 = v8++;
*v13 = *(_BYTE *)(v3 + v12);
if ( (_DWORD)v12 + 1 == v26 && (int)v12 + 1 < v9 )
{
v13[1] = 46;
v8 = v13 + 2;
}
++v12;
}
while ( v9 != (_DWORD)v12 );
v4 = v26;
}
if ( v11 <= v4 )
{
v14 = v11 - 1;
do
{
*v8++ = 48;
v4 = v26;
++v14;
}
while ( v14 < v26 );
}
if ( v10 > 0 )
{
if ( v4 >= v9 )
{
*v8++ = 46;
v4 = v26;
}
v15 = v9 - v4;
if ( v15 < v10 )
{
v16 = 0;
if ( v15 > 0 )
v16 = v15;
v17 = (unsigned int)(v10 + ~v16);
memset(v8, 48LL, v17 + 1);
v8 += v17 + 1;
}
}
*v8 = 0;
v18 = v21;
if ( v23 )
*v23 = 0;
if ( (unsigned long long)v28 <= v3 || v3 < (unsigned long long)v27 )
free(v3);
return (_BYTE *)(v8 - (_BYTE *)v18);
}
return (_BYTE *)v5;
}
|
my_fcvt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe98
MOV qword ptr [RBP + -0xea8],RDX
MOV R14,RSI
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0xe94]
LEA RCX,[RBP + -0xe9c]
LEA R8,[RBP + -0xec0]
LEA RBX,[RBP + -0xe90]
MOV EDI,0x5
MOV dword ptr [RBP + -0xe98],ESI
MOV RDX,R13
MOV R9,RBX
CALL 0x001d32b6
MOV R15,RAX
MOV R12D,dword ptr [R13]
CMP R12D,0x270f
JNZ 0x001d3123
CMP R15,RBX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x001d30ff
MOV RDI,R15
CALL 0x00129160
LAB_001d30ff:
MOV word ptr [R14],0x30
MOV R13D,0x1
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
JZ 0x001d328d
MOV byte ptr [RAX],0x1
JMP 0x001d328d
LAB_001d3123:
MOV RBX,qword ptr [RBP + -0xec0]
MOV RAX,R14
MOV R14D,EBX
CMP dword ptr [RBP + -0xe9c],0x0
MOV R13,RAX
JZ 0x001d3143
LEA R13,[RAX + 0x1]
MOV byte ptr [RAX],0x2d
LAB_001d3143:
MOV qword ptr [RBP + -0xeb8],RAX
SUB R14D,R15D
TEST R12D,R12D
MOV R8D,dword ptr [RBP + -0xe98]
JG 0x001d319d
MOV word ptr [R13],0x2e30
LEA RDI,[R13 + 0x2]
TEST R12D,R12D
JS 0x001d316e
MOV R13,RDI
JMP 0x001d319d
LAB_001d316e:
MOV EAX,R12D
NOT EAX
MOV qword ptr [RBP + -0xeb0],RAX
LEA RDX,[RAX + 0x1]
MOV ESI,0x30
CALL 0x001292c0
MOV R8D,dword ptr [RBP + -0xe98]
MOV RAX,qword ptr [RBP + -0xeb0]
ADD R13,RAX
ADD R13,0x3
LAB_001d319d:
TEST R14D,R14D
JLE 0x001d31e4
SUB EBX,R15D
INC EBX
MOV EAX,R14D
XOR ECX,ECX
LAB_001d31ac:
MOV RDX,R13
LEA ESI,[RCX + 0x1]
MOV DIL,byte ptr [R15 + RCX*0x1]
INC R13
MOV byte ptr [RDX],DIL
CMP ESI,dword ptr [RBP + -0xe94]
JNZ 0x001d31d4
CMP ESI,R14D
JGE 0x001d31d4
MOV byte ptr [RDX + 0x1],0x2e
ADD RDX,0x2
MOV R13,RDX
LAB_001d31d4:
INC RCX
CMP EAX,ECX
JNZ 0x001d31ac
MOV R12D,dword ptr [RBP + -0xe94]
JMP 0x001d31e9
LAB_001d31e4:
MOV EBX,0x1
LAB_001d31e9:
CMP EBX,R12D
JG 0x001d3206
DEC EBX
LAB_001d31f0:
MOV byte ptr [R13],0x30
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
INC EBX
CMP EBX,R12D
JL 0x001d31f0
LAB_001d3206:
TEST R8D,R8D
JLE 0x001d324c
CMP R12D,R14D
JL 0x001d321f
MOV byte ptr [R13],0x2e
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
LAB_001d321f:
SUB R14D,R12D
CMP R14D,R8D
JGE 0x001d324c
XOR EBX,EBX
TEST R14D,R14D
CMOVG EBX,R14D
NOT EBX
ADD EBX,R8D
LEA RDX,[RBX + 0x1]
MOV RDI,R13
MOV ESI,0x30
CALL 0x001292c0
ADD R13,RBX
INC R13
LAB_001d324c:
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
MOV RBX,qword ptr [RBP + -0xeb8]
JZ 0x001d3267
MOV byte ptr [RAX],0x0
LAB_001d3267:
LEA RAX,[RBP + -0xe90]
CMP R15,RAX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x001d328a
MOV RDI,R15
CALL 0x00129160
LAB_001d328a:
SUB R13,RBX
LAB_001d328d:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001d32b1
MOV RAX,R13
ADD RSP,0xe98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d32b1:
CALL 0x00129270
|
long my_fcvt(int param_1,int2 *param_2,int1 *param_3)
{
long *__ptr;
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
int2 *puVar5;
int2 *__s;
int iVar6;
long in_FS_OFFSET;
int local_ec8 [2];
int2 *local_ec0;
ulong local_eb8;
int1 *local_eb0;
int local_ea4;
int local_ea0;
uint local_e9c;
long local_e98 [460];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_eb0 = param_3;
local_ea0 = param_1;
__ptr = (long *)dtoa(5,param_1,&local_e9c,&local_ea4,local_ec8,local_e98);
uVar3 = local_e9c;
if (local_e9c == 9999) {
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
*param_2 = 0x30;
lVar4 = 1;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 1;
}
}
else {
puVar5 = param_2;
if (local_ea4 != 0) {
puVar5 = (int2 *)((long)param_2 + 1);
*(int1 *)param_2 = 0x2d;
}
iVar6 = local_ec8[0] - (int)__ptr;
__s = puVar5;
local_ec0 = param_2;
if ((int)local_e9c < 1) {
*puVar5 = 0x2e30;
__s = puVar5 + 1;
if ((int)local_e9c < 0) {
local_eb8 = (ulong)~local_e9c;
memset(__s,0x30,local_eb8 + 1);
__s = (int2 *)((long)puVar5 + local_eb8 + 3);
}
}
if (iVar6 < 1) {
iVar1 = 1;
}
else {
iVar1 = (local_ec8[0] - (int)__ptr) + 1;
lVar4 = 0;
puVar5 = __s;
do {
uVar3 = (int)lVar4 + 1;
__s = (int2 *)((long)puVar5 + 1);
*(int1 *)puVar5 = *(int1 *)((long)__ptr + lVar4);
if ((uVar3 == local_e9c) && ((int)uVar3 < iVar6)) {
*(int1 *)((long)puVar5 + 1) = 0x2e;
__s = puVar5 + 1;
}
lVar4 = lVar4 + 1;
puVar5 = __s;
uVar3 = local_e9c;
} while (iVar6 != (int)lVar4);
}
if (iVar1 <= (int)uVar3) {
iVar1 = iVar1 + -1;
do {
*(int1 *)__s = 0x30;
__s = (int2 *)((long)__s + 1);
iVar1 = iVar1 + 1;
uVar3 = local_e9c;
} while (iVar1 < (int)local_e9c);
}
if (0 < local_ea0) {
if (iVar6 <= (int)uVar3) {
*(int1 *)__s = 0x2e;
__s = (int2 *)((long)__s + 1);
uVar3 = local_e9c;
}
uVar3 = iVar6 - uVar3;
if ((int)uVar3 < local_ea0) {
uVar2 = 0;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
uVar3 = ~uVar2 + local_ea0;
memset(__s,0x30,(ulong)uVar3 + 1);
__s = (int2 *)((long)__s + (ulong)uVar3 + 1);
}
}
puVar5 = local_ec0;
*(int1 *)__s = 0;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 0;
}
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
lVar4 = (long)__s - (long)puVar5;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
|
|
9,650 |
LefDefParser::defiFill::Init()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiFill.cpp
|
void defiFill::Init() {
numPolys_ = 0;
numPts_ = 0;
clear();
layerNameLength_ = 0;
xl_ = (int*)malloc(sizeof(int)*1);
yl_ = (int*)malloc(sizeof(int)*1);
xh_ = (int*)malloc(sizeof(int)*1);
yh_ = (int*)malloc(sizeof(int)*1);
rectsAllocated_ = 1; // At least 1 rectangle will define
polysAllocated_ = 0;
polygons_ = 0;
layerName_ = 0;
viaName_ = 0;
viaNameLength_ = 0;
viaPts_ = 0;
ptsAllocated_ = 0;
viaPts_ = 0;
}
|
O3
|
cpp
|
LefDefParser::defiFill::Init():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl %r14d, 0x40(%rdi)
movl %r14d, (%rdi)
movl %r14d, 0x50(%rdi)
movl %r14d, 0x70(%rdi)
movl $0x4, %edi
callq 0x7270
movq %rax, 0x20(%rbx)
movl $0x4, %edi
callq 0x7270
movq %rax, 0x28(%rbx)
movl $0x4, %edi
callq 0x7270
movq %rax, 0x30(%rbx)
movl $0x4, %edi
callq 0x7270
movq %rax, 0x38(%rbx)
movaps 0x20f6c(%rip), %xmm0 # 0x4b750
movups %xmm0, 0x10(%rbx)
movl %r14d, 0x44(%rbx)
movq %r14, 0x48(%rbx)
movq %r14, 0x8(%rbx)
movq %r14, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq %r14, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN12LefDefParser8defiFill4InitEv:
push r14
push rbx
push rax
mov rbx, rdi
xor r14d, r14d
mov [rdi+40h], r14d
mov [rdi], r14d
mov [rdi+50h], r14d
mov [rdi+70h], r14d
mov edi, 4
call _malloc
mov [rbx+20h], rax
mov edi, 4
call _malloc
mov [rbx+28h], rax
mov edi, 4
call _malloc
mov [rbx+30h], rax
mov edi, 4
call _malloc
mov [rbx+38h], rax
movaps xmm0, cs:xmmword_4B750
movups xmmword ptr [rbx+10h], xmm0
mov [rbx+44h], r14d
mov [rbx+48h], r14
mov [rbx+8], r14
mov [rbx+58h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+60h], xmm0
mov [rbx+78h], r14
add rsp, 8
pop rbx
pop r14
retn
|
long long LefDefParser::defiFill::Init(LefDefParser::defiFill *this)
{
long long result; // rax
*((_DWORD *)this + 16) = 0;
*(_DWORD *)this = 0;
*((_DWORD *)this + 20) = 0;
*((_DWORD *)this + 28) = 0;
*((_QWORD *)this + 4) = malloc(4uLL);
*((_QWORD *)this + 5) = malloc(4uLL);
*((_QWORD *)this + 6) = malloc(4uLL);
result = malloc(4uLL);
*((_QWORD *)this + 7) = result;
*((_OWORD *)this + 1) = xmmword_4B750;
*((_DWORD *)this + 17) = 0;
*((_QWORD *)this + 9) = 0LL;
*((_QWORD *)this + 1) = 0LL;
*((_QWORD *)this + 11) = 0LL;
*((_OWORD *)this + 6) = 0LL;
*((_QWORD *)this + 15) = 0LL;
return result;
}
|
Init:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR R14D,R14D
MOV dword ptr [RDI + 0x40],R14D
MOV dword ptr [RDI],R14D
MOV dword ptr [RDI + 0x50],R14D
MOV dword ptr [RDI + 0x70],R14D
MOV EDI,0x4
CALL 0x00107270
MOV qword ptr [RBX + 0x20],RAX
MOV EDI,0x4
CALL 0x00107270
MOV qword ptr [RBX + 0x28],RAX
MOV EDI,0x4
CALL 0x00107270
MOV qword ptr [RBX + 0x30],RAX
MOV EDI,0x4
CALL 0x00107270
MOV qword ptr [RBX + 0x38],RAX
MOVAPS XMM0,xmmword ptr [0x0014b750]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV dword ptr [RBX + 0x44],R14D
MOV qword ptr [RBX + 0x48],R14
MOV qword ptr [RBX + 0x8],R14
MOV qword ptr [RBX + 0x58],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x60],XMM0
MOV qword ptr [RBX + 0x78],R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* LefDefParser::defiFill::Init() */
void __thiscall LefDefParser::defiFill::Init(defiFill *this)
{
int8 uVar1;
void *pvVar2;
*(int4 *)(this + 0x40) = 0;
*(int4 *)this = 0;
*(int4 *)(this + 0x50) = 0;
*(int4 *)(this + 0x70) = 0;
pvVar2 = malloc(4);
*(void **)(this + 0x20) = pvVar2;
pvVar2 = malloc(4);
*(void **)(this + 0x28) = pvVar2;
pvVar2 = malloc(4);
*(void **)(this + 0x30) = pvVar2;
pvVar2 = malloc(4);
*(void **)(this + 0x38) = pvVar2;
uVar1 = _UNK_0014b758;
*(int8 *)(this + 0x10) = _DAT_0014b750;
*(int8 *)(this + 0x18) = uVar1;
*(int4 *)(this + 0x44) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x78) = 0;
return;
}
|
|
9,651 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object()
|
zkingston[P]unknot/build_O0/_deps/json-src/include/nlohmann/detail/input/json_sax.hpp
|
bool end_object()
{
if (ref_stack.back())
{
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
else
{
ref_stack.back()->set_parents();
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
{
// remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
{
if (it->is_discarded())
{
ref_stack.back()->erase(it);
break;
}
}
}
return true;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object():
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0x80ba0
cmpq $0x0, (%rax)
je 0x7fa98
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x806e0
movq 0x18(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0x80ba0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq (%rax), %rcx
movl $0x1, %edx
callq 0x80680
testb $0x1, %al
jne 0x7fa80
movq 0x18(%rsp), %rsi
addq $0xa8, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x64fd0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x7b380
leaq 0xa0(%rsp), %rdi
callq 0x5f190
jmp 0x7fa96
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rdi
callq 0x62a40
jmp 0x7fa98
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x818a0
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x80660
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ef0
testb $0x1, %al
jne 0x7fbbf
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
cmpq $0x0, (%rax)
je 0x7fbbf
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rdi
callq 0x818c0
testb $0x1, %al
jne 0x7fb01
jmp 0x7fbbf
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rsi
leaq 0x80(%rsp), %rdi
callq 0x75ad0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rsi
leaq 0x60(%rsp), %rdi
callq 0x75b10
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x75b50
testb $0x1, %al
jne 0x7fb52
jmp 0x7fbbd
leaq 0x80(%rsp), %rdi
callq 0x81900
movq %rax, %rdi
callq 0x7b400
testb $0x1, %al
jne 0x7fb6d
jmp 0x7fba9
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x80ba0
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x81fc0
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x81a70
jmp 0x7fbbd
jmp 0x7fbab
leaq 0x80(%rsp), %rdi
callq 0x75fc0
jmp 0x7fb1f
jmp 0x7fbbf
movb $0x1, %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10end_objectEv:
sub rsp, 0B8h
mov qword ptr [rsp+0B8h+var_8], rdi; int
mov rdi, qword ptr [rsp+0B8h+var_8]
mov qword ptr [rsp+0B8h+var_A0], rdi; int
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_7FA98
mov rdi, qword ptr [rsp+0B8h+var_A0]
mov rax, rdi
add rax, 80h
mov [rsp+0B8h+var_B0], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; 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::allocator<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> *>>::size(void)
mov rdi, qword ptr [rsp+0B8h+var_A0]
sub eax, 1
mov [rsp+0B8h+var_A4], eax
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rsp+0B8h+var_B0]
mov esi, [rsp+0B8h+var_A4]
mov rcx, [rax]
mov edx, 1
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
test al, 1
jnz short loc_7FA80
mov rsi, qword ptr [rsp+0B8h+var_A0]
add rsi, 0A8h
lea rdi, [rsp+0B8h+var_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(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&)
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
lea rsi, [rsp+0B8h+var_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; 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>::operator=(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>)
lea rdi, [rsp+0B8h+var_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_7FA96
loc_7FA80:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
loc_7FA96:
jmp short $+2
loc_7FA98:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; 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::allocator<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> *>>::pop_back(void)
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; 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::allocator<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> *>>::empty(void)
test al, 1
jnz loc_7FBBF
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_7FBBF
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE13is_structuredEv; 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>::is_structured(void)
test al, 1
jnz short loc_7FB01
jmp loc_7FBBF
loc_7FB01:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rsi, [rax]
lea rdi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5beginEv; 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>::begin(void)
loc_7FB1F:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rsi, [rax]
lea rdi, [rsp+0B8h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
lea rdi, [rsp+0B8h+var_38]; int
lea rsi, [rsp+0B8h+var_58]; void *
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
test al, 1
jnz short loc_7FB52
jmp short loc_7FBBD
loc_7FB52:
lea rdi, [rsp+0B8h+var_38]; int
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator->(void)
mov rdi, rax
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12is_discardedEv; 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>::is_discarded(void)
test al, 1
jnz short loc_7FB6D
jmp short loc_7FBA9
loc_7FB6D:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rax, [rax]
mov [rsp+0B8h+var_B8], rax; void *
lea rdi, [rsp+0B8h+var_78]
lea rsi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERKSG_; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::iter_impl(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
mov rsi, [rsp+0B8h+var_B8]
lea rdi, [rsp+0B8h+var_98]; int
lea rdx, [rsp+0B8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
jmp short loc_7FBBD
loc_7FBA9:
jmp short $+2
loc_7FBAB:
lea rdi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator++(void)
jmp loc_7FB1F
loc_7FBBD:
jmp short $+2
loc_7FBBF:
mov al, 1
and al, 1
add rsp, 0B8h
retn
|
end_object:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV RDI,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x8
CALL 0x00180ba0
CMP qword ptr [RAX],0x0
JZ 0x0017fa98
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x8
CALL 0x001806e0
MOV RDI,qword ptr [RSP + 0x18]
SUB EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
ADD RDI,0x8
CALL 0x00180ba0
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RAX]
MOV EDX,0x1
CALL 0x00180680
TEST AL,0x1
JNZ 0x0017fa80
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,0xa8
LEA RDI,[RSP + 0xa0]
CALL 0x00164fd0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0xa0]
CALL 0x0017b380
LEA RDI,[RSP + 0xa0]
CALL 0x0015f190
JMP 0x0017fa96
LAB_0017fa80:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RDI,qword ptr [RAX]
CALL 0x00162a40
LAB_0017fa96:
JMP 0x0017fa98
LAB_0017fa98:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001818a0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x20
CALL 0x00180660
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ef0
TEST AL,0x1
JNZ 0x0017fbbf
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
CMP qword ptr [RAX],0x0
JZ 0x0017fbbf
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RDI,qword ptr [RAX]
CALL 0x001818c0
TEST AL,0x1
JNZ 0x0017fb01
JMP 0x0017fbbf
LAB_0017fb01:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RSI,qword ptr [RAX]
LEA RDI,[RSP + 0x80]
CALL 0x00175ad0
LAB_0017fb1f:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RSI,qword ptr [RAX]
LEA RDI,[RSP + 0x60]
CALL 0x00175b10
LEA RDI,[RSP + 0x80]
LEA RSI,[RSP + 0x60]
CALL 0x00175b50
TEST AL,0x1
JNZ 0x0017fb52
JMP 0x0017fbbd
LAB_0017fb52:
LEA RDI,[RSP + 0x80]
CALL 0x00181900
MOV RDI,RAX
CALL 0x0017b400
TEST AL,0x1
JNZ 0x0017fb6d
JMP 0x0017fba9
LAB_0017fb6d:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x00180ba0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x40]
LEA RSI,[RSP + 0x80]
CALL 0x00181fc0
MOV RSI,qword ptr [RSP]
LEA RDI,[RSP + 0x20]
LEA RDX,[RSP + 0x40]
CALL 0x00181a70
JMP 0x0017fbbd
LAB_0017fba9:
JMP 0x0017fbab
LAB_0017fbab:
LEA RDI,[RSP + 0x80]
CALL 0x00175fc0
JMP 0x0017fb1f
LAB_0017fbbd:
JMP 0x0017fbbf
LAB_0017fbbf:
MOV AL,0x1
AND AL,0x1
ADD RSP,0xb8
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_object() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_object(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
int8 uVar1;
int iVar2;
long *plVar3;
int8 *puVar4;
ulong uVar5;
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_00;
int1 local_98 [32];
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
local_78 [32];
int1 local_58 [32];
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
local_38 [32];
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_18 [16];
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*local_8;
local_8 = this;
plVar3 = (long *)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>*>>
::back((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>*>>
*)(this + 8));
if (*plVar3 != 0) {
iVar2 = 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>*>>
::size((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>*>>
*)(this + 8));
puVar4 = (int8 *)
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>*>>
::back((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>*>>
*)(this + 8));
uVar5 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),iVar2 + -1,1,*puVar4);
if ((uVar5 & 1) == 0) {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_18,this + 0xa8);
puVar4 = (int8 *)
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>*>>
::back((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>*>>
*)(this + 8));
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>
*)*puVar4,local_18);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_18);
}
else {
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>*>>
::back((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>*>>
*)(this + 8));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::set_parents();
}
}
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>*>>
::pop_back((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>*>>
*)(this + 8));
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
uVar5 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((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>*>>
*)(this + 8));
if (((uVar5 & 1) == 0) &&
(plVar3 = (long *)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>*>>
::back((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>*>>
*)(this + 8)), *plVar3 != 0)) {
puVar4 = (int8 *)
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>*>>
::back((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>*>>
*)(this + 8));
uVar5 = 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>
::is_structured((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>
*)*puVar4);
if ((uVar5 & 1) != 0) {
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>*>>
::back((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>*>>
*)(this + 8));
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>
::begin();
while( true ) {
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>*>>
::back((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>*>>
*)(this + 8));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end();
uVar5 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(local_38,local_58);
if ((uVar5 & 1) == 0) break;
this_00 = (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>
*)iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(local_38);
uVar5 = 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>
::is_discarded(this_00);
if ((uVar5 & 1) != 0) {
puVar4 = (int8 *)
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>*>>
::back((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>*>>
*)(this + 8));
uVar1 = *puVar4;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::iter_impl(local_78,(iter_impl *)local_38);
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(local_98,uVar1,local_78);
return 1;
}
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(local_38);
}
}
}
return 1;
}
|
||
9,652 |
mysql_stmt_fetch@libmariadbclient_18
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
}
|
O0
|
c
|
mysql_stmt_fetch@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x50(%rax)
ja 0x36c57
jmp 0x36be8
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x2c498(%rip), %rax # 0x630a0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x172e0
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x2c47e(%rip), %rax # 0x630b0
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x172e0
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x36e25
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jb 0x36c6b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x36cdc
jmp 0x36c6d
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x2c413(%rip), %rax # 0x630a0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x172e0
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x2c3f9(%rip), %rax # 0x630b0
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x172e0
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x36e25
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jne 0x36cf7
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x36cf9
movq -0x10(%rbp), %rax
cmpl $0x6, 0x50(%rax)
jne 0x36d0f
movl $0x64, -0x4(%rbp)
jmp 0x36e25
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x36d5c
movq -0x10(%rbp), %rax
movl $0x6, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x488(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36e25
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x1be1c(%rip), %rsi # 0x52bcb
callq 0x17540
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x36deb
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x36ded
jmp 0x36def
movq -0x10(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x1bdbc(%rip), %rsi # 0x52bcb
callq 0x17540
movq -0x10(%rbp), %rax
movb $0x0, 0x10c(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
|
mysql_stmt_fetch@libmariadbclient_18:
push rbp; Alternative name is 'mysql_stmt_fetch'
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 2
ja short loc_36C57
jmp short $+2
loc_36BE8:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_36E25
loc_36C57:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jb short loc_36C6B
mov rax, [rbp+var_10]
cmp dword ptr [rax+60h], 0
jnz short loc_36CDC
loc_36C6B:
jmp short $+2
loc_36C6D:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_36E25
loc_36CDC:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jnz short loc_36CF7
mov rax, [rbp+var_10]
mov rax, [rax+358h]
mov rdi, [rbp+var_10]
call rax
loc_36CF7:
jmp short $+2
loc_36CF9:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 6
jnz short loc_36D0F
mov [rbp+var_4], 64h ; 'd'
jmp loc_36E25
loc_36D0F:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+68h]
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
cmp eax, 0
jz short loc_36D5C
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 6
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+488h], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp loc_36E25
loc_36D5C:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 5
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
mov rax, [rax+38h]
cmp qword ptr [rax+2A0h], 0
jz short loc_36DEB
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_36DEB:
jmp short $+2
loc_36DED:
jmp short $+2
loc_36DEF:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 0
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+10Ch], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_36E25:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long mysql_stmt_fetch_libmariadbclient_18(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-1Ch]
unsigned int v3; // [rsp+4h] [rbp-1Ch]
long long v4; // [rsp+8h] [rbp-18h] BYREF
long long v5; // [rsp+10h] [rbp-10h]
v5 = a1;
if ( *(_DWORD *)(a1 + 80) > 2u && *(_DWORD *)(v5 + 80) >= 3u && *(_DWORD *)(v5 + 96) )
{
if ( *(_DWORD *)(v5 + 80) == 3 )
(*(void ( **)(long long))(v5 + 856))(v5);
if ( *(_DWORD *)(v5 + 80) == 6 )
{
return 100;
}
else
{
v2 = (*(long long ( **)(long long, long long *))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 104LL))(v5, &v4);
if ( v2 )
{
*(_DWORD *)(v5 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 1160LL) = 0;
return v2;
}
else
{
v3 = (*(long long ( **)(long long, long long))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 112LL))(v5, v4);
*(_DWORD *)(v5 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 144LL) = 0;
strcpy(*(_QWORD *)(v5 + 56) + 663LL, "00000");
*(_BYTE *)(*(_QWORD *)(v5 + 56) + 151LL) = 0;
if ( *(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) )
*(_DWORD *)(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) + 4LL) = 0;
*(_DWORD *)(v5 + 264) = 0;
strcpy(v5 + 781, "00000");
*(_BYTE *)(v5 + 268) = 0;
return v3;
}
}
}
else
{
*(_DWORD *)(v5 + 264) = 2014;
strncpy(v5 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v5 + 786) = 0;
strncpy(v5 + 268, client_errors[14], 512LL);
*(_BYTE *)(v5 + 779) = 0;
return 1;
}
}
|
mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x2
JA 0x00136c57
JMP 0x00136be8
LAB_00136be8:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x1630a0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x1630b0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00136e25
LAB_00136c57:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JC 0x00136c6b
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x60],0x0
JNZ 0x00136cdc
LAB_00136c6b:
JMP 0x00136c6d
LAB_00136c6d:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x1630a0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x1630b0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x001172e0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00136e25
LAB_00136cdc:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JNZ 0x00136cf7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x358]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
LAB_00136cf7:
JMP 0x00136cf9
LAB_00136cf9:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x6
JNZ 0x00136d0f
MOV dword ptr [RBP + -0x4],0x64
JMP 0x00136e25
LAB_00136d0f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x68]
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JZ 0x00136d5c
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x6
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136e25
LAB_00136d5c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x5
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RSI,[0x152bcb]
CALL 0x00117540
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x00136deb
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_00136deb:
JMP 0x00136ded
LAB_00136ded:
JMP 0x00136def
LAB_00136def:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RSI,[0x152bcb]
CALL 0x00117540
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x10c],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00136e25:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mysql_stmt_fetch(long param_1)
{
int iVar1;
int8 local_20;
long local_18;
int local_c;
local_18 = param_1;
if (*(uint *)(param_1 + 0x50) < 3) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_00163120,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else if ((*(uint *)(param_1 + 0x50) < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_00163120,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
}
if (*(int *)(local_18 + 0x50) == 6) {
local_c = 100;
}
else {
local_c = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x68))
(local_18,&local_20);
if (local_c == 0) {
iVar1 = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x70))
(local_18,local_20);
*(int4 *)(local_18 + 0x50) = 5;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x90) = 0;
strcpy((char *)(*(long *)(local_18 + 0x38) + 0x297),"00000");
*(int1 *)(*(long *)(local_18 + 0x38) + 0x97) = 0;
if (*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) != 0) {
*(int4 *)(*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) + 4) = 0;
}
*(int4 *)(local_18 + 0x108) = 0;
strcpy((char *)(local_18 + 0x30d),"00000");
*(int1 *)(local_18 + 0x10c) = 0;
local_c = iVar1;
}
else {
*(int4 *)(local_18 + 0x50) = 6;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x488) = 0;
}
}
}
return local_c;
}
|
|
9,653 |
mysql_stmt_fetch@libmariadbclient_18
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
}
|
O3
|
c
|
mysql_stmt_fetch@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %ecx
cmpl $0x2, %ecx
jbe 0x29312
cmpl $0x0, 0x60(%rbx)
je 0x29312
cmpl $0x3, %ecx
jne 0x292d4
movq %rbx, %rdi
callq *0x358(%rbx)
movl 0x50(%rbx), %ecx
movl $0x64, %eax
cmpl $0x6, %ecx
je 0x29369
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x68(%rax)
testl %eax, %eax
je 0x29372
movl $0x6, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x488(%rcx)
jmp 0x29369
movl $0x7de, 0x108(%rbx) # imm = 0x7DE
leaq 0x30d(%rbx), %rdi
leaq 0x22a26(%rip), %rax # 0x4bd50
movq (%rax), %rsi
movl $0x5, %edx
callq 0x172d0
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x22a11(%rip), %rax # 0x4bd60
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x172d0
movb %r14b, 0x30b(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x70(%rax)
movl $0x5, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x90(%rcx)
movq 0x38(%rbx), %rcx
movl $0x30303030, 0x297(%rcx) # imm = 0x30303030
movw $0x30, 0x29b(%rcx)
movq 0x38(%rbx), %rcx
movb $0x0, 0x97(%rcx)
movq 0x38(%rbx), %rcx
movq 0x2a0(%rcx), %rcx
testq %rcx, %rcx
je 0x293d5
movl $0x0, 0x4(%rcx)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
jmp 0x29369
|
mysql_stmt_fetch@libmariadbclient_18:
push rbp; Alternative name is 'mysql_stmt_fetch'
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov ecx, [rdi+50h]
cmp ecx, 2
jbe short loc_29312
cmp dword ptr [rbx+60h], 0
jz short loc_29312
cmp ecx, 3
jnz short loc_292D4
mov rdi, rbx
call qword ptr [rbx+358h]
mov ecx, [rbx+50h]
loc_292D4:
mov eax, 64h ; 'd'
cmp ecx, 6
jz loc_29369
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
lea rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+68h]
test eax, eax
jz short loc_29372
mov dword ptr [rbx+50h], 6
mov rcx, [rbx+38h]
mov dword ptr [rcx+488h], 0
jmp short loc_29369
loc_29312:
mov dword ptr [rbx+108h], 7DEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov eax, 1
loc_29369:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_29372:
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
mov rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+70h]
mov dword ptr [rbx+50h], 5
mov rcx, [rbx+38h]
mov dword ptr [rcx+90h], 0
mov rcx, [rbx+38h]
mov dword ptr [rcx+297h], 30303030h
mov word ptr [rcx+29Bh], 30h ; '0'
mov rcx, [rbx+38h]
mov byte ptr [rcx+97h], 0
mov rcx, [rbx+38h]
mov rcx, [rcx+2A0h]
test rcx, rcx
jz short loc_293D5
mov dword ptr [rcx+4], 0
loc_293D5:
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
jmp loc_29369
|
long long mysql_stmt_fetch_libmariadbclient_18(long long a1)
{
unsigned int v1; // ecx
long long result; // rax
long long v3; // rcx
_QWORD v4[3]; // [rsp+8h] [rbp-18h] BYREF
v1 = *(_DWORD *)(a1 + 80);
if ( v1 > 2 && *(_DWORD *)(a1 + 96) )
{
if ( v1 == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
v1 = *(_DWORD *)(a1 + 80);
}
result = 100LL;
if ( v1 != 6 )
{
result = (*(long long ( **)(long long, _QWORD *))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 104LL))(
a1,
v4);
if ( (_DWORD)result )
{
*(_DWORD *)(a1 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
}
else
{
result = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 112LL))(
a1,
v4[0]);
*(_DWORD *)(a1 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v3 )
*(_DWORD *)(v3 + 4) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
}
}
}
else
{
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1LL;
}
return result;
}
|
mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV ECX,dword ptr [RDI + 0x50]
CMP ECX,0x2
JBE 0x00129312
CMP dword ptr [RBX + 0x60],0x0
JZ 0x00129312
CMP ECX,0x3
JNZ 0x001292d4
MOV RDI,RBX
CALL qword ptr [RBX + 0x358]
MOV ECX,dword ptr [RBX + 0x50]
LAB_001292d4:
MOV EAX,0x64
CMP ECX,0x6
JZ 0x00129369
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
LEA RSI,[RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x68]
TEST EAX,EAX
JZ 0x00129372
MOV dword ptr [RBX + 0x50],0x6
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x488],0x0
JMP 0x00129369
LAB_00129312:
MOV dword ptr [RBX + 0x108],0x7de
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x14bd50]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x001172d0
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x14bd60]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x001172d0
MOV byte ptr [RBX + 0x30b],R14B
MOV EAX,0x1
LAB_00129369:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_00129372:
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x70]
MOV dword ptr [RBX + 0x50],0x5
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x90],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x297],0x30303030
MOV word ptr [RCX + 0x29b],0x30
MOV RCX,qword ptr [RBX + 0x38]
MOV byte ptr [RCX + 0x97],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RCX + 0x2a0]
TEST RCX,RCX
JZ 0x001293d5
MOV dword ptr [RCX + 0x4],0x0
LAB_001293d5:
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
JMP 0x00129369
|
int8 mysql_stmt_fetch(long param_1)
{
long lVar1;
int8 uVar2;
uint uVar3;
int8 local_20;
uVar3 = *(uint *)(param_1 + 0x50);
if ((uVar3 < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_0014bdd0,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar2 = 1;
}
else {
if (uVar3 == 3) {
(**(code **)(param_1 + 0x358))(param_1);
uVar3 = *(uint *)(param_1 + 0x50);
}
uVar2 = 100;
if (uVar3 != 6) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x68))(param_1,&local_20);
if ((int)uVar2 == 0) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x70))(param_1,local_20)
;
*(int4 *)(param_1 + 0x50) = 5;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
}
else {
*(int4 *)(param_1 + 0x50) = 6;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
}
}
}
return uVar2;
}
|
|
9,654 |
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O0
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x4c(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x10(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x3ef58
movl 0x10(%rbp), %eax
orl $0xf, %eax
movl %eax, 0x10(%rbp)
jmp 0x3ef5a
movl -0x4c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl 0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x3efcd
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x4c(%rbp)
je 0x3efc8
movl -0x4c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4c(%rbp)
cmpl $0x0, %eax
jne 0x3efab
movq -0x48(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x3efb6
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x3f227
movslq -0x4c(%rbp), %rcx
leaq 0x18e6b8(%rip), %rax # 0x1cd690
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3f001
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3ef6a
cmpl $0x2, -0x34(%rbp)
jne 0x3f10d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq %eax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x99(%rbp)
jge 0x3f060
movslq -0x4c(%rbp), %rcx
leaq 0x18e64b(%rip), %rax # 0x1cd690
movq (%rax,%rcx,8), %rax
movq -0x70(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
sete %al
movb %al, -0x99(%rbp)
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x3f06c
jmp 0x3f07a
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x3f01b
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x3f099
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x2, -0x4c(%rbp)
jg 0x3f0be
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3f0be
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x3f0da
jmp 0x3ef6a
cmpl $0x1, -0x4c(%rbp)
jle 0x3f0e5
jmp 0x3f227
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3f227
cmpl $0xff, -0x34(%rbp)
jne 0x3f21b
movl $0x0, -0x74(%rbp)
cmpl $0x50, -0x74(%rbp)
jge 0x3f219
movslq -0x74(%rbp), %rcx
leaq 0x18e57a(%rip), %rax # 0x1cd6b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3f1c6
movq -0x88(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq -0x30(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x3f1a1
movq -0x88(%rbp), %rax
movsbl (%rax), %eax
movq -0x80(%rbp), %rcx
movslq -0x8c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3f1a3
jmp 0x3f1c6
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x3f159
movq -0x80(%rbp), %rax
movslq -0x8c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x3f209
movslq -0x74(%rbp), %rcx
leaq 0x18e4ce(%rip), %rax # 0x1cd6b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x4c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x88(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x3f219
jmp 0x3f20b
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x3f121
jmp 0x3f21b
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x3f254
movq -0x58(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3f252
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x3f254
jmp 0x3f256
cmpl $0x0, -0x34(%rbp)
jne 0x3ef5a
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3f299
movq -0x18(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x3f299
movq -0x10(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x58(%rbp), %rdx
movl $0x20, %esi
callq 0x24180
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov [rbp+var_4C], 0
mov [rbp+var_58], 0
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov eax, [rbp+arg_0]
and eax, 0Fh
cmp eax, 0
jnz short loc_3EF58
mov eax, [rbp+arg_0]
or eax, 0Fh
mov [rbp+arg_0], eax
loc_3EF58:
jmp short $+2
loc_3EF5A:
mov ecx, [rbp+var_4C]
mov eax, 1
shl eax, cl
and eax, [rbp+arg_0]
mov [rbp+var_5C], eax
loc_3EF6A:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_3EFCD
mov [rbp+var_34], 0
cmp [rbp+var_4C], 3
jz short loc_3EFC8
mov eax, [rbp+var_4C]
mov ecx, eax
add ecx, 1
mov [rbp+var_4C], ecx
cmp eax, 0
jnz short loc_3EFAB
mov rax, [rbp+var_48]
mov [rbp+var_98], rax
jmp short loc_3EFB6
loc_3EFAB:
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
loc_3EFB6:
mov rax, [rbp+var_98]
mov [rbp+var_40], rax
mov [rbp+var_34], 1
loc_3EFC8:
jmp loc_3F227
loc_3EFCD:
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
cmp [rbp+var_34], 0
jnz short loc_3F001
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp loc_3EF6A
loc_3F001:
cmp [rbp+var_34], 2
jnz loc_3F10D
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
mov [rbp+var_70], rax
loc_3F01B:
mov rcx, [rbp+var_70]
mov rax, [rbp+var_28]
sub rcx, rax
mov rax, [rbp+var_30]
movsxd rdx, eax
xor eax, eax
cmp rcx, rdx
mov [rbp+var_99], al
jge short loc_3F060
movsxd rcx, [rbp+var_4C]
lea rax, CZ_SORT_TABLE
mov rax, [rax+rcx*8]
mov rcx, [rbp+var_70]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
cmp eax, 2
setz al
mov [rbp+var_99], al
loc_3F060:
mov al, [rbp+var_99]
test al, 1
jnz short loc_3F06C
jmp short loc_3F07A
loc_3F06C:
mov rax, [rbp+var_70]
add rax, 1
mov [rbp+var_70], rax
jmp short loc_3F01B
loc_3F07A:
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_3F099
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_3F099:
cmp [rbp+var_4C], 2
jg short loc_3F0BE
mov rax, [rbp+var_70]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_3F0BE
mov rax, [rbp+var_70]
mov [rbp+var_40], rax
loc_3F0BE:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jl short loc_3F0DA
jmp loc_3EF6A
loc_3F0DA:
cmp [rbp+var_4C], 1
jle short loc_3F0E5
jmp loc_3F227
loc_3F0E5:
mov rax, [rbp+var_40]
mov [rbp+var_68], rax
mov eax, 1
sub eax, [rbp+var_4C]
mov [rbp+var_4C], eax
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
mov rax, [rbp+var_68]
mov [rbp+var_48], rax
jmp loc_3F227
loc_3F10D:
cmp [rbp+var_34], 0FFh
jnz loc_3F21B
mov [rbp+var_74], 0
loc_3F121:
cmp [rbp+var_74], 50h ; 'P'
jge loc_3F219
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_40]
mov [rbp+var_88], rax
mov [rbp+var_8C], 0
loc_3F159:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jz short loc_3F1C6
mov rax, [rbp+var_88]
mov rcx, [rbp+var_28]
sub rax, rcx
mov rcx, [rbp+var_30]
movsxd rcx, ecx
cmp rax, rcx
jge short loc_3F1A1
mov rax, [rbp+var_88]
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movsxd rdx, [rbp+var_8C]
movsx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_3F1A3
loc_3F1A1:
jmp short loc_3F1C6
loc_3F1A3:
mov eax, [rbp+var_8C]
add eax, 1
mov [rbp+var_8C], eax
mov rax, [rbp+var_88]
add rax, 1
mov [rbp+var_88], rax
jmp short loc_3F159
loc_3F1C6:
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_8C]
cmp byte ptr [rax+rcx], 0
jnz short loc_3F209
movsxd rcx, [rbp+var_74]
lea rax, doubles
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
movsxd rcx, [rbp+var_4C]
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
mov rax, [rbp+var_88]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rax
jmp short loc_3F219
loc_3F209:
jmp short $+2
loc_3F20B:
mov eax, [rbp+var_74]
add eax, 1
mov [rbp+var_74], eax
jmp loc_3F121
loc_3F219:
jmp short $+2
loc_3F21B:
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
loc_3F227:
cmp [rbp+var_5C], 0
jz short loc_3F254
mov rax, [rbp+var_58]
cmp rax, [rbp+var_18]
jnb short loc_3F252
mov eax, [rbp+var_34]
mov dl, al
mov rax, [rbp+var_10]
mov rcx, [rbp+var_58]
mov rsi, rcx
add rsi, 1
mov [rbp+var_58], rsi
mov [rax+rcx], dl
loc_3F252:
jmp short $+2
loc_3F254:
jmp short $+2
loc_3F256:
cmp [rbp+var_34], 0
jnz loc_3EF5A
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_3F299
mov rax, [rbp+var_18]
cmp rax, [rbp+var_58]
jbe short loc_3F299
mov rdi, [rbp+var_10]
add rdi, [rbp+var_58]
mov rdx, [rbp+var_18]
sub rdx, [rbp+var_58]
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
loc_3F299:
mov rax, [rbp+var_58]
add rsp, 0A0h
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
char *a5,
int a6,
int a7)
{
long long v8; // rcx
long long v9; // rcx
bool v11; // [rsp+7h] [rbp-99h]
char *v12; // [rsp+8h] [rbp-98h]
int k; // [rsp+14h] [rbp-8Ch]
char *v14; // [rsp+18h] [rbp-88h]
long long v15; // [rsp+20h] [rbp-80h]
int j; // [rsp+2Ch] [rbp-74h]
unsigned __int8 *i; // [rsp+30h] [rbp-70h]
char *v18; // [rsp+38h] [rbp-68h]
int v19; // [rsp+44h] [rbp-5Ch]
unsigned long long v20; // [rsp+48h] [rbp-58h]
int v21; // [rsp+54h] [rbp-4Ch]
char *v22; // [rsp+58h] [rbp-48h]
char *v23; // [rsp+60h] [rbp-40h]
int v24; // [rsp+6Ch] [rbp-34h]
v21 = 0;
v20 = 0LL;
v23 = a5;
v22 = a5;
if ( (a7 & 0xF) == 0 )
a7 |= 0xFu;
do
{
v19 = a7 & (1 << v21);
while ( 1 )
{
while ( 1 )
{
if ( v23 - a5 >= a6 )
{
v24 = 0;
if ( v21 != 3 )
{
if ( v21++ )
v12 = a5;
else
v12 = v22;
v23 = v12;
v24 = 1;
}
goto LABEL_40;
}
v8 = (unsigned __int8)*v23;
v24 = *((unsigned __int8 *)*(&CZ_SORT_TABLE + v21) + v8);
if ( *((_BYTE *)*(&CZ_SORT_TABLE + v21) + v8) )
break;
++v23;
}
if ( v24 != 2 )
break;
for ( i = (unsigned __int8 *)++v23; ; ++i )
{
v11 = 0;
if ( i - (unsigned __int8 *)a5 < a6 )
v11 = *((_BYTE *)*(&CZ_SORT_TABLE + v21) + *i) == 2;
if ( !v11 )
break;
}
if ( i - (unsigned __int8 *)a5 >= a6 )
v23 = (char *)i;
if ( v21 <= 2 && i - (unsigned __int8 *)a5 < a6 )
v23 = (char *)i;
if ( v23 - a5 < a6 )
{
if ( v21 <= 1 )
{
v18 = v23;
v21 = 1 - v21;
v23 = v22;
v22 = v18;
}
goto LABEL_40;
}
}
if ( v24 == 255 )
{
for ( j = 0; j < 80; ++j )
{
v15 = (long long)*(&doubles + 2 * j);
v14 = v23;
for ( k = 0; *(_BYTE *)(v15 + k) && v14 - a5 < a6 && *v14 == *(char *)(v15 + k); ++k )
++v14;
if ( !*(_BYTE *)(v15 + k) )
{
v24 = *((unsigned __int8 *)*(&doubles + 2 * j + 1) + v21);
v23 = v14 - 1;
break;
}
}
}
++v23;
LABEL_40:
if ( v19 && v20 < a3 )
{
v9 = v20++;
*(_BYTE *)(a2 + v9) = v24;
}
}
while ( v24 );
if ( (a7 & 0x80) != 0 && a3 > v20 )
{
memset(v20 + a2, 32LL, a3 - v20);
return a3;
}
return v20;
}
|
my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x4c],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0xf
CMP EAX,0x0
JNZ 0x0013ef58
MOV EAX,dword ptr [RBP + 0x10]
OR EAX,0xf
MOV dword ptr [RBP + 0x10],EAX
LAB_0013ef58:
JMP 0x0013ef5a
LAB_0013ef5a:
MOV ECX,dword ptr [RBP + -0x4c]
MOV EAX,0x1
SHL EAX,CL
AND EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x5c],EAX
LAB_0013ef6a:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x0013efcd
MOV dword ptr [RBP + -0x34],0x0
CMP dword ptr [RBP + -0x4c],0x3
JZ 0x0013efc8
MOV EAX,dword ptr [RBP + -0x4c]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x4c],ECX
CMP EAX,0x0
JNZ 0x0013efab
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0013efb6
LAB_0013efab:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
LAB_0013efb6:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x34],0x1
LAB_0013efc8:
JMP 0x0013f227
LAB_0013efcd:
MOVSXD RCX,dword ptr [RBP + -0x4c]
LEA RAX,[0x2cd690]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0013f001
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013ef6a
LAB_0013f001:
CMP dword ptr [RBP + -0x34],0x2
JNZ 0x0013f10d
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x70],RAX
LAB_0013f01b:
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x28]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RDX,EAX
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x99],AL
JGE 0x0013f060
MOVSXD RCX,dword ptr [RBP + -0x4c]
LEA RAX,[0x2cd690]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RCX,qword ptr [RBP + -0x70]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x2
SETZ AL
MOV byte ptr [RBP + -0x99],AL
LAB_0013f060:
MOV AL,byte ptr [RBP + -0x99]
TEST AL,0x1
JNZ 0x0013f06c
JMP 0x0013f07a
LAB_0013f06c:
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x1
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0013f01b
LAB_0013f07a:
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x0013f099
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x40],RAX
LAB_0013f099:
CMP dword ptr [RBP + -0x4c],0x2
JG 0x0013f0be
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x0013f0be
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x40],RAX
LAB_0013f0be:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JL 0x0013f0da
JMP 0x0013ef6a
LAB_0013f0da:
CMP dword ptr [RBP + -0x4c],0x1
JLE 0x0013f0e5
JMP 0x0013f227
LAB_0013f0e5:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,0x1
SUB EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0013f227
LAB_0013f10d:
CMP dword ptr [RBP + -0x34],0xff
JNZ 0x0013f21b
MOV dword ptr [RBP + -0x74],0x0
LAB_0013f121:
CMP dword ptr [RBP + -0x74],0x50
JGE 0x0013f219
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2cd6b0]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x88],RAX
MOV dword ptr [RBP + -0x8c],0x0
LAB_0013f159:
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x8c]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x0013f1c6
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
CMP RAX,RCX
JGE 0x0013f1a1
MOV RAX,qword ptr [RBP + -0x88]
MOVSX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVSXD RDX,dword ptr [RBP + -0x8c]
MOVSX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0013f1a3
LAB_0013f1a1:
JMP 0x0013f1c6
LAB_0013f1a3:
MOV EAX,dword ptr [RBP + -0x8c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8c],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,0x1
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0013f159
LAB_0013f1c6:
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x8c]
CMP byte ptr [RAX + RCX*0x1],0x0
JNZ 0x0013f209
MOVSXD RCX,dword ptr [RBP + -0x74]
LEA RAX,[0x2cd6b0]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x4c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013f219
LAB_0013f209:
JMP 0x0013f20b
LAB_0013f20b:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV dword ptr [RBP + -0x74],EAX
JMP 0x0013f121
LAB_0013f219:
JMP 0x0013f21b
LAB_0013f21b:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_0013f227:
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x0013f254
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x0013f252
MOV EAX,dword ptr [RBP + -0x34]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x58]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x58],RSI
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0013f252:
JMP 0x0013f254
LAB_0013f254:
JMP 0x0013f256
LAB_0013f256:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0013ef5a
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x0013f299
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x0013f299
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr [RBP + -0x58]
MOV ESI,0x20
CALL 0x00124180
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
LAB_0013f299:
MOV RAX,qword ptr [RBP + -0x58]
ADD RSP,0xa0
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
char cVar1;
long lVar2;
byte *pbVar3;
byte bVar4;
bool bVar5;
byte *local_a0;
int local_94;
byte *local_90;
int local_7c;
byte *local_78;
ulong local_60;
int local_54;
byte *local_50;
byte *local_48;
local_54 = 0;
local_60 = 0;
local_50 = param_5;
local_48 = param_5;
if ((param_7 & 0xf) == 0) {
param_7 = param_7 | 0xf;
}
LAB_0013ef5a:
bVar4 = (byte)local_54;
do {
while( true ) {
if ((long)param_6 <= (long)local_48 - (long)param_5) {
cVar1 = '\0';
if (local_54 != 3) {
local_a0 = param_5;
if (local_54 == 0) {
local_a0 = local_50;
}
local_48 = local_a0;
cVar1 = '\x01';
local_54 = local_54 + 1;
}
goto LAB_0013f227;
}
cVar1 = (&CZ_SORT_TABLE)[local_54][*local_48];
if (cVar1 != '\0') break;
local_48 = local_48 + 1;
}
if (cVar1 != '\x02') {
if (cVar1 != -1) goto LAB_0013f21b;
local_7c = 0;
goto LAB_0013f121;
}
local_48 = local_48 + 1;
local_78 = local_48;
while( true ) {
bVar5 = false;
if ((long)local_78 - (long)param_5 < (long)param_6) {
bVar5 = (&CZ_SORT_TABLE)[local_54][*local_78] == '\x02';
}
if (!bVar5) break;
local_78 = local_78 + 1;
}
if ((long)param_6 <= (long)local_78 - (long)param_5) {
local_48 = local_78;
}
if ((local_54 < 3) && ((long)local_78 - (long)param_5 < (long)param_6)) {
local_48 = local_78;
}
pbVar3 = local_48;
} while ((long)param_6 <= (long)local_48 - (long)param_5);
if (local_54 < 2) {
local_48 = local_50;
local_50 = pbVar3;
local_54 = 1 - local_54;
}
goto LAB_0013f227;
LAB_0013f121:
if (0x4f < local_7c) goto LAB_0013f21b;
lVar2 = *(long *)(doubles + (long)local_7c * 0x10);
local_94 = 0;
for (local_90 = local_48;
((*(char *)(lVar2 + local_94) != '\0' && ((long)local_90 - (long)param_5 < (long)param_6)) &&
(*local_90 == *(byte *)(lVar2 + local_94))); local_90 = local_90 + 1) {
local_94 = local_94 + 1;
}
if (*(char *)(lVar2 + local_94) == '\0') {
cVar1 = *(char *)(*(long *)(doubles + (long)local_7c * 0x10 + 8) + (long)local_54);
local_48 = local_90 + -1;
goto LAB_0013f21b;
}
local_7c = local_7c + 1;
goto LAB_0013f121;
LAB_0013f21b:
local_48 = local_48 + 1;
LAB_0013f227:
if (((1 << (bVar4 & 0x1f) & param_7) != 0) && (local_60 < param_3)) {
*(char *)(param_2 + local_60) = cVar1;
local_60 = local_60 + 1;
}
if (cVar1 == '\0') {
if (((param_7 & 0x80) != 0) && (local_60 < param_3)) {
memset((void *)(param_2 + local_60),0x20,param_3 - local_60);
local_60 = param_3;
}
return local_60;
}
goto LAB_0013ef5a;
}
|
|
9,655 |
trnman_free_trn
|
eloqsql/storage/maria/trnman.c
|
static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
}
|
O0
|
c
|
trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x79dee
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xd9c0f(%rip), %rsi # 0x153a0c
movl $0x22d, %edx # imm = 0x22D
callq 0x79d10
movq -0x8(%rbp), %rax
movw $0x0, 0xac(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x79d80
movq 0xc012e0(%rip), %rax # 0xc7b108
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
lock
cmpxchgq %rcx, 0xc012b7(%rip) # 0xc7b108
movq %rax, %rcx
sete %al
movb %al, -0x29(%rbp)
movq %rcx, -0x28(%rbp)
testb $0x1, %al
jne 0x79e6a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x79e2c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
trnman_free_trn:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
jmp short $+2
loc_79DEE:
mov rdi, [rbp+var_8]
add rdi, 10h
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 22Dh
call inline_mysql_mutex_lock_11
mov rax, [rbp+var_8]
mov word ptr [rax+0ACh], 0
mov rdi, [rbp+var_8]
add rdi, 10h
call inline_mysql_mutex_unlock_12
mov rax, cs:pool
mov [rbp+var_10], rax
loc_79E2C:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
lock cmpxchg cs:pool, rcx
mov rcx, rax
setz al
mov [rbp+var_29], al
mov [rbp+var_28], rcx
test al, 1
jnz short loc_79E6A
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_79E6A:
mov al, [rbp+var_29]
and al, 1
mov [rbp+var_19], al
mov al, [rbp+var_19]
xor al, 0FFh
test al, 1
jnz short loc_79E2C
add rsp, 30h
pop rbp
retn
|
char trnman_free_trn(signed long long a1)
{
signed long long v1; // rax
signed long long v2; // rtt
char result; // al
bool v4; // [rsp+7h] [rbp-29h]
signed long long v5; // [rsp+20h] [rbp-10h]
inline_mysql_mutex_lock_11(
a1 + 16,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x22Du);
*(_WORD *)(a1 + 172) = 0;
inline_mysql_mutex_unlock_12(a1 + 16);
v5 = pool;
do
{
*(_QWORD *)(a1 + 104) = v5;
v2 = v5;
v1 = _InterlockedCompareExchange64(&pool, a1, v5);
v4 = v2 == v1;
if ( v2 != v1 )
v5 = v1;
result = ~v4;
}
while ( !v4 );
return result;
}
|
trnman_free_trn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
JMP 0x00179dee
LAB_00179dee:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
LEA RSI,[0x253a0c]
MOV EDX,0x22d
CALL 0x00179d10
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0xac],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
CALL 0x00179d80
MOV RAX,qword ptr [0x00d7b108]
MOV qword ptr [RBP + -0x10],RAX
LAB_00179e2c:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
CMPXCHG.LOCK qword ptr [0x00d7b108],RCX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x28],RCX
TEST AL,0x1
JNZ 0x00179e6a
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_00179e6a:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV AL,byte ptr [RBP + -0x19]
XOR AL,0xff
TEST AL,0x1
JNZ 0x00179e2c
ADD RSP,0x30
POP RBP
RET
|
void trnman_free_trn(long param_1)
{
long lVar1;
bool bVar2;
long local_18;
inline_mysql_mutex_lock
(param_1 + 0x10,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d)
;
*(int2 *)(param_1 + 0xac) = 0;
inline_mysql_mutex_unlock(param_1 + 0x10);
local_18 = pool;
do {
*(long *)(param_1 + 0x68) = local_18;
LOCK();
bVar2 = local_18 != pool;
lVar1 = param_1;
if (bVar2) {
local_18 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar2);
return;
}
|
|
9,656 |
trnman_free_trn
|
eloqsql/storage/maria/trnman.c
|
static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
}
|
O3
|
c
|
trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x50(%rdi)
jne 0x611da
movq %r14, %rdi
callq 0x29210
movw $0x0, 0xac(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
jne 0x611f0
movq %r14, %rdi
callq 0x291d0
movq 0xb9e1b2(%rip), %rax # 0xbff378
movq %rax, 0x68(%rbx)
lock
cmpxchgq %rbx, 0xb9e1a5(%rip) # 0xbff378
jne 0x611c6
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x799c6(%rip), %rsi # 0xdaba7
movq %r14, %rdi
movl $0x22d, %edx # imm = 0x22D
callq 0x2ebaf
jmp 0x611a5
leaq 0x324e19(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x611b7
|
trnman_free_trn:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+10h]
cmp qword ptr [rdi+50h], 0
jnz short loc_611DA
mov rdi, r14
call _pthread_mutex_lock
loc_611A5:
mov word ptr [rbx+0ACh], 0
mov rdi, [rbx+50h]
test rdi, rdi
jnz short loc_611F0
loc_611B7:
mov rdi, r14
call _pthread_mutex_unlock
mov rax, cs:pool
loc_611C6:
mov [rbx+68h], rax
lock cmpxchg cs:pool, rbx
jnz short loc_611C6
pop rbx
pop r14
pop rbp
retn
loc_611DA:
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 22Dh
call psi_mutex_lock
jmp short loc_611A5
loc_611F0:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_611B7
|
signed long long trnman_free_trn(signed long long a1)
{
signed long long result; // rax
signed long long v2; // rtt
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x22Du);
else
pthread_mutex_lock(a1 + 16);
*(_WORD *)(a1 + 172) = 0;
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
result = pool;
do
{
*(_QWORD *)(a1 + 104) = result;
v2 = result;
result = _InterlockedCompareExchange64(&pool, a1, result);
}
while ( v2 != result );
return result;
}
|
trnman_free_trn:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x10]
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x001611da
MOV RDI,R14
CALL 0x00129210
LAB_001611a5:
MOV word ptr [RBX + 0xac],0x0
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JNZ 0x001611f0
LAB_001611b7:
MOV RDI,R14
CALL 0x001291d0
MOV RAX,qword ptr [0x00cff378]
LAB_001611c6:
MOV qword ptr [RBX + 0x68],RAX
CMPXCHG.LOCK qword ptr [0x00cff378],RBX
JNZ 0x001611c6
POP RBX
POP R14
POP RBP
RET
LAB_001611da:
LEA RSI,[0x1daba7]
MOV RDI,R14
MOV EDX,0x22d
CALL 0x0012ebaf
JMP 0x001611a5
LAB_001611f0:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001611b7
|
void trnman_free_trn(long param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
bool bVar3;
__mutex = (pthread_mutex_t *)(param_1 + 0x10);
if (*(long *)(param_1 + 0x50) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d);
}
*(int2 *)(param_1 + 0xac) = 0;
if (*(long *)(param_1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar2 = pool;
do {
*(long *)(param_1 + 0x68) = lVar2;
LOCK();
bVar3 = lVar2 != pool;
lVar1 = param_1;
if (bVar3) {
lVar2 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar3);
return;
}
|
|
9,657 |
google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
void ServiceDescriptor::CopyTo(ServiceDescriptorProto* proto) const {
proto->set_name(name());
for (int i = 0; i < method_count(); i++) {
method(i)->CopyTo(proto->add_method());
}
if (&options() != &ServiceOptions::default_instance()) {
proto->mutable_options()->CopyFrom(options());
}
}
|
O0
|
cpp
|
google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const:
subq $0x78, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x161b0
movq 0x28(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movslq 0x6c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
orl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq %rdi, %rax
addq $0x10, %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x80180
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x183680
movl $0x0, 0x44(%rsp)
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x161c0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x3882e
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x161d0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x76700
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x39720
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x387db
movq 0x20(%rsp), %rdi
callq 0x76730
movq %rax, 0x8(%rsp)
callq 0x76740
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x38873
movq 0x48(%rsp), %rdi
callq 0x76750
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
callq 0x76730
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc7190
addq $0x78, %rsp
retq
nopl (%rax,%rax)
|
_ZNK6google8protobuf17ServiceDescriptor6CopyToEPNS0_22ServiceDescriptorProtoE:
sub rsp, 78h
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_30], rsi
mov rdi, [rsp+78h+var_28]
mov [rsp+78h+var_58], rdi
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_50], rax
call _ZNK6google8protobuf17ServiceDescriptor4nameB5cxx11Ev; google::protobuf::ServiceDescriptor::name(void)
mov rcx, [rsp+78h+var_50]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_18]; this
mov rax, rdi
add rax, 10h
mov [rsp+78h+var_8], rax
mov [rsp+78h+var_C], 0
mov rax, [rsp+78h+var_8]
movsxd rcx, [rsp+78h+var_C]
mov edx, [rax+rcx*4]
or edx, 1
mov [rax+rcx*4], edx
mov rax, rdi
add rax, 10h
add rax, 20h ; ' '
mov qword ptr [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_20]
mov qword ptr [rsp+78h+var_40], rax
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov rdi, qword ptr [rsp+78h+var_48]; int
mov rsi, qword ptr [rsp+78h+var_40]; int
mov rdx, rax; int
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
mov [rsp+78h+var_34], 0
loc_387DB:
mov rdi, [rsp+78h+var_58]; this
mov eax, [rsp+78h+var_34]
mov [rsp+78h+var_5C], eax
call _ZNK6google8protobuf17ServiceDescriptor12method_countEv; google::protobuf::ServiceDescriptor::method_count(void)
mov ecx, eax
mov eax, [rsp+78h+var_5C]
cmp eax, ecx
jge short loc_3882E
mov rdi, [rsp+78h+var_58]; this
mov esi, [rsp+78h+var_34]; int
call _ZNK6google8protobuf17ServiceDescriptor6methodEi; google::protobuf::ServiceDescriptor::method(int)
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_30]; this
call _ZN6google8protobuf22ServiceDescriptorProto10add_methodEv; google::protobuf::ServiceDescriptorProto::add_method(void)
mov rdi, [rsp+78h+var_68]; this
mov rsi, rax; google::protobuf::MethodDescriptorProto *
call _ZNK6google8protobuf16MethodDescriptor6CopyToEPNS0_21MethodDescriptorProtoE; google::protobuf::MethodDescriptor::CopyTo(google::protobuf::MethodDescriptorProto *)
mov eax, [rsp+78h+var_34]
add eax, 1
mov [rsp+78h+var_34], eax
jmp short loc_387DB
loc_3882E:
mov rdi, [rsp+78h+var_58]; this
call _ZNK6google8protobuf17ServiceDescriptor7optionsEv; google::protobuf::ServiceDescriptor::options(void)
mov [rsp+78h+var_70], rax
call _ZN6google8protobuf14ServiceOptions16default_instanceEv; google::protobuf::ServiceOptions::default_instance(void)
mov rcx, rax
mov rax, [rsp+78h+var_70]
cmp rax, rcx
jz short loc_38873
mov rdi, [rsp+78h+var_30]; this
call _ZN6google8protobuf22ServiceDescriptorProto15mutable_optionsEv; google::protobuf::ServiceDescriptorProto::mutable_options(void)
mov rdi, [rsp+78h+var_58]; this
mov [rsp+78h+var_78], rax
call _ZNK6google8protobuf17ServiceDescriptor7optionsEv; google::protobuf::ServiceDescriptor::options(void)
mov rdi, [rsp+78h+var_78]; this
mov rsi, rax; google::protobuf::ServiceOptions *
call _ZN6google8protobuf14ServiceOptions8CopyFromERKS1_; google::protobuf::ServiceOptions::CopyFrom(google::protobuf::ServiceOptions const&)
loc_38873:
add rsp, 78h
retn
|
long long google::protobuf::ServiceDescriptor::CopyTo(
google::protobuf::ServiceDescriptor *this,
google::protobuf::ServiceDescriptorProto *a2)
{
int ArenaForAllocation; // eax
google::protobuf::MethodDescriptorProto *v3; // rax
long long v4; // rcx
long long result; // rax
const google::protobuf::ServiceOptions *v6; // rax
google::protobuf::ServiceOptions *v7; // [rsp+0h] [rbp-78h]
long long v8; // [rsp+8h] [rbp-70h]
google::protobuf::MethodDescriptor *v9; // [rsp+10h] [rbp-68h]
int i; // [rsp+44h] [rbp-34h]
int v11; // [rsp+58h] [rbp-20h]
v11 = google::protobuf::ServiceDescriptor::name[abi:cxx11]((long long)this);
*((_DWORD *)a2 + 4) |= 1u;
ArenaForAllocation = google::protobuf::MessageLite::GetArenaForAllocation(a2);
google::protobuf::internal::ArenaStringPtr::Set((_DWORD)a2 + 48, v11, ArenaForAllocation);
for ( i = 0; i < (int)google::protobuf::ServiceDescriptor::method_count(this); ++i )
{
v9 = (google::protobuf::MethodDescriptor *)google::protobuf::ServiceDescriptor::method(this, i);
v3 = (google::protobuf::MethodDescriptorProto *)google::protobuf::ServiceDescriptorProto::add_method(a2);
google::protobuf::MethodDescriptor::CopyTo(v9, v3);
}
v8 = google::protobuf::ServiceDescriptor::options(this);
v4 = google::protobuf::ServiceOptions::default_instance(this);
result = v8;
if ( v8 != v4 )
{
v7 = (google::protobuf::ServiceOptions *)google::protobuf::ServiceDescriptorProto::mutable_options(a2);
v6 = (const google::protobuf::ServiceOptions *)google::protobuf::ServiceDescriptor::options(this);
return google::protobuf::ServiceOptions::CopyFrom(v7, v6);
}
return result;
}
|
CopyTo:
SUB RSP,0x78
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x28],RAX
CALL 0x001161b0
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RAX,RDI
ADD RAX,0x10
MOV qword ptr [RSP + 0x70],RAX
MOV dword ptr [RSP + 0x6c],0x0
MOV RAX,qword ptr [RSP + 0x70]
MOVSXD RCX,dword ptr [RSP + 0x6c]
MOV EDX,dword ptr [RAX + RCX*0x4]
OR EDX,0x1
MOV dword ptr [RAX + RCX*0x4],EDX
MOV RAX,RDI
ADD RAX,0x10
ADD RAX,0x20
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x38],RAX
CALL 0x00180180
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,RAX
CALL 0x00283680
MOV dword ptr [RSP + 0x44],0x0
LAB_001387db:
MOV RDI,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x44]
MOV dword ptr [RSP + 0x1c],EAX
CALL 0x001161c0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,ECX
JGE 0x0013882e
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x44]
CALL 0x001161d0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00176700
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00139720
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,0x1
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001387db
LAB_0013882e:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00176730
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00176740
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JZ 0x00138873
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00176750
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
CALL 0x00176730
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x001c7190
LAB_00138873:
ADD RSP,0x78
RET
|
/* google::protobuf::ServiceDescriptor::CopyTo(google::protobuf::ServiceDescriptorProto*) const */
void __thiscall
google::protobuf::ServiceDescriptor::CopyTo(ServiceDescriptor *this,ServiceDescriptorProto *param_1)
{
int iVar1;
string *psVar2;
Arena *pAVar3;
MethodDescriptor *this_00;
MethodDescriptorProto *pMVar4;
long lVar5;
long lVar6;
ServiceOptions *this_01;
ServiceOptions *pSVar7;
int local_34;
psVar2 = (string *)name_abi_cxx11_(this);
*(uint *)(param_1 + 0x10) = *(uint *)(param_1 + 0x10) | 1;
pAVar3 = (Arena *)MessageLite::GetArenaForAllocation((MessageLite *)param_1);
internal::ArenaStringPtr::Set((ArenaStringPtr *)(param_1 + 0x30),psVar2,pAVar3);
local_34 = 0;
while( true ) {
iVar1 = method_count(this);
if (iVar1 <= local_34) break;
this_00 = (MethodDescriptor *)method(this,local_34);
pMVar4 = (MethodDescriptorProto *)ServiceDescriptorProto::add_method(param_1);
MethodDescriptor::CopyTo(this_00,pMVar4);
local_34 = local_34 + 1;
}
lVar5 = options(this);
lVar6 = ServiceOptions::default_instance();
if (lVar5 != lVar6) {
this_01 = (ServiceOptions *)ServiceDescriptorProto::mutable_options(param_1);
pSVar7 = (ServiceOptions *)options(this);
ServiceOptions::CopyFrom(this_01,pSVar7);
}
return;
}
|
|
9,658 |
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 0x68a0f
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 0x68a12
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181a0
testl %eax, %eax
je 0x68a02
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0x689e8
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0x68a15
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_68A0F
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_68A12
mov r15, rsi
loc_689E8:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_68A02
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_689E8
loc_68A02:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_68A15
loc_68A0F:
xor eax, eax
retn
loc_68A12:
mov rax, rbx
loc_68A15:
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_IhSaIhEEvE8containsIRA5_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_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x00168a0f
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 0x00168a12
MOV R15,RSI
LAB_001689e8:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001181a0
TEST EAX,EAX
JZ 0x00168a02
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001689e8
LAB_00168a02:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x00168a15
LAB_00168a0f:
XOR EAX,EAX
RET
LAB_00168a12:
MOV RAX,RBX
LAB_00168a15:
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_IhSaIhEEvE8containsIRA5_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);
}
|
|
9,659 |
OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(OpenSubdiv::v3_6_0::Far::TopologyRefiner const&)
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/ptexIndices.cpp
|
PtexIndices::PtexIndices(TopologyRefiner const &refiner) {
initializePtexIndices(refiner);
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(OpenSubdiv::v3_6_0::Far::TopologyRefiner const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x385c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x71ce1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq %r14, %rdi
callq 0x3bd30
nop
|
_ZN10OpenSubdiv6v3_6_03Far11PtexIndicesC2ERKNS1_15TopologyRefinerE:
push r14; Alternative name is 'OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(OpenSubdiv::v3_6_0::Far::TopologyRefiner const&)'
push rbx
push rax
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
call __ZN10OpenSubdiv6v3_6_03Far11PtexIndices21initializePtexIndicesERKNS1_15TopologyRefinerE; OpenSubdiv::v3_6_0::Far::PtexIndices::initializePtexIndices(OpenSubdiv::v3_6_0::Far::TopologyRefiner const&)
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_71CE1
mov rsi, [rbx+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71CE1:
mov rdi, r14
call __Unwind_Resume
|
long long OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(
OpenSubdiv::v3_6_0::Far::PtexIndices *this,
const OpenSubdiv::v3_6_0::Far::TopologyRefiner *a2)
{
*(_OWORD *)this = 0LL;
*((_QWORD *)this + 2) = 0LL;
return OpenSubdiv::v3_6_0::Far::PtexIndices::initializePtexIndices(this, a2);
}
|
PtexIndices:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
LAB_00171cbd:
CALL 0x001385c0
LAB_00171cc2:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(OpenSubdiv::v3_6_0::Far::TopologyRefiner
const&) */
void __thiscall
OpenSubdiv::v3_6_0::Far::PtexIndices::PtexIndices(PtexIndices *this,TopologyRefiner *param_1)
{
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
/* try { // try from 00171cbd to 00171cc1 has its CatchHandler @ 00171cca */
initializePtexIndices(this,param_1);
return;
}
|
|
9,660 |
spdlog::set_error_handler(void (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&))
|
AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/spdlog-inl.h
|
SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) {
details::registry::instance().set_error_handler(handler);
}
|
O3
|
c
|
spdlog::set_error_handler(void (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)):
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2e0ae
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
testq %rbx, %rbx
je 0x2f7d0
movq %rbx, (%rsp)
leaq 0xa99b(%rip), %rax # 0x3a15a
movq %rax, 0x18(%rsp)
leaq 0xa997(%rip), %rax # 0x3a162
movq %rax, 0x10(%rsp)
leaq 0x85079(%rip), %rdi # 0xb4850
movq %rsp, %rsi
callq 0x2dc9a
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f7f6
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x2f820
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f818
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11760
movq %rax, %rdi
callq 0x18a8f
|
_ZN6spdlog17set_error_handlerEPFvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE:
push rbx
sub rsp, 20h
mov rbx, rdi
call _ZN6spdlog7details8registry8instanceEv; spdlog::details::registry::instance(void)
xorps xmm0, xmm0
movaps [rsp+28h+var_28], xmm0
movaps [rsp+28h+var_18], xmm0
test rbx, rbx
jz short loc_2F7D0
mov qword ptr [rsp+28h+var_28], rbx
lea rax, _ZNSt17_Function_handlerIFvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEPS8_E9_M_invokeERKSt9_Any_dataS7_; std::_Function_handler<void ()(std::string const&),void (*)(std::string const&)>::_M_invoke(std::_Any_data const&,std::string const&)
mov qword ptr [rsp+28h+var_18+8], rax
lea rax, _ZNSt17_Function_handlerIFvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEPS8_E10_M_managerERSt9_Any_dataRKSB_St18_Manager_operation; std::_Function_handler<void ()(std::string const&),void (*)(std::string const&)>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov qword ptr [rsp+28h+var_18], rax
loc_2F7D0:
lea rdi, _ZZN6spdlog7details8registry8instanceEvE10s_instance; spdlog::details::registry::instance(void)::s_instance
mov rsi, rsp
call _ZN6spdlog7details8registry17set_error_handlerESt8functionIFvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE; spdlog::details::registry::set_error_handler(std::function<void ()(std::string const&)>)
mov rax, qword ptr [rsp+28h+var_18]
test rax, rax
jz short loc_2F7F6
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_2F7F6:
add rsp, 20h
pop rbx
retn
jmp short loc_2F820
mov rbx, rax
mov rax, qword ptr [rsp+28h+var_18]
test rax, rax
jz short loc_2F818
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_2F818:
mov rdi, rbx
call __Unwind_Resume
loc_2F820:
mov rdi, rax
call __clang_call_terminate
|
long long spdlog::set_error_handler(spdlog::details::registry *a1)
{
long long result; // rax
__int128 v2; // [rsp+0h] [rbp-28h] BYREF
__int128 v3; // [rsp+10h] [rbp-18h]
spdlog::details::registry::instance(a1);
v2 = 0LL;
v3 = 0LL;
if ( a1 )
{
*(_QWORD *)&v2 = a1;
*((_QWORD *)&v3 + 1) = std::_Function_handler<void ()(std::string const&),void (*)(std::string const&)>::_M_invoke;
*(_QWORD *)&v3 = std::_Function_handler<void ()(std::string const&),void (*)(std::string const&)>::_M_manager;
}
spdlog::details::registry::set_error_handler(
(long long)&spdlog::details::registry::instance(void)::s_instance,
(long long)&v2);
result = v3;
if ( (_QWORD)v3 )
return ((long long ( *)(__int128 *, __int128 *, long long))v3)(&v2, &v2, 3LL);
return result;
}
|
set_error_handler:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
CALL 0x0012e0ae
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
TEST RBX,RBX
JZ 0x0012f7d0
MOV qword ptr [RSP],RBX
LEA RAX,[0x13a15a]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x13a162]
MOV qword ptr [RSP + 0x10],RAX
LAB_0012f7d0:
LEA RDI,[0x1b4850]
MOV RSI,RSP
CALL 0x0012dc9a
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x0012f7f6
LAB_0012f7e9:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0012f7f6:
ADD RSP,0x20
POP RBX
RET
|
/* spdlog::set_error_handler(void (*)(std::__cxx11::string const&)) */
void spdlog::set_error_handler(_func_void_string_ptr *param_1)
{
_func_void_string_ptr *local_28;
int8 uStack_20;
code *local_18;
code *pcStack_10;
details::registry::instance();
local_28 = (_func_void_string_ptr *)0x0;
uStack_20 = 0;
local_18 = (code *)0x0;
pcStack_10 = (code *)0x0;
if (param_1 != (_func_void_string_ptr *)0x0) {
pcStack_10 = std::
_Function_handler<void(std::__cxx11::string_const&),void(*)(std::__cxx11::string_const&)>
::_M_invoke;
local_18 = std::
_Function_handler<void(std::__cxx11::string_const&),void(*)(std::__cxx11::string_const&)>
::_M_manager;
local_28 = param_1;
}
/* try { // try from 0012f7d0 to 0012f7de has its CatchHandler @ 0012f7fe */
details::registry::set_error_handler
((registry *)details::registry::instance()::s_instance,&local_28);
if (local_18 != (code *)0x0) {
/* try { // try from 0012f7e9 to 0012f7f5 has its CatchHandler @ 0012f7fc */
(*local_18)(&local_28,&local_28,3);
}
return;
}
|
|
9,661 |
mysql_list_processes_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_list_processes_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_processes,
(parms->mysql),
parms->mysql,
MYSQL_RES *,
r_ptr)
}
|
O0
|
c
|
mysql_list_processes_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_list_processes_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call _mysql_list_processes@libmariadbclient_18
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
long long mysql_list_processes_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*a1 + 1152) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_list_processes_libmariadbclient_18(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_list_processes_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00117220
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_list_processes_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_processes(*param_1);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
9,662 |
my_hash_sort_ucs2_nopad_bin
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_ucs2_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; key < end ; key++)
{
MY_HASH_ADD(m1, m2, (uint)*key);
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_ucs2_nopad_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x55375
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x55349
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
|
my_hash_sort_ucs2_nopad_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_55375
push rbp
mov rbp, rsp
add rdx, rsi
loc_55349:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_55349
pop rbp
loc_55375:
mov [rcx], rax
mov [r8], rdi
retn
|
long long my_hash_sort_ucs2_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
|
my_hash_sort_ucs2_nopad_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x00155375
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_00155349:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00155349
POP RBP
LAB_00155375:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
|
|
9,663 |
simple_key_cache_insert
|
eloqsql/mysys/mf_keycache.c
|
static
int simple_key_cache_insert(SIMPLE_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
int error= 0;
DBUG_ENTER("key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file,(ulong) filepos, length));
if (keycache->key_cache_inited)
{
/* Key cache is used */
reg1 BLOCK_LINK *block;
uint read_length;
uint offset;
int page_st;
my_bool locked_and_incremented= FALSE;
/*
When the keycache is once initialized, we use the cache_lock to
reliably distinguish the cases of normal operation, resizing, and
disabled cache. We always increment and decrement
'cnt_for_resize_op' so that a resizer can wait for pending I/O.
*/
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
We do not load index data into a disabled cache nor into an
ongoing resize.
*/
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Register the pseudo I/O for the next resize. */
inc_counter_for_resize_op(keycache);
locked_and_incremented= TRUE;
/* Loaded data may not always be aligned to cache blocks. */
offset= (uint) (filepos % keycache->key_cache_block_size);
/* Load data in key_cache_block_size increments. */
do
{
/* Cache could be disabled or resizing in a later iteration. */
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Start loading at the beginning of the cache block. */
filepos-= offset;
/* Do not load beyond the end of the cache block. */
read_length= length;
set_if_smaller(read_length, keycache->key_cache_block_size-offset);
KEYCACHE_DBUG_ASSERT(read_length > 0);
/* The block has been read by the caller already. */
keycache->global_cache_read++;
/* Request the cache block that matches file/pos. */
keycache->global_cache_r_requests++;
block= find_key_block(keycache, file, filepos, level, 0, &page_st);
if (!block)
{
/*
This happens only for requests submitted during key cache
resize. The block is not in the cache and shall not go in.
Stop loading index data.
*/
goto no_key_cache;
}
if (!(block->status & BLOCK_ERROR))
{
if (page_st == PAGE_WAIT_TO_BE_READ)
{
/*
this is a secondary request for a block to be read into the
cache. The block is in eviction. It is not yet assigned to
the requested file block (It does not point to the right
hash_link). So we cannot call remove_reader() on the block.
And we cannot access the hash_link directly here. We need to
wait until the assignment is complete. read_block_secondary()
executes the correct wait.
*/
read_block_secondary(keycache, block);
/*
A secondary request must now have the block assigned to the
requested file block.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
}
else if (page_st == PAGE_TO_BE_READ &&
(offset || (read_length < keycache->key_cache_block_size)))
{
/*
this is a primary request for a block to be read into the
cache and the supplied data does not fill the whole block.
This function is called on behalf of a LOAD INDEX INTO CACHE
statement, which is a read-only task and allows other
readers. It is possible that a parallel running reader tries
to access this block. If it needs more data than has been
supplied here, it would report an error. To be sure that we
have all data in the block that is available in the file, we
read the block ourselves.
Though reading again what the caller did read already is an
expensive operation, we need to do this for correctness.
*/
read_block_primary(keycache, block, keycache->key_cache_block_size,
read_length + offset);
}
else if (page_st == PAGE_TO_BE_READ)
{
/*
This is a new block in the cache. If we come here, we have
data for the whole block.
*/
DBUG_ASSERT(block->hash_link->requests);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
#endif
/* Copy data from buff */
memcpy(block->buffer+offset, buff, (size_t) read_length);
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_lock(&keycache->cache_lock);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#endif
/*
After the data is in the buffer, we can declare the block
valid. Now other threads do not need to register as
secondary readers any more. They can immediately access the
block.
*/
block->status|= BLOCK_READ;
block->length= read_length+offset;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
KEYCACHE_DBUG_PRINT("key_cache_insert",
("primary request: new page in cache"));
/* Signal all pending requests. */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
}
else
{
/*
page_st == PAGE_READ. The block is in the buffer. All data
must already be present. Blocks are always read with all
data available on file. Assert that the block does not have
less contents than the preloader supplies. If the caller has
data beyond block->length, it means that a file write has
been done while this block was in cache and not extended
with the new data. If the condition is met, we can simply
ignore the block.
*/
DBUG_ASSERT((page_st == PAGE_READ) &&
(read_length + offset <= block->length));
}
/*
A secondary request must now have the block assigned to the
requested file block. It does not hurt to check it for primary
requests too.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
} /* end of if (!(block->status & BLOCK_ERROR)) */
remove_reader(block);
/* Error injection for coverage testing. */
DBUG_EXECUTE_IF("key_cache_insert_block_error",
block->status|= BLOCK_ERROR; errno=EIO;);
/* Do not link erroneous blocks into the LRU ring, but free them. */
if (!(block->status & BLOCK_ERROR))
{
/*
Link the block into the LRU ring if it's the last submitted
request for the block. This enables eviction for the block.
*/
unreg_request(keycache, block, 1);
}
else
{
free_block(keycache, block);
error= 1;
break;
}
buff+= read_length;
filepos+= read_length+offset;
offset= 0;
} while ((length-= read_length));
no_key_cache:
if (locked_and_incremented)
dec_counter_for_resize_op(keycache);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
}
DBUG_RETURN(error);
}
|
O3
|
c
|
simple_key_cache_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movl %ecx, -0x48(%rbp)
movl %esi, -0x44(%rbp)
cmpb $0x0, (%rdi)
je 0x9944f
movq %r8, %r15
movq %rdx, %r13
movq %rdi, %r12
leaq 0xc0(%rdi), %r14
cmpq $0x0, 0x100(%rdi)
jne 0x994a7
movq %r14, %rdi
callq 0x29220
xorl %ebx, %ebx
cmpb $0x0, 0x3(%r12)
je 0x99481
cmpb $0x0, 0x1(%r12)
jne 0x99481
movq %r15, -0x60(%rbp)
movq %r14, -0x38(%rbp)
incq 0x70(%r12)
movl 0x18(%r12), %ecx
movq %r13, -0x40(%rbp)
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movq %r12, %r15
cmpb $0x0, 0x3(%r15)
je 0x99453
cmpb $0x0, 0x1(%r15)
jne 0x99453
movl %r13d, %eax
movq -0x40(%rbp), %rdx
movq %rax, -0x70(%rbp)
subq %rax, %rdx
movl 0x18(%r15), %r14d
subl %r13d, %r14d
movl -0x2c(%rbp), %eax
cmpl %r14d, %eax
cmovbl %eax, %r14d
movdqu 0x150(%r15), %xmm0
psubq 0x3fe4f(%rip), %xmm0 # 0xd9140
movdqu %xmm0, 0x150(%r15)
xorl %ebx, %ebx
movq %r15, %rdi
movl -0x44(%rbp), %esi
movq %rdx, -0x40(%rbp)
movl -0x48(%rbp), %ecx
xorl %r8d, %r8d
leaq -0x4c(%rbp), %r9
callq 0x97795
testq %rax, %rax
je 0x99467
movq %rax, %r12
testb $0x1, 0x50(%rax)
movl %r14d, %ebx
jne 0x993e2
movl -0x4c(%rbp), %eax
cmpl $0x1, %eax
je 0x99354
cmpl $0x2, %eax
jne 0x993e2
movq %r12, %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x97704
jmp 0x993e2
movl 0x18(%r15), %edx
testl %r13d, %r13d
jne 0x993d3
cmpl %edx, %r14d
jb 0x993d3
movq %rbx, -0x58(%rbp)
movq %r15, -0x68(%rbp)
movq 0x100(%r15), %rdi
testq %rdi, %rdi
jne 0x99421
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x291e0
movq -0x70(%rbp), %rdi
addq 0x40(%r12), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x29080
movq -0x68(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x99436
movq %rbx, %rdi
callq 0x29220
orb $0x2, 0x50(%r12)
movl %r14d, 0x4c(%r12)
movq %r12, %rdi
addq $0x28, %rdi
callq 0x989b9
movq -0x58(%rbp), %rbx
jmp 0x993e2
leal (%r14,%r13), %ecx
movq %r15, %rdi
movq %r12, %rsi
callq 0x97f96
movq %r12, %rdi
callq 0x98064
testb $0x1, 0x50(%r12)
jne 0x99457
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x980ac
addq %rbx, -0x60(%rbp)
addl %r14d, %r13d
addq %r13, -0x40(%rbp)
xorl %r13d, %r13d
movl $0x0, %ebx
subl %r14d, -0x2c(%rbp)
jne 0x992ab
jmp 0x99467
leaq 0x2ecbe8(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9937a
movq %rbx, %rdi
leaq 0x42f2b(%rip), %rsi # 0xdc36b
movl $0xc4b, %edx # imm = 0xC4B
callq 0x2eb8f
jmp 0x993b6
xorl %ebx, %ebx
jmp 0x99496
xorl %ebx, %ebx
jmp 0x99467
movq %r15, %rdi
movq %r12, %rsi
callq 0x981b4
movl $0x1, %ebx
decq 0x70(%r15)
movq %r15, %r12
jne 0x9947d
leaq 0x110(%r12), %rdi
callq 0x989b9
movq -0x38(%rbp), %r14
movq 0x100(%r12), %rdi
testq %rdi, %rdi
jne 0x994c0
movq %r14, %rdi
callq 0x291e0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42ebd(%rip), %rsi # 0xdc36b
movq %r14, %rdi
movl $0xbe2, %edx # imm = 0xBE2
callq 0x2eb8f
jmp 0x9926d
leaq 0x2ecb49(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x9948e
|
simple_key_cache_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_2C], r9d
mov [rbp+var_48], ecx
mov [rbp+var_44], esi
cmp byte ptr [rdi], 0
jz loc_9944F
mov r15, r8
mov r13, rdx
mov r12, rdi
lea r14, [rdi+0C0h]
cmp qword ptr [rdi+100h], 0
jnz loc_994A7
mov rdi, r14
call _pthread_mutex_lock
loc_9926D:
xor ebx, ebx
cmp byte ptr [r12+3], 0
jz loc_99481
cmp byte ptr [r12+1], 0
jnz loc_99481
mov [rbp+var_60], r15
mov [rbp+var_38], r14
inc qword ptr [r12+70h]
mov ecx, [r12+18h]
mov [rbp+var_40], r13
mov rax, r13
xor edx, edx
div rcx
mov r13, rdx
mov r15, r12
loc_992AB:
cmp byte ptr [r15+3], 0
jz loc_99453
cmp byte ptr [r15+1], 0
jnz loc_99453
mov eax, r13d
mov rdx, [rbp+var_40]
mov [rbp+var_70], rax
sub rdx, rax
mov r14d, [r15+18h]
sub r14d, r13d
mov eax, [rbp+var_2C]
cmp eax, r14d
cmovb r14d, eax
movdqu xmm0, xmmword ptr [r15+150h]
psubq xmm0, cs:xmmword_D9140
movdqu xmmword ptr [r15+150h], xmm0
xor ebx, ebx
mov rdi, r15
mov esi, [rbp+var_44]
mov [rbp+var_40], rdx
mov ecx, [rbp+var_48]
xor r8d, r8d
lea r9, [rbp+var_4C]
call find_key_block
test rax, rax
jz loc_99467
mov r12, rax
test byte ptr [rax+50h], 1
mov ebx, r14d
jnz loc_993E2
mov eax, [rbp+var_4C]
cmp eax, 1
jz short loc_99354
cmp eax, 2
jnz loc_993E2
mov rdi, r12
add rdi, 28h ; '('
mov rsi, [rbp+var_38]
call wait_on_queue
jmp loc_993E2
loc_99354:
mov edx, [r15+18h]
test r13d, r13d
jnz short loc_993D3
cmp r14d, edx
jb short loc_993D3
mov [rbp+var_58], rbx
mov [rbp+var_68], r15
mov rdi, [r15+100h]
test rdi, rdi
jnz loc_99421
loc_9937A:
mov rbx, [rbp+var_38]
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, [rbp+var_70]
add rdi, [r12+40h]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_58]
call _memcpy
mov rax, [rbp+var_68]
cmp qword ptr [rax+100h], 0
jnz loc_99436
mov rdi, rbx
call _pthread_mutex_lock
loc_993B6:
or byte ptr [r12+50h], 2
mov [r12+4Ch], r14d
mov rdi, r12
add rdi, 28h ; '('
call release_whole_queue
mov rbx, [rbp+var_58]
jmp short loc_993E2
loc_993D3:
lea ecx, [r14+r13]
mov rdi, r15
mov rsi, r12
call read_block_primary
loc_993E2:
mov rdi, r12
call remove_reader
test byte ptr [r12+50h], 1
jnz short loc_99457
mov rdi, r15
mov rsi, r12
mov edx, 1
call unreg_request_0
add [rbp+var_60], rbx
add r13d, r14d
add [rbp+var_40], r13
xor r13d, r13d
mov ebx, 0
sub [rbp+var_2C], r14d
jnz loc_992AB
jmp short loc_99467
loc_99421:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_9937A
loc_99436:
mov rdi, rbx
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0C4Bh
call psi_mutex_lock
jmp loc_993B6
loc_9944F:
xor ebx, ebx
jmp short loc_99496
loc_99453:
xor ebx, ebx
jmp short loc_99467
loc_99457:
mov rdi, r15
mov rsi, r12
call free_block_0
mov ebx, 1
loc_99467:
dec qword ptr [r15+70h]
mov r12, r15
jnz short loc_9947D
lea rdi, [r12+110h]
call release_whole_queue
loc_9947D:
mov r14, [rbp+var_38]
loc_99481:
mov rdi, [r12+100h]
test rdi, rdi
jnz short loc_994C0
loc_9948E:
mov rdi, r14
call _pthread_mutex_unlock
loc_99496:
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_994A7:
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 0BE2h
call psi_mutex_lock
jmp loc_9926D
loc_994C0:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_9948E
|
long long simple_key_cache_insert(
__m128i *a1,
unsigned int a2,
unsigned long long a3,
int a4,
long long a5,
unsigned int a6)
{
__m128i *v8; // r12
const char *m128i_i8; // r14
unsigned int v10; // ebx
unsigned long long v11; // rcx
unsigned long long v12; // r13
unsigned long long v14; // rdx
unsigned int v15; // r14d
long long key_block; // rax
long long v17; // r12
long long v18; // rbx
unsigned int v19; // edx
long long v20; // rdi
const char *v21; // rbx
bool v22; // zf
long long v24; // [rsp+10h] [rbp-60h]
int v25; // [rsp+24h] [rbp-4Ch] BYREF
int v26; // [rsp+28h] [rbp-48h]
unsigned int v27; // [rsp+2Ch] [rbp-44h]
unsigned long long v28; // [rsp+30h] [rbp-40h]
__m128i *v29; // [rsp+38h] [rbp-38h]
unsigned int v30; // [rsp+44h] [rbp-2Ch]
v30 = a6;
v26 = a4;
v27 = a2;
if ( a1->m128i_i8[0] )
{
v8 = a1;
m128i_i8 = a1[12].m128i_i8;
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(
(long long)a1[12].m128i_i64,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xBE2u);
else
pthread_mutex_lock(&a1[12]);
v10 = 0;
if ( a1->m128i_i8[3] && !a1->m128i_i8[1] )
{
v24 = a5;
v29 = a1 + 12;
++a1[7].m128i_i64[0];
v11 = a1[1].m128i_u32[2];
v28 = a3;
v12 = a3 % v11;
while ( 1 )
{
if ( !a1->m128i_i8[3] || a1->m128i_i8[1] )
{
v10 = 0;
goto LABEL_31;
}
v14 = v28 - (unsigned int)v12;
v15 = a1[1].m128i_i32[2] - v12;
if ( v30 < v15 )
v15 = v30;
a1[21] = _mm_sub_epi64(_mm_loadu_si128(a1 + 21), (__m128i)xmmword_D9140);
v10 = 0;
v28 = v14;
key_block = find_key_block((unsigned long long)a1, v27, v14, v26, 0, &v25);
if ( !key_block )
goto LABEL_31;
v17 = key_block;
v18 = v15;
if ( (*(_BYTE *)(key_block + 80) & 1) == 0 )
{
if ( v25 == 1 )
{
v19 = a1[1].m128i_u32[2];
if ( (_DWORD)v12 || v15 < v19 )
{
read_block_primary((long long)a1, key_block, v19, v15 + v12);
}
else
{
v20 = a1[16].m128i_i64[0];
if ( v20 )
((void ( *)(long long))PSI_server[44])(v20);
v21 = (const char *)v29;
pthread_mutex_unlock(v29);
memcpy(*(_QWORD *)(v17 + 64) + (unsigned int)v12, v24, v15);
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(
(long long)v21,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xC4Bu);
else
pthread_mutex_lock(v21);
*(_BYTE *)(v17 + 80) |= 2u;
*(_DWORD *)(v17 + 76) = v15;
release_whole_queue((long long *)(v17 + 40));
v18 = v15;
}
}
else if ( v25 == 2 )
{
wait_on_queue((long long *)(key_block + 40), v29->m128i_i8);
}
}
remove_reader(v17);
if ( (*(_BYTE *)(v17 + 80) & 1) != 0 )
break;
unreg_request_0(a1, v17, 1LL);
v24 += v18;
v28 += v15 + (unsigned int)v12;
LODWORD(v12) = 0;
v10 = 0;
v30 -= v15;
if ( !v30 )
goto LABEL_31;
}
free_block_0((long long)a1, v17);
v10 = 1;
LABEL_31:
v22 = a1[7].m128i_i64[0]-- == 1;
v8 = a1;
if ( v22 )
release_whole_queue(a1[17].m128i_i64);
m128i_i8 = (const char *)v29;
}
if ( v8[16].m128i_i64[0] )
PSI_server[44]();
pthread_mutex_unlock(m128i_i8);
}
else
{
return 0;
}
return v10;
}
|
simple_key_cache_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x2c],R9D
MOV dword ptr [RBP + -0x48],ECX
MOV dword ptr [RBP + -0x44],ESI
CMP byte ptr [RDI],0x0
JZ 0x0019944f
MOV R15,R8
MOV R13,RDX
MOV R12,RDI
LEA R14,[RDI + 0xc0]
CMP qword ptr [RDI + 0x100],0x0
JNZ 0x001994a7
MOV RDI,R14
CALL 0x00129220
LAB_0019926d:
XOR EBX,EBX
CMP byte ptr [R12 + 0x3],0x0
JZ 0x00199481
CMP byte ptr [R12 + 0x1],0x0
JNZ 0x00199481
MOV qword ptr [RBP + -0x60],R15
MOV qword ptr [RBP + -0x38],R14
INC qword ptr [R12 + 0x70]
MOV ECX,dword ptr [R12 + 0x18]
MOV qword ptr [RBP + -0x40],R13
MOV RAX,R13
XOR EDX,EDX
DIV RCX
MOV R13,RDX
MOV R15,R12
LAB_001992ab:
CMP byte ptr [R15 + 0x3],0x0
JZ 0x00199453
CMP byte ptr [R15 + 0x1],0x0
JNZ 0x00199453
MOV EAX,R13D
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
SUB RDX,RAX
MOV R14D,dword ptr [R15 + 0x18]
SUB R14D,R13D
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,R14D
CMOVC R14D,EAX
MOVDQU XMM0,xmmword ptr [R15 + 0x150]
PSUBQ XMM0,xmmword ptr [0x001d9140]
MOVDQU xmmword ptr [R15 + 0x150],XMM0
XOR EBX,EBX
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0x40],RDX
MOV ECX,dword ptr [RBP + -0x48]
XOR R8D,R8D
LEA R9,[RBP + -0x4c]
CALL 0x00197795
TEST RAX,RAX
JZ 0x00199467
MOV R12,RAX
TEST byte ptr [RAX + 0x50],0x1
MOV EBX,R14D
JNZ 0x001993e2
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,0x1
JZ 0x00199354
CMP EAX,0x2
JNZ 0x001993e2
MOV RDI,R12
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00197704
JMP 0x001993e2
LAB_00199354:
MOV EDX,dword ptr [R15 + 0x18]
TEST R13D,R13D
JNZ 0x001993d3
CMP R14D,EDX
JC 0x001993d3
MOV qword ptr [RBP + -0x58],RBX
MOV qword ptr [RBP + -0x68],R15
MOV RDI,qword ptr [R15 + 0x100]
TEST RDI,RDI
JNZ 0x00199421
LAB_0019937a:
MOV RBX,qword ptr [RBP + -0x38]
MOV RDI,RBX
CALL 0x001291e0
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,qword ptr [R12 + 0x40]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RAX + 0x100],0x0
JNZ 0x00199436
MOV RDI,RBX
CALL 0x00129220
LAB_001993b6:
OR byte ptr [R12 + 0x50],0x2
MOV dword ptr [R12 + 0x4c],R14D
MOV RDI,R12
ADD RDI,0x28
CALL 0x001989b9
MOV RBX,qword ptr [RBP + -0x58]
JMP 0x001993e2
LAB_001993d3:
LEA ECX,[R14 + R13*0x1]
MOV RDI,R15
MOV RSI,R12
CALL 0x00197f96
LAB_001993e2:
MOV RDI,R12
CALL 0x00198064
TEST byte ptr [R12 + 0x50],0x1
JNZ 0x00199457
MOV RDI,R15
MOV RSI,R12
MOV EDX,0x1
CALL 0x001980ac
ADD qword ptr [RBP + -0x60],RBX
ADD R13D,R14D
ADD qword ptr [RBP + -0x40],R13
XOR R13D,R13D
MOV EBX,0x0
SUB dword ptr [RBP + -0x2c],R14D
JNZ 0x001992ab
JMP 0x00199467
LAB_00199421:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019937a
LAB_00199436:
MOV RDI,RBX
LEA RSI,[0x1dc36b]
MOV EDX,0xc4b
CALL 0x0012eb8f
JMP 0x001993b6
LAB_0019944f:
XOR EBX,EBX
JMP 0x00199496
LAB_00199453:
XOR EBX,EBX
JMP 0x00199467
LAB_00199457:
MOV RDI,R15
MOV RSI,R12
CALL 0x001981b4
MOV EBX,0x1
LAB_00199467:
DEC qword ptr [R15 + 0x70]
MOV R12,R15
JNZ 0x0019947d
LEA RDI,[R12 + 0x110]
CALL 0x001989b9
LAB_0019947d:
MOV R14,qword ptr [RBP + -0x38]
LAB_00199481:
MOV RDI,qword ptr [R12 + 0x100]
TEST RDI,RDI
JNZ 0x001994c0
LAB_0019948e:
MOV RDI,R14
CALL 0x001291e0
LAB_00199496:
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001994a7:
LEA RSI,[0x1dc36b]
MOV RDI,R14
MOV EDX,0xbe2
CALL 0x0012eb8f
JMP 0x0019926d
LAB_001994c0:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0019948e
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8
simple_key_cache_insert
(char *param_1,int4 param_2,ulong param_3,int4 param_4,void *param_5,
uint param_6)
{
long *plVar1;
uint uVar2;
ulong uVar3;
int8 uVar4;
int iVar5;
pthread_mutex_t *ppVar6;
long lVar7;
void *local_68;
int local_54;
int4 local_50;
int4 local_4c;
ulong local_48;
pthread_mutex_t *local_40;
uint local_34;
if (*param_1 == '\0') {
uVar4 = 0;
}
else {
ppVar6 = (pthread_mutex_t *)(param_1 + 0xc0);
local_50 = param_4;
local_4c = param_2;
local_34 = param_6;
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xbe2);
}
uVar4 = 0;
if ((param_1[3] != '\0') && (param_1[1] == '\0')) {
*(long *)(param_1 + 0x70) = *(long *)(param_1 + 0x70) + 1;
uVar3 = param_3 % (ulong)*(uint *)(param_1 + 0x18);
local_68 = param_5;
local_48 = param_3;
local_40 = ppVar6;
do {
if ((param_1[3] == '\0') || (param_1[1] != '\0')) {
uVar4 = 0;
break;
}
iVar5 = (int)uVar3;
local_48 = local_48 - uVar3;
uVar2 = *(int *)(param_1 + 0x18) - iVar5;
if (local_34 < (uint)(*(int *)(param_1 + 0x18) - iVar5)) {
uVar2 = local_34;
}
lVar7 = *(long *)(param_1 + 0x158) - _UNK_001d9148;
*(long *)(param_1 + 0x150) = *(long *)(param_1 + 0x150) - _DAT_001d9140;
*(long *)(param_1 + 0x158) = lVar7;
uVar4 = 0;
lVar7 = find_key_block(param_1,local_4c,local_48,local_50,0,&local_54);
if (lVar7 == 0) break;
if ((*(byte *)(lVar7 + 0x50) & 1) == 0) {
if (local_54 == 1) {
if ((iVar5 == 0) && (*(uint *)(param_1 + 0x18) <= uVar2)) {
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
ppVar6 = local_40;
pthread_mutex_unlock(local_40);
memcpy((void *)(uVar3 + *(long *)(lVar7 + 0x40)),local_68,(ulong)uVar2);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c"
,0xc4b);
}
*(byte *)(lVar7 + 0x50) = *(byte *)(lVar7 + 0x50) | 2;
*(uint *)(lVar7 + 0x4c) = uVar2;
release_whole_queue(lVar7 + 0x28);
}
else {
read_block_primary(param_1,lVar7,*(uint *)(param_1 + 0x18),uVar2 + iVar5);
}
}
else if (local_54 == 2) {
wait_on_queue(lVar7 + 0x28,local_40);
}
}
remove_reader(lVar7);
if ((*(byte *)(lVar7 + 0x50) & 1) != 0) {
free_block(param_1,lVar7);
uVar4 = 1;
break;
}
unreg_request(param_1,lVar7,1);
local_68 = (void *)((long)local_68 + (ulong)uVar2);
local_48 = local_48 + (iVar5 + uVar2);
uVar3 = 0;
uVar4 = 0;
local_34 = local_34 - uVar2;
} while (local_34 != 0);
plVar1 = (long *)(param_1 + 0x70);
*plVar1 = *plVar1 + -1;
ppVar6 = local_40;
if (*plVar1 == 0) {
release_whole_queue(param_1 + 0x110);
ppVar6 = local_40;
}
}
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar6);
}
return uVar4;
}
|
|
9,664 |
bf_logic_op
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
{
bf_t b1_s, a1_s, *a, *b;
limb_t a_sign, b_sign, r_sign;
slimb_t l, i, a_bit_offset, b_bit_offset;
limb_t v1, v2, v1_mask, v2_mask, r_mask;
int ret;
assert(r != a1 && r != b1);
if (a1->expn <= 0)
a_sign = 0; /* minus zero is considered as positive */
else
a_sign = a1->sign;
if (b1->expn <= 0)
b_sign = 0; /* minus zero is considered as positive */
else
b_sign = b1->sign;
if (a_sign) {
a = &a1_s;
bf_init(r->ctx, a);
if (bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ)) {
b = NULL;
goto fail;
}
} else {
a = (bf_t *)a1;
}
if (b_sign) {
b = &b1_s;
bf_init(r->ctx, b);
if (bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ))
goto fail;
} else {
b = (bf_t *)b1;
}
r_sign = bf_logic_op1(a_sign, b_sign, op);
if (op == BF_LOGIC_AND && r_sign == 0) {
/* no need to compute extra zeros for and */
if (a_sign == 0 && b_sign == 0)
l = bf_min(a->expn, b->expn);
else if (a_sign == 0)
l = a->expn;
else
l = b->expn;
} else {
l = bf_max(a->expn, b->expn);
}
/* Note: a or b can be zero */
l = (bf_max(l, 1) + LIMB_BITS - 1) / LIMB_BITS;
if (bf_resize(r, l))
goto fail;
a_bit_offset = a->len * LIMB_BITS - a->expn;
b_bit_offset = b->len * LIMB_BITS - b->expn;
v1_mask = -a_sign;
v2_mask = -b_sign;
r_mask = -r_sign;
for(i = 0; i < l; i++) {
v1 = get_bits(a->tab, a->len, a_bit_offset + i * LIMB_BITS) ^ v1_mask;
v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS) ^ v2_mask;
r->tab[i] = bf_logic_op1(v1, v2, op) ^ r_mask;
}
r->expn = l * LIMB_BITS;
r->sign = r_sign;
bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ); /* cannot fail */
if (r_sign) {
if (bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ))
goto fail;
}
ret = 0;
done:
if (a == &a1_s)
bf_delete(a);
if (b == &b1_s)
bf_delete(b);
return ret;
fail:
bf_set_nan(r);
ret = BF_ST_MEM_ERROR;
goto done;
}
|
O1
|
c
|
bf_logic_op:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdx), %rsi
cmpq $0x0, 0x10(%r14)
jle 0x880a1
movslq 0x8(%r14), %rbp
jmp 0x880a3
xorl %ebp, %ebp
cmpq $0x0, (%rsi)
jle 0x880b4
movslq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x880bd
movq $0x0, 0x8(%rsp)
movl %ecx, 0x14(%rsp)
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
testq %rbp, %rbp
je 0x88123
movq %rsi, %r12
leaq 0x70(%rsp), %rax
movq (%r15), %rsi
movq %rsi, -0x18(%rax)
movl $0x0, -0x10(%rax)
movq %rdx, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x58(%rsp), %r13
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x86f60
testl %eax, %eax
je 0x88129
xorl %ebx, %ebx
movq %r13, %r14
jmp 0x88259
leaq 0x10(%r14), %rdi
jmp 0x8813e
leaq 0x68(%rsp), %rdi
movq %r13, %r14
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %r12, %rsi
cmpq $0x0, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
je 0x881bb
movq %rbp, %r12
leaq 0x98(%rsp), %rax
movq (%r15), %rcx
movq %rcx, -0x18(%rax)
movl $0x0, -0x10(%rax)
movq %rdx, %rbp
movq %rdx, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x80(%rsp), %r13
movl $0x1, %edx
movq %r13, %rdi
movq %rbx, %rsi
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
movl $0x1, %r8d
callq 0x86f60
testl %eax, %eax
je 0x881a8
movq %r13, %rbx
movq %rbp, %r12
jmp 0x88263
leaq 0x90(%rsp), %rsi
movq %r13, %rbx
movq %r12, %rbp
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
cmpl $0x1, %eax
je 0x881d2
testl %eax, %eax
jne 0x881dc
movq 0x8(%rsp), %rcx
orq %rbp, %rcx
jmp 0x881e4
movq 0x8(%rsp), %rcx
xorq %rbp, %rcx
jmp 0x881e4
movq 0x8(%rsp), %rcx
andq %rbp, %rcx
cmpl $0x2, %eax
movq %rcx, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
jne 0x8820c
testq %rcx, %rcx
jne 0x8820c
movq 0x8(%rsp), %rax
orq %rbp, %rax
je 0x8821b
testq %rbp, %rbp
je 0x8822a
movq (%rsi), %rax
jmp 0x8822d
movq (%rdi), %rcx
movq (%rsi), %rax
cmpq %rax, %rcx
cmovgq %rcx, %rax
jmp 0x8822d
movq (%rdi), %rcx
movq (%rsi), %rax
cmpq %rax, %rcx
cmovlq %rcx, %rax
jmp 0x8822d
movq (%rdi), %rax
cmpq $0x2, %rax
movl $0x1, %r13d
cmovgeq %rax, %r13
addq $0x3f, %r13
movq %r13, %r12
shrq $0x6, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x84a70
testl %eax, %eax
je 0x882fa
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
cmpq $0x0, 0x18(%r15)
je 0x88285
movq (%r15), %rax
movq 0x20(%r15), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%r15)
movq $0x0, 0x18(%r15)
decq %r12
movq %r12, 0x10(%r15)
movl $0x0, 0x8(%r15)
movl $0x20, %ebp
leaq 0x58(%rsp), %rax
cmpq %rax, %r14
je 0x882c4
leaq 0x80(%rsp), %rax
cmpq %rax, %rbx
je 0x882df
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
testq %rax, %rax
je 0x882a3
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x882a3
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x882a3
movq (%rbx), %rax
testq %rax, %rax
je 0x882b0
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x882b0
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x882b0
movq 0x18(%r14), %r8
shlq $0x6, %r8
movq 0x18(%rsp), %rax
subq (%rax), %r8
movq 0x20(%r14), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rbx), %r10
movq 0x20(%rbx), %rax
movq %rax, 0x30(%rsp)
shlq $0x6, %r10
movq 0x28(%rsp), %rax
subq (%rax), %r10
negq %rbp
negq 0x8(%rsp)
movq 0x20(%rsp), %rax
negq %rax
movq %rax, 0x18(%rsp)
movl %r8d, %eax
andl $0x3f, %eax
movl $0x40, %ecx
movl $0x40, %edx
subl %eax, %edx
movq %rdx, 0x48(%rsp)
movl %r10d, %edi
andl $0x3f, %edi
subl %edi, %ecx
movq %rcx, 0x50(%rsp)
movq %r15, 0x40(%rsp)
movq 0x20(%r15), %rcx
movq %rcx, 0x28(%rsp)
xorl %r15d, %r15d
movq %rbp, %rdx
movq %r12, %rbp
movq 0x18(%r14), %r11
movq %r8, %rcx
sarq $0x6, %rcx
cmpq %r11, %rcx
jae 0x88397
movq 0x38(%rsp), %rsi
movq (%rsi,%rcx,8), %r9
jmp 0x8839a
xorl %r9d, %r9d
testl %eax, %eax
je 0x883c6
leaq 0x1(%rcx), %r12
cmpq %r11, %r12
jae 0x883b3
movq 0x38(%rsp), %rsi
movq 0x8(%rsi,%rcx,8), %r11
jmp 0x883b6
xorl %r11d, %r11d
movl %eax, %ecx
shrq %cl, %r9
movq 0x48(%rsp), %rcx
shlq %cl, %r11
orq %r11, %r9
movq 0x18(%rbx), %r12
movq %r10, %rcx
sarq $0x6, %rcx
cmpq %r12, %rcx
jae 0x883e1
movq 0x30(%rsp), %rsi
movq (%rsi,%rcx,8), %r11
jmp 0x883e4
xorl %r11d, %r11d
testl %edi, %edi
je 0x88422
movq %rbp, %rsi
movq %r14, %rbp
movq %rbx, %r14
leaq 0x1(%rcx), %rbx
cmpq %r12, %rbx
jae 0x88406
movq 0x30(%rsp), %rbx
movq 0x8(%rbx,%rcx,8), %r12
jmp 0x88409
xorl %r12d, %r12d
movl %edi, %ecx
shrq %cl, %r11
movq 0x50(%rsp), %rcx
shlq %cl, %r12
orq %r12, %r11
movq %r14, %rbx
movq %rbp, %r14
movq %rsi, %rbp
xorq 0x8(%rsp), %r11
xorq %rdx, %r9
movl 0x14(%rsp), %ecx
cmpl $0x1, %ecx
je 0x8843c
testl %ecx, %ecx
jne 0x88441
orq %r9, %r11
jmp 0x88444
xorq %r9, %r11
jmp 0x88444
andq %r9, %r11
xorq 0x18(%rsp), %r11
movq 0x28(%rsp), %rcx
movq %r11, (%rcx,%r15,8)
incq %r15
addq $0x40, %r8
addq $0x40, %r10
cmpq %r15, %rbp
jne 0x8837c
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
leaq -0x40(%r12), %rax
andq %rax, %r13
movq 0x40(%rsp), %r15
movq %r13, 0x10(%r15)
movq 0x20(%rsp), %rax
movl %eax, 0x8(%r15)
movq %r15, %rdi
movabsq $0x3fffffffffffffff, %r13 # imm = 0x3FFFFFFFFFFFFFFF
movq %r13, %rsi
movl $0x1, %edx
callq 0x84d5c
xorl %ebp, %ebp
cmpq $0x0, 0x20(%rsp)
je 0x88299
movq %r15, %rdi
movq %r15, %rsi
movq $-0x1, %rdx
movq %r13, %rcx
movl $0x1, %r8d
callq 0x86f60
testl %eax, %eax
jne 0x88263
jmp 0x88299
|
bf_logic_op:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea rsi, [rdx+10h]
cmp qword ptr [r14+10h], 0
jle short loc_880A1
movsxd rbp, dword ptr [r14+8]
jmp short loc_880A3
loc_880A1:
xor ebp, ebp
loc_880A3:
cmp qword ptr [rsi], 0
jle short loc_880B4
movsxd rax, dword ptr [rbx+8]
mov [rsp+0D8h+var_D0], rax
jmp short loc_880BD
loc_880B4:
mov [rsp+0D8h+var_D0], 0
loc_880BD:
mov [rsp+0D8h+var_C4], ecx
mov rdx, 8000000000000000h
mov rcx, 3FFFFFFFFFFFFFFFh
test rbp, rbp
jz short loc_88123
mov r12, rsi
lea rax, [rsp+0D8h+var_68]
mov rsi, [r15]
mov [rax-18h], rsi
mov dword ptr [rax-10h], 0
mov [rax-8], rdx
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
lea r13, [rsp+0D8h+var_80]
mov edx, 1
mov rdi, r13
mov rsi, r14
mov r8d, 1
call bf_add_si
test eax, eax
jz short loc_88129
xor ebx, ebx
mov r14, r13
jmp loc_88259
loc_88123:
lea rdi, [r14+10h]
jmp short loc_8813E
loc_88129:
lea rdi, [rsp+0D8h+var_70]
mov r14, r13
mov rdx, 8000000000000000h
mov rsi, r12
loc_8813E:
cmp [rsp+0D8h+var_D0], 0
mov [rsp+0D8h+var_C0], rdi
jz short loc_881BB
mov r12, rbp
lea rax, [rsp+0D8h+var_40]
mov rcx, [r15]
mov [rax-18h], rcx
mov dword ptr [rax-10h], 0
mov rbp, rdx
mov [rax-8], rdx
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
lea r13, [rsp+0D8h+var_58]
mov edx, 1
mov rdi, r13
mov rsi, rbx
mov rcx, 3FFFFFFFFFFFFFFFh
mov r8d, 1
call bf_add_si
test eax, eax
jz short loc_881A8
mov rbx, r13
mov r12, rbp
jmp loc_88263
loc_881A8:
lea rsi, [rsp+0D8h+var_48]
mov rbx, r13
mov rbp, r12
mov rdi, [rsp+0D8h+var_C0]
loc_881BB:
mov eax, [rsp+0D8h+var_C4]
cmp eax, 1
jz short loc_881D2
test eax, eax
jnz short loc_881DC
mov rcx, [rsp+0D8h+var_D0]
or rcx, rbp
jmp short loc_881E4
loc_881D2:
mov rcx, [rsp+0D8h+var_D0]
xor rcx, rbp
jmp short loc_881E4
loc_881DC:
mov rcx, [rsp+0D8h+var_D0]
and rcx, rbp
loc_881E4:
cmp eax, 2
mov [rsp+0D8h+var_B8], rcx
mov [rsp+0D8h+var_B0], rsi
jnz short loc_8820C
test rcx, rcx
jnz short loc_8820C
mov rax, [rsp+0D8h+var_D0]
or rax, rbp
jz short loc_8821B
test rbp, rbp
jz short loc_8822A
mov rax, [rsi]
jmp short loc_8822D
loc_8820C:
mov rcx, [rdi]
mov rax, [rsi]
cmp rcx, rax
cmovg rax, rcx
jmp short loc_8822D
loc_8821B:
mov rcx, [rdi]
mov rax, [rsi]
cmp rcx, rax
cmovl rax, rcx
jmp short loc_8822D
loc_8822A:
mov rax, [rdi]
loc_8822D:
cmp rax, 2
mov r13d, 1
cmovge r13, rax
add r13, 3Fh ; '?'
mov r12, r13
shr r12, 6
mov rdi, r15
mov rsi, r12
call bf_resize
test eax, eax
jz loc_882FA
loc_88259:
mov r12, 8000000000000000h
loc_88263:
cmp qword ptr [r15+18h], 0
jz short loc_88285
mov rax, [r15]
mov rsi, [r15+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [r15+20h], rax
mov qword ptr [r15+18h], 0
loc_88285:
dec r12
mov [r15+10h], r12
mov dword ptr [r15+8], 0
mov ebp, 20h ; ' '
loc_88299:
lea rax, [rsp+0D8h+var_80]
cmp r14, rax
jz short loc_882C4
loc_882A3:
lea rax, [rsp+0D8h+var_58]
cmp rbx, rax
jz short loc_882DF
loc_882B0:
mov eax, ebp
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_882C4:
mov rax, [r14]
test rax, rax
jz short loc_882A3
mov rsi, [r14+20h]
test rsi, rsi
jz short loc_882A3
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
jmp short loc_882A3
loc_882DF:
mov rax, [rbx]
test rax, rax
jz short loc_882B0
mov rsi, [rbx+20h]
test rsi, rsi
jz short loc_882B0
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
jmp short loc_882B0
loc_882FA:
mov r8, [r14+18h]
shl r8, 6
mov rax, [rsp+0D8h+var_C0]
sub r8, [rax]
mov rax, [r14+20h]
mov [rsp+0D8h+var_A0], rax
mov r10, [rbx+18h]
mov rax, [rbx+20h]
mov [rsp+0D8h+var_A8], rax
shl r10, 6
mov rax, [rsp+0D8h+var_B0]
sub r10, [rax]
neg rbp
neg [rsp+0D8h+var_D0]
mov rax, [rsp+0D8h+var_B8]
neg rax
mov [rsp+0D8h+var_C0], rax
mov eax, r8d
and eax, 3Fh
mov ecx, 40h ; '@'
mov edx, 40h ; '@'
sub edx, eax
mov [rsp+0D8h+var_90], rdx
mov edi, r10d
and edi, 3Fh
sub ecx, edi
mov [rsp+0D8h+var_88], rcx
mov [rsp+0D8h+var_98], r15
mov rcx, [r15+20h]
mov [rsp+0D8h+var_B0], rcx
xor r15d, r15d
mov rdx, rbp
mov rbp, r12
loc_8837C:
mov r11, [r14+18h]
mov rcx, r8
sar rcx, 6
cmp rcx, r11
jnb short loc_88397
mov rsi, [rsp+0D8h+var_A0]
mov r9, [rsi+rcx*8]
jmp short loc_8839A
loc_88397:
xor r9d, r9d
loc_8839A:
test eax, eax
jz short loc_883C6
lea r12, [rcx+1]
cmp r12, r11
jnb short loc_883B3
mov rsi, [rsp+0D8h+var_A0]
mov r11, [rsi+rcx*8+8]
jmp short loc_883B6
loc_883B3:
xor r11d, r11d
loc_883B6:
mov ecx, eax
shr r9, cl
mov rcx, [rsp+0D8h+var_90]
shl r11, cl
or r9, r11
loc_883C6:
mov r12, [rbx+18h]
mov rcx, r10
sar rcx, 6
cmp rcx, r12
jnb short loc_883E1
mov rsi, [rsp+0D8h+var_A8]
mov r11, [rsi+rcx*8]
jmp short loc_883E4
loc_883E1:
xor r11d, r11d
loc_883E4:
test edi, edi
jz short loc_88422
mov rsi, rbp
mov rbp, r14
mov r14, rbx
lea rbx, [rcx+1]
cmp rbx, r12
jnb short loc_88406
mov rbx, [rsp+0D8h+var_A8]
mov r12, [rbx+rcx*8+8]
jmp short loc_88409
loc_88406:
xor r12d, r12d
loc_88409:
mov ecx, edi
shr r11, cl
mov rcx, [rsp+0D8h+var_88]
shl r12, cl
or r11, r12
mov rbx, r14
mov r14, rbp
mov rbp, rsi
loc_88422:
xor r11, [rsp+0D8h+var_D0]
xor r9, rdx
mov ecx, [rsp+0D8h+var_C4]
cmp ecx, 1
jz short loc_8843C
test ecx, ecx
jnz short loc_88441
or r11, r9
jmp short loc_88444
loc_8843C:
xor r11, r9
jmp short loc_88444
loc_88441:
and r11, r9
loc_88444:
xor r11, [rsp+0D8h+var_C0]
mov rcx, [rsp+0D8h+var_B0]
mov [rcx+r15*8], r11
inc r15
add r8, 40h ; '@'
add r10, 40h ; '@'
cmp rbp, r15
jnz loc_8837C
mov r12, 8000000000000000h
lea rax, [r12-40h]
and r13, rax
mov r15, [rsp+0D8h+var_98]
mov [r15+10h], r13
mov rax, [rsp+0D8h+var_B8]
mov [r15+8], eax
mov rdi, r15
mov r13, 3FFFFFFFFFFFFFFFh
mov rsi, r13
mov edx, 1
call bf_normalize_and_round
xor ebp, ebp
cmp [rsp+0D8h+var_B8], 0
jz loc_88299
mov rdi, r15
mov rsi, r15
mov rdx, 0FFFFFFFFFFFFFFFFh
mov rcx, r13
mov r8d, 1
call bf_add_si
test eax, eax
jnz loc_88263
jmp loc_88299
|
long long bf_logic_op(long long *a1, long long *a2, long long a3, int a4)
{
long long *v4; // rbx
_QWORD *v6; // r15
long long *v7; // rsi
long long v8; // rbp
long long *v9; // rdi
long long v10; // rcx
long long v11; // rax
long long v12; // r13
unsigned long long v13; // r13
unsigned int v14; // ebp
long long v16; // rsi
long long v17; // rsi
long long v18; // r8
long long v19; // r10
int v20; // eax
int v21; // edi
long long v22; // r15
unsigned long long v23; // r11
long long v24; // rcx
unsigned long long v25; // r9
long long v26; // r11
unsigned long long v27; // r12
long long v28; // rcx
unsigned long long v29; // r11
long long v30; // r12
long long v31; // r11
long long v32; // r9
long long v33; // r11
long long v34; // [rsp+8h] [rbp-D0h]
long long v35; // [rsp+8h] [rbp-D0h]
long long v37; // [rsp+20h] [rbp-B8h]
long long v38; // [rsp+28h] [rbp-B0h]
long long v39; // [rsp+30h] [rbp-A8h]
long long v40; // [rsp+38h] [rbp-A0h]
long long v41; // [rsp+40h] [rbp-98h]
long long v42; // [rsp+58h] [rbp-80h] BYREF
int v43; // [rsp+60h] [rbp-78h]
unsigned long long v44; // [rsp+68h] [rbp-70h] BYREF
__int128 v45; // [rsp+70h] [rbp-68h]
_QWORD *v46; // [rsp+80h] [rbp-58h] BYREF
int v47; // [rsp+88h] [rbp-50h]
unsigned long long v48; // [rsp+90h] [rbp-48h] BYREF
__int128 v49; // [rsp+98h] [rbp-40h]
v4 = (long long *)a3;
v6 = a1;
v7 = (long long *)(a3 + 16);
if ( a2[2] <= 0 )
v8 = 0LL;
else
v8 = *((int *)a2 + 2);
if ( *v7 <= 0 )
v34 = 0LL;
else
v34 = *(int *)(a3 + 8);
if ( v8 )
{
v42 = *a1;
v43 = 0;
v44 = 0x8000000000000000LL;
v45 = 0LL;
if ( (unsigned int)bf_add_si(&v42, (long long)a2, 1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
{
v4 = 0LL;
a2 = &v42;
LABEL_36:
if ( v6[3] )
{
v6[4] = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*v6 + 8LL))(*(_QWORD *)*v6, v6[4], 0LL);
v6[3] = 0LL;
}
v6[2] = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)v6 + 2) = 0;
v14 = 32;
goto LABEL_39;
}
v9 = (long long *)&v44;
a2 = &v42;
}
else
{
v9 = a2 + 2;
}
if ( v34 )
{
v46 = (_QWORD *)*v6;
v47 = 0;
v48 = 0x8000000000000000LL;
v49 = 0LL;
if ( (unsigned int)bf_add_si((long long *)&v46, (long long)v4, 1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
{
v4 = (long long *)&v46;
goto LABEL_36;
}
v7 = (long long *)&v48;
v4 = (long long *)&v46;
}
if ( a4 == 1 )
{
v10 = v8 ^ v34;
}
else if ( a4 )
{
v10 = v8 & v34;
}
else
{
v10 = v8 | v34;
}
v37 = v10;
if ( a4 != 2 || v10 )
{
v11 = *v7;
if ( *v9 > *v7 )
v11 = *v9;
}
else if ( v8 | v34 )
{
if ( v8 )
v11 = *v7;
else
v11 = *v9;
}
else
{
v11 = *v7;
if ( *v9 < *v7 )
v11 = *v9;
}
v12 = 1LL;
if ( v11 >= 2 )
v12 = v11;
v13 = v12 + 63;
if ( (unsigned int)bf_resize((long long)v6, v13 >> 6) )
goto LABEL_36;
v18 = (a2[3] << 6) - *v9;
v40 = a2[4];
v39 = v4[4];
v19 = (v4[3] << 6) - *v7;
v35 = -v34;
v20 = v18 & 0x3F;
v21 = v19 & 0x3F;
v41 = (long long)v6;
v38 = v6[4];
v22 = 0LL;
do
{
v23 = a2[3];
v24 = v18 >> 6;
if ( v18 >> 6 >= v23 )
v25 = 0LL;
else
v25 = *(_QWORD *)(v40 + 8 * v24);
if ( v20 )
{
if ( v24 + 1 >= v23 )
v26 = 0LL;
else
v26 = *(_QWORD *)(v40 + 8 * v24 + 8);
v25 = (v26 << (64 - (unsigned __int8)v20)) | (v25 >> v20);
}
v27 = v4[3];
v28 = v19 >> 6;
if ( v19 >> 6 >= v27 )
v29 = 0LL;
else
v29 = *(_QWORD *)(v39 + 8 * v28);
if ( v21 )
{
if ( v28 + 1 >= v27 )
v30 = 0LL;
else
v30 = *(_QWORD *)(v39 + 8 * v28 + 8);
v29 = (v30 << (64 - (unsigned __int8)v21)) | (v29 >> v21);
}
v31 = v35 ^ v29;
v32 = -v8 ^ v25;
if ( a4 == 1 )
{
v33 = v32 ^ v31;
}
else if ( a4 )
{
v33 = v32 & v31;
}
else
{
v33 = v32 | v31;
}
*(_QWORD *)(v38 + 8 * v22++) = -v37 ^ v33;
v18 += 64LL;
v19 += 64LL;
}
while ( v13 >> 6 != v22 );
v6 = (_QWORD *)v41;
*(_QWORD *)(v41 + 16) = v13 & 0x7FFFFFFFFFFFFFC0LL;
*(_DWORD *)(v41 + 8) = v37;
bf_normalize_and_round((_QWORD *)v41, 0x3FFFFFFFFFFFFFFFLL, 1LL);
v14 = 0;
if ( v37 )
{
if ( (unsigned int)bf_add_si((long long *)v41, v41, -1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
goto LABEL_36;
}
LABEL_39:
if ( a2 == &v42 )
{
if ( *a2 )
{
v16 = a2[4];
if ( v16 )
(*(void ( **)(_QWORD, long long, _QWORD))(*a2 + 8))(*(_QWORD *)*a2, v16, 0LL);
}
}
if ( v4 == (long long *)&v46 )
{
if ( *v4 )
{
v17 = v4[4];
if ( v17 )
(*(void ( **)(_QWORD, long long, _QWORD))(*v4 + 8))(*(_QWORD *)*v4, v17, 0LL);
}
}
return v14;
}
| |||
9,665 |
bf_logic_op
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
{
bf_t b1_s, a1_s, *a, *b;
limb_t a_sign, b_sign, r_sign;
slimb_t l, i, a_bit_offset, b_bit_offset;
limb_t v1, v2, v1_mask, v2_mask, r_mask;
int ret;
assert(r != a1 && r != b1);
if (a1->expn <= 0)
a_sign = 0; /* minus zero is considered as positive */
else
a_sign = a1->sign;
if (b1->expn <= 0)
b_sign = 0; /* minus zero is considered as positive */
else
b_sign = b1->sign;
if (a_sign) {
a = &a1_s;
bf_init(r->ctx, a);
if (bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ)) {
b = NULL;
goto fail;
}
} else {
a = (bf_t *)a1;
}
if (b_sign) {
b = &b1_s;
bf_init(r->ctx, b);
if (bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ))
goto fail;
} else {
b = (bf_t *)b1;
}
r_sign = bf_logic_op1(a_sign, b_sign, op);
if (op == BF_LOGIC_AND && r_sign == 0) {
/* no need to compute extra zeros for and */
if (a_sign == 0 && b_sign == 0)
l = bf_min(a->expn, b->expn);
else if (a_sign == 0)
l = a->expn;
else
l = b->expn;
} else {
l = bf_max(a->expn, b->expn);
}
/* Note: a or b can be zero */
l = (bf_max(l, 1) + LIMB_BITS - 1) / LIMB_BITS;
if (bf_resize(r, l))
goto fail;
a_bit_offset = a->len * LIMB_BITS - a->expn;
b_bit_offset = b->len * LIMB_BITS - b->expn;
v1_mask = -a_sign;
v2_mask = -b_sign;
r_mask = -r_sign;
for(i = 0; i < l; i++) {
v1 = get_bits(a->tab, a->len, a_bit_offset + i * LIMB_BITS) ^ v1_mask;
v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS) ^ v2_mask;
r->tab[i] = bf_logic_op1(v1, v2, op) ^ r_mask;
}
r->expn = l * LIMB_BITS;
r->sign = r_sign;
bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ); /* cannot fail */
if (r_sign) {
if (bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ))
goto fail;
}
ret = 0;
done:
if (a == &a1_s)
bf_delete(a);
if (b == &b1_s)
bf_delete(b);
return ret;
fail:
bf_set_nan(r);
ret = BF_ST_MEM_ERROR;
goto done;
}
|
O2
|
c
|
bf_logic_op:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x10, %rdx
cmpq $0x0, 0x10(%rsi)
jle 0x72053
movslq 0x8(%r14), %r15
jmp 0x72056
xorl %r15d, %r15d
cmpq $0x0, (%rdx)
jle 0x72067
movslq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x72070
movq $0x0, 0x8(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
testq %r15, %r15
movl %ecx, 0x14(%rsp)
je 0x720dc
movq %rdx, %rbp
movq %r15, %r13
movq %rax, %rdx
leaq 0x60(%rsp), %rax
movq (%r12), %rcx
movq %rcx, -0x18(%rax)
andl $0x0, -0x10(%rax)
movq %rdx, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x48(%rsp), %r15
pushq $0x1
popq %rdx
pushq $0x1
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq %r9, %rcx
movq %r9, %r14
callq 0x7137a
testl %eax, %eax
je 0x720e2
xorl %ebx, %ebx
movq %r15, %r14
jmp 0x721d1
leaq 0x10(%r14), %rdi
jmp 0x72101
leaq 0x58(%rsp), %rdi
movq %r14, %r9
movq %r15, %r14
movl 0x14(%rsp), %ecx
movq %r13, %r15
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rbp, %rdx
cmpq $0x0, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
je 0x7216c
movq %r15, %r13
movq %rax, %rdx
leaq 0x88(%rsp), %rax
movq (%r12), %rcx
movq %rcx, -0x18(%rax)
andl $0x0, -0x10(%rax)
movq %rdx, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x70(%rsp), %r15
pushq $0x1
popq %rdx
pushq $0x1
popq %r8
movq %r15, %rdi
movq %rbx, %rsi
movq %r9, %rcx
callq 0x7137a
testl %eax, %eax
je 0x72155
movq %r15, %rbx
jmp 0x721d1
leaq 0x80(%rsp), %rdx
movq %r15, %rbx
movl 0x14(%rsp), %ecx
movq %r13, %r15
movq 0x18(%rsp), %rdi
pushq $0x1
popq %rbp
cmpl $0x1, %ecx
movq %rdx, 0x28(%rsp)
je 0x7218b
testl %ecx, %ecx
jne 0x72330
movq 0x8(%rsp), %rsi
orq %r15, %rsi
jmp 0x72193
movq 0x8(%rsp), %rsi
xorq %r15, %rsi
testq %rsi, %rsi
sete %al
movq %rsi, 0x20(%rsp)
movb %al, 0x7(%rsp)
movq (%rdi), %rcx
movq (%rdx), %rax
cmpq %rax, %rcx
cmovgq %rcx, %rax
cmpq $0x2, %rax
cmovgeq %rax, %rbp
addq $0x3f, %rbp
movq %rbp, %r13
shrq $0x6, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6f50f
testl %eax, %eax
je 0x72214
movq %r12, %rdi
callq 0x6f5cd
pushq $0x20
popq %rbp
leaq 0x48(%rsp), %rax
cmpq %rax, %r14
jne 0x721ee
movq %r14, %rdi
callq 0x7145e
leaq 0x70(%rsp), %rax
cmpq %rax, %rbx
jne 0x72200
movq %rbx, %rdi
callq 0x7145e
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x40(%rsp)
movq %r12, 0x38(%rsp)
movq %r14, 0x30(%rsp)
movq 0x18(%r14), %r12
shlq $0x6, %r12
movq 0x18(%rsp), %rax
subq (%rax), %r12
movq %rbx, 0x18(%rsp)
movq %r15, %rax
movq 0x18(%rbx), %r15
shlq $0x6, %r15
movq 0x28(%rsp), %rcx
subq (%rcx), %r15
negq %rax
movq %rax, 0x28(%rsp)
negq 0x8(%rsp)
movq 0x20(%rsp), %rbx
negq %rbx
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x722d6
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdi
movq %r12, %rdx
callq 0x72665
movq %rax, %rbp
xorq 0x28(%rsp), %rbp
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdi
movq %r15, %rdx
callq 0x72665
xorq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpl $0x1, %ecx
je 0x722b1
testl %ecx, %ecx
jne 0x722b6
orq %rbp, %rax
jmp 0x722b9
xorq %rbp, %rax
jmp 0x722b9
andq %rbp, %rax
xorq %rbx, %rax
movq 0x38(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
addq $0x40, %r12
addq $0x40, %r15
jmp 0x72263
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
addq $-0x40, %rax
movq 0x40(%rsp), %rcx
andq %rax, %rcx
movq 0x38(%rsp), %r12
movq %rcx, 0x10(%r12)
movq 0x20(%rsp), %rax
movl %eax, 0x8(%r12)
pushq $0x1
popq %rdx
movq %r12, %rdi
movabsq $0x3fffffffffffffff, %rbx # imm = 0x3FFFFFFFFFFFFFFF
movq %rbx, %rsi
callq 0x6f707
xorl %ebp, %ebp
cmpb $0x0, 0x7(%rsp)
je 0x72361
movq 0x18(%rsp), %rbx
movq 0x30(%rsp), %r14
jmp 0x721dc
movq 0x8(%rsp), %rsi
andq %r15, %rsi
sete %al
cmpl $0x2, %ecx
jne 0x72199
testq %rsi, %rsi
jne 0x72199
movq 0x8(%rsp), %rax
orq %r15, %rax
je 0x7238d
testq %r15, %r15
je 0x7239c
movq (%rdx), %rax
jmp 0x7239f
pushq $-0x1
popq %rdx
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x7137a
testl %eax, %eax
movq 0x18(%rsp), %rbx
movq 0x30(%rsp), %r14
jne 0x721d1
jmp 0x721dc
movq (%rdi), %rcx
movq (%rdx), %rax
cmpq %rax, %rcx
cmovlq %rcx, %rax
jmp 0x7239f
movq (%rdi), %rax
movb $0x1, 0x7(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x721af
|
bf_logic_op:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov rbx, rdx
mov r14, rsi
mov r12, rdi
add rdx, 10h
cmp qword ptr [rsi+10h], 0
jle short loc_72053
movsxd r15, dword ptr [r14+8]
jmp short loc_72056
loc_72053:
xor r15d, r15d
loc_72056:
cmp qword ptr [rdx], 0
jle short loc_72067
movsxd rax, dword ptr [rbx+8]
mov [rsp+0C8h+var_C0], rax
jmp short loc_72070
loc_72067:
mov [rsp+0C8h+var_C0], 0
loc_72070:
mov rax, 8000000000000000h
mov r9, 3FFFFFFFFFFFFFFFh
test r15, r15
mov [rsp+0C8h+var_B4], ecx
jz short loc_720DC
mov rbp, rdx
mov r13, r15
mov rdx, rax
lea rax, [rsp+0C8h+var_68]
mov rcx, [r12]
mov [rax-18h], rcx
and dword ptr [rax-10h], 0
mov [rax-8], rdx
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
lea r15, [rsp+0C8h+var_80]
push 1
pop rdx
push 1
pop r8
mov rdi, r15
mov rsi, r14
mov rcx, r9
mov r14, r9
call bf_add_si
test eax, eax
jz short loc_720E2
xor ebx, ebx
mov r14, r15
jmp loc_721D1
loc_720DC:
lea rdi, [r14+10h]
jmp short loc_72101
loc_720E2:
lea rdi, [rsp+0C8h+var_70]
mov r9, r14
mov r14, r15
mov ecx, [rsp+0C8h+var_B4]
mov r15, r13
mov rax, 8000000000000000h
mov rdx, rbp
loc_72101:
cmp [rsp+0C8h+var_C0], 0
mov [rsp+0C8h+var_B0], rdi
jz short loc_7216C
mov r13, r15
mov rdx, rax
lea rax, [rsp+0C8h+var_40]
mov rcx, [r12]
mov [rax-18h], rcx
and dword ptr [rax-10h], 0
mov [rax-8], rdx
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
lea r15, [rsp+0C8h+var_58]
push 1
pop rdx
push 1
pop r8
mov rdi, r15
mov rsi, rbx
mov rcx, r9
call bf_add_si
test eax, eax
jz short loc_72155
mov rbx, r15
jmp short loc_721D1
loc_72155:
lea rdx, [rsp+0C8h+var_48]
mov rbx, r15
mov ecx, [rsp+0C8h+var_B4]
mov r15, r13
mov rdi, [rsp+0C8h+var_B0]
loc_7216C:
push 1
pop rbp
cmp ecx, 1
mov [rsp+0C8h+var_A0], rdx
jz short loc_7218B
test ecx, ecx
jnz loc_72330
mov rsi, [rsp+0C8h+var_C0]
or rsi, r15
jmp short loc_72193
loc_7218B:
mov rsi, [rsp+0C8h+var_C0]
xor rsi, r15
loc_72193:
test rsi, rsi
setz al
loc_72199:
mov [rsp+0C8h+var_A8], rsi
mov [rsp+0C8h+var_C1], al
mov rcx, [rdi]
mov rax, [rdx]
cmp rcx, rax
cmovg rax, rcx
loc_721AF:
cmp rax, 2
cmovge rbp, rax
add rbp, 3Fh ; '?'
mov r13, rbp
shr r13, 6
mov rdi, r12
mov rsi, r13
call bf_resize
test eax, eax
jz short loc_72214
loc_721D1:
mov rdi, r12
call bf_set_nan
push 20h ; ' '
pop rbp
loc_721DC:
lea rax, [rsp+0C8h+var_80]
cmp r14, rax
jnz short loc_721EE
mov rdi, r14
call bf_delete_0
loc_721EE:
lea rax, [rsp+0C8h+var_58]
cmp rbx, rax
jnz short loc_72200
mov rdi, rbx
call bf_delete_0
loc_72200:
mov eax, ebp
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_72214:
mov [rsp+0C8h+var_88], rbp
mov [rsp+0C8h+var_90], r12
mov [rsp+0C8h+var_98], r14
mov r12, [r14+18h]
shl r12, 6
mov rax, [rsp+0C8h+var_B0]
sub r12, [rax]
mov [rsp+0C8h+var_B0], rbx
mov rax, r15
mov r15, [rbx+18h]
shl r15, 6
mov rcx, [rsp+0C8h+var_A0]
sub r15, [rcx]
neg rax
mov [rsp+0C8h+var_A0], rax
neg [rsp+0C8h+var_C0]
mov rbx, [rsp+0C8h+var_A8]
neg rbx
xor r14d, r14d
loc_72263:
cmp r13, r14
jz short loc_722D6
mov rax, [rsp+0C8h+var_98]
mov rsi, [rax+18h]
mov rdi, [rax+20h]
mov rdx, r12
call get_bits
mov rbp, rax
xor rbp, [rsp+0C8h+var_A0]
mov rax, [rsp+0C8h+var_B0]
mov rsi, [rax+18h]
mov rdi, [rax+20h]
mov rdx, r15
call get_bits
xor rax, [rsp+0C8h+var_C0]
mov ecx, [rsp+0C8h+var_B4]
cmp ecx, 1
jz short loc_722B1
test ecx, ecx
jnz short loc_722B6
or rax, rbp
jmp short loc_722B9
loc_722B1:
xor rax, rbp
jmp short loc_722B9
loc_722B6:
and rax, rbp
loc_722B9:
xor rax, rbx
mov rcx, [rsp+0C8h+var_90]
mov rcx, [rcx+20h]
mov [rcx+r14*8], rax
inc r14
add r12, 40h ; '@'
add r15, 40h ; '@'
jmp short loc_72263
loc_722D6:
mov rax, 8000000000000000h
add rax, 0FFFFFFFFFFFFFFC0h
mov rcx, [rsp+0C8h+var_88]
and rcx, rax
mov r12, [rsp+0C8h+var_90]
mov [r12+10h], rcx
mov rax, [rsp+0C8h+var_A8]
mov [r12+8], eax
push 1
pop rdx
mov rdi, r12
mov rbx, 3FFFFFFFFFFFFFFFh
mov rsi, rbx
call bf_normalize_and_round
xor ebp, ebp
cmp [rsp+0C8h+var_C1], 0
jz short loc_72361
mov rbx, [rsp+0C8h+var_B0]
mov r14, [rsp+0C8h+var_98]
jmp loc_721DC
loc_72330:
mov rsi, [rsp+0C8h+var_C0]
and rsi, r15
setz al
cmp ecx, 2
jnz loc_72199
test rsi, rsi
jnz loc_72199
mov rax, [rsp+0C8h+var_C0]
or rax, r15
jz short loc_7238D
test r15, r15
jz short loc_7239C
mov rax, [rdx]
jmp short loc_7239F
loc_72361:
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 1
pop r8
mov rdi, r12
mov rsi, r12
mov rcx, rbx
call bf_add_si
test eax, eax
mov rbx, [rsp+0C8h+var_B0]
mov r14, [rsp+0C8h+var_98]
jnz loc_721D1
jmp loc_721DC
loc_7238D:
mov rcx, [rdi]
mov rax, [rdx]
cmp rcx, rax
cmovl rax, rcx
jmp short loc_7239F
loc_7239C:
mov rax, [rdi]
loc_7239F:
mov [rsp+0C8h+var_C1], 1
mov [rsp+0C8h+var_A8], 0
jmp loc_721AF
|
long long bf_logic_op(long long *a1, long long a2, long long *a3, int a4)
{
long long *v4; // rbx
long long *v5; // r14
long long *v6; // r12
long long *v7; // rdx
long long v8; // r15
long long *v9; // rbp
long long *v10; // rdi
long long v11; // rbp
long long v12; // rsi
bool v13; // al
long long v14; // rax
unsigned long long v15; // rbp
unsigned long long v16; // r13
unsigned int v17; // ebp
long long v19; // r12
long long v20; // rax
long long v21; // r15
long long i; // r14
long long v23; // rbp
long long v24; // rax
long long v25; // rax
char v26; // [rsp+7h] [rbp-C1h]
long long v27; // [rsp+8h] [rbp-C0h]
long long v28; // [rsp+8h] [rbp-C0h]
int v29; // [rsp+14h] [rbp-B4h]
long long v30; // [rsp+20h] [rbp-A8h]
long long *v31; // [rsp+28h] [rbp-A0h]
long long v32; // [rsp+28h] [rbp-A0h]
long long *v33; // [rsp+30h] [rbp-98h]
long long v34; // [rsp+38h] [rbp-90h]
unsigned long long v35; // [rsp+40h] [rbp-88h]
long long v36; // [rsp+48h] [rbp-80h] BYREF
int v37; // [rsp+50h] [rbp-78h]
unsigned long long v38; // [rsp+58h] [rbp-70h] BYREF
__int128 v39; // [rsp+60h] [rbp-68h]
long long v40; // [rsp+70h] [rbp-58h] BYREF
int v41; // [rsp+78h] [rbp-50h]
unsigned long long v42; // [rsp+80h] [rbp-48h] BYREF
__int128 v43; // [rsp+88h] [rbp-40h]
v4 = a3;
v5 = (long long *)a2;
v6 = a1;
v7 = a3 + 2;
if ( *(long long *)(a2 + 16) <= 0 )
v8 = 0LL;
else
v8 = *(int *)(a2 + 8);
if ( *v7 <= 0 )
v27 = 0LL;
else
v27 = *((int *)v4 + 2);
v29 = a4;
if ( v8 )
{
v9 = v7;
v36 = *a1;
v37 = 0;
v38 = 0x8000000000000000LL;
v39 = 0LL;
if ( (unsigned int)bf_add_si(&v36, a2, 1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
{
v4 = 0LL;
v5 = &v36;
LABEL_26:
bf_set_nan((long long)v6);
v17 = 32;
goto LABEL_27;
}
v10 = (long long *)&v38;
v5 = &v36;
a4 = v29;
v7 = v9;
}
else
{
v10 = (long long *)(a2 + 16);
}
if ( v27 )
{
v40 = *v6;
v41 = 0;
v42 = 0x8000000000000000LL;
v43 = 0LL;
if ( (unsigned int)bf_add_si(&v40, (long long)v4, 1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
{
v4 = &v40;
goto LABEL_26;
}
v7 = (long long *)&v42;
v4 = &v40;
a4 = v29;
}
v11 = 1LL;
v31 = v7;
if ( a4 == 1 )
{
v12 = v8 ^ v27;
goto LABEL_20;
}
if ( !a4 )
{
v12 = v8 | v27;
LABEL_20:
v13 = v12 == 0;
goto LABEL_21;
}
v12 = v8 & v27;
v13 = (v8 & v27) == 0;
if ( a4 != 2 || v12 )
{
LABEL_21:
v30 = v12;
v26 = v13;
v14 = *v7;
if ( *v10 > *v7 )
v14 = *v10;
goto LABEL_23;
}
if ( v8 | v27 )
{
if ( v8 )
v14 = *v7;
else
v14 = *v10;
}
else
{
v14 = *v7;
if ( *v10 < *v7 )
v14 = *v10;
}
v26 = 1;
v30 = 0LL;
LABEL_23:
if ( v14 >= 2 )
v11 = v14;
v15 = v11 + 63;
v16 = v15 >> 6;
if ( (unsigned int)bf_resize((long long)v6, v15 >> 6) )
goto LABEL_26;
v35 = v15;
v34 = (long long)v6;
v33 = v5;
v19 = (v5[3] << 6) - *v10;
v20 = v8;
v21 = (v4[3] << 6) - *v31;
v32 = -v20;
v28 = -v27;
for ( i = 0LL; v16 != i; ++i )
{
v23 = v32 ^ get_bits(v33[4], v33[3], v19);
v24 = v28 ^ get_bits(v4[4], v4[3], v21);
if ( v29 == 1 )
{
v25 = v23 ^ v24;
}
else if ( v29 )
{
v25 = v23 & v24;
}
else
{
v25 = v23 | v24;
}
*(_QWORD *)(*(_QWORD *)(v34 + 32) + 8 * i) = -v30 ^ v25;
v19 += 64LL;
v21 += 64LL;
}
v6 = (long long *)v34;
*(_QWORD *)(v34 + 16) = v35 & 0x7FFFFFFFFFFFFFC0LL;
*(_DWORD *)(v34 + 8) = v30;
bf_normalize_and_round((_QWORD *)v34, 0x3FFFFFFFFFFFFFFFLL, 1LL);
v17 = 0;
if ( v26 )
{
v5 = v33;
}
else
{
v5 = v33;
if ( (unsigned int)bf_add_si((long long *)v34, v34, -1LL, 0x3FFFFFFFFFFFFFFFLL, 1u) )
goto LABEL_26;
}
LABEL_27:
if ( v5 == &v36 )
bf_delete_0(v5);
if ( v4 == &v40 )
bf_delete_0(v4);
return v17;
}
|
bf_logic_op:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
ADD RDX,0x10
CMP qword ptr [RSI + 0x10],0x0
JLE 0x00172053
MOVSXD R15,dword ptr [R14 + 0x8]
JMP 0x00172056
LAB_00172053:
XOR R15D,R15D
LAB_00172056:
CMP qword ptr [RDX],0x0
JLE 0x00172067
MOVSXD RAX,dword ptr [RBX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00172070
LAB_00172067:
MOV qword ptr [RSP + 0x8],0x0
LAB_00172070:
MOV RAX,-0x8000000000000000
MOV R9,0x3fffffffffffffff
TEST R15,R15
MOV dword ptr [RSP + 0x14],ECX
JZ 0x001720dc
MOV RBP,RDX
MOV R13,R15
MOV RDX,RAX
LEA RAX,[RSP + 0x60]
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX + -0x18],RCX
AND dword ptr [RAX + -0x10],0x0
MOV qword ptr [RAX + -0x8],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LEA R15,[RSP + 0x48]
PUSH 0x1
POP RDX
PUSH 0x1
POP R8
MOV RDI,R15
MOV RSI,R14
MOV RCX,R9
MOV R14,R9
CALL 0x0017137a
TEST EAX,EAX
JZ 0x001720e2
XOR EBX,EBX
MOV R14,R15
JMP 0x001721d1
LAB_001720dc:
LEA RDI,[R14 + 0x10]
JMP 0x00172101
LAB_001720e2:
LEA RDI,[RSP + 0x58]
MOV R9,R14
MOV R14,R15
MOV ECX,dword ptr [RSP + 0x14]
MOV R15,R13
MOV RAX,-0x8000000000000000
MOV RDX,RBP
LAB_00172101:
CMP qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x18],RDI
JZ 0x0017216c
MOV R13,R15
MOV RDX,RAX
LEA RAX,[RSP + 0x88]
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX + -0x18],RCX
AND dword ptr [RAX + -0x10],0x0
MOV qword ptr [RAX + -0x8],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LEA R15,[RSP + 0x70]
PUSH 0x1
POP RDX
PUSH 0x1
POP R8
MOV RDI,R15
MOV RSI,RBX
MOV RCX,R9
CALL 0x0017137a
TEST EAX,EAX
JZ 0x00172155
MOV RBX,R15
JMP 0x001721d1
LAB_00172155:
LEA RDX,[RSP + 0x80]
MOV RBX,R15
MOV ECX,dword ptr [RSP + 0x14]
MOV R15,R13
MOV RDI,qword ptr [RSP + 0x18]
LAB_0017216c:
PUSH 0x1
POP RBP
CMP ECX,0x1
MOV qword ptr [RSP + 0x28],RDX
JZ 0x0017218b
TEST ECX,ECX
JNZ 0x00172330
MOV RSI,qword ptr [RSP + 0x8]
OR RSI,R15
JMP 0x00172193
LAB_0017218b:
MOV RSI,qword ptr [RSP + 0x8]
XOR RSI,R15
LAB_00172193:
TEST RSI,RSI
SETZ AL
LAB_00172199:
MOV qword ptr [RSP + 0x20],RSI
MOV byte ptr [RSP + 0x7],AL
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDX]
CMP RCX,RAX
CMOVG RAX,RCX
LAB_001721af:
CMP RAX,0x2
CMOVGE RBP,RAX
ADD RBP,0x3f
MOV R13,RBP
SHR R13,0x6
MOV RDI,R12
MOV RSI,R13
CALL 0x0016f50f
TEST EAX,EAX
JZ 0x00172214
LAB_001721d1:
MOV RDI,R12
CALL 0x0016f5cd
PUSH 0x20
POP RBP
LAB_001721dc:
LEA RAX,[RSP + 0x48]
CMP R14,RAX
JNZ 0x001721ee
MOV RDI,R14
CALL 0x0017145e
LAB_001721ee:
LEA RAX,[RSP + 0x70]
CMP RBX,RAX
JNZ 0x00172200
MOV RDI,RBX
CALL 0x0017145e
LAB_00172200:
MOV EAX,EBP
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00172214:
MOV qword ptr [RSP + 0x40],RBP
MOV qword ptr [RSP + 0x38],R12
MOV qword ptr [RSP + 0x30],R14
MOV R12,qword ptr [R14 + 0x18]
SHL R12,0x6
MOV RAX,qword ptr [RSP + 0x18]
SUB R12,qword ptr [RAX]
MOV qword ptr [RSP + 0x18],RBX
MOV RAX,R15
MOV R15,qword ptr [RBX + 0x18]
SHL R15,0x6
MOV RCX,qword ptr [RSP + 0x28]
SUB R15,qword ptr [RCX]
NEG RAX
MOV qword ptr [RSP + 0x28],RAX
NEG qword ptr [RSP + 0x8]
MOV RBX,qword ptr [RSP + 0x20]
NEG RBX
XOR R14D,R14D
LAB_00172263:
CMP R13,R14
JZ 0x001722d6
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RDX,R12
CALL 0x00172665
MOV RBP,RAX
XOR RBP,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RDX,R15
CALL 0x00172665
XOR RAX,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x14]
CMP ECX,0x1
JZ 0x001722b1
TEST ECX,ECX
JNZ 0x001722b6
OR RAX,RBP
JMP 0x001722b9
LAB_001722b1:
XOR RAX,RBP
JMP 0x001722b9
LAB_001722b6:
AND RAX,RBP
LAB_001722b9:
XOR RAX,RBX
MOV RCX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RCX + 0x20]
MOV qword ptr [RCX + R14*0x8],RAX
INC R14
ADD R12,0x40
ADD R15,0x40
JMP 0x00172263
LAB_001722d6:
MOV RAX,-0x8000000000000000
ADD RAX,-0x40
MOV RCX,qword ptr [RSP + 0x40]
AND RCX,RAX
MOV R12,qword ptr [RSP + 0x38]
MOV qword ptr [R12 + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [R12 + 0x8],EAX
PUSH 0x1
POP RDX
MOV RDI,R12
MOV RBX,0x3fffffffffffffff
MOV RSI,RBX
CALL 0x0016f707
XOR EBP,EBP
CMP byte ptr [RSP + 0x7],0x0
JZ 0x00172361
MOV RBX,qword ptr [RSP + 0x18]
MOV R14,qword ptr [RSP + 0x30]
JMP 0x001721dc
LAB_00172330:
MOV RSI,qword ptr [RSP + 0x8]
AND RSI,R15
SETZ AL
CMP ECX,0x2
JNZ 0x00172199
TEST RSI,RSI
JNZ 0x00172199
MOV RAX,qword ptr [RSP + 0x8]
OR RAX,R15
JZ 0x0017238d
TEST R15,R15
JZ 0x0017239c
MOV RAX,qword ptr [RDX]
JMP 0x0017239f
LAB_00172361:
PUSH -0x1
POP RDX
PUSH 0x1
POP R8
MOV RDI,R12
MOV RSI,R12
MOV RCX,RBX
CALL 0x0017137a
TEST EAX,EAX
MOV RBX,qword ptr [RSP + 0x18]
MOV R14,qword ptr [RSP + 0x30]
JNZ 0x001721d1
JMP 0x001721dc
LAB_0017238d:
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDX]
CMP RCX,RAX
CMOVL RAX,RCX
JMP 0x0017239f
LAB_0017239c:
MOV RAX,qword ptr [RDI]
LAB_0017239f:
MOV byte ptr [RSP + 0x7],0x1
MOV qword ptr [RSP + 0x20],0x0
JMP 0x001721af
|
int8 bf_logic_op(int8 *param_1,int8 *param_2,long *param_3,int param_4)
{
int iVar1;
ulong uVar2;
ulong uVar3;
long *plVar4;
long *plVar5;
long lVar6;
int8 uVar7;
long *plVar8;
long lVar9;
ulong uVar10;
int8 *puVar11;
ulong uVar12;
ulong uVar13;
long lVar14;
bool bVar15;
ulong local_c0;
ulong local_a8;
int8 local_80;
int4 local_78;
long local_70 [4];
int4 local_50;
long local_48 [3];
plVar4 = param_3 + 2;
if ((long)param_2[2] < 1) {
uVar13 = 0;
}
else {
uVar13 = (ulong)*(int *)(param_2 + 1);
}
if (*plVar4 < 1) {
local_c0 = 0;
}
else {
local_c0 = (ulong)(int)param_3[1];
}
if (uVar13 == 0) {
plVar8 = param_2 + 2;
puVar11 = param_2;
LAB_00172101:
plVar5 = param_3;
if (local_c0 != 0) {
local_70[3] = *param_1;
local_50 = 0;
local_48[0] = -0x8000000000000000;
local_48[1] = 0;
local_48[2] = 0;
plVar5 = local_70 + 3;
iVar1 = bf_add_si(plVar5,param_3,1,0x3fffffffffffffff,1);
if (iVar1 != 0) goto LAB_001721d1;
plVar4 = local_48;
}
if (param_4 == 1) {
local_a8 = local_c0 ^ uVar13;
LAB_00172193:
bVar15 = local_a8 == 0;
LAB_00172199:
lVar9 = *plVar4;
if (*plVar4 < *plVar8) {
lVar9 = *plVar8;
}
}
else {
if (param_4 == 0) {
local_a8 = local_c0 | uVar13;
goto LAB_00172193;
}
local_a8 = local_c0 & uVar13;
bVar15 = local_a8 == 0;
if ((param_4 != 2) || (local_a8 != 0)) goto LAB_00172199;
if (local_c0 == 0 && uVar13 == 0) {
lVar9 = *plVar4;
if (*plVar8 < *plVar4) {
lVar9 = *plVar8;
}
}
else if (uVar13 == 0) {
lVar9 = *plVar8;
}
else {
lVar9 = *plVar4;
}
bVar15 = true;
local_a8 = 0;
}
lVar6 = 1;
if (1 < lVar9) {
lVar6 = lVar9;
}
uVar10 = lVar6 + 0x3fU >> 6;
iVar1 = bf_resize(param_1,uVar10);
if (iVar1 == 0) {
lVar9 = puVar11[3] * 0x40 - *plVar8;
lVar14 = plVar5[3] * 0x40 - *plVar4;
for (uVar12 = 0; uVar10 != uVar12; uVar12 = uVar12 + 1) {
uVar2 = get_bits(puVar11[4],puVar11[3],lVar9);
uVar2 = uVar2 ^ -uVar13;
uVar3 = get_bits(plVar5[4],plVar5[3],lVar14);
uVar3 = uVar3 ^ -local_c0;
if (param_4 == 1) {
uVar3 = uVar3 ^ uVar2;
}
else if (param_4 == 0) {
uVar3 = uVar3 | uVar2;
}
else {
uVar3 = uVar3 & uVar2;
}
*(ulong *)(param_1[4] + uVar12 * 8) = uVar3 ^ -local_a8;
lVar9 = lVar9 + 0x40;
lVar14 = lVar14 + 0x40;
}
param_1[2] = lVar6 + 0x3fU & 0x7fffffffffffffc0;
*(int *)(param_1 + 1) = (int)local_a8;
bf_normalize_and_round(param_1,0x3fffffffffffffff,1);
uVar7 = 0;
if ((bVar15) ||
(iVar1 = bf_add_si(param_1,param_1,0xffffffffffffffff,0x3fffffffffffffff,1), iVar1 == 0))
goto LAB_001721dc;
}
}
else {
local_80 = *param_1;
local_78 = 0;
local_70[0] = -0x8000000000000000;
local_70[1] = 0;
local_70[2] = 0;
puVar11 = &local_80;
iVar1 = bf_add_si(puVar11,param_2,1,0x3fffffffffffffff,1);
if (iVar1 == 0) {
plVar8 = local_70;
goto LAB_00172101;
}
plVar5 = (long *)0x0;
}
LAB_001721d1:
bf_set_nan(param_1);
uVar7 = 0x20;
LAB_001721dc:
if (puVar11 == &local_80) {
bf_delete(puVar11);
}
if (plVar5 == local_70 + 3) {
bf_delete(plVar5);
}
return uVar7;
}
|
|
9,666 |
getopt_ll
|
eloqsql/mysys/my_getopt.c
|
static longlong getopt_ll(char *arg, const struct my_option *optp, int *err)
{
longlong num=eval_num_suffix_ll(arg, err, (char*) optp->name);
return getopt_ll_limit_value(num, optp, NULL);
}
|
O3
|
c
|
getopt_ll:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
movl %r15d, (%rdx)
callq 0x36a30
movq %rax, %r13
movl %r15d, (%rax)
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0x36970
cmpl $0x22, (%r13)
jne 0x611a2
leaq 0x2dc4a6(%rip), %rcx # 0x33d628
leaq 0x3889b(%rip), %rsi # 0x99a24
xorl %r13d, %r13d
xorl %edi, %edi
movq %r14, %rdx
xorl %eax, %eax
callq *(%rcx)
movl $0x1, (%r12)
jmp 0x61266
movq -0x38(%rbp), %rdx
movb (%rdx), %cl
movzbl %cl, %esi
cmpl $0x53, %esi
jle 0x611c8
leal -0x65(%rsi), %edi
cmpl $0xb, %edi
ja 0x611ec
leaq 0x3c43d(%rip), %rsi # 0x9d5fc
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
leal -0x45(%rsi), %edi
cmpl $0xb, %edi
ja 0x6122a
leaq 0x3c3f5(%rip), %rsi # 0x9d5cc
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
movabsq $0x1000000000000000, %r13 # imm = 0x1000000000000000
jmp 0x61234
cmpl $0x54, %esi
je 0x611fa
cmpl $0x74, %esi
jne 0x61282
movabsq $0x10000000000, %r13 # imm = 0x10000000000
jmp 0x61234
movabsq $0x4000000000000, %r13 # imm = 0x4000000000000
jmp 0x61234
movl $0x400, %r13d # imm = 0x400
jmp 0x61234
movl $0x40000000, %r13d # imm = 0x40000000
jmp 0x61234
movl $0x100000, %r13d # imm = 0x100000
jmp 0x61234
movl $0x1, %r13d
testl %esi, %esi
jne 0x61282
imulq %rax, %r13
cmpl $0x0, (%r12)
je 0x61266
movq 0x2d8d82(%rip), %rax # 0x339fc8
movq (%rax), %rdi
movsbl %cl, %ecx
leaq 0x387ef(%rip), %rdx # 0x99a42
movl $0x1, %esi
movq -0x30(%rbp), %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x36260
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x604bb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, (%r12)
movb (%rdx), %cl
xorl %r13d, %r13d
jmp 0x6123f
|
getopt_ll:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov rbx, rsi
mov r14, rdi
mov rax, [rsi]
mov [rbp+var_30], rax
xor r15d, r15d
mov [rdx], r15d
call ___errno_location
mov r13, rax
mov [rax], r15d
lea rsi, [rbp+var_38]
mov rdi, r14
mov edx, 0Ah
call ___isoc23_strtol
cmp dword ptr [r13+0], 22h ; '"'
jnz short loc_611A2
lea rcx, my_getopt_error_reporter
lea rsi, aIncorrectInteg; "Incorrect integer value: '%s'"
xor r13d, r13d
xor edi, edi
mov rdx, r14
xor eax, eax
call qword ptr [rcx]
mov dword ptr [r12], 1
jmp loc_61266
loc_611A2:
mov rdx, [rbp+var_38]
mov cl, [rdx]
movzx esi, cl
cmp esi, 53h ; 'S'
jle short loc_611C8
lea edi, [rsi-65h]; switch 12 cases
cmp edi, 0Bh
ja short def_611C6; jumptable 00000000000611C6 default case
lea rsi, jpt_611C6
movsxd rdi, ds:(jpt_611C6 - 9D5FCh)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_611C8:
lea edi, [rsi-45h]; switch 12 cases
cmp edi, 0Bh
ja short def_611DE; jumptable 00000000000611DE default case
lea rsi, jpt_611DE
movsxd rdi, ds:(jpt_611DE - 9D5CCh)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_611E0:
mov r13, 1000000000000000h; jumptable 00000000000611C6 case 101
jmp short loc_61234
def_611C6:
cmp esi, 54h ; 'T'; jumptable 00000000000611C6 default case
jz short loc_611FA
cmp esi, 74h ; 't'
jnz loc_61282; jumptable 00000000000611C6 cases 102,104-106,108,110,111
loc_611FA:
mov r13, 10000000000h
jmp short loc_61234
loc_61206:
mov r13, 4000000000000h; jumptable 00000000000611C6 case 112
jmp short loc_61234
loc_61212:
mov r13d, 400h; jumptable 00000000000611C6 case 107
jmp short loc_61234
loc_6121A:
mov r13d, 40000000h; jumptable 00000000000611C6 case 103
jmp short loc_61234
loc_61222:
mov r13d, offset unk_100000; jumptable 00000000000611C6 case 109
jmp short loc_61234
def_611DE:
mov r13d, 1; jumptable 00000000000611DE default case
test esi, esi
jnz short loc_61282; jumptable 00000000000611C6 cases 102,104-106,108,110,111
loc_61234:
imul r13, rax
cmp dword ptr [r12], 0
jz short loc_61266
loc_6123F:
mov rax, cs:stderr_ptr
mov rdi, [rax]
movsx ecx, cl
lea rdx, aUnknownSuffixC; "Unknown suffix '%c' used for variable '"...
mov esi, 1
mov r8, [rbp+var_30]
mov r9, r14
xor eax, eax
call ___fprintf_chk
loc_61266:
mov rdi, r13
mov rsi, rbx
xor edx, edx
call getopt_ll_limit_value
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_61282:
mov dword ptr [r12], 1; jumptable 00000000000611C6 cases 102,104-106,108,110,111
mov cl, [rdx]
xor r13d, r13d
jmp short loc_6123F
|
long long getopt_ll(const char *a1, const char **a2, _DWORD *a3)
{
_DWORD *v5; // r13
long long v6; // rax
long long v7; // r13
char *v8; // rdx
char v9; // cl
unsigned int v10; // esi
long long v11; // r13
char *v13; // [rsp+8h] [rbp-38h] BYREF
const char *v14; // [rsp+10h] [rbp-30h]
v14 = *a2;
*a3 = 0;
v5 = (_DWORD *)__errno_location(a1);
*v5 = 0;
v6 = __isoc23_strtol(a1, &v13, 10LL);
if ( *v5 == 34 )
{
v7 = 0LL;
my_getopt_error_reporter(0, "Incorrect integer value: '%s'", a1);
*a3 = 1;
return getopt_ll_limit_value(v7, (long long)a2, 0LL);
}
v8 = v13;
v9 = *v13;
v10 = (unsigned __int8)*v13;
if ( v10 <= 0x53 )
{
switch ( *v13 )
{
case 'E':
LABEL_6:
v11 = 0x1000000000000000LL;
goto LABEL_15;
case 'F':
case 'H':
case 'I':
case 'J':
case 'L':
case 'N':
case 'O':
break;
case 'G':
LABEL_12:
v11 = 0x40000000LL;
goto LABEL_15;
case 'K':
LABEL_11:
v11 = 1024LL;
goto LABEL_15;
case 'M':
LABEL_13:
v11 = (long long)&unk_100000;
goto LABEL_15;
case 'P':
LABEL_10:
v11 = 0x4000000000000LL;
goto LABEL_15;
default:
v11 = 1LL;
if ( !*v13 )
goto LABEL_15;
break;
}
LABEL_18:
*a3 = 1;
v9 = *v8;
v7 = 0LL;
goto LABEL_16;
}
switch ( *v13 )
{
case 'e':
goto LABEL_6;
case 'f':
case 'h':
case 'i':
case 'j':
case 'l':
case 'n':
case 'o':
goto LABEL_18;
case 'g':
goto LABEL_12;
case 'k':
goto LABEL_11;
case 'm':
goto LABEL_13;
case 'p':
goto LABEL_10;
default:
if ( v10 != 84 && v10 != 116 )
goto LABEL_18;
v11 = 0x10000000000LL;
break;
}
LABEL_15:
v7 = v6 * v11;
if ( *a3 )
LABEL_16:
__fprintf_chk(stderr, 1LL, "Unknown suffix '%c' used for variable '%s' (value '%s')\n", (unsigned int)v9, v14, a1);
return getopt_ll_limit_value(v7, (long long)a2, 0LL);
}
|
getopt_ll:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RSI]
MOV qword ptr [RBP + -0x30],RAX
XOR R15D,R15D
MOV dword ptr [RDX],R15D
CALL 0x00136a30
MOV R13,RAX
MOV dword ptr [RAX],R15D
LEA RSI,[RBP + -0x38]
MOV RDI,R14
MOV EDX,0xa
CALL 0x00136970
CMP dword ptr [R13],0x22
JNZ 0x001611a2
LEA RCX,[0x43d628]
LEA RSI,[0x199a24]
XOR R13D,R13D
XOR EDI,EDI
MOV RDX,R14
XOR EAX,EAX
CALL qword ptr [RCX]
MOV dword ptr [R12],0x1
JMP 0x00161266
LAB_001611a2:
MOV RDX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RDX]
MOVZX ESI,CL
CMP ESI,0x53
JLE 0x001611c8
LEA EDI,[RSI + -0x65]
CMP EDI,0xb
JA 0x001611ec
LEA RSI,[0x19d5fc]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
LAB_001611c8:
LEA EDI,[RSI + -0x45]
CMP EDI,0xb
JA 0x0016122a
LEA RSI,[0x19d5cc]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
caseD_65:
MOV R13,0x1000000000000000
JMP 0x00161234
default:
CMP ESI,0x54
JZ 0x001611fa
CMP ESI,0x74
JNZ 0x00161282
LAB_001611fa:
MOV R13,0x10000000000
JMP 0x00161234
caseD_70:
MOV R13,0x4000000000000
JMP 0x00161234
caseD_6b:
MOV R13D,0x400
JMP 0x00161234
caseD_67:
MOV R13D,0x40000000
JMP 0x00161234
caseD_6d:
MOV R13D,0x100000
JMP 0x00161234
default:
MOV R13D,0x1
TEST ESI,ESI
JNZ 0x00161282
LAB_00161234:
IMUL R13,RAX
CMP dword ptr [R12],0x0
JZ 0x00161266
LAB_0016123f:
MOV RAX,qword ptr [0x00439fc8]
MOV RDI,qword ptr [RAX]
MOVSX ECX,CL
LEA RDX,[0x199a42]
MOV ESI,0x1
MOV R8,qword ptr [RBP + -0x30]
MOV R9,R14
XOR EAX,EAX
CALL 0x00136260
LAB_00161266:
MOV RDI,R13
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001604bb
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_66:
MOV dword ptr [R12],0x1
MOV CL,byte ptr [RDX]
XOR R13D,R13D
JMP 0x0016123f
|
void getopt_ll(int8 param_1,int8 *param_2,int *param_3)
{
int *piVar1;
long lVar2;
byte bVar3;
long lVar4;
byte *local_40;
int8 local_38;
local_38 = *param_2;
*param_3 = 0;
piVar1 = __errno_location();
*piVar1 = 0;
lVar2 = __isoc23_strtol(param_1,&local_40,10);
if (*piVar1 == 0x22) {
lVar4 = 0;
(*(code *)my_getopt_error_reporter)(0,"Incorrect integer value: \'%s\'",param_1);
*param_3 = 1;
goto LAB_00161266;
}
bVar3 = *local_40;
if (bVar3 < 0x54) {
switch(bVar3) {
case 0x45:
goto switchD_001611c6_caseD_65;
case 0x46:
case 0x48:
case 0x49:
case 0x4a:
case 0x4c:
case 0x4e:
case 0x4f:
break;
case 0x47:
goto switchD_001611c6_caseD_67;
case 0x4b:
goto switchD_001611c6_caseD_6b;
case 0x4d:
goto switchD_001611c6_caseD_6d;
case 0x50:
goto switchD_001611c6_caseD_70;
default:
lVar4 = 1;
if (bVar3 == 0) goto LAB_00161234;
}
switchD_001611c6_caseD_66:
*param_3 = 1;
bVar3 = *local_40;
lVar4 = 0;
}
else {
switch(bVar3) {
case 0x65:
switchD_001611c6_caseD_65:
lVar4 = 0x1000000000000000;
break;
case 0x66:
case 0x68:
case 0x69:
case 0x6a:
case 0x6c:
case 0x6e:
case 0x6f:
goto switchD_001611c6_caseD_66;
case 0x67:
switchD_001611c6_caseD_67:
lVar4 = 0x40000000;
break;
case 0x6b:
switchD_001611c6_caseD_6b:
lVar4 = 0x400;
break;
case 0x6d:
switchD_001611c6_caseD_6d:
lVar4 = 0x100000;
break;
case 0x70:
switchD_001611c6_caseD_70:
lVar4 = 0x4000000000000;
break;
default:
if ((bVar3 != 0x54) && (bVar3 != 0x74)) goto switchD_001611c6_caseD_66;
lVar4 = 0x10000000000;
}
LAB_00161234:
lVar4 = lVar4 * lVar2;
if (*param_3 == 0) goto LAB_00161266;
}
__fprintf_chk(*(int8 *)PTR_stderr_00439fc8,1,
"Unknown suffix \'%c\' used for variable \'%s\' (value \'%s\')\n",(int)(char)bVar3,
local_38,param_1);
LAB_00161266:
getopt_ll_limit_value(lVar4,param_2,0);
return;
}
|
|
9,667 |
JS_DetachArrayBuffer
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_DetachArrayBuffer(JSContext *ctx, JSValue obj)
{
JSArrayBuffer *abuf = JS_GetOpaque(obj, JS_CLASS_ARRAY_BUFFER);
struct list_head *el;
if (!abuf || abuf->detached)
return;
if (abuf->free_func)
abuf->free_func(ctx->rt, abuf->opaque, abuf->data);
abuf->data = NULL;
abuf->byte_length = 0;
abuf->detached = TRUE;
list_for_each(el, &abuf->array_list) {
JSTypedArray *ta;
JSObject *p;
ta = list_entry(el, JSTypedArray, link);
p = ta->obj;
/* Note: the typed array length and offset fields are not modified */
if (p->class_id != JS_CLASS_DATAVIEW) {
p->u.array.count = 0;
p->u.array.u.ptr = NULL;
}
}
}
|
O2
|
c
|
JS_DetachArrayBuffer:
cmpl $-0x1, %edx
jne 0x314ee
pushq %rbx
cmpw $0x13, 0x6(%rsi)
jne 0x314ed
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x314ed
cmpb $0x0, 0x8(%rbx)
je 0x314ef
popq %rbx
retq
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x31506
movq 0x18(%rdi), %rdi
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rsi
callq *%rax
andq $0x0, 0x10(%rbx)
andl $0x0, (%rbx)
movb $0x1, 0x8(%rbx)
leaq 0x18(%rbx), %rax
addq $0x20, %rbx
movq (%rbx), %rbx
cmpq %rax, %rbx
je 0x314ed
movq 0x10(%rbx), %rcx
cmpw $0x21, 0x6(%rcx)
je 0x31536
andl $0x0, 0x40(%rcx)
andq $0x0, 0x38(%rcx)
addq $0x8, %rbx
jmp 0x3151a
|
JS_DetachArrayBuffer:
cmp edx, 0FFFFFFFFh
jnz short locret_314EE
push rbx
cmp word ptr [rsi+6], 13h
jnz short loc_314ED
mov rbx, [rsi+30h]
test rbx, rbx
jz short loc_314ED
cmp byte ptr [rbx+8], 0
jz short loc_314EF
loc_314ED:
pop rbx
locret_314EE:
retn
loc_314EF:
mov rax, [rbx+30h]
test rax, rax
jz short loc_31506
mov rdi, [rdi+18h]
mov rdx, [rbx+10h]
mov rsi, [rbx+28h]
call rax
loc_31506:
and qword ptr [rbx+10h], 0
and dword ptr [rbx], 0
mov byte ptr [rbx+8], 1
lea rax, [rbx+18h]
add rbx, 20h ; ' '
loc_3151A:
mov rbx, [rbx]
cmp rbx, rax
jz short loc_314ED
mov rcx, [rbx+10h]
cmp word ptr [rcx+6], 21h ; '!'
jz short loc_31536
and dword ptr [rcx+40h], 0
and qword ptr [rcx+38h], 0
loc_31536:
add rbx, 8
jmp short loc_3151A
|
void JS_DetachArrayBuffer(long long a1, long long a2, int a3)
{
long long v3; // rbx
void ( *v4)(_QWORD, _QWORD, _QWORD); // rax
long long v5; // rax
long long *i; // rbx
long long v7; // rbx
long long v8; // rcx
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 19 )
{
v3 = *(_QWORD *)(a2 + 48);
if ( v3 )
{
if ( !*(_BYTE *)(v3 + 8) )
{
v4 = *(void ( **)(_QWORD, _QWORD, _QWORD))(v3 + 48);
if ( v4 )
v4(*(_QWORD *)(a1 + 24), *(_QWORD *)(v3 + 40), *(_QWORD *)(v3 + 16));
*(_QWORD *)(v3 + 16) = 0LL;
*(_DWORD *)v3 = 0;
*(_BYTE *)(v3 + 8) = 1;
v5 = v3 + 24;
for ( i = (long long *)(v3 + 32); ; i = (long long *)(v7 + 8) )
{
v7 = *i;
if ( v7 == v5 )
break;
v8 = *(_QWORD *)(v7 + 16);
if ( *(_WORD *)(v8 + 6) != 33 )
{
*(_DWORD *)(v8 + 64) = 0;
*(_QWORD *)(v8 + 56) = 0LL;
}
}
}
}
}
}
|
JS_DetachArrayBuffer:
CMP EDX,-0x1
JNZ 0x001314ee
PUSH RBX
CMP word ptr [RSI + 0x6],0x13
JNZ 0x001314ed
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x001314ed
CMP byte ptr [RBX + 0x8],0x0
JZ 0x001314ef
LAB_001314ed:
POP RBX
LAB_001314ee:
RET
LAB_001314ef:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x00131506
MOV RDI,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RBX + 0x28]
CALL RAX
LAB_00131506:
AND qword ptr [RBX + 0x10],0x0
AND dword ptr [RBX],0x0
MOV byte ptr [RBX + 0x8],0x1
LEA RAX,[RBX + 0x18]
ADD RBX,0x20
LAB_0013151a:
MOV RBX,qword ptr [RBX]
CMP RBX,RAX
JZ 0x001314ed
MOV RCX,qword ptr [RBX + 0x10]
CMP word ptr [RCX + 0x6],0x21
JZ 0x00131536
AND dword ptr [RCX + 0x40],0x0
AND qword ptr [RCX + 0x38],0x0
LAB_00131536:
ADD RBX,0x8
JMP 0x0013151a
|
void JS_DetachArrayBuffer(long param_1,long param_2,int param_3)
{
int4 *puVar1;
int4 *puVar2;
long lVar3;
int8 *puVar4;
if ((((param_3 == -1) && (*(short *)(param_2 + 6) == 0x13)) &&
(puVar1 = *(int4 **)(param_2 + 0x30), puVar1 != (int4 *)0x0)) &&
(*(char *)(puVar1 + 2) == '\0')) {
if (*(code **)(puVar1 + 0xc) != (code *)0x0) {
(**(code **)(puVar1 + 0xc))
(*(int8 *)(param_1 + 0x18),*(int8 *)(puVar1 + 10),
*(int8 *)(puVar1 + 4));
}
*(int8 *)(puVar1 + 4) = 0;
*puVar1 = 0;
*(int1 *)(puVar1 + 2) = 1;
puVar4 = (int8 *)(puVar1 + 8);
while (puVar2 = (int4 *)*puVar4, puVar2 != puVar1 + 6) {
lVar3 = *(long *)(puVar2 + 4);
if (*(short *)(lVar3 + 6) != 0x21) {
*(int4 *)(lVar3 + 0x40) = 0;
*(int8 *)(lVar3 + 0x38) = 0;
}
puVar4 = (int8 *)(puVar2 + 2);
}
}
return;
}
|
|
9,668 |
JS_DetachArrayBuffer
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_DetachArrayBuffer(JSContext *ctx, JSValue obj)
{
JSArrayBuffer *abuf = JS_GetOpaque(obj, JS_CLASS_ARRAY_BUFFER);
struct list_head *el;
if (!abuf || abuf->detached)
return;
if (abuf->free_func)
abuf->free_func(ctx->rt, abuf->opaque, abuf->data);
abuf->data = NULL;
abuf->byte_length = 0;
abuf->detached = TRUE;
list_for_each(el, &abuf->array_list) {
JSTypedArray *ta;
JSObject *p;
ta = list_entry(el, JSTypedArray, link);
p = ta->obj;
/* Note: the typed array length and offset fields are not modified */
if (p->class_id != JS_CLASS_DATAVIEW) {
p->u.array.count = 0;
p->u.array.u.ptr = NULL;
}
}
}
|
O3
|
c
|
JS_DetachArrayBuffer:
cmpl $-0x1, %edx
jne 0x395f1
pushq %rbx
cmpw $0x13, 0x6(%rsi)
jne 0x395f0
movq 0x30(%rsi), %rbx
testq %rbx, %rbx
je 0x395f0
cmpb $0x0, 0x8(%rbx)
je 0x395f2
popq %rbx
retq
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x39609
movq 0x18(%rdi), %rdi
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rsi
callq *%rax
movq $0x0, 0x10(%rbx)
movl $0x0, (%rbx)
movb $0x1, 0x8(%rbx)
movq 0x20(%rbx), %rax
addq $0x18, %rbx
cmpq %rbx, %rax
je 0x395f0
movq 0x10(%rax), %rcx
cmpw $0x21, 0x6(%rcx)
je 0x39642
movl $0x0, 0x40(%rcx)
movq $0x0, 0x38(%rcx)
movq 0x8(%rax), %rax
jmp 0x39623
|
JS_DetachArrayBuffer:
cmp edx, 0FFFFFFFFh
jnz short locret_395F1
push rbx
cmp word ptr [rsi+6], 13h
jnz short loc_395F0
mov rbx, [rsi+30h]
test rbx, rbx
jz short loc_395F0
cmp byte ptr [rbx+8], 0
jz short loc_395F2
loc_395F0:
pop rbx
locret_395F1:
retn
loc_395F2:
mov rax, [rbx+30h]
test rax, rax
jz short loc_39609
mov rdi, [rdi+18h]
mov rdx, [rbx+10h]
mov rsi, [rbx+28h]
call rax
loc_39609:
mov qword ptr [rbx+10h], 0
mov dword ptr [rbx], 0
mov byte ptr [rbx+8], 1
mov rax, [rbx+20h]
add rbx, 18h
loc_39623:
cmp rax, rbx
jz short loc_395F0
mov rcx, [rax+10h]
cmp word ptr [rcx+6], 21h ; '!'
jz short loc_39642
mov dword ptr [rcx+40h], 0
mov qword ptr [rcx+38h], 0
loc_39642:
mov rax, [rax+8]
jmp short loc_39623
|
void JS_DetachArrayBuffer(long long a1, long long a2, int a3)
{
long long v3; // rbx
void ( *v4)(_QWORD, _QWORD, _QWORD); // rax
long long v5; // rax
long long v6; // rbx
long long v7; // rcx
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 19 )
{
v3 = *(_QWORD *)(a2 + 48);
if ( v3 )
{
if ( !*(_BYTE *)(v3 + 8) )
{
v4 = *(void ( **)(_QWORD, _QWORD, _QWORD))(v3 + 48);
if ( v4 )
v4(*(_QWORD *)(a1 + 24), *(_QWORD *)(v3 + 40), *(_QWORD *)(v3 + 16));
*(_QWORD *)(v3 + 16) = 0LL;
*(_DWORD *)v3 = 0;
*(_BYTE *)(v3 + 8) = 1;
v5 = *(_QWORD *)(v3 + 32);
v6 = v3 + 24;
while ( v5 != v6 )
{
v7 = *(_QWORD *)(v5 + 16);
if ( *(_WORD *)(v7 + 6) != 33 )
{
*(_DWORD *)(v7 + 64) = 0;
*(_QWORD *)(v7 + 56) = 0LL;
}
v5 = *(_QWORD *)(v5 + 8);
}
}
}
}
}
|
JS_DetachArrayBuffer:
CMP EDX,-0x1
JNZ 0x001395f1
PUSH RBX
CMP word ptr [RSI + 0x6],0x13
JNZ 0x001395f0
MOV RBX,qword ptr [RSI + 0x30]
TEST RBX,RBX
JZ 0x001395f0
CMP byte ptr [RBX + 0x8],0x0
JZ 0x001395f2
LAB_001395f0:
POP RBX
LAB_001395f1:
RET
LAB_001395f2:
MOV RAX,qword ptr [RBX + 0x30]
TEST RAX,RAX
JZ 0x00139609
MOV RDI,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RBX + 0x28]
CALL RAX
LAB_00139609:
MOV qword ptr [RBX + 0x10],0x0
MOV dword ptr [RBX],0x0
MOV byte ptr [RBX + 0x8],0x1
MOV RAX,qword ptr [RBX + 0x20]
ADD RBX,0x18
LAB_00139623:
CMP RAX,RBX
JZ 0x001395f0
MOV RCX,qword ptr [RAX + 0x10]
CMP word ptr [RCX + 0x6],0x21
JZ 0x00139642
MOV dword ptr [RCX + 0x40],0x0
MOV qword ptr [RCX + 0x38],0x0
LAB_00139642:
MOV RAX,qword ptr [RAX + 0x8]
JMP 0x00139623
|
void JS_DetachArrayBuffer(long param_1,long param_2,int param_3)
{
int4 *puVar1;
long lVar2;
int4 *puVar3;
if ((((param_3 == -1) && (*(short *)(param_2 + 6) == 0x13)) &&
(puVar1 = *(int4 **)(param_2 + 0x30), puVar1 != (int4 *)0x0)) &&
(*(char *)(puVar1 + 2) == '\0')) {
if (*(code **)(puVar1 + 0xc) != (code *)0x0) {
(**(code **)(puVar1 + 0xc))
(*(int8 *)(param_1 + 0x18),*(int8 *)(puVar1 + 10),
*(int8 *)(puVar1 + 4));
}
*(int8 *)(puVar1 + 4) = 0;
*puVar1 = 0;
*(int1 *)(puVar1 + 2) = 1;
for (puVar3 = *(int4 **)(puVar1 + 8); puVar3 != puVar1 + 6;
puVar3 = *(int4 **)(puVar3 + 2)) {
lVar2 = *(long *)(puVar3 + 4);
if (*(short *)(lVar2 + 6) != 0x21) {
*(int4 *)(lVar2 + 0x40) = 0;
*(int8 *)(lVar2 + 0x38) = 0;
}
}
}
return;
}
|
|
9,669 |
format_literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
static std::string format_literal(const std::string & literal) {
std::string escaped = replacePattern(literal, GRAMMAR_LITERAL_ESCAPE_RE, [&](const std::smatch & match) {
char c = match.str()[0];
return GRAMMAR_LITERAL_ESCAPES.at(c);
});
return "\"" + escaped + "\"";
}
|
O3
|
cpp
|
format_literal(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 $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x80(%rsp)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x2ef(%rip), %rax # 0x9bcbc
movq %rax, 0x18(%rcx)
leaq 0x366(%rip), %rax # 0x9bd3e
movq %rax, 0x10(%rcx)
movq %rsp, %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq %rsi, %r14
leaq 0x46a00(%rip), %r13 # 0xe2408
leaq 0x20(%rsp), %rbp
leaq 0x40(%rsp), %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x5d68a
testb %al, %al
je 0x9baec
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq -0x48(%rcx), %rsi
cmpq $0x48, %rdx
movq %rax, %rdx
cmoveq %rsi, %rdx
cmpq %rax, %rcx
cmoveq %rsi, %rdx
movq (%rdx), %r8
subq 0x18(%rsp), %r8
movq 0x28(%rsp), %rsi
movq %rbp, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x187a0
cmpq $0x0, 0x70(%rsp)
je 0x9bbe7
movq %rbx, %rdi
leaq 0x60(%rsp), %rsi
movq %r12, %rdx
callq *0x78(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rbp, %rdi
callq 0x181e0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x9bab6
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x186e0
movq 0x8(%rsp), %rax
movq %rax, %rcx
subq (%rsp), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
leaq -0x18(%rax), %rdx
addq $-0x48, %rax
cmpq $0x4, %rcx
cmovaeq %rdx, %rax
movq (%rax), %r15
jmp 0x9ba12
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
subq %r15, %r14
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x187a0
movq (%rsp), %rdi
testq %rdi, %rdi
movq 0x80(%rsp), %rbx
je 0x9bb23
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x186e0
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x9bb3c
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x18eee(%rip), %rsi # 0xb4a31
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x2841e
leaq 0x18eda(%rip), %rsi # 0xb4a31
movq %rsp, %rdi
callq 0x18d40
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x9bb81
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x9bb87
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9bbb9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186e0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x9bbd5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186e0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18260
jmp 0x9bcb3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9bc14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186e0
jmp 0x9bc14
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x9bcab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186e0
jmp 0x9bcab
jmp 0x9bc5d
jmp 0x9bc5d
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x9bc60
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x186e0
jmp 0x9bc60
jmp 0x9bc5d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x9bc7c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186e0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9bc92
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x186e0
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x9bcab
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x18c10
movq %rax, %rdi
callq 0x1f25d
nop
|
_ZL14format_literalRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov [rsp+0B8h+var_38], rdi
xorps xmm0, xmm0
lea rcx, [rsp+0B8h+var_58]
movaps xmmword ptr [rcx], xmm0
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_13match_resultsIN9__gnu_cxx17__normal_iteratorIPKcS5_EESaINS0_9sub_matchISB_EEEEEEZL14format_literalRKS5_E3$_0E9_M_invokeERKSt9_Any_dataSH_; std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_invoke(std::_Any_data const&,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)
mov [rcx+18h], rax
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_13match_resultsIN9__gnu_cxx17__normal_iteratorIPKcS5_EESaINS0_9sub_matchISB_EEEEEEZL14format_literalRKS5_E3$_0E10_M_managerERSt9_Any_dataRKSN_St18_Manager_operation; std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rcx+10h], rax
mov r12, rsp
movaps xmmword ptr [r12+10h], xmm0
movaps xmmword ptr [r12], xmm0
lea rax, [rsp+0B8h+var_88]
mov [rax-10h], rax
mov qword ptr [rax-8], 0
mov byte ptr [rax], 0
add r14, rsi
lea r13, _Z25GRAMMAR_LITERAL_ESCAPE_REB5cxx11; GRAMMAR_LITERAL_ESCAPE_RE
lea rbp, [rsp+0B8h+var_98]
lea rbx, [rsp+0B8h+var_78]
loc_9BA12:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, r13
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz loc_9BAEC
mov rax, [rsp+0B8h+var_B8]
mov rcx, [rsp+0B8h+var_B0]
mov rdx, rcx
sub rdx, rax
lea rsi, [rcx-48h]
cmp rdx, 48h ; 'H'
mov rdx, rax
cmovz rdx, rsi
cmp rcx, rax
cmovz rdx, rsi
mov r8, [rdx]
sub r8, [rsp+0B8h+var_A0]
mov rsi, [rsp+0B8h+var_90]
mov rdi, rbp
xor edx, edx
mov rcx, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
cmp [rsp+0B8h+var_48], 0
jz loc_9BBE7
mov rdi, rbx
lea rsi, [rsp+0B8h+var_58]
mov rdx, r12
call [rsp+0B8h+var_40]
mov rsi, [rsp+0B8h+var_78]
mov rdx, [rsp+0B8h+var_70]
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0B8h+var_78]; void *
lea rax, [rsp+0B8h+var_68]
cmp rdi, rax
jz short loc_9BAB6
mov rsi, [rsp+0B8h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BAB6:
mov rax, [rsp+0B8h+var_B0]
mov rcx, rax
sub rcx, [rsp+0B8h+var_B8]
sar rcx, 3
mov rdx, 0AAAAAAAAAAAAAAABh
imul rcx, rdx
lea rdx, [rax-18h]
add rax, 0FFFFFFFFFFFFFFB8h
cmp rcx, 4
cmovnb rax, rdx
mov r15, [rax]
jmp loc_9BA12
loc_9BAEC:
lea rdi, [rsp+0B8h+var_98]
mov rsi, [rdi+8]
sub r14, r15
xor edx, edx
mov rcx, r15
mov r8, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
mov rdi, [rsp+0B8h+var_B8]; void *
test rdi, rdi
mov rbx, [rsp+0B8h+var_38]
jz short loc_9BB23
mov rsi, [rsp+0B8h+var_A8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BB23:
mov rax, [rsp+0B8h+var_48]
test rax, rax
jz short loc_9BB3C
lea rdi, [rsp+0B8h+var_58]
mov rsi, rdi
mov edx, 3
call rax
loc_9BB3C:
lea rsi, aName+9; "\""
mov rdi, rsp
lea rdx, [rsp+0B8h+var_98]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rsi, aName+9; "\""
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
mov rcx, rax
add rcx, 10h
cmp rsi, rcx
jz short loc_9BB81
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_9BB87
loc_9BB81:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_9BB87:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rax, [rsp+0B8h+var_A8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9BBB9
mov rsi, [rsp+0B8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BBB9:
mov rdi, [rsp+0B8h+var_98]; void *
lea rax, [rsp+0B8h+var_88]
cmp rdi, rax
jz short loc_9BBD5
mov rsi, [rsp+0B8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BBD5:
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9BBE7:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp loc_9BCB3
mov rbx, rax
lea rax, [rsp+0B8h+var_A8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9BC14
mov rsi, [rsp+0B8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9BC14
mov rbx, rax
loc_9BC14:
mov rdi, [rsp+0B8h+var_98]; void *
lea rax, [rsp+0B8h+var_88]
cmp rdi, rax
jz loc_9BCAB
mov rsi, [rsp+0B8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9BCAB
jmp short loc_9BC5D
jmp short loc_9BC5D
mov rbx, rax
mov rdi, [rsp+0B8h+var_78]; void *
lea rax, [rsp+0B8h+var_68]
cmp rdi, rax
jz short loc_9BC60
mov rsi, [rsp+0B8h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9BC60
jmp short $+2
loc_9BC5D:
mov rbx, rax
loc_9BC60:
mov rdi, [rsp+0B8h+var_98]; void *
lea rax, [rsp+0B8h+var_88]
cmp rdi, rax
jz short loc_9BC7C
mov rsi, [rsp+0B8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BC7C:
mov rdi, [rsp+0B8h+var_B8]; void *
test rdi, rdi
jz short loc_9BC92
mov rsi, [rsp+0B8h+var_A8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9BC92:
mov rax, [rsp+0B8h+var_48]
test rax, rax
jz short loc_9BCAB
lea rdi, [rsp+0B8h+var_58]
mov rsi, rdi
mov edx, 3
call rax
loc_9BCAB:
mov rdi, rbx
call __Unwind_Resume
loc_9BCB3:
mov rdi, rax
call __clang_call_terminate
|
void format_literal(long long a1, long long *a2, long long a3)
{
long long *v3; // r15
long long v4; // r14
_QWORD *v5; // rdx
long long **v6; // rax
long long v7; // rbx
long long v8; // rax
_OWORD *v9; // rcx
__int128 v10; // [rsp+0h] [rbp-B8h] BYREF
__int128 v11; // [rsp+10h] [rbp-A8h] BYREF
void *v12; // [rsp+20h] [rbp-98h] BYREF
long long v13; // [rsp+28h] [rbp-90h]
_QWORD v14[2]; // [rsp+30h] [rbp-88h] BYREF
void *v15[2]; // [rsp+40h] [rbp-78h] BYREF
long long v16; // [rsp+50h] [rbp-68h] BYREF
__int128 v17; // [rsp+60h] [rbp-58h] BYREF
long long ( *v18)(); // [rsp+70h] [rbp-48h]
long long ( *v19)(); // [rsp+78h] [rbp-40h]
long long v20; // [rsp+80h] [rbp-38h]
v3 = a2;
v20 = a1;
v17 = 0LL;
v19 = std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_invoke;
v18 = std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_manager;
v11 = 0LL;
v10 = 0LL;
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v4 = (long long)a2 + a3;
while ( std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
v3,
v4,
(long long **)&v10,
(long long)&GRAMMAR_LITERAL_ESCAPE_RE[abi:cxx11],
0) )
{
v5 = (_QWORD *)v10;
if ( *((_QWORD *)&v10 + 1) - (_QWORD)v10 == 72LL )
v5 = (_QWORD *)(*((_QWORD *)&v10 + 1) - 72LL);
if ( *((_QWORD *)&v10 + 1) == (_QWORD)v10 )
v5 = (_QWORD *)(*((_QWORD *)&v10 + 1) - 72LL);
std::string::replace(&v12, v13, 0LL, v3, *v5 - *((_QWORD *)&v11 + 1));
if ( !v18 )
std::__throw_bad_function_call();
((void ( *)(void **, __int128 *, __int128 *))v19)(v15, &v17, &v10);
std::string::_M_append(&v12, v15[0], v15[1]);
if ( v15[0] != &v16 )
operator delete(v15[0], v16 + 1);
v6 = (long long **)(*((_QWORD *)&v10 + 1) - 72LL);
if ( 0xAAAAAAAAAAAAAAABLL * ((long long)(*((_QWORD *)&v10 + 1) - v10) >> 3) >= 4 )
v6 = (long long **)(*((_QWORD *)&v10 + 1) - 24LL);
v3 = *v6;
}
std::string::replace(&v12, v13, 0LL, v3, v4 - (_QWORD)v3);
v7 = v20;
if ( (_QWORD)v10 )
operator delete((void *)v10, v11 - v10);
if ( v18 )
((void ( *)(__int128 *, __int128 *, long long))v18)(&v17, &v17, 3LL);
std::operator+<char>((long long)&v10, (long long)"\"", &v12);
v8 = std::string::append(&v10, "\"");
*(_QWORD *)v7 = v7 + 16;
v9 = (_OWORD *)(v8 + 16);
if ( *(_QWORD *)v8 == v8 + 16 )
{
*(_OWORD *)(v7 + 16) = *v9;
}
else
{
*(_QWORD *)v7 = *(_QWORD *)v8;
*(_QWORD *)(v7 + 16) = *(_QWORD *)v9;
}
*(_QWORD *)(v7 + 8) = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = v9;
*(_QWORD *)(v8 + 8) = 0LL;
*(_BYTE *)(v8 + 16) = 0;
if ( (__int128 *)v10 != &v11 )
operator delete((void *)v10, v11 + 1);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
}
|
format_literal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV qword ptr [RSP + 0x80],RDI
XORPS XMM0,XMM0
LEA RCX,[RSP + 0x60]
MOVAPS xmmword ptr [RCX],XMM0
LEA RAX,[0x19bcbc]
MOV qword ptr [RCX + 0x18],RAX
LEA RAX,[0x19bd3e]
MOV qword ptr [RCX + 0x10],RAX
MOV R12,RSP
MOVAPS xmmword ptr [R12 + 0x10],XMM0
MOVAPS xmmword ptr [R12],XMM0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RAX + -0x10],RAX
MOV qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
ADD R14,RSI
LEA R13,[0x1e2408]
LEA RBP,[RSP + 0x20]
LEA RBX,[RSP + 0x40]
LAB_0019ba12:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,R13
XOR R8D,R8D
CALL 0x0015d68a
TEST AL,AL
JZ 0x0019baec
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RCX
SUB RDX,RAX
LEA RSI,[RCX + -0x48]
CMP RDX,0x48
MOV RDX,RAX
CMOVZ RDX,RSI
CMP RCX,RAX
CMOVZ RDX,RSI
MOV R8,qword ptr [RDX]
SUB R8,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,RBP
XOR EDX,EDX
MOV RCX,R15
CALL 0x001187a0
CMP qword ptr [RSP + 0x70],0x0
JZ 0x0019bbe7
LAB_0019ba79:
MOV RDI,RBX
LEA RSI,[RSP + 0x60]
MOV RDX,R12
CALL qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
LAB_0019ba92:
MOV RDI,RBP
CALL 0x001181e0
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x0019bab6
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x001186e0
LAB_0019bab6:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,RAX
SUB RCX,qword ptr [RSP]
SAR RCX,0x3
MOV RDX,-0x5555555555555555
IMUL RCX,RDX
LEA RDX,[RAX + -0x18]
ADD RAX,-0x48
CMP RCX,0x4
CMOVNC RAX,RDX
MOV R15,qword ptr [RAX]
JMP 0x0019ba12
LAB_0019baec:
LEA RDI,[RSP + 0x20]
MOV RSI,qword ptr [RDI + 0x8]
SUB R14,R15
LAB_0019baf8:
XOR EDX,EDX
MOV RCX,R15
MOV R8,R14
CALL 0x001187a0
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
MOV RBX,qword ptr [RSP + 0x80]
JZ 0x0019bb23
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x001186e0
LAB_0019bb23:
MOV RAX,qword ptr [RSP + 0x70]
TEST RAX,RAX
JZ 0x0019bb3c
LAB_0019bb2d:
LEA RDI,[RSP + 0x60]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0019bb3c:
LEA RSI,[0x1b4a31]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x0012841e
LAB_0019bb50:
LEA RSI,[0x1b4a31]
MOV RDI,RSP
CALL 0x00118d40
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RSI,RCX
JZ 0x0019bb81
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x0019bb87
LAB_0019bb81:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0019bb87:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0019bbb9
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001186e0
LAB_0019bbb9:
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0019bbd5
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001186e0
LAB_0019bbd5:
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019bbe7:
CALL 0x00118260
|
/* format_literal(std::__cxx11::string const&) */
void format_literal(string *param_1)
{
string *psVar1;
bool bVar2;
ulong *puVar3;
int8 *puVar4;
long *plVar5;
long in_RDX;
ulong in_RSI;
long lVar6;
long *local_b8;
long lStack_b0;
long local_a8 [2];
int1 *local_98;
ulong local_90;
int1 local_88;
int7 uStack_87;
long *local_78 [2];
long local_68 [2];
int8 local_58;
int8 uStack_50;
code *local_48;
code *local_40;
string *local_38;
local_58 = 0;
uStack_50 = 0;
local_40 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&),format_literal(std::__cxx11::string_const&)::$_0>
::_M_invoke;
local_48 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&),format_literal(std::__cxx11::string_const&)::$_0>
::_M_manager;
local_a8[0] = 0;
local_a8[1] = 0;
local_b8 = (long *)0x0;
lStack_b0 = 0;
local_98 = &local_88;
local_90 = 0;
local_88 = 0;
lVar6 = in_RDX + in_RSI;
local_38 = param_1;
while( true ) {
/* try { // try from 0019ba12 to 0019ba6c has its CatchHandler @ 0019bc5d */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(in_RSI,lVar6,&local_b8,GRAMMAR_LITERAL_ESCAPE_RE_abi_cxx11_,0);
if (!bVar2) {
/* try { // try from 0019baf8 to 0019bb04 has its CatchHandler @ 0019bc36 */
std::__cxx11::string::replace((ulong)&local_98,local_90,(char *)0x0,in_RSI);
psVar1 = local_38;
if (local_b8 != (long *)0x0) {
operator_delete(local_b8,local_a8[0] - (long)local_b8);
}
if (local_48 != (code *)0x0) {
/* try { // try from 0019bb2d to 0019bb3b has its CatchHandler @ 0019bbec */
(*local_48)(&local_58,&local_58,3);
}
/* try { // try from 0019bb3c to 0019bb4f has its CatchHandler @ 0019bc11 */
std::operator+((char *)&local_b8,(string *)&DAT_001b4a31);
/* try { // try from 0019bb50 to 0019bb5e has its CatchHandler @ 0019bbf1 */
puVar4 = (int8 *)std::__cxx11::string::append((char *)&local_b8);
*(string **)psVar1 = psVar1 + 0x10;
plVar5 = puVar4 + 2;
if ((long *)*puVar4 == plVar5) {
lVar6 = puVar4[3];
*(long *)(psVar1 + 0x10) = *plVar5;
*(long *)(psVar1 + 0x18) = lVar6;
}
else {
*(long **)psVar1 = (long *)*puVar4;
*(long *)(psVar1 + 0x10) = *plVar5;
}
*(int8 *)(psVar1 + 8) = puVar4[1];
*puVar4 = plVar5;
puVar4[1] = 0;
*(int1 *)(puVar4 + 2) = 0;
if (local_b8 != local_a8) {
operator_delete(local_b8,local_a8[0] + 1);
}
if (local_98 != &local_88) {
operator_delete(local_98,CONCAT71(uStack_87,local_88) + 1);
}
return;
}
std::__cxx11::string::replace((ulong)&local_98,local_90,(char *)0x0,in_RSI);
if (local_48 == (code *)0x0) break;
/* try { // try from 0019ba79 to 0019ba87 has its CatchHandler @ 0019bc5b */
(*local_40)(local_78,&local_58,&local_b8);
/* try { // try from 0019ba92 to 0019ba99 has its CatchHandler @ 0019bc3a */
std::__cxx11::string::_M_append((char *)&local_98,(ulong)local_78[0]);
if (local_78[0] != local_68) {
operator_delete(local_78[0],local_68[0] + 1);
}
puVar3 = (ulong *)(lStack_b0 + -0x48);
if (3 < (ulong)((lStack_b0 - (long)local_b8 >> 3) * -0x5555555555555555)) {
puVar3 = (ulong *)(lStack_b0 + -0x18);
}
in_RSI = *puVar3;
}
/* WARNING: Subroutine does not return */
/* try { // try from 0019bbe7 to 0019bbeb has its CatchHandler @ 0019bc38 */
std::__throw_bad_function_call();
}
|
|
9,670 |
ma_once_end_block_record
|
eloqsql/storage/maria/ma_blockrec.c
|
my_bool _ma_once_end_block_record(MARIA_SHARE *share)
{
int res= _ma_bitmap_end(share);
if (share->bitmap.file.file >= 0)
{
if (flush_pagecache_blocks(share->pagecache, &share->bitmap.file,
share->deleting ? FLUSH_IGNORE_CHANGED : FLUSH_RELEASE))
res= 1;
/*
File must be synced as it is going out of the maria_open_list and so
becoming unknown to Checkpoint.
*/
if (!share->s3_path)
{
if (share->now_transactional &&
mysql_file_sync(share->bitmap.file.file, MYF(MY_WME)))
res= 1;
if (mysql_file_close(share->bitmap.file.file, MYF(MY_WME)))
res= 1;
}
/*
Trivial assignment to guard against multiple invocations
(May happen if file are closed but we want to keep the maria object
around a bit longer)
*/
share->bitmap.file.file= -1;
}
if (share->id != 0)
{
/*
We de-assign the id even though index has not been flushed, this is ok
as close_lock serializes us with a Checkpoint looking at our share.
*/
translog_deassign_id_from_share(share);
}
return res;
}
|
O0
|
c
|
ma_once_end_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5fbe0
movsbl %al, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa60(%rax)
jl 0x51f70
movq -0x8(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
addq $0x40, %rsi
movq -0x8(%rbp), %rax
movsbl 0x7ea(%rax), %ecx
movl $0x1, %edx
movl $0x2, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x9bac0
cmpl $0x0, %eax
je 0x51eea
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x798(%rax)
jne 0x51f62
movq -0x8(%rbp), %rax
movsbl 0x7e7(%rax), %eax
cmpl $0x0, %eax
je 0x51f34
movq -0x8(%rbp), %rax
movl 0xa60(%rax), %edx
leaq 0x10ba82(%rip), %rdi # 0x15d99b
movl $0x1cd, %esi # imm = 0x1CD
movl $0x10, %ecx
callq 0x51fa0
cmpl $0x0, %eax
je 0x51f34
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xa60(%rax), %edx
leaq 0x10ba56(%rip), %rdi # 0x15d99b
movl $0x1cf, %esi # imm = 0x1CF
movl $0x10, %ecx
callq 0x52080
cmpl $0x0, %eax
je 0x51f60
movl $0x1, -0xc(%rbp)
jmp 0x51f62
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xa60(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movzwl 0x620(%rax), %eax
cmpl $0x0, %eax
je 0x51f89
movq -0x8(%rbp), %rdi
callq 0x91950
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_once_end_block_record:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _ma_bitmap_end
movsx eax, al
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp dword ptr [rax+0A60h], 0
jl loc_51F70
mov rax, [rbp+var_8]
mov rdi, [rax+600h]
mov rsi, [rbp+var_8]
add rsi, 0A10h
add rsi, 40h ; '@'
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax+7EAh]
mov edx, 1
mov eax, 2
cmp ecx, 0
cmovnz edx, eax
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_51EEA
mov [rbp+var_C], 1
loc_51EEA:
mov rax, [rbp+var_8]
cmp qword ptr [rax+798h], 0
jnz short loc_51F62
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+7E7h]
cmp eax, 0
jz short loc_51F34
mov rax, [rbp+var_8]
mov edx, [rax+0A60h]
lea rdi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1CDh
mov ecx, 10h
call inline_mysql_file_sync_0
cmp eax, 0
jz short loc_51F34
mov [rbp+var_C], 1
loc_51F34:
mov rax, [rbp+var_8]
mov edx, [rax+0A60h]
lea rdi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1CFh
mov ecx, 10h
call inline_mysql_file_close_0
cmp eax, 0
jz short loc_51F60
mov [rbp+var_C], 1
loc_51F60:
jmp short $+2
loc_51F62:
mov rax, [rbp+var_8]
mov dword ptr [rax+0A60h], 0FFFFFFFFh
loc_51F70:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+620h]
cmp eax, 0
jz short loc_51F89
mov rdi, [rbp+var_8]
call translog_deassign_id_from_share
loc_51F89:
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long ma_once_end_block_record(long long a1)
{
long long v1; // rdx
unsigned int v3; // [rsp+4h] [rbp-Ch]
v3 = (char)ma_bitmap_end(a1);
if ( *(int *)(a1 + 2656) >= 0 )
{
v1 = 1LL;
if ( *(_BYTE *)(a1 + 2026) )
v1 = 2LL;
if ( (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(a1 + 1536), a1 + 2640, v1, 0LL) )
v3 = 1;
if ( !*(_QWORD *)(a1 + 1944) )
{
if ( *(_BYTE *)(a1 + 2023)
&& (unsigned int)inline_mysql_file_sync_0(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
461LL,
*(unsigned int *)(a1 + 2656),
16LL) )
{
v3 = 1;
}
if ( (unsigned int)inline_mysql_file_close_0(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
463LL,
*(unsigned int *)(a1 + 2656),
16LL) )
v3 = 1;
}
*(_DWORD *)(a1 + 2656) = -1;
}
if ( *(_WORD *)(a1 + 1568) )
translog_deassign_id_from_share(a1);
return v3;
}
|
_ma_once_end_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0015fbe0
MOVSX EAX,AL
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xa60],0x0
JL 0x00151f70
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xa10
ADD RSI,0x40
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX + 0x7ea]
MOV EDX,0x1
MOV EAX,0x2
CMP ECX,0x0
CMOVNZ EDX,EAX
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0019bac0
CMP EAX,0x0
JZ 0x00151eea
MOV dword ptr [RBP + -0xc],0x1
LAB_00151eea:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x798],0x0
JNZ 0x00151f62
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x7e7]
CMP EAX,0x0
JZ 0x00151f34
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xa60]
LEA RDI,[0x25d99b]
MOV ESI,0x1cd
MOV ECX,0x10
CALL 0x00151fa0
CMP EAX,0x0
JZ 0x00151f34
MOV dword ptr [RBP + -0xc],0x1
LAB_00151f34:
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xa60]
LEA RDI,[0x25d99b]
MOV ESI,0x1cf
MOV ECX,0x10
CALL 0x00152080
CMP EAX,0x0
JZ 0x00151f60
MOV dword ptr [RBP + -0xc],0x1
LAB_00151f60:
JMP 0x00151f62
LAB_00151f62:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xa60],0xffffffff
LAB_00151f70:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0x620]
CMP EAX,0x0
JZ 0x00151f89
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00191950
LAB_00151f89:
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int _ma_once_end_block_record(long param_1)
{
char cVar1;
int iVar2;
int8 uVar3;
int local_14;
cVar1 = _ma_bitmap_end(param_1);
local_14 = (int)cVar1;
if (-1 < *(int *)(param_1 + 0xa60)) {
uVar3 = 1;
if (*(char *)(param_1 + 0x7ea) != '\0') {
uVar3 = 2;
}
iVar2 = flush_pagecache_blocks_with_filter
(*(int8 *)(param_1 + 0x600),param_1 + 0xa50,uVar3,0);
if (iVar2 != 0) {
local_14 = 1;
}
if (*(long *)(param_1 + 0x798) == 0) {
if ((*(char *)(param_1 + 0x7e7) != '\0') &&
(iVar2 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1cd,*(int4 *)(param_1 + 0xa60),0x10), iVar2 != 0)) {
local_14 = 1;
}
iVar2 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1cf,*(int4 *)(param_1 + 0xa60),0x10);
if (iVar2 != 0) {
local_14 = 1;
}
}
*(int4 *)(param_1 + 0xa60) = 0xffffffff;
}
if (*(short *)(param_1 + 0x620) != 0) {
translog_deassign_id_from_share(param_1);
}
return local_14;
}
|
|
9,671 |
OpenSubdiv::v3_6_0::Bfr::FaceSurface::print(bool) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceSurface.cpp
|
void
FaceSurface::print(bool printVerts) const {
MultiVertexTag const & tag = _combinedTag;
printf(" FaceTopology:\n");
printf(" face size = %d\n", _topology->GetFaceSize());
printf(" num-face-verts = %d\n", _topology->GetNumFaceVertices());
printf(" Properties:\n");
printf(" is regular = %d\n", IsRegular());
printf(" Combined tags:\n");
printf(" inf-sharp verts = %d\n", tag.HasInfSharpVertices());
printf(" semi-sharp verts = %d\n", tag.HasSemiSharpVertices());
printf(" inf-sharp edges = %d\n", tag.HasInfSharpEdges());
printf(" semi-sharp edges = %d\n", tag.HasSemiSharpEdges());
printf(" inf-sharp darts = %d\n", tag.HasInfSharpDarts());
printf(" unsharp boundary = %d\n", tag.HasNonSharpBoundary());
printf(" irregular faces = %d\n", tag.HasIrregularFaceSizes());
printf(" unordered verts = %d\n", tag.HasUnOrderedVertices());
if (printVerts) {
Index const * indices = _indices;
for (int i = 0; i < GetFaceSize(); ++i) {
FaceVertex const & top = GetCornerTopology(i);
FaceVertexSubset const & sub = GetCornerSubset(i);
printf(" corner %d:\n", i);
printf(" topology: num faces = %d, boundary = %d\n",
top.GetNumFaces(), top.GetTag().IsBoundary());
printf(" subset: num faces = %d, boundary = %d\n",
sub.GetNumFaces(), sub.IsBoundary());
printf(" num before = %d, num after = %d\n",
sub._numFacesBefore, sub._numFacesAfter);
printf(" face-vert indices:\n");
for (int j = 0, n = 0; j < top.GetNumFaces(); ++j) {
printf(" face %d: ", j);
int S = top.GetFaceSize(j);
for (int k = 0; k < S; ++k, ++n) {
printf("%3d", indices[n]);
}
printf("\n");
}
indices += top.GetNumFaceVertices();
}
}
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::FaceSurface::print(bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x32fb3(%rip), %rdi # 0xc8a2b
callq 0x544b0
movq (%r14), %rax
movl 0x8(%rax), %esi
leaq 0x32c89(%rip), %rdi # 0xc8713
xorl %eax, %eax
callq 0x4f1b0
movq (%r14), %rax
movl 0x10(%rax), %esi
leaq 0x32c92(%rip), %rdi # 0xc8730
xorl %eax, %eax
callq 0x4f1b0
leaq 0x32f91(%rip), %rdi # 0xc8a3d
callq 0x544b0
movzbl 0x8e(%r14), %esi
shrl $0x2, %esi
andl $0x1, %esi
leaq 0x32c87(%rip), %rdi # 0xc874d
xorl %eax, %eax
callq 0x4f1b0
leaq 0x32f79(%rip), %rdi # 0xc8a4d
callq 0x544b0
movl 0x88(%r14), %esi
shrl %esi
andl $0x1, %esi
leaq 0x32c7e(%rip), %rdi # 0xc876a
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x4, %esi
andl $0x1, %esi
leaq 0x32c81(%rip), %rdi # 0xc8788
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x2, %esi
andl $0x1, %esi
leaq 0x32c84(%rip), %rdi # 0xc87a6
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x5, %esi
andl $0x1, %esi
leaq 0x32c87(%rip), %rdi # 0xc87c4
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x3, %esi
andl $0x1, %esi
leaq 0x32c8a(%rip), %rdi # 0xc87e2
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0xa, %esi
andl $0x1, %esi
leaq 0x32c8d(%rip), %rdi # 0xc8800
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x7, %esi
andl $0x1, %esi
leaq 0x32c90(%rip), %rdi # 0xc881e
xorl %eax, %eax
callq 0x4f1b0
movl 0x88(%r14), %esi
shrl $0x8, %esi
andl $0x1, %esi
leaq 0x32c93(%rip), %rdi # 0xc883c
xorl %eax, %eax
callq 0x4f1b0
testl %ebp, %ebp
je 0x95d0c
movq 0x8(%r14), %r13
leaq 0x32d68(%rip), %r12 # 0xc892b
xorl %esi, %esi
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movslq 0x8(%rax), %rcx
cmpq %rcx, %rsi
jge 0x95d0c
movq 0x18(%rax), %rbx
imulq $0xe0, %rsi, %r15
leaq (%rbx,%r15), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
imulq $0xc, %rsi, %r14
xorl %ebp, %ebp
leaq 0x32c56(%rip), %rdi # 0xc885a
movq %rsi, 0x18(%rsp)
xorl %eax, %eax
callq 0x4f1b0
movswl 0x2(%rbx,%r15), %esi
movzwl 0x98(%rbx,%r15), %edx
andl $0x1, %edx
leaq 0x32c45(%rip), %rdi # 0xc886e
xorl %eax, %eax
callq 0x4f1b0
movq 0x10(%rsp), %rax
movswl 0x6(%rax,%r14), %esi
movzwl (%rax,%r14), %edx
movq %rax, %rbx
andl $0x1, %edx
leaq 0x32c58(%rip), %rdi # 0xc88a5
xorl %eax, %eax
callq 0x4f1b0
movswl 0x2(%rbx,%r14), %esi
movswl 0x4(%rbx,%r14), %edx
leaq 0x32c75(%rip), %rdi # 0xc88dc
xorl %eax, %eax
callq 0x4f1b0
leaq 0x32deb(%rip), %rdi # 0xc8a60
callq 0x544b0
xorl %r14d, %r14d
movq 0x20(%rsp), %rbx
movswq 0x2(%rbx), %rax
cmpq %rax, %rbp
jge 0x95cee
leaq 0x32c81(%rip), %rdi # 0xc8914
movl %ebp, %esi
xorl %eax, %eax
callq 0x4f1b0
movswl 0x9c(%rbx), %eax
testl %eax, %eax
jne 0x95cb2
movq 0x60(%rbx), %rcx
movl 0x4(%rcx,%rbp,4), %eax
subl (%rcx,%rbp,4), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
movslq %r14d, %r15
movl %eax, %r14d
addl %r15d, %r14d
movslq %r14d, %rbx
cmpq %r15, %rbx
je 0x95ce1
movl (%r13,%r15,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x4f1b0
incq %r15
jmp 0x95cc8
pushq $0xa
popq %rdi
callq 0x53d40
incq %rbp
jmp 0x95c7d
movslq 0xa0(%rbx), %rax
leaq (%r13,%rax,4), %r13
movq 0x18(%rsp), %rsi
incq %rsi
movq 0x8(%rsp), %r14
jmp 0x95bca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK10OpenSubdiv6v3_6_03Bfr11FaceSurface5printEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, esi
mov r14, rdi
lea rdi, aFacetopology; " FaceTopology:"
call _puts
mov rax, [r14]
mov esi, [rax+8]
lea rdi, aFaceSizeD; " face size = %d\n"
xor eax, eax
call _printf
mov rax, [r14]
mov esi, [rax+10h]
lea rdi, aNumFaceVertsD; " num-face-verts = %d\n"
xor eax, eax
call _printf
lea rdi, aProperties; " Properties:"
call _puts
movzx esi, byte ptr [r14+8Eh]
shr esi, 2
and esi, 1
lea rdi, aIsRegularD; " is regular = %d\n"
xor eax, eax
call _printf
lea rdi, aCombinedTags; " Combined tags:"
call _puts
mov esi, [r14+88h]
shr esi, 1
and esi, 1
lea rdi, aInfSharpVertsD; " inf-sharp verts = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 4
and esi, 1
lea rdi, aSemiSharpVerts; " semi-sharp verts = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 2
and esi, 1
lea rdi, aInfSharpEdgesD; " inf-sharp edges = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 5
and esi, 1
lea rdi, aSemiSharpEdges; " semi-sharp edges = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 3
and esi, 1
lea rdi, aInfSharpDartsD; " inf-sharp darts = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 0Ah
and esi, 1
lea rdi, aUnsharpBoundar; " unsharp boundary = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 7
and esi, 1
lea rdi, aIrregularFaces; " irregular faces = %d\n"
xor eax, eax
call _printf
mov esi, [r14+88h]
shr esi, 8
and esi, 1
lea rdi, aUnorderedVerts; " unordered verts = %d\n"
xor eax, eax
call _printf
test ebp, ebp
jz loc_95D0C
mov r13, [r14+8]
lea r12, a3d; "%3d"
xor esi, esi
mov [rsp+58h+var_50], r14
loc_95BCA:
mov rax, [r14]
movsxd rcx, dword ptr [rax+8]
cmp rsi, rcx
jge loc_95D0C
mov rbx, [rax+18h]
imul r15, rsi, 0E0h
lea rax, [rbx+r15]
mov [rsp+58h+var_38], rax
mov rax, [r14+10h]
mov [rsp+58h+var_48], rax
imul r14, rsi, 0Ch
xor ebp, ebp
lea rdi, aCornerD_0; " corner %d:\n"
mov [rsp+58h+var_40], rsi
xor eax, eax
call _printf
movsx esi, word ptr [rbx+r15+2]
movzx edx, word ptr [rbx+r15+98h]
and edx, 1
lea rdi, aTopologyNumFac; " topology: num faces = %d,"...
xor eax, eax
call _printf
mov rax, [rsp+58h+var_48]
movsx esi, word ptr [rax+r14+6]
movzx edx, word ptr [rax+r14]
mov rbx, rax
and edx, 1
lea rdi, aSubsetNumFaces; " subset: num faces = %d,"...
xor eax, eax
call _printf
movsx esi, word ptr [rbx+r14+2]
movsx edx, word ptr [rbx+r14+4]
lea rdi, aNumBeforeDNumA; " num before = %d,"...
xor eax, eax
call _printf
lea rdi, aFaceVertIndice_0; " face-vert indices:"
call _puts
xor r14d, r14d
loc_95C7D:
mov rbx, [rsp+58h+var_38]
movsx rax, word ptr [rbx+2]
cmp rbp, rax
jge short loc_95CEE
lea rdi, aFaceD_0; " face %d: "
mov esi, ebp
xor eax, eax
call _printf
movsx eax, word ptr [rbx+9Ch]
test eax, eax
jnz short loc_95CB2
mov rcx, [rbx+60h]
mov eax, [rcx+rbp*4+4]
sub eax, [rcx+rbp*4]
loc_95CB2:
test eax, eax
mov ecx, 0
cmovle eax, ecx
movsxd r15, r14d
mov r14d, eax
add r14d, r15d
movsxd rbx, r14d
loc_95CC8:
cmp rbx, r15
jz short loc_95CE1
mov esi, [r13+r15*4+0]
mov rdi, r12
xor eax, eax
call _printf
inc r15
jmp short loc_95CC8
loc_95CE1:
push 0Ah
pop rdi
call _putchar
inc rbp
jmp short loc_95C7D
loc_95CEE:
movsxd rax, dword ptr [rbx+0A0h]
lea r13, [r13+rax*4+0]
mov rsi, [rsp+58h+var_40]
inc rsi
mov r14, [rsp+58h+var_50]
jmp loc_95BCA
loc_95D0C:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long OpenSubdiv::v3_6_0::Bfr::FaceSurface::print(OpenSubdiv::v3_6_0::Bfr::FaceSurface *this, int a2)
{
OpenSubdiv::v3_6_0::Bfr::FaceSurface *v2; // r14
long long result; // rax
long long v4; // r13
long long i; // rsi
long long v6; // r14
long long v7; // rbp
int v8; // r14d
int v9; // eax
long long v10; // r15
long long v11; // [rsp+10h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-38h]
v2 = this;
puts(" FaceTopology:");
printf(" face size = %d\n", *(_DWORD *)(*(_QWORD *)this + 8LL));
printf(" num-face-verts = %d\n", *(_DWORD *)(*(_QWORD *)this + 16LL));
puts(" Properties:");
printf(" is regular = %d\n", (*((unsigned __int8 *)this + 142) >> 2) & 1);
puts(" Combined tags:");
printf(" inf-sharp verts = %d\n", (*((_DWORD *)this + 34) >> 1) & 1);
printf(" semi-sharp verts = %d\n", (*((_DWORD *)this + 34) >> 4) & 1);
printf(" inf-sharp edges = %d\n", (*((_DWORD *)this + 34) >> 2) & 1);
printf(" semi-sharp edges = %d\n", (*((_DWORD *)this + 34) >> 5) & 1);
printf(" inf-sharp darts = %d\n", (*((_DWORD *)this + 34) >> 3) & 1);
printf(" unsharp boundary = %d\n", (*((_DWORD *)this + 34) >> 10) & 1);
printf(" irregular faces = %d\n", (*((_DWORD *)this + 34) >> 7) & 1);
result = printf(" unordered verts = %d\n", (*((_DWORD *)this + 34) >> 8) & 1);
if ( a2 )
{
v4 = *((_QWORD *)this + 1);
for ( i = 0LL; ; ++i )
{
result = *(_QWORD *)v2;
if ( i >= *(int *)(*(_QWORD *)v2 + 8LL) )
break;
v12 = *(_QWORD *)(result + 24) + 224 * i;
v11 = *((_QWORD *)v2 + 2);
v6 = 12 * i;
v7 = 0LL;
printf(" corner %d:\n", i);
printf(
" topology: num faces = %d, boundary = %d\n",
*(__int16 *)(v12 + 2),
*(_WORD *)(v12 + 152) & 1);
printf(
" subset: num faces = %d, boundary = %d\n",
*(__int16 *)(v11 + v6 + 6),
*(_WORD *)(v11 + v6) & 1);
printf(
" num before = %d, num after = %d\n",
*(__int16 *)(v11 + v6 + 2),
*(__int16 *)(v11 + v6 + 4));
puts(" face-vert indices:");
v8 = 0;
while ( v7 < *(__int16 *)(v12 + 2) )
{
printf(" face %d: ", v7);
v9 = *(__int16 *)(v12 + 156);
if ( !*(_WORD *)(v12 + 156) )
v9 = *(_DWORD *)(*(_QWORD *)(v12 + 96) + 4 * v7 + 4) - *(_DWORD *)(*(_QWORD *)(v12 + 96) + 4 * v7);
if ( v9 <= 0 )
v9 = 0;
v10 = v8;
v8 += v9;
while ( v8 != v10 )
printf("%3d", *(_DWORD *)(v4 + 4 * v10++));
putchar(10LL);
++v7;
}
v4 += 4LL * *(int *)(v12 + 160);
v2 = this;
}
}
return result;
}
|
print:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ESI
MOV R14,RDI
LEA RDI,[0x1c8a2b]
CALL 0x001544b0
MOV RAX,qword ptr [R14]
MOV ESI,dword ptr [RAX + 0x8]
LEA RDI,[0x1c8713]
XOR EAX,EAX
CALL 0x0014f1b0
MOV RAX,qword ptr [R14]
MOV ESI,dword ptr [RAX + 0x10]
LEA RDI,[0x1c8730]
XOR EAX,EAX
CALL 0x0014f1b0
LEA RDI,[0x1c8a3d]
CALL 0x001544b0
MOVZX ESI,byte ptr [R14 + 0x8e]
SHR ESI,0x2
AND ESI,0x1
LEA RDI,[0x1c874d]
XOR EAX,EAX
CALL 0x0014f1b0
LEA RDI,[0x1c8a4d]
CALL 0x001544b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x1
AND ESI,0x1
LEA RDI,[0x1c876a]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x4
AND ESI,0x1
LEA RDI,[0x1c8788]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x2
AND ESI,0x1
LEA RDI,[0x1c87a6]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x5
AND ESI,0x1
LEA RDI,[0x1c87c4]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x3
AND ESI,0x1
LEA RDI,[0x1c87e2]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0xa
AND ESI,0x1
LEA RDI,[0x1c8800]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x7
AND ESI,0x1
LEA RDI,[0x1c881e]
XOR EAX,EAX
CALL 0x0014f1b0
MOV ESI,dword ptr [R14 + 0x88]
SHR ESI,0x8
AND ESI,0x1
LEA RDI,[0x1c883c]
XOR EAX,EAX
CALL 0x0014f1b0
TEST EBP,EBP
JZ 0x00195d0c
MOV R13,qword ptr [R14 + 0x8]
LEA R12,[0x1c892b]
XOR ESI,ESI
MOV qword ptr [RSP + 0x8],R14
LAB_00195bca:
MOV RAX,qword ptr [R14]
MOVSXD RCX,dword ptr [RAX + 0x8]
CMP RSI,RCX
JGE 0x00195d0c
MOV RBX,qword ptr [RAX + 0x18]
IMUL R15,RSI,0xe0
LEA RAX,[RBX + R15*0x1]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
IMUL R14,RSI,0xc
XOR EBP,EBP
LEA RDI,[0x1c885a]
MOV qword ptr [RSP + 0x18],RSI
XOR EAX,EAX
CALL 0x0014f1b0
MOVSX ESI,word ptr [RBX + R15*0x1 + 0x2]
MOVZX EDX,word ptr [RBX + R15*0x1 + 0x98]
AND EDX,0x1
LEA RDI,[0x1c886e]
XOR EAX,EAX
CALL 0x0014f1b0
MOV RAX,qword ptr [RSP + 0x10]
MOVSX ESI,word ptr [RAX + R14*0x1 + 0x6]
MOVZX EDX,word ptr [RAX + R14*0x1]
MOV RBX,RAX
AND EDX,0x1
LEA RDI,[0x1c88a5]
XOR EAX,EAX
CALL 0x0014f1b0
MOVSX ESI,word ptr [RBX + R14*0x1 + 0x2]
MOVSX EDX,word ptr [RBX + R14*0x1 + 0x4]
LEA RDI,[0x1c88dc]
XOR EAX,EAX
CALL 0x0014f1b0
LEA RDI,[0x1c8a60]
CALL 0x001544b0
XOR R14D,R14D
LAB_00195c7d:
MOV RBX,qword ptr [RSP + 0x20]
MOVSX RAX,word ptr [RBX + 0x2]
CMP RBP,RAX
JGE 0x00195cee
LEA RDI,[0x1c8914]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x0014f1b0
MOVSX EAX,word ptr [RBX + 0x9c]
TEST EAX,EAX
JNZ 0x00195cb2
MOV RCX,qword ptr [RBX + 0x60]
MOV EAX,dword ptr [RCX + RBP*0x4 + 0x4]
SUB EAX,dword ptr [RCX + RBP*0x4]
LAB_00195cb2:
TEST EAX,EAX
MOV ECX,0x0
CMOVLE EAX,ECX
MOVSXD R15,R14D
MOV R14D,EAX
ADD R14D,R15D
MOVSXD RBX,R14D
LAB_00195cc8:
CMP RBX,R15
JZ 0x00195ce1
MOV ESI,dword ptr [R13 + R15*0x4]
MOV RDI,R12
XOR EAX,EAX
CALL 0x0014f1b0
INC R15
JMP 0x00195cc8
LAB_00195ce1:
PUSH 0xa
POP RDI
CALL 0x00153d40
INC RBP
JMP 0x00195c7d
LAB_00195cee:
MOVSXD RAX,dword ptr [RBX + 0xa0]
LEA R13,[R13 + RAX*0x4]
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
MOV R14,qword ptr [RSP + 0x8]
JMP 0x00195bca
LAB_00195d0c:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Bfr::FaceSurface::print(bool) const */
void __thiscall OpenSubdiv::v3_6_0::Bfr::FaceSurface::print(FaceSurface *this,bool param_1)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int7 in_register_00000031;
long lVar5;
long lVar6;
int iVar7;
long lVar8;
long lVar9;
long lVar10;
puts(" FaceTopology:");
printf(" face size = %d\n",(ulong)*(uint *)(*(long *)this + 8));
printf(" num-face-verts = %d\n",(ulong)*(uint *)(*(long *)this + 0x10));
puts(" Properties:");
printf(" is regular = %d\n",(ulong)((byte)this[0x8e] >> 2 & 1));
puts(" Combined tags:");
printf(" inf-sharp verts = %d\n",(ulong)(*(uint *)(this + 0x88) >> 1 & 1));
printf(" semi-sharp verts = %d\n",(ulong)(*(uint *)(this + 0x88) >> 4 & 1));
printf(" inf-sharp edges = %d\n",(ulong)(*(uint *)(this + 0x88) >> 2 & 1));
printf(" semi-sharp edges = %d\n",(ulong)(*(uint *)(this + 0x88) >> 5 & 1));
printf(" inf-sharp darts = %d\n",(ulong)(*(uint *)(this + 0x88) >> 3 & 1));
printf(" unsharp boundary = %d\n",(ulong)(*(uint *)(this + 0x88) >> 10 & 1));
printf(" irregular faces = %d\n",(ulong)(*(uint *)(this + 0x88) >> 7 & 1));
printf(" unordered verts = %d\n");
if ((int)CONCAT71(in_register_00000031,param_1) != 0) {
lVar6 = *(long *)(this + 8);
lVar5 = 0;
while( true ) {
if (*(int *)(*(long *)this + 8) <= lVar5) break;
lVar10 = *(long *)(*(long *)this + 0x18);
lVar9 = lVar5 * 0xe0;
lVar1 = lVar10 + lVar9;
lVar2 = *(long *)(this + 0x10);
lVar8 = lVar5 * 0xc;
printf(" corner %d:\n");
printf(" topology: num faces = %d, boundary = %d\n",
(ulong)(uint)(int)*(short *)(lVar10 + 2 + lVar9),
(ulong)(*(ushort *)(lVar10 + 0x98 + lVar9) & 1));
printf(" subset: num faces = %d, boundary = %d\n",
(ulong)(uint)(int)*(short *)(lVar2 + 6 + lVar8),(ulong)(*(ushort *)(lVar2 + lVar8) & 1)
);
printf(" num before = %d, num after = %d\n",
(ulong)(uint)(int)*(short *)(lVar2 + 2 + lVar8),
(ulong)(uint)(int)*(short *)(lVar2 + 4 + lVar8));
puts(" face-vert indices:");
iVar7 = 0;
for (uVar4 = 0; (long)uVar4 < (long)*(short *)(lVar1 + 2); uVar4 = uVar4 + 1) {
printf(" face %d: ",uVar4 & 0xffffffff);
iVar3 = (int)*(short *)(lVar1 + 0x9c);
if (*(short *)(lVar1 + 0x9c) == 0) {
iVar3 = *(int *)(*(long *)(lVar1 + 0x60) + 4 + uVar4 * 4) -
*(int *)(*(long *)(lVar1 + 0x60) + uVar4 * 4);
}
if (iVar3 < 1) {
iVar3 = 0;
}
for (lVar10 = (long)iVar7; iVar3 + iVar7 != lVar10; lVar10 = lVar10 + 1) {
printf("%3d",(ulong)*(uint *)(lVar6 + lVar10 * 4));
}
putchar(10);
iVar7 = iVar3 + iVar7;
}
lVar6 = lVar6 + (long)*(int *)(lVar1 + 0xa0) * 4;
lVar5 = lVar5 + 1;
}
}
return;
}
|
|
9,672 |
init_available_charsets
|
eloqsql/mysys/charset.c
|
static void init_available_charsets(void)
{
char fname[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
struct charset_info_st **cs;
MY_CHARSET_LOADER loader;
DBUG_ENTER("init_available_charsets");
bzero((char*) &all_charsets,sizeof(all_charsets));
bzero((char*) &my_collation_statistics, sizeof(my_collation_statistics));
my_hash_init2(key_memory_charsets, &charset_name_hash, 16,
&my_charset_latin1, 64, 0, 0, get_charset_key,
0, 0, HASH_UNIQUE);
init_compiled_charsets(MYF(0));
/* Copy compiled charsets */
for (cs= (struct charset_info_st**) all_charsets;
cs < (struct charset_info_st**) all_charsets +
array_elements(all_charsets)-1 ;
cs++)
{
if (*cs)
{
DBUG_ASSERT(cs[0]->mbmaxlen <= MY_CS_MBMAXLEN);
if (cs[0]->m_ctype)
if (init_state_maps(*cs))
*cs= NULL;
}
}
my_charset_loader_init_mysys(&loader);
strmov(get_charsets_dir(fname), MY_CHARSET_INDEX);
my_read_charset_file(&loader, fname, MYF(0));
DBUG_VOID_RETURN;
}
|
O0
|
c
|
init_available_charsets:
pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq 0xb9ebe1(%rip), %rdi # 0xc7b960
xorl %esi, %esi
movl $0x4000, %edx # imm = 0x4000
callq 0x2a2c0
leaq 0xba2c3e(%rip), %rdi # 0xc7f9d0
xorl %esi, %esi
movl $0x4000, %edx # imm = 0x4000
callq 0x2a2c0
leaq 0xba7807(%rip), %rax # 0xc845ac
movl (%rax), %edi
leaq 0xba2bb2(%rip), %rsi # 0xc7f960
movl $0x10, %edx
leaq 0x28a2b6(%rip), %rcx # 0x367070
movl $0x40, %r8d
xorl %eax, %eax
movl %eax, %r9d
leaq 0x1ab4(%rip), %rax # 0xde880
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0xdf1f0
xorl %eax, %eax
movl %eax, %edi
callq 0x103600
leaq 0xb9eb58(%rip), %rax # 0xc7b960
movq %rax, -0x2d8(%rbp)
leaq 0xb9eb4a(%rip), %rax # 0xc7b960
addq $0x4000, %rax # imm = 0x4000
addq $-0x8, %rax
cmpq %rax, -0x2d8(%rbp)
jae 0xdce86
movq -0x2d8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdce70
jmp 0xdce38
jmp 0xdce3a
movq -0x2d8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0xdce6e
movq -0x2d8(%rbp), %rax
movq (%rax), %rdi
callq 0xde3e0
cmpb $0x0, %al
je 0xdce6c
movq -0x2d8(%rbp), %rax
movq $0x0, (%rax)
jmp 0xdce6e
jmp 0xdce70
jmp 0xdce72
movq -0x2d8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x2d8(%rbp)
jmp 0xdce0f
leaq -0x2d0(%rbp), %rdi
callq 0xdc380
leaq -0x220(%rbp), %rdi
callq 0xdca20
movq %rax, %rdi
leaq 0x78319(%rip), %rsi # 0x1551c1
callq 0x2a730
leaq -0x220(%rbp), %rsi
leaq -0x2d0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xde8c0
jmp 0xdcec6
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xdcee1
addq $0x300, %rsp # imm = 0x300
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
init_available_charsets:
push rbp
mov rbp, rsp
sub rsp, 300h
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, all_charsets
xor esi, esi
mov edx, 4000h
call _memset
lea rdi, my_collation_statistics
xor esi, esi
mov edx, 4000h
call _memset
lea rax, key_memory_charsets
mov edi, [rax]
lea rsi, charset_name_hash
mov edx, 10h
lea rcx, my_charset_latin1
mov r8d, 40h ; '@'
xor eax, eax
mov r9d, eax
lea rax, get_charset_key
mov [rsp+300h+var_300], 0
mov [rsp+300h+var_2F8], rax
mov [rsp+300h+var_2F0], 0
mov [rsp+300h+var_2E8], 0
mov [rsp+300h+var_2E0], 1
call my_hash_init2
xor eax, eax
mov edi, eax
call init_compiled_charsets
lea rax, all_charsets
mov [rbp+var_2D8], rax
loc_DCE0F:
lea rax, all_charsets
add rax, 4000h
add rax, 0FFFFFFFFFFFFFFF8h
cmp [rbp+var_2D8], rax
jnb short loc_DCE86
mov rax, [rbp+var_2D8]
cmp qword ptr [rax], 0
jz short loc_DCE70
jmp short $+2
loc_DCE38:
jmp short $+2
loc_DCE3A:
mov rax, [rbp+var_2D8]
mov rax, [rax]
cmp qword ptr [rax+40h], 0
jz short loc_DCE6E
mov rax, [rbp+var_2D8]
mov rdi, [rax]
call init_state_maps
cmp al, 0
jz short loc_DCE6C
mov rax, [rbp+var_2D8]
mov qword ptr [rax], 0
loc_DCE6C:
jmp short $+2
loc_DCE6E:
jmp short $+2
loc_DCE70:
jmp short $+2
loc_DCE72:
mov rax, [rbp+var_2D8]
add rax, 8
mov [rbp+var_2D8], rax
jmp short loc_DCE0F
loc_DCE86:
lea rdi, [rbp+var_2D0]
call my_charset_loader_init_mysys
lea rdi, [rbp+var_220]
call get_charsets_dir
mov rdi, rax
lea rsi, aIndexXml; "Index.xml"
call _stpcpy
lea rsi, [rbp+var_220]
lea rdi, [rbp+var_2D0]
xor eax, eax
mov edx, eax
call my_read_charset_file
jmp short $+2
loc_DCEC6:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DCEE1
add rsp, 300h
pop rbp
retn
loc_DCEE1:
call ___stack_chk_fail
|
unsigned long long init_available_charsets()
{
long long charsets_dir; // rax
_QWORD *i; // [rsp+28h] [rbp-2D8h]
_BYTE v3[176]; // [rsp+30h] [rbp-2D0h] BYREF
_BYTE v4[536]; // [rsp+E0h] [rbp-220h] BYREF
unsigned long long v5; // [rsp+2F8h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(all_charsets, 0LL, sizeof(all_charsets));
memset(my_collation_statistics, 0LL, sizeof(my_collation_statistics));
my_hash_init2(
key_memory_charsets,
(unsigned int)&charset_name_hash,
16,
(unsigned int)&my_charset_latin1,
64,
0,
0LL,
(long long)get_charset_key,
0LL,
0LL,
1);
init_compiled_charsets(0LL);
for ( i = all_charsets; i < &all_charsets[2047]; ++i )
{
if ( *i && *(_QWORD *)(*i + 64LL) )
{
if ( (unsigned __int8)init_state_maps(*i) )
*i = 0LL;
}
}
my_charset_loader_init_mysys((long long)v3);
charsets_dir = get_charsets_dir((long long)v4);
stpcpy(charsets_dir, "Index.xml");
my_read_charset_file(v3, v4, 0LL);
return __readfsqword(0x28u);
}
|
init_available_charsets:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x300
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0xd7b960]
XOR ESI,ESI
MOV EDX,0x4000
CALL 0x0012a2c0
LEA RDI,[0xd7f9d0]
XOR ESI,ESI
MOV EDX,0x4000
CALL 0x0012a2c0
LEA RAX,[0xd845ac]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd7f960]
MOV EDX,0x10
LEA RCX,[0x467070]
MOV R8D,0x40
XOR EAX,EAX
MOV R9D,EAX
LEA RAX,[0x1de880]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x20],0x1
CALL 0x001df1f0
XOR EAX,EAX
MOV EDI,EAX
CALL 0x00203600
LEA RAX,[0xd7b960]
MOV qword ptr [RBP + -0x2d8],RAX
LAB_001dce0f:
LEA RAX,[0xd7b960]
ADD RAX,0x4000
ADD RAX,-0x8
CMP qword ptr [RBP + -0x2d8],RAX
JNC 0x001dce86
MOV RAX,qword ptr [RBP + -0x2d8]
CMP qword ptr [RAX],0x0
JZ 0x001dce70
JMP 0x001dce38
LAB_001dce38:
JMP 0x001dce3a
LAB_001dce3a:
MOV RAX,qword ptr [RBP + -0x2d8]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x001dce6e
MOV RAX,qword ptr [RBP + -0x2d8]
MOV RDI,qword ptr [RAX]
CALL 0x001de3e0
CMP AL,0x0
JZ 0x001dce6c
MOV RAX,qword ptr [RBP + -0x2d8]
MOV qword ptr [RAX],0x0
LAB_001dce6c:
JMP 0x001dce6e
LAB_001dce6e:
JMP 0x001dce70
LAB_001dce70:
JMP 0x001dce72
LAB_001dce72:
MOV RAX,qword ptr [RBP + -0x2d8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x2d8],RAX
JMP 0x001dce0f
LAB_001dce86:
LEA RDI,[RBP + -0x2d0]
CALL 0x001dc380
LEA RDI,[RBP + -0x220]
CALL 0x001dca20
MOV RDI,RAX
LEA RSI,[0x2551c1]
CALL 0x0012a730
LEA RSI,[RBP + -0x220]
LEA RDI,[RBP + -0x2d0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001de8c0
JMP 0x001dcec6
LAB_001dcec6:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001dcee1
ADD RSP,0x300
POP RBP
RET
LAB_001dcee1:
CALL 0x0012a270
|
void init_available_charsets(void)
{
char cVar1;
char *__dest;
long in_FS_OFFSET;
long *local_2e0;
int1 local_2d8 [176];
int1 local_228 [536];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
memset(&all_charsets,0,0x4000);
memset(my_collation_statistics,0,0x4000);
my_hash_init2(key_memory_charsets,charset_name_hash,0x10,&my_charset_latin1,0x40,0,0,
get_charset_key,0,0,1);
init_compiled_charsets(0);
for (local_2e0 = &all_charsets; local_2e0 < (long *)0xd7f958; local_2e0 = local_2e0 + 1) {
if (((*local_2e0 != 0) && (*(long *)(*local_2e0 + 0x40) != 0)) &&
(cVar1 = init_state_maps(*local_2e0), cVar1 != '\0')) {
*local_2e0 = 0;
}
}
my_charset_loader_init_mysys(local_2d8);
__dest = (char *)get_charsets_dir(local_228);
stpcpy(__dest,"Index.xml");
my_read_charset_file(local_2d8,local_228,0);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
9,673 |
get_record_position
|
eloqsql/storage/maria/ma_blockrec.c
|
static uchar *get_record_position(MARIA_SHARE *share, uchar *buff,
uint record_number, uchar **end_of_data)
{
uint block_size= share->block_size;
uint number_of_records= (uint) buff[DIR_COUNT_OFFSET];
uchar *dir;
uchar *data;
uint offset, length;
#ifdef SANITY_CHECKS
if (record_number >= number_of_records ||
record_number > ((block_size - PAGE_HEADER_SIZE(share) - PAGE_SUFFIX_SIZE)
/ DIR_ENTRY_SIZE))
{
DBUG_PRINT("error",
("Wrong row number: record_number: %u number_of_records: %u",
record_number, number_of_records));
return 0;
}
#endif
dir= dir_entry_pos(buff, block_size, record_number);
offset= uint2korr(dir);
length= uint2korr(dir + 2);
#ifdef SANITY_CHECKS
if (offset < PAGE_HEADER_SIZE(share) ||
offset + length > (block_size -
number_of_records * DIR_ENTRY_SIZE -
PAGE_SUFFIX_SIZE))
{
DBUG_PRINT("error",
("Wrong row position: record_number: %u offset: %u "
"length: %u number_of_records: %u",
record_number, offset, length, number_of_records));
return 0;
}
#endif
data= buff + offset;
*end_of_data= data + length;
return data;
}
|
O0
|
c
|
get_record_position:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x79a46
movl -0x1c(%rbp), %eax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
movl 0xc18(%rdx), %edx
addl $0xc, %edx
subl %edx, %ecx
subl $0x4, %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jbe 0x79a57
jmp 0x79a48
jmp 0x79a4a
movq $0x0, -0x8(%rbp)
jmp 0x79ae0
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x76380
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0xc, %ecx
cmpl %ecx, %eax
jb 0x79aab
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %edx
shll $0x2, %edx
subl %edx, %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jbe 0x79ab9
jmp 0x79aad
jmp 0x79aaf
movq $0x0, -0x8(%rbp)
jmp 0x79ae0
movq -0x18(%rbp), %rax
movl -0x44(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
get_record_position:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov eax, [rax+7BCh]
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+8]
mov [rbp+var_30], eax
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_30]
jnb short loc_79A46
mov eax, [rbp+var_1C]
mov ecx, [rbp+var_2C]
mov rdx, [rbp+var_10]
mov edx, [rdx+0C18h]
add edx, 0Ch
sub ecx, edx
sub ecx, 4
shr ecx, 2
cmp eax, ecx
jbe short loc_79A57
loc_79A46:
jmp short $+2
loc_79A48:
jmp short $+2
loc_79A4A:
mov [rbp+var_8], 0
jmp loc_79AE0
loc_79A57:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_2C]
mov edx, [rbp+var_1C]
call dir_entry_pos
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax]
mov [rbp+var_44], eax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+2]
mov [rbp+var_48], eax
mov eax, [rbp+var_44]
mov rcx, [rbp+var_10]
mov ecx, [rcx+0C18h]
add ecx, 0Ch
cmp eax, ecx
jb short loc_79AAB
mov eax, [rbp+var_44]
add eax, [rbp+var_48]
mov ecx, [rbp+var_2C]
mov edx, [rbp+var_30]
shl edx, 2
sub ecx, edx
sub ecx, 4
cmp eax, ecx
jbe short loc_79AB9
loc_79AAB:
jmp short $+2
loc_79AAD:
jmp short $+2
loc_79AAF:
mov [rbp+var_8], 0
jmp short loc_79AE0
loc_79AB9:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_44]
add rax, rcx
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
mov eax, [rbp+var_48]
add rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_79AE0:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
long long get_record_position(long long a1, long long a2, unsigned int a3, _QWORD *a4)
{
unsigned int v5; // [rsp+Ch] [rbp-44h]
unsigned __int16 *v6; // [rsp+18h] [rbp-38h]
unsigned int v7; // [rsp+20h] [rbp-30h]
unsigned int v8; // [rsp+24h] [rbp-2Ch]
v8 = *(_DWORD *)(a1 + 1980);
v7 = *(unsigned __int8 *)(a2 + 8);
if ( a3 >= v7 || a3 > (v8 - (*(_DWORD *)(a1 + 3096) + 12) - 4) >> 2 )
return 0LL;
v6 = (unsigned __int16 *)dir_entry_pos(a2, v8, a3);
v5 = *v6;
if ( v5 < *(_DWORD *)(a1 + 3096) + 12 || v6[1] + v5 > v8 - 4 * v7 - 4 )
return 0LL;
*a4 = v6[1] + *v6 + a2;
return v5 + a2;
}
|
get_record_position:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x30]
JNC 0x00179a46
MOV EAX,dword ptr [RBP + -0x1c]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX + 0xc18]
ADD EDX,0xc
SUB ECX,EDX
SUB ECX,0x4
SHR ECX,0x2
CMP EAX,ECX
JBE 0x00179a57
LAB_00179a46:
JMP 0x00179a48
LAB_00179a48:
JMP 0x00179a4a
LAB_00179a4a:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00179ae0
LAB_00179a57:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x00176380
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x2]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0xc
CMP EAX,ECX
JC 0x00179aab
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RBP + -0x48]
MOV ECX,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x30]
SHL EDX,0x2
SUB ECX,EDX
SUB ECX,0x4
CMP EAX,ECX
JBE 0x00179ab9
LAB_00179aab:
JMP 0x00179aad
LAB_00179aad:
JMP 0x00179aaf
LAB_00179aaf:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00179ae0
LAB_00179ab9:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x44]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x48]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00179ae0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long get_record_position(long param_1,long param_2,uint param_3,long *param_4)
{
byte bVar1;
int iVar2;
uint uVar3;
ushort *puVar4;
long local_10;
iVar2 = *(int *)(param_1 + 0x7bc);
bVar1 = *(byte *)(param_2 + 8);
if ((param_3 < bVar1) && (param_3 <= (iVar2 - (*(int *)(param_1 + 0xc18) + 0xc)) - 4U >> 2)) {
puVar4 = (ushort *)dir_entry_pos(param_2,iVar2,param_3);
uVar3 = (uint)*puVar4;
if ((uVar3 < *(int *)(param_1 + 0xc18) + 0xcU) ||
((iVar2 + (uint)bVar1 * -4) - 4 < uVar3 + puVar4[1])) {
local_10 = 0;
}
else {
local_10 = param_2 + (ulong)uVar3;
*param_4 = local_10 + (ulong)(uint)puVar4[1];
}
}
else {
local_10 = 0;
}
return local_10;
}
|
|
9,674 |
uf_zerofill_skip_zero
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_zerofill_skip_zero(MARIA_COLUMNDEF *rec,
MARIA_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);
}
}
|
O3
|
c
|
uf_zerofill_skip_zero:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x45200
movl (%r12), %ecx
decl %eax
movl %eax, 0x4(%r12)
btl %eax, %ecx
jae 0x45218
subl %r14d, %ebx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
jmp 0x45239
movq %r12, %rdi
callq 0x4519c
movl $0x1f, 0x4(%r12)
cmpl $0x0, (%r12)
js 0x451f3
movl 0x24(%r15), %eax
subq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x45359
movl 0x24(%r15), %edx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x292a0
|
uf_zerofill_skip_zero:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_45200
mov ecx, [r12]
dec eax
mov [r12+4], eax
bt ecx, eax
jnb short loc_45218
loc_451F3:
sub ebx, r14d
mov rdi, r14
xor esi, esi
mov rdx, rbx
jmp short loc_45239
loc_45200:
mov rdi, r12
call fill_buffer
mov dword ptr [r12+4], 1Fh
cmp dword ptr [r12], 0
js short loc_451F3
loc_45218:
mov eax, [r15+24h]
sub rbx, rax
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call decode_bytes
mov edx, [r15+24h]
mov rdi, rbx
xor esi, esi
loc_45239:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _memset
|
long long uf_zerofill_skip_zero(long long a1, int *a2, long long a3, long long a4)
{
int v6; // eax
int v7; // ecx
unsigned int v8; // eax
long long v10; // rbx
v6 = a2[1];
if ( v6 )
{
v7 = *a2;
v8 = v6 - 1;
a2[1] = v8;
if ( _bittest(&v7, v8) )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
else
{
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 0LL, (unsigned int)(a4 - a3));
}
v10 = a4 - *(unsigned int *)(a1 + 36);
decode_bytes(a1, a2, a3, v10);
return memset(v10, 0LL, *(unsigned int *)(a1 + 36));
}
|
uf_zerofill_skip_zero:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00145200
MOV ECX,dword ptr [R12]
DEC EAX
MOV dword ptr [R12 + 0x4],EAX
BT ECX,EAX
JNC 0x00145218
LAB_001451f3:
SUB EBX,R14D
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
JMP 0x00145239
LAB_00145200:
MOV RDI,R12
CALL 0x0014519c
MOV dword ptr [R12 + 0x4],0x1f
CMP dword ptr [R12],0x0
JS 0x001451f3
LAB_00145218:
MOV EAX,dword ptr [R15 + 0x24]
SUB RBX,RAX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL 0x00145359
MOV EDX,dword ptr [R15 + 0x24]
MOV RDI,RBX
XOR ESI,ESI
LAB_00145239:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001292a0
|
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;
if (-1 < (int)*param_2) goto LAB_00145218;
}
else {
uVar1 = param_2[1] - 1;
param_2[1] = uVar1;
if ((*param_2 >> (uVar1 & 0x1f) & 1) == 0) {
LAB_00145218:
__s = (void *)(param_4 - (ulong)*(uint *)(param_1 + 0x24));
decode_bytes(param_1,param_2,param_3,__s);
uVar1 = *(uint *)(param_1 + 0x24);
goto LAB_00145239;
}
}
uVar1 = (int)param_4 - (int)param_3;
__s = param_3;
LAB_00145239:
memset(__s,0,(ulong)uVar1);
return;
}
|
|
9,675 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t)
|
llama.cpp/common/json.hpp
|
basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
// (many string types can be constructed from 0 via its null-pointer guise, so we get a
// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
});
// adjust type if type deduction is not wanted
if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
{
is_an_object = false;
}
// if object is wanted but impossible, throw an exception
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
}
}
if (is_an_object)
{
// the initializer list is a list of pairs -> create object
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
for (auto& element_ref : init)
{
auto element = element_ref.moved_or_copied();
m_data.m_value.object->emplace(
std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
std::move((*element.m_data.m_value.array)[1]));
}
}
else
{
// the initializer list describes an array -> create array
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>(init.begin(), init.end());
}
set_parents();
assert_invariant();
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r12, %rsi
callq 0x8753e
cmpq %r12, %rax
sete %cl
testb %r13b, %r13b
jne 0x68105
cmpq %r12, %rax
sete %al
cmpb $0x2, %bpl
setne %cl
cmpb $0x1, %bpl
setne %dl
orb %al, %dl
je 0x681b0
andb %al, %cl
testb %cl, %cl
je 0x6817a
movb $0x1, (%rbx)
movl $0x20, %edi
callq 0x1c160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0x68194
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x87498
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
callq 0x31554
movq %r15, %rdi
xorl %esi, %esi
callq 0x732fc
movq %r15, %rdi
callq 0x300e0
addq $0x18, %r14
addq $-0x18, %r12
jne 0x68138
jmp 0x68194
movb $0x2, (%rbx)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
callq 0x874ea
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x732fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1c460
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x65662(%rip), %rsi # 0xcd830
leaq 0x65685(%rip), %rdx # 0xcd85a
movq %rsp, %rdi
callq 0x3fe82
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x12d, %esi # imm = 0x12D
xorl %ecx, %ecx
callq 0x34e2a
xorl %ebp, %ebp
leaq 0x95ce5(%rip), %rsi # 0xfdee0
leaq -0x3a9fc(%rip), %rdx # 0x2d806
movq %r14, %rdi
callq 0x1c7b0
jmp 0x68210
jmp 0x68210
jmp 0x68210
movq %rax, %r15
jmp 0x6825a
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x732fc
movq %r14, %rdi
callq 0x300e0
jmp 0x6825a
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x68248
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x68252
jmp 0x6825a
movq %rax, %r15
movq %r14, %rdi
callq 0x1caa0
movq %rbx, %rdi
callq 0x300e0
movq %r15, %rdi
callq 0x1c7d0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov ebp, r8d
mov r13d, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdx+rdx*2]
lea r12, [rsi+rax*8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, rsi
mov rsi, r12
call _ZSt9__find_ifIPKN8nlohmann16json_abi_v3_11_36detail8json_refINS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEN9__gnu_cxx5__ops12_Iter_negateIZNSG_C1ESt16initializer_listISH_EbNS2_7value_tEEUlRSI_E_EEET_ST_ST_T0_St26random_access_iterator_tag; std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>,std::random_access_iterator_tag)
cmp rax, r12
setz cl
test r13b, r13b
jnz short loc_68105
cmp rax, r12
setz al
cmp bpl, 2
setnz cl
cmp bpl, 1
setnz dl
or dl, al
jz loc_681B0
and cl, al
loc_68105:
test cl, cl
jz short loc_6817A
mov byte ptr [rbx], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [rbx+8], rax
test r15, r15
jz short loc_68194
shl r15, 3
lea r12, [r15+r15*2]
mov r15, rsp
loc_68138:
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, [rbx+8]
mov rax, [rsp+58h+var_50]
mov rdx, [rax]
mov rsi, [rdx+8]
add rdx, 10h
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 18h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_68138
jmp short loc_68194
loc_6817A:
mov byte ptr [rbx], 2
mov rdi, rsp
mov [rdi], r14
lea rsi, [rsp+58h+var_38]
mov [rsi], r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJPKNS0_6detail8json_refISD_EESL_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const* &&)
mov [rbx+8], rax
loc_68194:
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_681B0:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r12, [rsp+58h+var_48]
mov [r12-10h], r12
lea rsi, aCannotCreateOb; "cannot create object from initializer l"...
lea rdx, aCannotCreateOb+2Ah; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 12Dh; int
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_68210
jmp short loc_68210
jmp short $+2
loc_68210:
mov r15, rax
jmp short loc_6825A
mov r15, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_6825A
mov r15, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r12
jz short loc_68248
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_68248:
test bpl, bpl
jnz short loc_68252
jmp short loc_6825A
mov r15, rax
loc_68252:
mov rdi, r14; void *
call ___cxa_free_exception
loc_6825A:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r15
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
long long a1,
char *a2,
long long a3,
char a4,
char a5)
{
char *v8; // r14
char *v9; // r12
long long v10; // rax
bool v11; // cl
bool v12; // al
long long v13; // rax
long long v14; // r12
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
void *v17; // [rsp+0h] [rbp-58h] BYREF
long long v18; // [rsp+8h] [rbp-50h]
_QWORD v19[9]; // [rsp+10h] [rbp-48h] BYREF
v8 = a2;
v9 = &a2[24 * a3];
*(_OWORD *)a1 = 0LL;
v10 = std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const&)#1}>>(
a2,
v9);
v11 = v10 == (_QWORD)v9;
if ( !a4 )
{
v12 = v10 == (_QWORD)v9;
if ( !v12 && a5 == 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v17 = v19;
std::string::_M_construct<char const*>((long long)&v17, "cannot create object from initializer list", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
exception,
301,
&v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v11 = v12 && a5 != 2;
}
if ( v11 )
{
*(_BYTE *)a1 = 1;
v13 = operator new(0x20uLL);
*(_OWORD *)v13 = 0LL;
*(_QWORD *)(v13 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v13;
if ( a3 )
{
v14 = 24 * a3;
do
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
&v17,
v8);
nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
*(_QWORD **)(a1 + 8),
*(long long **)(*(_QWORD *)v18 + 8LL),
*(_QWORD *)v18 + 16LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v17,
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>::data::~data(&v17);
v8 += 24;
v14 -= 24LL;
}
while ( v14 );
}
}
else
{
*(_BYTE *)a1 = 2;
v17 = a2;
v19[2] = v9;
*(_QWORD *)(a1 + 8) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*>(&v17);
}
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1,
1LL);
}
|
basic_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDX + RDX*0x2]
LEA R12,[RSI + RAX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001680d1:
MOV RDI,RSI
MOV RSI,R12
CALL 0x0018753e
CMP RAX,R12
SETZ CL
TEST R13B,R13B
JNZ 0x00168105
CMP RAX,R12
SETZ AL
CMP BPL,0x2
SETNZ CL
CMP BPL,0x1
SETNZ DL
OR DL,AL
JZ 0x001681b0
AND CL,AL
LAB_00168105:
TEST CL,CL
JZ 0x0016817a
MOV byte ptr [RBX],0x1
LAB_0016810c:
MOV EDI,0x20
CALL 0x0011c160
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RBX + 0x8],RAX
TEST R15,R15
JZ 0x00168194
SHL R15,0x3
LEA R12,[R15 + R15*0x2]
MOV R15,RSP
LAB_00168138:
MOV RDI,R15
MOV RSI,R14
CALL 0x00187498
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x8]
ADD RDX,0x10
LAB_00168157:
CALL 0x00131554
MOV RDI,R15
XOR ESI,ESI
CALL 0x001732fc
MOV RDI,R15
CALL 0x001300e0
ADD R14,0x18
ADD R12,-0x18
JNZ 0x00168138
JMP 0x00168194
LAB_0016817a:
MOV byte ptr [RBX],0x2
MOV RDI,RSP
MOV qword ptr [RDI],R14
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI],R12
LAB_0016818b:
CALL 0x001874ea
LAB_00168190:
MOV qword ptr [RBX + 0x8],RAX
LAB_00168194:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001732fc
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001681b0:
MOV EDI,0x20
CALL 0x0011c460
MOV R14,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_001681c7:
LEA RSI,[0x1cd830]
LEA RDX,[0x1cd85a]
MOV RDI,RSP
CALL 0x0013fe82
MOV BPL,0x1
LAB_001681e0:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x12d
XOR ECX,ECX
CALL 0x00134e2a
XOR EBP,EBP
LEA RSI,[0x1fdee0]
LEA RDX,[0x12d806]
MOV RDI,R14
CALL 0x0011c7b0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool, nlohmann::json_abi_v3_11_3::detail::value_t) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(int8 *param_1,json_ref *param_2,long param_3,char param_4,char param_5)
{
json_ref *pjVar1;
json_ref *pjVar2;
int8 *puVar3;
vector *pvVar4;
int8 uVar5;
bool bVar6;
json_ref *local_58;
long *local_50;
json_ref local_48 [16];
json_ref *local_38;
pjVar1 = param_2 + param_3 * 0x18;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 001680d1 to 001680db has its CatchHandler @ 0016820e */
pjVar2 = std::
__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>::_Iter_negate(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::_lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const&)_1_>>
(param_2,pjVar1);
bVar6 = pjVar2 == pjVar1;
if (param_4 == '\0') {
if (param_5 == '\x01' && pjVar2 != pjVar1) {
uVar5 = __cxa_allocate_exception(0x20);
local_58 = local_48;
/* try { // try from 001681c7 to 001681dc has its CatchHandler @ 0016824f */
std::__cxx11::string::_M_construct<char_const*>
(&local_58,"cannot create object from initializer list","");
/* try { // try from 001681e0 to 00168209 has its CatchHandler @ 0016822f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(uVar5,0x12d,&local_58,0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&detail::type_error::typeinfo,detail::exception::~exception);
}
bVar6 = param_5 != '\x02' && pjVar2 == pjVar1;
}
if (bVar6) {
*(int1 *)param_1 = 1;
/* try { // try from 0016810c to 00168115 has its CatchHandler @ 0016820c */
puVar3 = (int8 *)operator_new(0x20);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
param_1[1] = puVar3;
if (param_3 != 0) {
param_3 = param_3 * 0x18;
do {
/* try { // try from 00168138 to 00168142 has its CatchHandler @ 00168210 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 00168157 to 0016815b has its CatchHandler @ 00168215 */
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace((ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)param_1[1],*(string **)(*local_50 + 8),(basic_json *)(*local_50 + 0x10));
assert_invariant(SUB81(&local_58,0));
data::~data((data *)&local_58);
param_3 = param_3 + -0x18;
} while (param_3 != 0);
}
}
else {
*(int1 *)param_1 = 2;
local_58 = param_2;
local_38 = pjVar1;
/* try { // try from 0016818b to 0016818f has its CatchHandler @ 0016820a */
pvVar4 = create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*>
(&local_58,&local_38);
param_1[1] = pvVar4;
}
assert_invariant(SUB81(param_1,0));
return;
}
|
|
9,676 |
reset_table_waits_by_table()
|
eloqsql/storage/perfschema/pfs_events_waits.cc
|
void reset_table_waits_by_table()
{
global_table_share_container.apply(fct_reset_table_waits_by_table);
}
|
O3
|
cpp
|
reset_table_waits_by_table():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
leaq 0x35df25(%rip), %r15 # 0x3a1ad8
movq 0xa8(%r15,%r14,8), %rax
testq %rax, %rax
je 0x43bfa
movq 0x50(%rax), %r12
testq %r12, %r12
jle 0x43bfa
movq 0x48(%rax), %rbx
shlq $0xa, %r12
addq %rbx, %r12
movl (%rbx), %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x43bee
movq %rbx, %rdi
callq 0x369d2
movq %rbx, %rdi
callq 0x370fe
addq $0x400, %rbx # imm = 0x400
cmpq %r12, %rbx
jb 0x43bd4
incq %r14
cmpq $0x1000, %r14 # imm = 0x1000
jne 0x43bb3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_Z26reset_table_waits_by_tablev:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor r14d, r14d
lea r15, global_table_share_container
loc_43BB3:
mov rax, [r15+r14*8+0A8h]
test rax, rax
jz short loc_43BFA
mov r12, [rax+50h]
test r12, r12
jle short loc_43BFA
mov rbx, [rax+48h]
shl r12, 0Ah
add r12, rbx
loc_43BD4:
mov eax, [rbx]
and eax, 3
cmp eax, 2
jnz short loc_43BEE
mov rdi, rbx; this
call _ZN15PFS_table_share12aggregate_ioEv; PFS_table_share::aggregate_io(void)
mov rdi, rbx; this
call _ZN15PFS_table_share14aggregate_lockEv; PFS_table_share::aggregate_lock(void)
loc_43BEE:
add rbx, 400h
cmp rbx, r12
jb short loc_43BD4
loc_43BFA:
inc r14
cmp r14, 1000h
jnz short loc_43BB3
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long reset_table_waits_by_table(void)
{
long long i; // r14
long long result; // rax
long long v2; // r12
PFS_table_share *v3; // rbx
PFS_table_share *v4; // r12
for ( i = 0LL; i != 4096; ++i )
{
result = global_table_share_container[i + 21];
if ( result )
{
v2 = *(_QWORD *)(result + 80);
if ( v2 > 0 )
{
v3 = *(PFS_table_share **)(result + 72);
v4 = (PFS_table_share *)((char *)v3 + 1024 * v2);
do
{
result = *(_DWORD *)v3 & 3;
if ( (_DWORD)result == 2 )
{
PFS_table_share::aggregate_io(v3);
result = PFS_table_share::aggregate_lock(v3);
}
v3 = (PFS_table_share *)((char *)v3 + 1024);
}
while ( v3 < v4 );
}
}
}
return result;
}
|
reset_table_waits_by_table:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR R14D,R14D
LEA R15,[0x4a1ad8]
LAB_00143bb3:
MOV RAX,qword ptr [R15 + R14*0x8 + 0xa8]
TEST RAX,RAX
JZ 0x00143bfa
MOV R12,qword ptr [RAX + 0x50]
TEST R12,R12
JLE 0x00143bfa
MOV RBX,qword ptr [RAX + 0x48]
SHL R12,0xa
ADD R12,RBX
LAB_00143bd4:
MOV EAX,dword ptr [RBX]
AND EAX,0x3
CMP EAX,0x2
JNZ 0x00143bee
MOV RDI,RBX
CALL 0x001369d2
MOV RDI,RBX
CALL 0x001370fe
LAB_00143bee:
ADD RBX,0x400
CMP RBX,R12
JC 0x00143bd4
LAB_00143bfa:
INC R14
CMP R14,0x1000
JNZ 0x00143bb3
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_table_waits_by_table() */
void reset_table_waits_by_table(void)
{
long lVar1;
PFS_table_share *this;
PFS_table_share *pPVar2;
long lVar3;
lVar3 = 0;
do {
lVar1 = (&DAT_004a1b80)[lVar3];
if ((lVar1 != 0) && (0 < *(long *)(lVar1 + 0x50))) {
this = *(PFS_table_share **)(lVar1 + 0x48);
pPVar2 = this + *(long *)(lVar1 + 0x50) * 0x400;
do {
if ((*(uint *)this & 3) == 2) {
PFS_table_share::aggregate_io(this);
PFS_table_share::aggregate_lock(this);
}
this = this + 0x400;
} while (this < pPVar2);
}
lVar3 = lVar3 + 1;
} while (lVar3 != 0x1000);
return;
}
|
|
9,677 |
my_strnxfrm_win1250ch
|
eloqsql/strings/ctype-win1250ch.c
|
static size_t
my_strnxfrm_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p;
int pass = 0;
size_t totlen = 0;
p = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
while (totlen < len)
{
NEXT_CMP_VALUE(src, p, pass, value, (int)srclen);
if (!value)
break;
if ((1 << pass) & flags)
dest[totlen++] = value;
}
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, 0x00, len - totlen);
totlen= len;
}
return totlen;
}
|
O3
|
c
|
my_strnxfrm_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, -0x50(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %edx
orl $0xf, %edx
testb $0xf, %al
cmovnel %eax, %edx
xorl %r10d, %r10d
testq %rbx, %rbx
je 0xdb818
movslq %r9d, %rdi
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x60(%rbp)
leaq 0x28bc25(%rip), %r14 # 0x3672e0
leaq 0x2b4bae(%rip), %r15 # 0x390270
xorl %eax, %eax
movq %r8, %r11
movq %rbx, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq %r11, %rsi
subq %r8, %rsi
cmpq %rdi, %rsi
jge 0xdb6f2
testl %r10d, %r10d
je 0xdb7b4
movl $0x9, %r12d
jmp 0xdb713
testl %r9d, %r9d
jle 0xdb81c
testl %r10d, %r10d
jne 0xdb81c
movl $0x1, %r10d
movl $0x9, %r12d
movq %r8, %r11
movq %r14, %rsi
movzbl (%r11), %ecx
movb (%rsi,%rcx), %sil
cmpb $-0x1, %sil
jne 0xdb7f4
movq %r12, -0x68(%rbp)
movq %r10, -0x58(%rbp)
movq %r11, %rdx
subq %r8, %rdx
movq -0x60(%rbp), %rcx
leaq (%rcx,%r11), %r13
xorl %r10d, %r10d
movq %r10, %rbx
shlq $0x4, %rbx
movq (%rbx,%r15), %rsi
movb (%rsi), %r9b
testb %r9b, %r9b
je 0xdb784
cmpq %rdi, %rdx
jge 0xdb784
incq %rsi
movq %r13, %r14
movq %r11, %r12
cmpb (%r12), %r9b
jne 0xdb78c
incq %r12
movb (%rsi), %r9b
testb %r9b, %r9b
je 0xdb787
leaq 0x1(%r14), %rcx
incq %rsi
cmpq %rdi, %r14
movq %rcx, %r14
jl 0xdb762
jmp 0xdb787
movq %r11, %r12
testb %r9b, %r9b
je 0xdb7c9
incq %r10
cmpq $0x50, %r10
jne 0xdb741
movb $-0x1, %sil
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r9
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %edx
movq -0x58(%rbp), %r10
leaq 0x28bb2e(%rip), %r14 # 0x3672e0
jmp 0xdb7f9
xorl %r10d, %r10d
movl $0x8, %r12d
leaq 0x28ba1c(%rip), %rsi # 0x3671e0
jmp 0xdb716
addq %r15, %rbx
movq -0x68(%rbp), %rcx
movb (%rbx,%rcx), %sil
decq %r12
movq %r12, %r11
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r9
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %edx
movq -0x58(%rbp), %r10
leaq 0x28baec(%rip), %r14 # 0x3672e0
testb %sil, %sil
je 0xdb81c
btl %r10d, %edx
jae 0xdb80a
movq -0x50(%rbp), %rcx
movb %sil, (%rcx,%rax)
incq %rax
incq %r11
cmpq %rbx, %rax
jb 0xdb6d6
jmp 0xdb837
xorl %eax, %eax
jmp 0xdb837
testb %dl, %dl
jns 0xdb837
movq -0x50(%rbp), %rdi
addq %rax, %rdi
movq %rbx, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x2a2a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdx
mov [rbp+var_50], rsi
mov eax, [rbp+arg_0]
mov edx, eax
or edx, 0Fh
test al, 0Fh
cmovnz edx, eax
xor r10d, r10d
test rbx, rbx
jz loc_DB818
movsxd rdi, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_60], rax
lea r14, _sort_order_win1250ch2
lea r15, doubles_0
xor eax, eax
mov r11, r8
mov [rbp+var_48], rbx
mov [rbp+var_40], r9
mov [rbp+var_38], r8
mov [rbp+var_2C], edx
loc_DB6D6:
mov rsi, r11
sub rsi, r8
cmp rsi, rdi
jge short loc_DB6F2
test r10d, r10d
jz loc_DB7B4
mov r12d, 9
jmp short loc_DB713
loc_DB6F2:
test r9d, r9d
jle loc_DB81C
test r10d, r10d
jnz loc_DB81C
mov r10d, 1
mov r12d, 9
mov r11, r8
loc_DB713:
mov rsi, r14
loc_DB716:
movzx ecx, byte ptr [r11]
mov sil, [rsi+rcx]
cmp sil, 0FFh
jnz loc_DB7F4
mov [rbp+var_68], r12
mov [rbp+var_58], r10
mov rdx, r11
sub rdx, r8
mov rcx, [rbp+var_60]
lea r13, [rcx+r11]
xor r10d, r10d
loc_DB741:
mov rbx, r10
shl rbx, 4
mov rsi, [rbx+r15]
mov r9b, [rsi]
test r9b, r9b
jz short loc_DB784
cmp rdx, rdi
jge short loc_DB784
inc rsi
mov r14, r13
mov r12, r11
loc_DB762:
cmp r9b, [r12]
jnz short loc_DB78C
inc r12
mov r9b, [rsi]
test r9b, r9b
jz short loc_DB787
lea rcx, [r14+1]
inc rsi
cmp r14, rdi
mov r14, rcx
jl short loc_DB762
jmp short loc_DB787
loc_DB784:
mov r12, r11
loc_DB787:
test r9b, r9b
jz short loc_DB7C9
loc_DB78C:
inc r10
cmp r10, 50h ; 'P'
jnz short loc_DB741
mov sil, 0FFh
mov rbx, [rbp+var_48]
mov r9, [rbp+var_40]
mov r8, [rbp+var_38]
mov edx, [rbp+var_2C]
mov r10, [rbp+var_58]
lea r14, _sort_order_win1250ch2
jmp short loc_DB7F9
loc_DB7B4:
xor r10d, r10d
mov r12d, 8
lea rsi, _sort_order_win1250ch1
jmp loc_DB716
loc_DB7C9:
add rbx, r15
mov rcx, [rbp+var_68]
mov sil, [rbx+rcx]
dec r12
mov r11, r12
mov rbx, [rbp+var_48]
mov r9, [rbp+var_40]
mov r8, [rbp+var_38]
mov edx, [rbp+var_2C]
mov r10, [rbp+var_58]
lea r14, _sort_order_win1250ch2
loc_DB7F4:
test sil, sil
jz short loc_DB81C
loc_DB7F9:
bt edx, r10d
jnb short loc_DB80A
mov rcx, [rbp+var_50]
mov [rcx+rax], sil
inc rax
loc_DB80A:
inc r11
cmp rax, rbx
jb loc_DB6D6
jmp short loc_DB837
loc_DB818:
xor eax, eax
jmp short loc_DB837
loc_DB81C:
test dl, dl
jns short loc_DB837
mov rdi, [rbp+var_50]
add rdi, rax
mov rdx, rbx
sub rdx, rax
xor esi, esi
call _memset
mov rax, rbx
loc_DB837:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_strnxfrm_win1250ch(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
int v8; // edx
long long v9; // r10
long long v10; // rdi
unsigned long long result; // rax
unsigned __int8 *v12; // r11
long long v13; // r12
_BYTE *v14; // rsi
char v15; // si
long long v16; // r10
char *v17; // rsi
char v18; // r9
char *v19; // rsi
unsigned __int8 *v20; // r14
_BYTE *v21; // r12
long long v23; // [rsp+8h] [rbp-68h]
long long v24; // [rsp+10h] [rbp-60h]
long long v25; // [rsp+18h] [rbp-58h]
unsigned long long v27; // [rsp+28h] [rbp-48h]
int v28; // [rsp+30h] [rbp-40h]
unsigned __int8 *v29; // [rsp+38h] [rbp-38h]
int v30; // [rsp+44h] [rbp-2Ch]
v8 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v8 = a7;
v9 = 0LL;
if ( !a3 )
return 0LL;
v10 = a6;
v24 = 1LL - (_QWORD)a5;
result = 0LL;
v12 = a5;
v27 = a3;
v28 = a6;
v29 = a5;
v30 = v8;
while ( 2 )
{
if ( v12 - a5 >= v10 )
{
if ( a6 <= 0 || (_DWORD)v9 )
break;
v9 = 1LL;
v13 = 9LL;
v12 = a5;
}
else
{
if ( !(_DWORD)v9 )
{
v9 = 0LL;
v13 = 8LL;
v14 = &sort_order_win1250ch1;
goto LABEL_12;
}
v13 = 9LL;
}
v14 = &sort_order_win1250ch2;
LABEL_12:
v15 = v14[*v12];
if ( v15 != -1 )
goto LABEL_27;
v23 = v13;
v25 = v9;
v16 = 0LL;
while ( 1 )
{
v17 = (char *)*(&doubles_0 + 2 * v16);
v18 = *v17;
if ( !*v17 || v12 - a5 >= v10 )
break;
v19 = v17 + 1;
v20 = &v12[v24];
v21 = v12;
while ( v18 == *v21 )
{
++v21;
v18 = *v19;
if ( *v19 )
{
++v19;
if ( (long long)v20++ < v10 )
continue;
}
goto LABEL_22;
}
LABEL_23:
if ( ++v16 == 80 )
{
v15 = -1;
a3 = v27;
a6 = v28;
a5 = v29;
v8 = v30;
v9 = v25;
goto LABEL_28;
}
}
v21 = v12;
LABEL_22:
if ( v18 )
goto LABEL_23;
v15 = *((_BYTE *)&doubles_0 + 16 * v16 + v23);
v12 = v21 - 1;
a3 = v27;
a6 = v28;
a5 = v29;
v8 = v30;
v9 = v25;
LABEL_27:
if ( v15 )
{
LABEL_28:
if ( _bittest(&v8, v9) )
*(_BYTE *)(a2 + result++) = v15;
++v12;
if ( result >= a3 )
return result;
continue;
}
break;
}
if ( (v8 & 0x80u) != 0 )
{
memset(result + a2, 0LL, a3 - result);
return a3;
}
return result;
}
|
my_strnxfrm_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV qword ptr [RBP + -0x50],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV EDX,EAX
OR EDX,0xf
TEST AL,0xf
CMOVNZ EDX,EAX
XOR R10D,R10D
TEST RBX,RBX
JZ 0x001db818
MOVSXD RDI,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x60],RAX
LEA R14,[0x4672e0]
LEA R15,[0x490270]
XOR EAX,EAX
MOV R11,R8
MOV qword ptr [RBP + -0x48],RBX
MOV qword ptr [RBP + -0x40],R9
MOV qword ptr [RBP + -0x38],R8
MOV dword ptr [RBP + -0x2c],EDX
LAB_001db6d6:
MOV RSI,R11
SUB RSI,R8
CMP RSI,RDI
JGE 0x001db6f2
TEST R10D,R10D
JZ 0x001db7b4
MOV R12D,0x9
JMP 0x001db713
LAB_001db6f2:
TEST R9D,R9D
JLE 0x001db81c
TEST R10D,R10D
JNZ 0x001db81c
MOV R10D,0x1
MOV R12D,0x9
MOV R11,R8
LAB_001db713:
MOV RSI,R14
LAB_001db716:
MOVZX ECX,byte ptr [R11]
MOV SIL,byte ptr [RSI + RCX*0x1]
CMP SIL,0xff
JNZ 0x001db7f4
MOV qword ptr [RBP + -0x68],R12
MOV qword ptr [RBP + -0x58],R10
MOV RDX,R11
SUB RDX,R8
MOV RCX,qword ptr [RBP + -0x60]
LEA R13,[RCX + R11*0x1]
XOR R10D,R10D
LAB_001db741:
MOV RBX,R10
SHL RBX,0x4
MOV RSI,qword ptr [RBX + R15*0x1]
MOV R9B,byte ptr [RSI]
TEST R9B,R9B
JZ 0x001db784
CMP RDX,RDI
JGE 0x001db784
INC RSI
MOV R14,R13
MOV R12,R11
LAB_001db762:
CMP R9B,byte ptr [R12]
JNZ 0x001db78c
INC R12
MOV R9B,byte ptr [RSI]
TEST R9B,R9B
JZ 0x001db787
LEA RCX,[R14 + 0x1]
INC RSI
CMP R14,RDI
MOV R14,RCX
JL 0x001db762
JMP 0x001db787
LAB_001db784:
MOV R12,R11
LAB_001db787:
TEST R9B,R9B
JZ 0x001db7c9
LAB_001db78c:
INC R10
CMP R10,0x50
JNZ 0x001db741
MOV SIL,0xff
MOV RBX,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV R10,qword ptr [RBP + -0x58]
LEA R14,[0x4672e0]
JMP 0x001db7f9
LAB_001db7b4:
XOR R10D,R10D
MOV R12D,0x8
LEA RSI,[0x4671e0]
JMP 0x001db716
LAB_001db7c9:
ADD RBX,R15
MOV RCX,qword ptr [RBP + -0x68]
MOV SIL,byte ptr [RBX + RCX*0x1]
DEC R12
MOV R11,R12
MOV RBX,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x2c]
MOV R10,qword ptr [RBP + -0x58]
LEA R14,[0x4672e0]
LAB_001db7f4:
TEST SIL,SIL
JZ 0x001db81c
LAB_001db7f9:
BT EDX,R10D
JNC 0x001db80a
MOV RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RCX + RAX*0x1],SIL
INC RAX
LAB_001db80a:
INC R11
CMP RAX,RBX
JC 0x001db6d6
JMP 0x001db837
LAB_001db818:
XOR EAX,EAX
JMP 0x001db837
LAB_001db81c:
TEST DL,DL
JNS 0x001db837
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,RAX
MOV RDX,RBX
SUB RDX,RAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV RAX,RBX
LAB_001db837:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_win1250ch
(int8 param_1,long param_2,ulong param_3,int8 param_4,byte *param_5,
int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte *pbVar4;
ulong uVar5;
char cVar6;
int1 *puVar7;
byte *pbVar8;
byte bVar9;
int iVar10;
long lVar11;
byte *pbVar12;
byte *pbVar13;
long lVar14;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
iVar10 = 0;
if (param_3 == 0) {
uVar5 = 0;
}
else {
uVar5 = 0;
pbVar12 = param_5;
do {
if ((long)pbVar12 - (long)param_5 < (long)param_6) {
if (iVar10 != 0) goto LAB_001db713;
iVar10 = 0;
lVar14 = 8;
puVar7 = _sort_order_win1250ch1;
}
else {
if ((param_6 < 1) || (iVar10 != 0)) goto LAB_001db81c;
iVar10 = 1;
pbVar12 = param_5;
LAB_001db713:
lVar14 = 9;
puVar7 = _sort_order_win1250ch2;
}
cVar6 = puVar7[*pbVar12];
if (cVar6 == -1) {
lVar11 = 0;
do {
pbVar8 = (&doubles)[lVar11 * 2];
bVar9 = *pbVar8;
pbVar13 = pbVar12;
pbVar4 = pbVar12 + (1 - (long)param_5);
pbVar3 = pbVar12 + -(long)param_5;
if (bVar9 != 0) {
while (pbVar2 = pbVar4, (long)pbVar3 < (long)param_6) {
pbVar8 = pbVar8 + 1;
if (bVar9 != *pbVar13) goto LAB_001db78c;
pbVar13 = pbVar13 + 1;
bVar9 = *pbVar8;
if (bVar9 == 0) break;
pbVar4 = pbVar2 + 1;
pbVar3 = pbVar2;
}
}
if (bVar9 == 0) {
cVar6 = *(char *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar12 = pbVar13 + -1;
goto LAB_001db7f4;
}
LAB_001db78c:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
cVar6 = -1;
}
else {
LAB_001db7f4:
if (cVar6 == '\0') {
LAB_001db81c:
if (-1 < (char)uVar1) {
return uVar5;
}
memset((void *)(param_2 + uVar5),0,param_3 - uVar5);
return param_3;
}
}
if ((uVar1 >> iVar10 & 1) != 0) {
*(char *)(param_2 + uVar5) = cVar6;
uVar5 = uVar5 + 1;
}
pbVar12 = pbVar12 + 1;
} while (uVar5 < param_3);
}
return uVar5;
}
|
|
9,678 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::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>&)
|
llama.cpp/common/json.hpp
|
reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::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>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xd776a
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x21220
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x9524a
jmp 0xd776f
cmpl $0x2, %eax
jne 0xd7790
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd7940
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x21660
movq %rax, %rbx
movq %r14, %rdi
callq 0x2e874
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x52d5e(%rip), %rsi # 0x12a512
leaq 0x10(%rsp), %rdi
callq 0xd78b7
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x2e618
xorl %ebp, %ebp
leaq 0x941a9(%rip), %rsi # 0x16b988
leaq -0xa5fdc(%rip), %rdx # 0x3180a
movq %rbx, %rdi
callq 0x21a80
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd780c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0xd7816
jmp 0xd781e
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f50
movq %r14, %rdi
callq 0x21b20
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_D776A
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_D776F
loc_D776A:
cmp eax, 2
jnz short loc_D7790
loc_D776F:
mov rdi, [r14+8]
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
mov rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_D7790:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D780C
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D780C:
test bpl, bpl
jnz short loc_D7816
jmp short loc_D781E
mov r14, rax
loc_D7816:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_D781E:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v5,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
0x137u,
v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
else
{
*(_BYTE *)a1 = 2;
v2 = operator new(0x18uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
*(_QWORD *)(a1 + 8),
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
|
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001d776a
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x00121220
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0019524a
JMP 0x001d776f
LAB_001d776a:
CMP EAX,0x2
JNZ 0x001d7790
LAB_001d776f:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
CALL 0x001d7940
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001d7790:
MOV EDI,0x20
CALL 0x00121660
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012e874
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001d77ad:
LEA RSI,[0x22a512]
LEA RDI,[RSP + 0x10]
CALL 0x001d78b7
MOV BPL,0x1
LAB_001d77c1:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x0012e618
XOR EBP,EBP
LEA RSI,[0x26b988]
LEA RDX,[0x13180a]
MOV RDI,RBX
CALL 0x00121a80
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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 * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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)
{
int8 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001d77ad to 001d77bd has its CatchHandler @ 001d7813 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001d77c1 to 001d77ed has its CatchHandler @ 001d77ee */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
|
|
9,679 |
mysql_stmt_next_result_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_next_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_next_result,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
}
|
O0
|
c
|
mysql_stmt_next_result_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2d510
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_next_result_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_next_result
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
_DWORD * mysql_stmt_next_result_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
v2[2] = mysql_stmt_next_result(*a1);
result = v2;
*v2 = 0;
return result;
}
|
mysql_stmt_next_result_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0012d510
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_stmt_next_result_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_next_result(*param_1);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
9,680 |
ma_get_hash_keyval
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
uchar *ma_get_hash_keyval(const uchar *hash_entry,
unsigned int *length,
my_bool not_used __attribute__((unused)))
{
/* Hash entry has the following format:
Offset: 0 key (\0 terminated)
key_length + 1 value (\0 terminated)
*/
uchar *p= (uchar *)hash_entry;
size_t len= strlen((char *)p);
*length= (unsigned int)len;
return p;
}
|
O0
|
c
|
ma_get_hash_keyval:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
|
ma_get_hash_keyval:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
|
long long ma_get_hash_keyval(long long a1, _DWORD *a2)
{
*a2 = strlen(a1);
return a1;
}
|
ma_get_hash_keyval:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
char * ma_get_hash_keyval(char *param_1,int4 *param_2)
{
size_t sVar1;
sVar1 = strlen(param_1);
*param_2 = (int)sVar1;
return param_1;
}
|
|
9,681 |
ma_crypt_pre_read_hook
|
eloqsql/storage/maria/ma_crypt.c
|
static my_bool ma_crypt_pre_read_hook(PAGECACHE_IO_HOOK_ARGS *args)
{
MARIA_SHARE *share= (MARIA_SHARE*) args->data;
uchar *crypt_buf= my_malloc(PSI_INSTRUMENT_ME, share->block_size, MYF(0));
if (crypt_buf == NULL)
{
args->crypt_buf= NULL; /* for post-hook */
return 1;
}
/* swap pointers to read into crypt_buf */
args->crypt_buf= args->page;
args->page= crypt_buf;
return 0;
}
|
O0
|
c
|
ma_crypt_pre_read_hook:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, %esi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf3860
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5e9fc
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5ea1a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_crypt_pre_read_hook:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax+7BCh]
mov esi, eax
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_5E9FC
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov [rbp+var_1], 1
jmp short loc_5EA1A
loc_5E9FC:
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_1], 0
loc_5EA1A:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char ma_crypt_pre_read_hook(long long *a1)
{
long long v2; // [rsp+0h] [rbp-20h]
v2 = my_malloc(0LL, *(unsigned int *)(a1[2] + 1980), 0LL);
if ( v2 )
{
a1[3] = *a1;
*a1 = v2;
return 0;
}
else
{
a1[3] = 0LL;
return 1;
}
}
|
ma_crypt_pre_read_hook:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV ESI,EAX
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f3860
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0015e9fc
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015ea1a
LAB_0015e9fc:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_0015ea1a:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
bool ma_crypt_pre_read_hook(long *param_1)
{
long lVar1;
bool local_9;
lVar1 = my_malloc(0,*(int4 *)(param_1[2] + 0x7bc),0);
if (lVar1 != 0) {
param_1[3] = *param_1;
*param_1 = lVar1;
}
else {
param_1[3] = 0;
}
local_9 = lVar1 == 0;
return local_9;
}
|
|
9,682 |
LefDefParser::lefiNonDefault::layerWidth(int) const
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp
|
double
lefiNonDefault::layerWidth(int index) const
{
char msg[160];
if (index < 0 || index >= numLayers_) {
sprintf(msg, "ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d", index, numLayers_);
lefiError(0, 1402, msg);
return 0.0;
}
return width_[index];
}
|
O0
|
cpp
|
LefDefParser::lefiNonDefault::layerWidth(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x46b6e
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x10(%rcx), %eax
jl 0x46baf
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x10(%rax), %ecx
leaq 0x4faf1(%rip), %rsi # 0x9667a
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x57a, %esi # imm = 0x57A
callq 0x59060
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x46bce
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0xb4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nop
|
_ZNK12LefDefParser14lefiNonDefault10layerWidthEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_46B6E
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+10h]
jl short loc_46BAF
loc_46B6E:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+10h]
lea rsi, aErrorLefpars14_3; "ERROR (LEFPARS-1402): The index number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 57Ah; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
movsd [rsp+0C8h+var_8], xmm0
jmp short loc_46BCE
loc_46BAF:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+20h]
movsxd rcx, [rsp+0C8h+var_14]
movsd xmm0, qword ptr [rax+rcx*8]
movsd [rsp+0C8h+var_8], xmm0
loc_46BCE:
movsd xmm0, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
|
double LefDefParser::lefiNonDefault::layerWidth(LefDefParser::lefiNonDefault *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiNonDefault *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 4) )
return *(double *)(*((_QWORD *)this + 4) + 8LL * v5);
sprintf(
v4,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d",
v5,
*((_DWORD *)this + 4));
LefDefParser::lefiError(0LL, 1402, (int)v4, v2);
return 0.0;
}
|
layerWidth:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x00146b6e
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x10]
JL 0x00146baf
LAB_00146b6e:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x10]
LEA RSI,[0x19667a]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x57a
CALL 0x00159060
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0xc0],XMM0
JMP 0x00146bce
LAB_00146baf:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOVSD qword ptr [RSP + 0xc0],XMM0
LAB_00146bce:
MOVSD XMM0,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiNonDefault::layerWidth(int) const */
int8 __thiscall LefDefParser::lefiNonDefault::layerWidth(lefiNonDefault *this,int param_1)
{
char local_b8 [164];
int local_14;
lefiNonDefault *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x10) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x10));
lefiError(0,0x57a,local_b8);
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x20) + (long)param_1 * 8);
}
return local_8;
}
|
|
9,683 |
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateFaceTagsFromParentFaces()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/../vtr/refinement.h
|
Index getFirstChildFaceFromFaces() const { return _firstChildFaceFromFace; }
|
O2
|
c
|
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateFaceTagsFromParentFaces():
movslq 0x40(%rdi), %rax
movslq 0x28(%rdi), %rcx
addq %rax, %rcx
cmpq %rcx, %rax
jge 0x61993
movq 0x108(%rdi), %rdx
movslq (%rdx,%rax,4), %rdx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %r8
movq 0x60(%rsi), %rsi
movq 0x60(%r8), %r8
movb (%rsi,%rdx), %dl
movb %dl, (%r8,%rax)
incq %rax
jmp 0x61967
retq
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal10Refinement31populateFaceTagsFromParentFacesEv:
movsxd rax, dword ptr [rdi+40h]
movsxd rcx, dword ptr [rdi+28h]
add rcx, rax
loc_61967:
cmp rax, rcx
jge short locret_61993
mov rdx, [rdi+108h]
movsxd rdx, dword ptr [rdx+rax*4]
mov rsi, [rdi+8]
mov r8, [rdi+10h]
mov rsi, [rsi+60h]
mov r8, [r8+60h]
mov dl, [rsi+rdx]
mov [r8+rax], dl
inc rax
jmp short loc_61967
locret_61993:
retn
|
long long OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateFaceTagsFromParentFaces(
OpenSubdiv::v3_6_0::Vtr::internal::Refinement *this)
{
long long result; // rax
long long v2; // rcx
result = *((int *)this + 16);
v2 = result + *((int *)this + 10);
while ( result < v2 )
{
*(_BYTE *)(*(_QWORD *)(*((_QWORD *)this + 2) + 96LL) + result) = *(_BYTE *)(*(_QWORD *)(*((_QWORD *)this + 1) + 96LL)
+ *(int *)(*((_QWORD *)this + 33)
+ 4 * result));
++result;
}
return result;
}
|
populateFaceTagsFromParentFaces:
MOVSXD RAX,dword ptr [RDI + 0x40]
MOVSXD RCX,dword ptr [RDI + 0x28]
ADD RCX,RAX
LAB_00161967:
CMP RAX,RCX
JGE 0x00161993
MOV RDX,qword ptr [RDI + 0x108]
MOVSXD RDX,dword ptr [RDX + RAX*0x4]
MOV RSI,qword ptr [RDI + 0x8]
MOV R8,qword ptr [RDI + 0x10]
MOV RSI,qword ptr [RSI + 0x60]
MOV R8,qword ptr [R8 + 0x60]
MOV DL,byte ptr [RSI + RDX*0x1]
MOV byte ptr [R8 + RAX*0x1],DL
INC RAX
JMP 0x00161967
LAB_00161993:
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateFaceTagsFromParentFaces() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::Refinement::populateFaceTagsFromParentFaces(Refinement *this)
{
long lVar1;
long lVar2;
lVar1 = (long)*(int *)(this + 0x40);
lVar2 = *(int *)(this + 0x28) + lVar1;
for (; lVar1 < lVar2; lVar1 = lVar1 + 1) {
*(int1 *)(*(long *)(*(long *)(this + 0x10) + 0x60) + lVar1) =
*(int1 *)
(*(long *)(*(long *)(this + 8) + 0x60) +
(long)*(int *)(*(long *)(this + 0x108) + lVar1 * 4));
}
return;
}
|
|
9,684 |
MyCTX_nopad::finish(unsigned char*, unsigned int*)
|
eloqsql/mysys_ssl/my_crypt.cc
|
int finish(uchar *dst, uint *dlen)
{
if (source_tail_len)
{
/*
Not much we can do, block ciphers cannot encrypt data that aren't
a multiple of the block length. At least not without padding.
Let's do something CTR-like for the last partial block.
*/
uchar mask[MY_AES_BLOCK_SIZE];
uint mlen;
int rc= my_aes_crypt(MY_AES_ECB, ENCRYPTION_FLAG_ENCRYPT | ENCRYPTION_FLAG_NOPAD,
oiv, sizeof(mask), mask, &mlen, key, klen, 0, 0);
DBUG_ASSERT(rc == MY_AES_OK);
if (rc)
return rc;
DBUG_ASSERT(mlen == sizeof(mask));
for (uint i=0; i < source_tail_len; i++)
dst[i]= source_tail[i] ^ mask[i];
}
*dlen= source_tail_len;
return MY_AES_OK;
}
|
O3
|
cpp
|
MyCTX_nopad::finish(unsigned char*, unsigned int*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
xorl %ebx, %ebx
cmpl $0x0, 0xdc(%rdi)
movl $0x0, %r13d
je 0xdf28b
movq %rsi, %r15
movq %rdi, %r12
leaq 0xe0(%rdi), %rdx
movl 0xd8(%rdi), %eax
xorl %r13d, %r13d
leaq -0x40(%rbp), %r8
leaq -0x44(%rbp), %r9
xorl %edi, %edi
movl $0x3, %esi
movl $0x10, %ecx
pushq $0x0
pushq $0x0
pushq %rax
pushq 0xd0(%r12)
callq 0xdee07
addq $0x20, %rsp
testl %eax, %eax
je 0xdf25e
movl %eax, %ebx
jmp 0xdf28e
cmpl $0x0, 0xdc(%r12)
je 0xdf28b
xorl %eax, %eax
movb -0x40(%rbp,%rax), %cl
xorb 0xf0(%r12,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
movl 0xdc(%r12), %r13d
cmpq %r13, %rax
jb 0xdf26b
movl %r13d, (%r14)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xdf2ae
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a270
nop
|
_ZN11MyCTX_nopad6finishEPhPj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov rax, fs:28h
mov [rbp+var_30], rax
xor ebx, ebx
cmp dword ptr [rdi+0DCh], 0
mov r13d, 0
jz short loc_DF28B
mov r15, rsi
mov r12, rdi
lea rdx, [rdi+0E0h]
mov eax, [rdi+0D8h]
xor r13d, r13d
lea r8, [rbp+var_40]
lea r9, [rbp+var_44]
xor edi, edi
mov esi, 3
mov ecx, 10h
push 0
push 0
push rax
push qword ptr [r12+0D0h]
call my_aes_crypt
add rsp, 20h
test eax, eax
jz short loc_DF25E
mov ebx, eax
jmp short loc_DF28E
loc_DF25E:
cmp dword ptr [r12+0DCh], 0
jz short loc_DF28B
xor eax, eax
loc_DF26B:
mov cl, [rbp+rax+var_40]
xor cl, [r12+rax+0F0h]
mov [r15+rax], cl
inc rax
mov r13d, [r12+0DCh]
cmp rax, r13
jb short loc_DF26B
loc_DF28B:
mov [r14], r13d
loc_DF28E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_DF2AE
mov eax, ebx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_DF2AE:
call ___stack_chk_fail
|
long long MyCTX_nopad::finish(MyCTX_nopad *this, unsigned __int8 *a2, unsigned int *a3)
{
unsigned int v4; // ebx
unsigned long long v5; // r13
unsigned int v6; // eax
unsigned long long v7; // rax
int v9; // [rsp+Ch] [rbp-44h] BYREF
_BYTE v10[16]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v11; // [rsp+20h] [rbp-30h]
v11 = __readfsqword(0x28u);
v4 = 0;
LODWORD(v5) = 0;
if ( !*((_DWORD *)this + 55) )
{
LABEL_7:
*a3 = v5;
return v4;
}
LODWORD(v5) = 0;
v6 = my_aes_crypt(
0,
3,
(long long)this + 224,
0x10u,
(long long)v10,
&v9,
*((_QWORD *)this + 26),
*((_DWORD *)this + 54),
0LL);
if ( !v6 )
{
if ( *((_DWORD *)this + 55) )
{
v7 = 0LL;
do
{
a2[v7] = *((_BYTE *)this + v7 + 240) ^ v10[v7];
++v7;
v5 = *((unsigned int *)this + 55);
}
while ( v7 < v5 );
}
goto LABEL_7;
}
return v6;
}
|
finish:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
XOR EBX,EBX
CMP dword ptr [RDI + 0xdc],0x0
MOV R13D,0x0
JZ 0x001df28b
MOV R15,RSI
MOV R12,RDI
LEA RDX,[RDI + 0xe0]
MOV EAX,dword ptr [RDI + 0xd8]
XOR R13D,R13D
LEA R8,[RBP + -0x40]
LEA R9,[RBP + -0x44]
XOR EDI,EDI
MOV ESI,0x3
MOV ECX,0x10
PUSH 0x0
PUSH 0x0
PUSH RAX
PUSH qword ptr [R12 + 0xd0]
CALL 0x001dee07
ADD RSP,0x20
TEST EAX,EAX
JZ 0x001df25e
MOV EBX,EAX
JMP 0x001df28e
LAB_001df25e:
CMP dword ptr [R12 + 0xdc],0x0
JZ 0x001df28b
XOR EAX,EAX
LAB_001df26b:
MOV CL,byte ptr [RBP + RAX*0x1 + -0x40]
XOR CL,byte ptr [R12 + RAX*0x1 + 0xf0]
MOV byte ptr [R15 + RAX*0x1],CL
INC RAX
MOV R13D,dword ptr [R12 + 0xdc]
CMP RAX,R13
JC 0x001df26b
LAB_001df28b:
MOV dword ptr [R14],R13D
LAB_001df28e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001df2ae
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001df2ae:
CALL 0x0012a270
|
/* MyCTX_nopad::finish(unsigned char*, unsigned int*) */
int __thiscall MyCTX_nopad::finish(MyCTX_nopad *this,uchar *param_1,uint *param_2)
{
int iVar1;
ulong uVar2;
uint uVar3;
long in_FS_OFFSET;
int1 local_4c [4];
byte local_48 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = 0;
if (*(int *)(this + 0xdc) != 0) {
uVar3 = 0;
iVar1 = my_aes_crypt(0,3,this + 0xe0,0x10,local_48,local_4c,*(int8 *)(this + 0xd0),
*(int4 *)(this + 0xd8),0,0);
if (iVar1 != 0) goto LAB_001df28e;
if (*(int *)(this + 0xdc) != 0) {
uVar2 = 0;
do {
param_1[uVar2] = local_48[uVar2] ^ (byte)this[uVar2 + 0xf0];
uVar2 = uVar2 + 1;
uVar3 = *(uint *)(this + 0xdc);
} while (uVar2 < uVar3);
}
}
*param_2 = uVar3;
iVar1 = 0;
LAB_001df28e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1;
}
|
|
9,685 |
aimrt::protocols::sensor::JointCommandArray::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
|
aimrt_mujoco_sim/build_O3/src/protocols/actuator/joint_command.pb.cc
|
uint8_t* JointCommandArray::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:aimrt.protocols.sensor.JointCommandArray)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
// .aimrt.protocols.common.Header header = 1;
if (this->_internal_has_header()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(1, _Internal::header(this),
_Internal::header(this).GetCachedSize(), target, stream);
}
// repeated .aimrt.protocols.sensor.JointCommand joints = 2;
for (unsigned i = 0,
n = static_cast<unsigned>(this->_internal_joints_size()); i < n; i++) {
const auto& repfield = this->_internal_joints(i);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:aimrt.protocols.sensor.JointCommandArray)
return target;
}
|
O3
|
cpp
|
aimrt::protocols::sensor::JointCommandArray::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x19aaab(%rip), %rcx # 0x211760
cmpq %rcx, %rdi
setne %cl
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x76cdf
movl 0x28(%rsi), %edx
movl $0x1, %edi
movq %rax, %rcx
movq %rbx, %r8
callq 0x8cace
movl 0x18(%r14), %ebp
testl %ebp, %ebp
je 0x76d11
xorl %r15d, %r15d
movq 0x20(%r14), %rcx
movslq %r15d, %r15
movq 0x8(%rcx,%r15,8), %rsi
movl 0x40(%rsi), %edx
movl $0x2, %edi
movq %rax, %rcx
movq %rbx, %r8
callq 0x8cace
incl %r15d
cmpl %r15d, %ebp
jne 0x76cea
movq 0x8(%r14), %rdi
testb $0x1, %dil
jne 0x76d26
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $-0x4, %rdi
addq $0x8, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa6e1e
nop
|
_ZNK5aimrt9protocols6sensor17JointCommandArray18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov rax, rsi
mov r14, rdi
lea rcx, _ZN5aimrt9protocols6sensor36_JointCommandArray_default_instance_E; aimrt::protocols::sensor::_JointCommandArray_default_instance_
cmp rdi, rcx
setnz cl
mov rsi, [rdi+28h]; int
test rsi, rsi
setnz dl
and dl, cl
cmp dl, 1
jnz short loc_76CDF
mov edx, [rsi+28h]; google::protobuf::MessageLite *
mov edi, (offset dword_0+1); this
mov rcx, rax; int
mov r8, rbx; unsigned __int8 *
call _ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageEiRKNS0_11MessageLiteEiPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormatLite::InternalWriteMessage(int,google::protobuf::MessageLite const&,int,uchar *,google::protobuf::io::EpsCopyOutputStream *)
loc_76CDF:
mov ebp, [r14+18h]
test ebp, ebp
jz short loc_76D11
xor r15d, r15d
loc_76CEA:
mov rcx, [r14+20h]
movsxd r15, r15d
mov rsi, [rcx+r15*8+8]; int
mov edx, [rsi+40h]; google::protobuf::MessageLite *
mov edi, (offset dword_0+2); this
mov rcx, rax; int
mov r8, rbx; unsigned __int8 *
call _ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageEiRKNS0_11MessageLiteEiPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormatLite::InternalWriteMessage(int,google::protobuf::MessageLite const&,int,uchar *,google::protobuf::io::EpsCopyOutputStream *)
inc r15d
cmp ebp, r15d
jnz short loc_76CEA
loc_76D11:
mov rdi, [r14+8]
test dil, 1
jnz short loc_76D26
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_76D26:
and rdi, 0FFFFFFFFFFFFFFFCh
add rdi, 8; this
mov rsi, rax; google::protobuf::UnknownFieldSet *
mov rdx, rbx; unsigned __int8 *
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN6google8protobuf8internal10WireFormat37InternalSerializeUnknownFieldsToArrayERKNS0_15UnknownFieldSetEPhPNS0_2io19EpsCopyOutputStreamE; google::protobuf::internal::WireFormat::InternalSerializeUnknownFieldsToArray(google::protobuf::UnknownFieldSet const&,uchar *,google::protobuf::io::EpsCopyOutputStream *)
|
const google::protobuf::UnknownFieldSet * aimrt::protocols::sensor::JointCommandArray::_InternalSerialize(
void ( ***this)(aimrt::protocols::sensor::JointCommandArray *__hidden this),
const google::protobuf::UnknownFieldSet *a2,
google::protobuf::io::EpsCopyOutputStream *a3,
long long a4,
long long a5,
google::protobuf::io::EpsCopyOutputStream *a6)
{
const google::protobuf::UnknownFieldSet *result; // rax
google::protobuf::io::EpsCopyOutputStream *v8; // rcx
void ( **v9)(aimrt::protocols::sensor::JointCommandArray *__hidden); // rsi
int v10; // ebp
int i; // r15d
void ( *v12)(aimrt::protocols::sensor::JointCommandArray *__hidden); // rsi
unsigned long long v13; // rdi
result = a2;
v8 = (google::protobuf::io::EpsCopyOutputStream *)&aimrt::protocols::sensor::_JointCommandArray_default_instance_;
LOBYTE(v8) = this != &aimrt::protocols::sensor::_JointCommandArray_default_instance_;
v9 = this[5];
if ( this != &aimrt::protocols::sensor::_JointCommandArray_default_instance_ && v9 != 0LL )
result = (const google::protobuf::UnknownFieldSet *)google::protobuf::internal::WireFormatLite::InternalWriteMessage(
(google::protobuf::internal::WireFormatLite *)((char *)&dword_0 + 1),
(int)v9,
(const google::protobuf::MessageLite *)*((unsigned int *)v9
+ 10),
(int)result,
(unsigned __int8 *)a3,
a6);
v10 = *((_DWORD *)this + 6);
if ( v10 )
{
for ( i = 0; i != v10; ++i )
{
v12 = this[4][i + 1];
result = (const google::protobuf::UnknownFieldSet *)google::protobuf::internal::WireFormatLite::InternalWriteMessage(
(google::protobuf::internal::WireFormatLite *)((char *)&dword_0 + 2),
(int)v12,
(const google::protobuf::MessageLite *)*((unsigned int *)v12 + 16),
(int)result,
(unsigned __int8 *)a3,
a6);
}
}
v13 = (unsigned long long)this[1];
if ( (v13 & 1) != 0 )
return (const google::protobuf::UnknownFieldSet *)google::protobuf::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
(google::protobuf::internal::WireFormat *)((v13 & 0xFFFFFFFFFFFFFFFCLL)
+ 8),
result,
(unsigned __int8 *)a3,
v8);
return result;
}
|
_InternalSerialize:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV RAX,RSI
MOV R14,RDI
LEA RCX,[0x311760]
CMP RDI,RCX
SETNZ CL
MOV RSI,qword ptr [RDI + 0x28]
TEST RSI,RSI
SETNZ DL
AND DL,CL
CMP DL,0x1
JNZ 0x00176cdf
MOV EDX,dword ptr [RSI + 0x28]
MOV EDI,0x1
MOV RCX,RAX
MOV R8,RBX
CALL 0x0018cace
LAB_00176cdf:
MOV EBP,dword ptr [R14 + 0x18]
TEST EBP,EBP
JZ 0x00176d11
XOR R15D,R15D
LAB_00176cea:
MOV RCX,qword ptr [R14 + 0x20]
MOVSXD R15,R15D
MOV RSI,qword ptr [RCX + R15*0x8 + 0x8]
MOV EDX,dword ptr [RSI + 0x40]
MOV EDI,0x2
MOV RCX,RAX
MOV R8,RBX
CALL 0x0018cace
INC R15D
CMP EBP,R15D
JNZ 0x00176cea
LAB_00176d11:
MOV RDI,qword ptr [R14 + 0x8]
TEST DIL,0x1
JNZ 0x00176d26
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00176d26:
AND RDI,-0x4
ADD RDI,0x8
MOV RSI,RAX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001a6e1e
|
/* aimrt::protocols::sensor::JointCommandArray::_InternalSerialize(unsigned char*,
google::protobuf::io::EpsCopyOutputStream*) const */
void __thiscall
aimrt::protocols::sensor::JointCommandArray::_InternalSerialize
(JointCommandArray *this,uchar *param_1,EpsCopyOutputStream *param_2)
{
int iVar1;
MessageLite *pMVar2;
int iVar3;
pMVar2 = *(MessageLite **)(this + 0x28);
if (pMVar2 != (MessageLite *)0x0 &&
this != (JointCommandArray *)_JointCommandArray_default_instance_) {
param_1 = (uchar *)google::protobuf::internal::WireFormatLite::InternalWriteMessage
(1,pMVar2,*(int *)(pMVar2 + 0x28),param_1,param_2);
}
iVar1 = *(int *)(this + 0x18);
if (iVar1 != 0) {
iVar3 = 0;
do {
pMVar2 = *(MessageLite **)(*(long *)(this + 0x20) + 8 + (long)iVar3 * 8);
param_1 = (uchar *)google::protobuf::internal::WireFormatLite::InternalWriteMessage
(2,pMVar2,*(int *)(pMVar2 + 0x40),param_1,param_2);
iVar3 = iVar3 + 1;
} while (iVar1 != iVar3);
}
if ((*(ulong *)(this + 8) & 1) == 0) {
return;
}
google::protobuf::internal::WireFormat::InternalSerializeUnknownFieldsToArray
((UnknownFieldSet *)((*(ulong *)(this + 8) & 0xfffffffffffffffc) + 8),param_1,param_2);
return;
}
|
|
9,686 |
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*)
|
7CodeWizard[P]stablediffusion/clip.hpp
|
void init_params(ggml_context* ctx, ggml_backend_t backend, ggml_type wtype, ggml_allocr* alloc) {
position_ids = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, max_position_embeddings);
token_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, vocab_size);
position_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, max_position_embeddings);
for (int i = 0; i < num_hidden_layers; i++) {
resblocks[i].init_params(ctx, alloc, wtype);
}
final_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
final_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
if (version == OPEN_CLIP_VIT_BIGG_14) {
text_projection = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, projection_dim, hidden_size);
}
// alloc all tensors linked to this context
for (struct ggml_tensor* t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) {
if (t->data == NULL) {
ggml_allocr_alloc(alloc, t);
}
}
if (ggml_backend_is_cpu(backend)) {
for (int i = 0; i < max_position_embeddings; i++) {
ggml_set_i32_1d(position_ids, i, i);
}
} else {
std::vector<int> pos_temp;
for (int i = 0; i < max_position_embeddings; i++) {
pos_temp.push_back(i);
}
ggml_backend_tensor_set(position_ids, pos_temp.data(), 0, ggml_nbytes(position_ids));
}
}
|
O1
|
cpp
|
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, 0x30(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movslq 0x8(%rdi), %rdx
movq %rsi, %rdi
movl $0x12, %esi
callq 0x8ec3c
movq %rax, 0x28(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x4(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x8ec55
movq %rax, 0x30(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x8(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x8ec55
movq %rax, 0x38(%rbx)
cmpl $0x0, 0x18(%rbx)
jle 0x42166
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x40(%rbx), %rdi
addq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x422da
incq %r14
movslq 0x18(%rbx), %rax
addq $0x90, %r13
cmpq %rax, %r14
jl 0x4213f
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8ec3c
movq %rax, 0x58(%rbx)
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8ec3c
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0x421a5
movslq 0x20(%rbx), %rdx
movslq 0xc(%rbx), %rcx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8ec55
movq %rax, 0x68(%rbx)
movq %r12, %rdi
callq 0x8e869
testq %rax, %rax
je 0x421dd
movq %rax, %r13
cmpq $0x0, 0x118(%r13)
jne 0x421ca
movq %r15, %rdi
movq %r13, %rsi
callq 0xb37b1
movq %r12, %rdi
movq %r13, %rsi
callq 0x8e88c
movq %rax, %r13
testq %rax, %rax
jne 0x421b5
movq 0x30(%rsp), %rdi
callq 0xb464a
testb %al, %al
je 0x42210
cmpl $0x0, 0x8(%rbx)
jle 0x422a6
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x9050c
incl %ebp
cmpl 0x8(%rbx), %ebp
jl 0x421f7
jmp 0x422a6
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x8(%rbx)
jle 0x4226e
xorl %eax, %eax
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x42254
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x4225f
movq %r14, %rdi
movq %r15, %rdx
callq 0x39bfe
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0x8(%rbx), %eax
jl 0x4223b
movq 0x28(%rbx), %rbx
movq 0x10(%rsp), %r14
movq %rbx, %rdi
callq 0x8e066
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb3fb5
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x422a6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x422b7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x422d1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5e0
movq %rbx, %rdi
callq 0xaae0
nop
|
_ZN13CLIPTextModel11init_paramsEP12ggml_contextP12ggml_backend9ggml_typeP11ggml_allocr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov ebp, ecx
mov [rsp+68h+var_38], rdx
mov r12, rsi
mov rbx, rdi
movsxd rdx, dword ptr [rdi+8]
mov rdi, rsi
mov esi, 12h
call ggml_new_tensor_1d
mov [rbx+28h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+4]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+30h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+8]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+38h], rax
cmp dword ptr [rbx+18h], 0
jle short loc_42166
xor r13d, r13d
xor r14d, r14d
loc_4213F:
mov rdi, [rbx+40h]
add rdi, r13
mov rsi, r12
mov rdx, r15
mov ecx, ebp
call _ZN22ResidualAttentionBlock11init_paramsEP12ggml_contextP11ggml_allocr9ggml_type; ResidualAttentionBlock::init_params(ggml_context *,ggml_allocr *,ggml_type)
inc r14
movsxd rax, dword ptr [rbx+18h]
add r13, 90h
cmp r14, rax
jl short loc_4213F
loc_42166:
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+58h], rax
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+60h], rax
cmp dword ptr [rbx], 2
jnz short loc_421A5
movsxd rdx, dword ptr [rbx+20h]
movsxd rcx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_2d
mov [rbx+68h], rax
loc_421A5:
mov rdi, r12
call ggml_get_first_tensor
test rax, rax
jz short loc_421DD
mov r13, rax
loc_421B5:
cmp qword ptr [r13+118h], 0
jnz short loc_421CA
mov rdi, r15
mov rsi, r13
call ggml_allocr_alloc
loc_421CA:
mov rdi, r12
mov rsi, r13
call ggml_get_next_tensor
mov r13, rax
test rax, rax
jnz short loc_421B5
loc_421DD:
mov rdi, [rsp+68h+var_38]
call ggml_backend_is_cpu
test al, al
jz short loc_42210
cmp dword ptr [rbx+8], 0
jle loc_422A6
xor ebp, ebp
loc_421F7:
mov rdi, [rbx+28h]
mov esi, ebp
mov edx, ebp
call ggml_set_i32_1d
inc ebp
cmp ebp, [rbx+8]
jl short loc_421F7
jmp loc_422A6
loc_42210:
xorps xmm0, xmm0
movaps xmmword ptr [rsp+68h+var_58], xmm0
mov [rsp+68h+var_48], 0
mov [rsp+68h+var_5C], 0
cmp dword ptr [rbx+8], 0
jle short loc_4226E
xor eax, eax
lea r14, [rsp+68h+var_58]
lea r15, [rsp+68h+var_5C]
loc_4223B:
mov rsi, [rsp+68h+var_58+8]
cmp rsi, [rsp+68h+var_48]
jz short loc_42254
mov [rsi], eax
add rsi, 4
mov [rsp+68h+var_58+8], rsi
jmp short loc_4225F
loc_42254:
mov rdi, r14
mov rdx, r15
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_4225F:
mov eax, [rsp+68h+var_5C]
inc eax
mov [rsp+68h+var_5C], eax
cmp eax, [rbx+8]
jl short loc_4223B
loc_4226E:
mov rbx, [rbx+28h]
mov r14, [rsp+68h+var_58]
mov rdi, rbx
call ggml_nbytes
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, rax
call ggml_backend_tensor_set
mov rdi, [rsp+68h+var_58]; void *
test rdi, rdi
jz short loc_422A6
mov rsi, [rsp+68h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_422A6:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_422B7:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_422D1
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_422D1:
mov rdi, rbx
call __Unwind_Resume
|
void CLIPTextModel::init_params(long long a1, long long a2, long long a3, unsigned int a4, long long a5)
{
long long v7; // r13
long long v8; // r14
long long first_tensor; // rax
long long next_tensor; // r13
unsigned int v11; // ebp
int v12; // eax
char *v13; // rsi
long long v14; // rbx
void *v15; // r14
long long v16; // rax
int v17; // [rsp+Ch] [rbp-5Ch] BYREF
void *v18[2]; // [rsp+10h] [rbp-58h] BYREF
void *v19; // [rsp+20h] [rbp-48h]
long long v20; // [rsp+30h] [rbp-38h]
v20 = a3;
*(_QWORD *)(a1 + 40) = ggml_new_tensor_1d(a2, 18LL, *(int *)(a1 + 8));
*(_QWORD *)(a1 + 48) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 4));
*(_QWORD *)(a1 + 56) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 8));
if ( *(int *)(a1 + 24) > 0 )
{
v7 = 0LL;
v8 = 0LL;
do
{
ResidualAttentionBlock::init_params(v7 + *(_QWORD *)(a1 + 64), a2, a5, a4);
++v8;
v7 += 144LL;
}
while ( v8 < *(int *)(a1 + 24) );
}
*(_QWORD *)(a1 + 88) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
*(_QWORD *)(a1 + 96) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
if ( *(_DWORD *)a1 == 2 )
*(_QWORD *)(a1 + 104) = ggml_new_tensor_2d(a2, 0LL, *(int *)(a1 + 32), *(int *)(a1 + 12));
first_tensor = ggml_get_first_tensor(a2);
if ( first_tensor )
{
next_tensor = first_tensor;
do
{
if ( !*(_QWORD *)(next_tensor + 280) )
ggml_allocr_alloc(a5, next_tensor);
next_tensor = ggml_get_next_tensor(a2, next_tensor);
}
while ( next_tensor );
}
if ( (unsigned __int8)ggml_backend_is_cpu(v20) )
{
if ( *(int *)(a1 + 8) > 0 )
{
v11 = 0;
do
{
ggml_set_i32_1d(*(_QWORD *)(a1 + 40), v11, v11);
++v11;
}
while ( (signed int)v11 < *(_DWORD *)(a1 + 8) );
}
}
else
{
*(_OWORD *)v18 = 0LL;
v19 = 0LL;
v17 = 0;
if ( *(int *)(a1 + 8) > 0 )
{
v12 = 0;
do
{
v13 = (char *)v18[1];
if ( v18[1] == v19 )
{
std::vector<int>::_M_realloc_insert<int const&>((long long *)v18, (long long)v18[1], &v17);
}
else
{
*(_DWORD *)v18[1] = v12;
v18[1] = v13 + 4;
}
v12 = v17 + 1;
v17 = v12;
}
while ( v12 < *(_DWORD *)(a1 + 8) );
}
v14 = *(_QWORD *)(a1 + 40);
v15 = v18[0];
v16 = ggml_nbytes(v14);
ggml_backend_tensor_set(v14, v15, 0LL, v16);
if ( v18[0] )
operator delete(v18[0], (unsigned long long)v19 - (unsigned long long)v18[0]);
}
}
| |||
9,687 |
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*)
|
7CodeWizard[P]stablediffusion/clip.hpp
|
void init_params(ggml_context* ctx, ggml_backend_t backend, ggml_type wtype, ggml_allocr* alloc) {
position_ids = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, max_position_embeddings);
token_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, vocab_size);
position_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, max_position_embeddings);
for (int i = 0; i < num_hidden_layers; i++) {
resblocks[i].init_params(ctx, alloc, wtype);
}
final_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
final_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
if (version == OPEN_CLIP_VIT_BIGG_14) {
text_projection = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, projection_dim, hidden_size);
}
// alloc all tensors linked to this context
for (struct ggml_tensor* t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) {
if (t->data == NULL) {
ggml_allocr_alloc(alloc, t);
}
}
if (ggml_backend_is_cpu(backend)) {
for (int i = 0; i < max_position_embeddings; i++) {
ggml_set_i32_1d(position_ids, i, i);
}
} else {
std::vector<int> pos_temp;
for (int i = 0; i < max_position_embeddings; i++) {
pos_temp.push_back(i);
}
ggml_backend_tensor_set(position_ids, pos_temp.data(), 0, ggml_nbytes(position_ids));
}
}
|
O2
|
cpp
|
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movslq 0x8(%rdi), %rdx
pushq $0x12
popq %rsi
movq %r12, %rdi
callq 0x68616
movq %rax, 0x28(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x4(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x68627
movq %rax, 0x30(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x8(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x68627
movq %rax, 0x38(%rbx)
xorl %r13d, %r13d
xorl %r14d, %r14d
movslq 0x18(%rbx), %rax
cmpq %rax, %r14
jge 0x29e0c
movq 0x40(%rbx), %rdi
addq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x29f28
incq %r14
addq $0x90, %r13
jmp 0x29de3
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x68616
movq %rax, 0x58(%rbx)
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x68616
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0x29e4b
movslq 0x20(%rbx), %rdx
movslq 0xc(%rbx), %rcx
movq %r12, %rdi
xorl %esi, %esi
callq 0x68627
movq %rax, 0x68(%rbx)
movq %r12, %rdi
callq 0x68311
movq %rax, %r13
testq %rax, %rax
je 0x29e7d
cmpq $0x0, 0x118(%r13)
jne 0x29e70
movq %r15, %rdi
movq %r13, %rsi
callq 0x8f58c
movq %r12, %rdi
movq %r13, %rsi
callq 0x68336
jmp 0x29e53
movq 0x8(%rsp), %rdi
callq 0x9072e
testb %al, %al
je 0x29ea3
xorl %ebp, %ebp
cmpl 0x8(%rbx), %ebp
jge 0x29f02
movq 0x28(%rbx), %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x68e87
incl %ebp
jmp 0x29e8d
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %eax, %eax
leaq 0x4(%rsp), %r15
movl %eax, 0x4(%rsp)
cmpl 0x8(%rbx), %eax
jge 0x29ed7
movq %r14, %rdi
movq %r15, %rsi
callq 0x2248e
movl 0x4(%rsp), %eax
incl %eax
jmp 0x29ebb
movq 0x28(%rbx), %rbx
movq 0x10(%rsp), %r14
movq %rbx, %rdi
callq 0x67afd
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x8fec1
leaq 0x10(%rsp), %rdi
callq 0x22d64
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29f13
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x22d64
movq %rbx, %rdi
callq 0xaab0
|
_ZN13CLIPTextModel11init_paramsEP12ggml_contextP12ggml_backend9ggml_typeP11ggml_allocr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, r8
mov ebp, ecx
mov [rsp+58h+var_50], rdx
mov r12, rsi
mov rbx, rdi
movsxd rdx, dword ptr [rdi+8]
push 12h
pop rsi
mov rdi, r12
call ggml_new_tensor_1d
mov [rbx+28h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+4]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+30h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+8]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+38h], rax
xor r13d, r13d
xor r14d, r14d
loc_29DE3:
movsxd rax, dword ptr [rbx+18h]
cmp r14, rax
jge short loc_29E0C
mov rdi, [rbx+40h]
add rdi, r13
mov rsi, r12
mov rdx, r15
mov ecx, ebp
call _ZN22ResidualAttentionBlock11init_paramsEP12ggml_contextP11ggml_allocr9ggml_type; ResidualAttentionBlock::init_params(ggml_context *,ggml_allocr *,ggml_type)
inc r14
add r13, 90h
jmp short loc_29DE3
loc_29E0C:
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+58h], rax
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+60h], rax
cmp dword ptr [rbx], 2
jnz short loc_29E4B
movsxd rdx, dword ptr [rbx+20h]
movsxd rcx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_2d
mov [rbx+68h], rax
loc_29E4B:
mov rdi, r12
call ggml_get_first_tensor
loc_29E53:
mov r13, rax
test rax, rax
jz short loc_29E7D
cmp qword ptr [r13+118h], 0
jnz short loc_29E70
mov rdi, r15
mov rsi, r13
call ggml_allocr_alloc
loc_29E70:
mov rdi, r12
mov rsi, r13
call ggml_get_next_tensor
jmp short loc_29E53
loc_29E7D:
mov rdi, [rsp+58h+var_50]
call ggml_backend_is_cpu
test al, al
jz short loc_29EA3
xor ebp, ebp
loc_29E8D:
cmp ebp, [rbx+8]
jge short loc_29F02
mov rdi, [rbx+28h]
mov esi, ebp
mov edx, ebp
call ggml_set_i32_1d
inc ebp
jmp short loc_29E8D
loc_29EA3:
lea r14, [rsp+58h+var_48]
and qword ptr [r14+10h], 0
xorps xmm0, xmm0
movaps xmmword ptr [r14], xmm0
xor eax, eax
lea r15, [rsp+58h+var_54]
loc_29EBB:
mov [rsp+58h+var_54], eax
cmp eax, [rbx+8]
jge short loc_29ED7
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov eax, [rsp+58h+var_54]
inc eax
jmp short loc_29EBB
loc_29ED7:
mov rbx, [rbx+28h]
mov r14, [rsp+58h+var_48]
mov rdi, rbx
call ggml_nbytes
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, rax
call ggml_backend_tensor_set
lea rdi, [rsp+58h+var_48]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
loc_29F02:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_29F13:
mov rbx, rax
lea rdi, [rsp+arg_8]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
|
long long CLIPTextModel::init_params(long long a1, long long a2, long long a3, unsigned int a4, long long a5)
{
long long v7; // r13
long long i; // r14
long long j; // rax
long long v10; // r13
long long result; // rax
unsigned int k; // ebp
signed int m; // eax
long long v14; // rbx
long long v15; // r14
long long v16; // rax
signed int v17; // [rsp+4h] [rbp-54h] BYREF
long long v18; // [rsp+8h] [rbp-50h]
__int128 v19; // [rsp+10h] [rbp-48h] BYREF
long long v20; // [rsp+20h] [rbp-38h]
v18 = a3;
*(_QWORD *)(a1 + 40) = ggml_new_tensor_1d(a2, 18LL, *(int *)(a1 + 8));
*(_QWORD *)(a1 + 48) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 4));
*(_QWORD *)(a1 + 56) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 8));
v7 = 0LL;
for ( i = 0LL; i < *(int *)(a1 + 24); ++i )
{
ResidualAttentionBlock::init_params(v7 + *(_QWORD *)(a1 + 64), a2, a5, a4);
v7 += 144LL;
}
*(_QWORD *)(a1 + 88) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
*(_QWORD *)(a1 + 96) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
if ( *(_DWORD *)a1 == 2 )
*(_QWORD *)(a1 + 104) = ggml_new_tensor_2d(a2, 0LL, *(int *)(a1 + 32), *(int *)(a1 + 12));
for ( j = ggml_get_first_tensor(a2); ; j = ggml_get_next_tensor(a2, v10) )
{
v10 = j;
if ( !j )
break;
if ( !*(_QWORD *)(j + 280) )
ggml_allocr_alloc(a5, j);
}
result = ggml_backend_is_cpu(v18);
if ( (_BYTE)result )
{
for ( k = 0; (signed int)k < *(_DWORD *)(a1 + 8); ++k )
result = ggml_set_i32_1d(*(_QWORD *)(a1 + 40), k, k);
}
else
{
v20 = 0LL;
v19 = 0LL;
for ( m = 0; ; m = v17 + 1 )
{
v17 = m;
if ( m >= *(_DWORD *)(a1 + 8) )
break;
std::vector<int>::push_back((long long)&v19, (unsigned int *)&v17);
}
v14 = *(_QWORD *)(a1 + 40);
v15 = v19;
v16 = ggml_nbytes(v14);
result = ggml_backend_tensor_set(v14, v15, 0LL, v16);
std::_Vector_base<int>::~_Vector_base(&v19);
}
return result;
}
|
init_params:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,R8
MOV EBP,ECX
MOV qword ptr [RSP + 0x8],RDX
MOV R12,RSI
MOV RBX,RDI
MOVSXD RDX,dword ptr [RDI + 0x8]
PUSH 0x12
POP RSI
MOV RDI,R12
CALL 0x00168616
MOV qword ptr [RBX + 0x28],RAX
MOVSXD RDX,dword ptr [RBX + 0xc]
MOVSXD RCX,dword ptr [RBX + 0x4]
MOV RDI,R12
MOV ESI,EBP
CALL 0x00168627
MOV qword ptr [RBX + 0x30],RAX
MOVSXD RDX,dword ptr [RBX + 0xc]
MOVSXD RCX,dword ptr [RBX + 0x8]
MOV RDI,R12
MOV ESI,EBP
CALL 0x00168627
MOV qword ptr [RBX + 0x38],RAX
XOR R13D,R13D
XOR R14D,R14D
LAB_00129de3:
MOVSXD RAX,dword ptr [RBX + 0x18]
CMP R14,RAX
JGE 0x00129e0c
MOV RDI,qword ptr [RBX + 0x40]
ADD RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV ECX,EBP
CALL 0x00129f28
INC R14
ADD R13,0x90
JMP 0x00129de3
LAB_00129e0c:
MOVSXD RDX,dword ptr [RBX + 0xc]
MOV RDI,R12
XOR ESI,ESI
CALL 0x00168616
MOV qword ptr [RBX + 0x58],RAX
MOVSXD RDX,dword ptr [RBX + 0xc]
MOV RDI,R12
XOR ESI,ESI
CALL 0x00168616
MOV qword ptr [RBX + 0x60],RAX
CMP dword ptr [RBX],0x2
JNZ 0x00129e4b
MOVSXD RDX,dword ptr [RBX + 0x20]
MOVSXD RCX,dword ptr [RBX + 0xc]
MOV RDI,R12
XOR ESI,ESI
CALL 0x00168627
MOV qword ptr [RBX + 0x68],RAX
LAB_00129e4b:
MOV RDI,R12
CALL 0x00168311
LAB_00129e53:
MOV R13,RAX
TEST RAX,RAX
JZ 0x00129e7d
CMP qword ptr [R13 + 0x118],0x0
JNZ 0x00129e70
MOV RDI,R15
MOV RSI,R13
CALL 0x0018f58c
LAB_00129e70:
MOV RDI,R12
MOV RSI,R13
CALL 0x00168336
JMP 0x00129e53
LAB_00129e7d:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0019072e
TEST AL,AL
JZ 0x00129ea3
XOR EBP,EBP
LAB_00129e8d:
CMP EBP,dword ptr [RBX + 0x8]
JGE 0x00129f02
MOV RDI,qword ptr [RBX + 0x28]
MOV ESI,EBP
MOV EDX,EBP
CALL 0x00168e87
INC EBP
JMP 0x00129e8d
LAB_00129ea3:
LEA R14,[RSP + 0x10]
AND qword ptr [R14 + 0x10],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14],XMM0
XOR EAX,EAX
LEA R15,[RSP + 0x4]
LAB_00129ebb:
MOV dword ptr [RSP + 0x4],EAX
CMP EAX,dword ptr [RBX + 0x8]
JGE 0x00129ed7
LAB_00129ec4:
MOV RDI,R14
MOV RSI,R15
CALL 0x0012248e
MOV EAX,dword ptr [RSP + 0x4]
INC EAX
JMP 0x00129ebb
LAB_00129ed7:
MOV RBX,qword ptr [RBX + 0x28]
MOV R14,qword ptr [RSP + 0x10]
LAB_00129ee0:
MOV RDI,RBX
CALL 0x00167afd
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
MOV RCX,RAX
CALL 0x0018fec1
LAB_00129ef8:
LEA RDI,[RSP + 0x10]
CALL 0x00122d64
LAB_00129f02:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*) */
void __thiscall
CLIPTextModel::init_params
(CLIPTextModel *this,int8 param_1,int8 param_2,int4 param_4,
int8 param_5)
{
int8 uVar1;
char cVar2;
int8 uVar3;
int8 uVar4;
int iVar5;
long lVar6;
long lVar7;
int local_54;
int8 local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
local_50 = param_2;
uVar3 = ggml_new_tensor_1d(param_1,0x12,(long)*(int *)(this + 8));
*(int8 *)(this + 0x28) = uVar3;
uVar3 = ggml_new_tensor_2d(param_1,param_4,(long)*(int *)(this + 0xc),(long)*(int *)(this + 4));
*(int8 *)(this + 0x30) = uVar3;
uVar3 = ggml_new_tensor_2d(param_1,param_4,(long)*(int *)(this + 0xc),(long)*(int *)(this + 8));
*(int8 *)(this + 0x38) = uVar3;
lVar6 = 0;
for (lVar7 = 0; lVar7 < *(int *)(this + 0x18); lVar7 = lVar7 + 1) {
ResidualAttentionBlock::init_params
((ResidualAttentionBlock *)(*(long *)(this + 0x40) + lVar6),param_1,param_5,param_4);
lVar6 = lVar6 + 0x90;
}
uVar3 = ggml_new_tensor_1d(param_1,0,(long)*(int *)(this + 0xc));
*(int8 *)(this + 0x58) = uVar3;
uVar3 = ggml_new_tensor_1d(param_1,0,(long)*(int *)(this + 0xc));
*(int8 *)(this + 0x60) = uVar3;
if (*(int *)this == 2) {
uVar3 = ggml_new_tensor_2d(param_1,0,(long)*(int *)(this + 0x20),(long)*(int *)(this + 0xc));
*(int8 *)(this + 0x68) = uVar3;
}
for (lVar6 = ggml_get_first_tensor(param_1); lVar6 != 0;
lVar6 = ggml_get_next_tensor(param_1,lVar6)) {
if (*(long *)(lVar6 + 0x118) == 0) {
ggml_allocr_alloc(param_5,lVar6);
}
}
cVar2 = ggml_backend_is_cpu(local_50);
if (cVar2 == '\0') {
local_38 = 0;
local_48 = 0;
uStack_40 = 0;
for (local_54 = 0; uVar3 = local_48, local_54 < *(int *)(this + 8); local_54 = local_54 + 1) {
/* try { // try from 00129ec4 to 00129ece has its CatchHandler @ 00129f13 */
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)&local_48,&local_54);
}
uVar1 = *(int8 *)(this + 0x28);
/* try { // try from 00129ee0 to 00129ef7 has its CatchHandler @ 00129f11 */
uVar4 = ggml_nbytes(uVar1);
ggml_backend_tensor_set(uVar1,uVar3,0,uVar4);
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_48);
}
else {
for (iVar5 = 0; iVar5 < *(int *)(this + 8); iVar5 = iVar5 + 1) {
ggml_set_i32_1d(*(int8 *)(this + 0x28),iVar5,iVar5);
}
}
return;
}
|
|
9,688 |
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*)
|
7CodeWizard[P]stablediffusion/clip.hpp
|
void init_params(ggml_context* ctx, ggml_backend_t backend, ggml_type wtype, ggml_allocr* alloc) {
position_ids = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, max_position_embeddings);
token_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, vocab_size);
position_embed_weight = ggml_new_tensor_2d(ctx, wtype, hidden_size, max_position_embeddings);
for (int i = 0; i < num_hidden_layers; i++) {
resblocks[i].init_params(ctx, alloc, wtype);
}
final_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
final_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, hidden_size);
if (version == OPEN_CLIP_VIT_BIGG_14) {
text_projection = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, projection_dim, hidden_size);
}
// alloc all tensors linked to this context
for (struct ggml_tensor* t = ggml_get_first_tensor(ctx); t != NULL; t = ggml_get_next_tensor(ctx, t)) {
if (t->data == NULL) {
ggml_allocr_alloc(alloc, t);
}
}
if (ggml_backend_is_cpu(backend)) {
for (int i = 0; i < max_position_embeddings; i++) {
ggml_set_i32_1d(position_ids, i, i);
}
} else {
std::vector<int> pos_temp;
for (int i = 0; i < max_position_embeddings; i++) {
pos_temp.push_back(i);
}
ggml_backend_tensor_set(position_ids, pos_temp.data(), 0, ggml_nbytes(position_ids));
}
}
|
O3
|
cpp
|
CLIPTextModel::init_params(ggml_context*, ggml_backend*, ggml_type, ggml_allocr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, 0x30(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movslq 0x8(%rdi), %rdx
movq %rsi, %rdi
movl $0x12, %esi
callq 0x8d9b7
movq %rax, 0x28(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x4(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x8d9d0
movq %rax, 0x30(%rbx)
movslq 0xc(%rbx), %rdx
movslq 0x8(%rbx), %rcx
movq %r12, %rdi
movl %ebp, %esi
callq 0x8d9d0
movq %rax, 0x38(%rbx)
cmpl $0x0, 0x18(%rbx)
jle 0x41698
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x40(%rbx), %rdi
addq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x41812
incq %r14
movslq 0x18(%rbx), %rax
addq $0x90, %r13
cmpq %rax, %r14
jl 0x41671
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8d9b7
movq %rax, 0x58(%rbx)
movslq 0xc(%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8d9b7
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0x416d7
movslq 0x20(%rbx), %rdx
movslq 0xc(%rbx), %rcx
movq %r12, %rdi
xorl %esi, %esi
callq 0x8d9d0
movq %rax, 0x68(%rbx)
movq %r12, %rdi
callq 0x8d601
testq %rax, %rax
je 0x4170f
movq %rax, %r13
cmpq $0x0, 0x118(%r13)
jne 0x416fc
movq %r15, %rdi
movq %r13, %rsi
callq 0xb240d
movq %r12, %rdi
movq %r13, %rsi
callq 0x8d624
movq %rax, %r13
testq %rax, %rax
jne 0x416e7
movq 0x30(%rsp), %rdi
callq 0xb320c
testb %al, %al
je 0x41742
cmpl $0x0, 0x8(%rbx)
jle 0x417de
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x8f272
incl %ebp
cmpl 0x8(%rbx), %ebp
jl 0x41729
jmp 0x417de
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
xorl %r14d, %r14d
cmpl $0x0, 0x8(%rbx)
jle 0x417ab
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x41788
movl %r14d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x41793
movq %r15, %rdi
movq %r12, %rdx
callq 0x39096
movl 0xc(%rsp), %r14d
incl %r14d
movl %r14d, 0xc(%rsp)
cmpl 0x8(%rbx), %r14d
jl 0x4176e
movq 0x10(%rsp), %r14
movq 0x28(%rbx), %rbx
movq %rbx, %rdi
callq 0x8cdf7
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb2b9d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x417de
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x417ef
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x41809
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0xa5d0
movq %rbx, %rdi
callq 0xaad0
nop
|
_ZN13CLIPTextModel11init_paramsEP12ggml_contextP12ggml_backend9ggml_typeP11ggml_allocr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov ebp, ecx
mov [rsp+68h+var_38], rdx
mov r12, rsi
mov rbx, rdi
movsxd rdx, dword ptr [rdi+8]
mov rdi, rsi
mov esi, 12h
call ggml_new_tensor_1d
mov [rbx+28h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+4]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+30h], rax
movsxd rdx, dword ptr [rbx+0Ch]
movsxd rcx, dword ptr [rbx+8]
mov rdi, r12
mov esi, ebp
call ggml_new_tensor_2d
mov [rbx+38h], rax
cmp dword ptr [rbx+18h], 0
jle short loc_41698
xor r13d, r13d
xor r14d, r14d
loc_41671:
mov rdi, [rbx+40h]
add rdi, r13
mov rsi, r12
mov rdx, r15
mov ecx, ebp
call _ZN22ResidualAttentionBlock11init_paramsEP12ggml_contextP11ggml_allocr9ggml_type; ResidualAttentionBlock::init_params(ggml_context *,ggml_allocr *,ggml_type)
inc r14
movsxd rax, dword ptr [rbx+18h]
add r13, 90h
cmp r14, rax
jl short loc_41671
loc_41698:
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+58h], rax
movsxd rdx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_1d
mov [rbx+60h], rax
cmp dword ptr [rbx], 2
jnz short loc_416D7
movsxd rdx, dword ptr [rbx+20h]
movsxd rcx, dword ptr [rbx+0Ch]
mov rdi, r12
xor esi, esi
call ggml_new_tensor_2d
mov [rbx+68h], rax
loc_416D7:
mov rdi, r12
call ggml_get_first_tensor
test rax, rax
jz short loc_4170F
mov r13, rax
loc_416E7:
cmp qword ptr [r13+118h], 0
jnz short loc_416FC
mov rdi, r15
mov rsi, r13
call ggml_allocr_alloc
loc_416FC:
mov rdi, r12
mov rsi, r13
call ggml_get_next_tensor
mov r13, rax
test rax, rax
jnz short loc_416E7
loc_4170F:
mov rdi, [rsp+68h+var_38]
call ggml_backend_is_cpu
test al, al
jz short loc_41742
cmp dword ptr [rbx+8], 0
jle loc_417DE
xor ebp, ebp
loc_41729:
mov rdi, [rbx+28h]
mov esi, ebp
mov edx, ebp
call ggml_set_i32_1d
inc ebp
cmp ebp, [rbx+8]
jl short loc_41729
jmp loc_417DE
loc_41742:
xorps xmm0, xmm0
movaps xmmword ptr [rsp+68h+var_58], xmm0
mov [rsp+68h+var_48], 0
mov [rsp+68h+var_5C], 0
xor r14d, r14d
cmp dword ptr [rbx+8], 0
jle short loc_417AB
lea r15, [rsp+68h+var_58]
lea r12, [rsp+68h+var_5C]
loc_4176E:
mov rsi, [rsp+68h+var_58+8]
cmp rsi, [rsp+68h+var_48]
jz short loc_41788
mov [rsi], r14d
add rsi, 4
mov [rsp+68h+var_58+8], rsi
jmp short loc_41793
loc_41788:
mov rdi, r15
mov rdx, r12
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
loc_41793:
mov r14d, [rsp+68h+var_5C]
inc r14d
mov [rsp+68h+var_5C], r14d
cmp r14d, [rbx+8]
jl short loc_4176E
mov r14, [rsp+68h+var_58]
loc_417AB:
mov rbx, [rbx+28h]
mov rdi, rbx
call ggml_nbytes
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, rax
call ggml_backend_tensor_set
mov rdi, [rsp+68h+var_58]; void *
test rdi, rdi
jz short loc_417DE
mov rsi, [rsp+68h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_417DE:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_417EF:
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_41809
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41809:
mov rdi, rbx
call __Unwind_Resume
|
void CLIPTextModel::init_params(long long a1, long long a2, long long a3, unsigned int a4, long long a5)
{
long long v7; // r13
long long v8; // r14
long long first_tensor; // rax
long long next_tensor; // r13
unsigned int v11; // ebp
void *v12; // r14
char *v13; // rsi
long long v14; // rbx
long long v15; // rax
int v16; // [rsp+Ch] [rbp-5Ch] BYREF
void *v17[2]; // [rsp+10h] [rbp-58h] BYREF
void *v18; // [rsp+20h] [rbp-48h]
long long v19; // [rsp+30h] [rbp-38h]
v19 = a3;
*(_QWORD *)(a1 + 40) = ggml_new_tensor_1d(a2, 18LL, *(int *)(a1 + 8));
*(_QWORD *)(a1 + 48) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 4));
*(_QWORD *)(a1 + 56) = ggml_new_tensor_2d(a2, a4, *(int *)(a1 + 12), *(int *)(a1 + 8));
if ( *(int *)(a1 + 24) > 0 )
{
v7 = 0LL;
v8 = 0LL;
do
{
ResidualAttentionBlock::init_params(v7 + *(_QWORD *)(a1 + 64), a2, a5, a4);
++v8;
v7 += 144LL;
}
while ( v8 < *(int *)(a1 + 24) );
}
*(_QWORD *)(a1 + 88) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
*(_QWORD *)(a1 + 96) = ggml_new_tensor_1d(a2, 0LL, *(int *)(a1 + 12));
if ( *(_DWORD *)a1 == 2 )
*(_QWORD *)(a1 + 104) = ggml_new_tensor_2d(a2, 0LL, *(int *)(a1 + 32), *(int *)(a1 + 12));
first_tensor = ggml_get_first_tensor(a2);
if ( first_tensor )
{
next_tensor = first_tensor;
do
{
if ( !*(_QWORD *)(next_tensor + 280) )
ggml_allocr_alloc(a5, next_tensor);
next_tensor = ggml_get_next_tensor(a2, next_tensor);
}
while ( next_tensor );
}
if ( (unsigned __int8)ggml_backend_is_cpu(v19) )
{
if ( *(int *)(a1 + 8) > 0 )
{
v11 = 0;
do
{
ggml_set_i32_1d(*(_QWORD *)(a1 + 40), v11, v11);
++v11;
}
while ( (signed int)v11 < *(_DWORD *)(a1 + 8) );
}
}
else
{
*(_OWORD *)v17 = 0LL;
v18 = 0LL;
v16 = 0;
v12 = 0LL;
if ( *(int *)(a1 + 8) > 0 )
{
do
{
v13 = (char *)v17[1];
if ( v17[1] == v18 )
{
std::vector<int>::_M_realloc_insert<int const&>((long long *)v17, (long long)v17[1], &v16);
}
else
{
*(_DWORD *)v17[1] = (_DWORD)v12;
v17[1] = v13 + 4;
}
LODWORD(v12) = v16 + 1;
v16 = (int)v12;
}
while ( (int)v12 < *(_DWORD *)(a1 + 8) );
v12 = v17[0];
}
v14 = *(_QWORD *)(a1 + 40);
v15 = ggml_nbytes(v14);
ggml_backend_tensor_set(v14, v12, 0LL, v15);
if ( v17[0] )
operator delete(v17[0], (unsigned long long)v18 - (unsigned long long)v17[0]);
}
}
| |||
9,689 |
js_array_at
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_at(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, ret;
int64_t len, idx;
ret = JS_EXCEPTION;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
if (JS_ToInt64Sat(ctx, &idx, argv[0]))
goto exception;
if (idx < 0)
idx = len + idx;
if (idx < 0 || idx >= len) {
ret = JS_UNDEFINED;
} else {
ret = JS_GetPropertyInt64(ctx, obj, idx);
}
exception:
JS_FreeValue(ctx, obj);
return ret;
}
|
O2
|
c
|
js_array_at:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r13
movq %rdi, %rbx
callq 0x20b92
movq %rax, %r14
movq %rdx, %r15
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x1cc43
pushq $0x6
popq %r12
testl %eax, %eax
jne 0x61af5
movq (%r13), %rdx
movq 0x8(%r13), %rcx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x21416
testl %eax, %eax
jne 0x61af5
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq %rax, %rcx
sarq $0x3f, %rcx
andq %rdx, %rcx
addq %rax, %rcx
setns %al
cmpq %rdx, %rcx
setl %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x61af1
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1e178
movq %rdx, %r12
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r13d
jmp 0x61afa
pushq $0x3
popq %r12
xorl %r13d, %r13d
xorl %ecx, %ecx
orq %rcx, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1801e
movq %r13, %rax
movq %r12, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
js_array_at:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r13, r8
mov rbx, rdi
call JS_ToObject
mov r14, rax
mov r15, rdx
lea rsi, [rsp+38h+var_30]
mov rdi, rbx
mov rdx, rax
mov rcx, r15
call js_get_length64
push 6
pop r12
test eax, eax
jnz short loc_61AF5
mov rdx, [r13+0]
mov rcx, [r13+8]
mov rsi, rsp
mov rdi, rbx
call JS_ToInt64Sat
test eax, eax
jnz short loc_61AF5
mov rax, [rsp+38h+var_38]
mov rdx, [rsp+38h+var_30]
mov rcx, rax
sar rcx, 3Fh
and rcx, rdx
add rcx, rax
setns al
cmp rcx, rdx
setl dl
and dl, al
cmp dl, 1
jnz short loc_61AF1
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_GetPropertyInt64
mov r12, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r13d, eax
jmp short loc_61AFA
loc_61AF1:
push 3
pop r12
loc_61AF5:
xor r13d, r13d
xor ecx, ecx
loc_61AFA:
or r13, rcx
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_FreeValue
mov rax, r13
mov rdx, r12
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
unsigned long long js_array_at(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // r14
long long v16; // rdx
long long v17; // r15
long long v18; // rcx
bool v19; // sf
signed long long v20; // rcx
unsigned long long PropertyInt64; // rax
unsigned long long v22; // rcx
long long v23; // r13
unsigned long long v24; // r13
long long v26; // [rsp+0h] [rbp-38h] BYREF
signed long long v27[6]; // [rsp+8h] [rbp-30h] BYREF
v15 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
if ( (unsigned int)js_get_length64(a1, v27, v15, v16)
|| (unsigned int)JS_ToInt64Sat(a1, (long long)&v26, *(_DWORD **)a5, *(_QWORD *)(a5 + 8))
|| (v18 = v27[0] & (v26 >> 63), v19 = v26 + v18 < 0, v20 = v26 + v18, v19 || v20 >= v27[0]) )
{
v23 = 0LL;
v22 = 0LL;
}
else
{
PropertyInt64 = JS_GetPropertyInt64(a1, v15, v17, v20);
v22 = PropertyInt64 & 0xFFFFFFFF00000000LL;
v23 = (unsigned int)PropertyInt64;
}
v24 = v22 | v23;
JS_FreeValue(a1, v15, v17);
return v24;
}
|
js_array_at:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R13,R8
MOV RBX,RDI
CALL 0x00120b92
MOV R14,RAX
MOV R15,RDX
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,RAX
MOV RCX,R15
CALL 0x0011cc43
PUSH 0x6
POP R12
TEST EAX,EAX
JNZ 0x00161af5
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00121416
TEST EAX,EAX
JNZ 0x00161af5
MOV RAX,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,RAX
SAR RCX,0x3f
AND RCX,RDX
ADD RCX,RAX
SETNS AL
CMP RCX,RDX
SETL DL
AND DL,AL
CMP DL,0x1
JNZ 0x00161af1
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011e178
MOV R12,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV R13D,EAX
JMP 0x00161afa
LAB_00161af1:
PUSH 0x3
POP R12
LAB_00161af5:
XOR R13D,R13D
XOR ECX,ECX
LAB_00161afa:
OR R13,RCX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011801e
MOV RAX,R13
MOV RDX,R12
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] js_array_at(int8 param_1)
{
int iVar1;
int8 uVar2;
ulong uVar3;
int8 *in_R8;
int8 uVar5;
ulong uVar6;
int1 auVar7 [16];
long local_38;
ulong local_30;
int8 uVar4;
auVar7 = JS_ToObject();
uVar4 = auVar7._8_8_;
uVar2 = auVar7._0_8_;
iVar1 = js_get_length64(param_1,&local_30,uVar2,uVar4);
uVar5 = 6;
if (iVar1 == 0) {
iVar1 = JS_ToInt64Sat(param_1,&local_38,*in_R8,in_R8[1]);
if (iVar1 == 0) {
local_38 = (local_38 >> 0x3f & local_30) + local_38;
if (local_38 < (long)local_30 && -1 < local_38) {
auVar7 = JS_GetPropertyInt64(param_1,uVar2,uVar4);
uVar5 = auVar7._8_8_;
uVar3 = auVar7._0_8_ & 0xffffffff00000000;
uVar6 = auVar7._0_8_ & 0xffffffff;
goto LAB_00161afa;
}
uVar5 = 3;
}
}
uVar6 = 0;
uVar3 = 0;
LAB_00161afa:
JS_FreeValue(param_1,uVar2,uVar4);
auVar7._8_8_ = uVar5;
auVar7._0_8_ = uVar6 | uVar3;
return auVar7;
}
|
|
9,690 |
plutovg_canvas_destroy
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c
|
void plutovg_canvas_destroy(plutovg_canvas_t* canvas)
{
if(canvas == NULL)
return;
if(--canvas->ref_count == 0) {
while(canvas->state) {
plutovg_state_t* state = canvas->state;
canvas->state = state->next;
plutovg_state_destroy(state);
}
while(canvas->freed_state) {
plutovg_state_t* state = canvas->freed_state;
canvas->freed_state = state->next;
plutovg_state_destroy(state);
}
plutovg_span_buffer_destroy(&canvas->fill_spans);
plutovg_span_buffer_destroy(&canvas->clip_spans);
plutovg_surface_destroy(canvas->surface);
plutovg_path_destroy(canvas->path);
free(canvas);
}
}
|
O1
|
c
|
plutovg_canvas_destroy:
pushq %rbx
testq %rdi, %rdi
je 0x235bf
movq %rdi, %rbx
decl (%rdi)
je 0x235d1
popq %rbx
retq
movq 0x98(%rdi), %rax
movq %rax, 0x18(%rbx)
callq 0x23622
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0x235c1
jmp 0x235ec
movq 0x98(%rdi), %rax
movq %rax, 0x20(%rbx)
callq 0x23622
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x235dc
leaq 0x58(%rbx), %rdi
callq 0x2cd2f
leaq 0x38(%rbx), %rdi
callq 0x2cd2f
movq 0x8(%rbx), %rdi
callq 0x2db55
movq 0x10(%rbx), %rdi
callq 0x2a24f
movq %rbx, %rdi
popq %rbx
jmp 0xa648
|
plutovg_canvas_destroy:
push rbx
test rdi, rdi
jz short loc_235BF
mov rbx, rdi
dec dword ptr [rdi]
jz short loc_235D1
loc_235BF:
pop rbx
retn
loc_235C1:
mov rax, [rdi+98h]
mov [rbx+18h], rax
call plutovg_state_destroy
loc_235D1:
mov rdi, [rbx+18h]
test rdi, rdi
jnz short loc_235C1
jmp short loc_235EC
loc_235DC:
mov rax, [rdi+98h]
mov [rbx+20h], rax
call plutovg_state_destroy
loc_235EC:
mov rdi, [rbx+20h]
test rdi, rdi
jnz short loc_235DC
lea rdi, [rbx+58h]
call plutovg_span_buffer_destroy
lea rdi, [rbx+38h]
call plutovg_span_buffer_destroy
mov rdi, [rbx+8]
call plutovg_surface_destroy
mov rdi, [rbx+10h]
call plutovg_path_destroy
mov rdi, rbx
pop rbx
jmp free
|
long long plutovg_canvas_destroy(long long a1)
{
long long v3; // rdi
long long v4; // rdi
long long result; // rax
if ( a1 )
{
if ( (*(_DWORD *)a1)-- == 1 )
{
while ( 1 )
{
v3 = *(_QWORD *)(a1 + 24);
if ( !v3 )
break;
*(_QWORD *)(a1 + 24) = *(_QWORD *)(v3 + 152);
plutovg_state_destroy();
}
while ( 1 )
{
v4 = *(_QWORD *)(a1 + 32);
if ( !v4 )
break;
*(_QWORD *)(a1 + 32) = *(_QWORD *)(v4 + 152);
plutovg_state_destroy();
}
plutovg_span_buffer_destroy(a1 + 88);
plutovg_span_buffer_destroy(a1 + 56);
plutovg_surface_destroy(*(_QWORD *)(a1 + 8));
plutovg_path_destroy(*(_QWORD *)(a1 + 16));
return free(a1);
}
}
return result;
}
|
plutovg_canvas_destroy:
PUSH RBX
TEST RDI,RDI
JZ 0x001235bf
MOV RBX,RDI
DEC dword ptr [RDI]
JZ 0x001235d1
LAB_001235bf:
POP RBX
RET
LAB_001235c1:
MOV RAX,qword ptr [RDI + 0x98]
MOV qword ptr [RBX + 0x18],RAX
CALL 0x00123622
LAB_001235d1:
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JNZ 0x001235c1
JMP 0x001235ec
LAB_001235dc:
MOV RAX,qword ptr [RDI + 0x98]
MOV qword ptr [RBX + 0x20],RAX
CALL 0x00123622
LAB_001235ec:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JNZ 0x001235dc
LEA RDI,[RBX + 0x58]
CALL 0x0012cd2f
LEA RDI,[RBX + 0x38]
CALL 0x0012cd2f
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x0012db55
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x0012a24f
MOV RDI,RBX
POP RBX
JMP 0x0010a648
|
void plutovg_canvas_destroy(int *param_1)
{
if ((param_1 != (int *)0x0) && (*param_1 = *param_1 + -1, *param_1 == 0)) {
while (*(long *)(param_1 + 6) != 0) {
*(int8 *)(param_1 + 6) = *(int8 *)(*(long *)(param_1 + 6) + 0x98);
plutovg_state_destroy();
}
while (*(long *)(param_1 + 8) != 0) {
*(int8 *)(param_1 + 8) = *(int8 *)(*(long *)(param_1 + 8) + 0x98);
plutovg_state_destroy();
}
plutovg_span_buffer_destroy(param_1 + 0x16);
plutovg_span_buffer_destroy(param_1 + 0xe);
plutovg_surface_destroy(*(int8 *)(param_1 + 2));
plutovg_path_destroy(*(int8 *)(param_1 + 4));
free(param_1);
return;
}
return;
}
|
|
9,691 |
llama_grammar_accept(llama_grammar*, unsigned int)
|
monkey531[P]llama/src/llama-grammar.cpp
|
void llama_grammar_accept(struct llama_grammar * grammar, uint32_t chr) {
llama_grammar_stacks stacks_new;
stacks_new.reserve(grammar->stacks.size());
for (const auto & stack : grammar->stacks) {
if (stack.empty()) {
continue;
}
auto match = llama_grammar_match_char(stack.back(), chr);
if (match.first) {
const llama_grammar_element * pos = match.second;
// update top of stack to next element, if any
llama_grammar_stack new_stack(stack.begin(), stack.end() - 1);
if (!llama_grammar_is_end_of_sequence(pos)) {
new_stack.push_back(pos);
}
llama_grammar_advance_stack(grammar->rules, new_stack, stacks_new);
}
}
grammar->stacks = std::move(stacks_new);
}
|
O3
|
cpp
|
llama_grammar_accept(llama_grammar*, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
movl %esi, %ebp
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
callq 0x68230
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
cmpq %r13, %r12
je 0xa44da
leaq 0x8(%rbx), %r14
leaq 0x18(%rsp), %r15
movq 0x8(%r12), %rax
cmpq %rax, (%r12)
je 0xa44c5
movq -0x8(%rax), %rdi
movl %ebp, %esi
callq 0xa4563
testb $0x1, %al
je 0xa44c5
movq %rdx, 0x10(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq $-0x8, %rdx
movq %r15, %rdi
leaq 0xf(%rsp), %rcx
callq 0x64d00
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
jb 0xa449e
movq 0x20(%rsp), %rsi
cmpq 0x28(%rsp), %rsi
je 0xa4491
movq %rax, (%rsi)
addq $0x8, 0x20(%rsp)
jmp 0xa449e
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
callq 0x653a0
movq %r14, %rdi
movq %r15, %rsi
leaq 0x30(%rsp), %rdx
callq 0xa45fa
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xa44c5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x681a0
addq $0x18, %r12
cmpq %r13, %r12
jne 0xa4433
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %rax
leaq 0x30(%rsp), %r14
movaps (%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x30(%rbx)
leaq 0x18(%rsp), %rdi
movq %r12, (%rdi)
movq %r13, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x6b6a0
movq %r14, %rdi
callq 0x6b6a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa454e
jmp 0xa454e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xa4551
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x681a0
jmp 0xa4551
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6b6a0
movq %rbx, %rdi
callq 0x6b5d0
|
_Z20llama_grammar_acceptP13llama_grammarj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
xorps xmm0, xmm0
lea rdi, [rsp+78h+var_48]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+28h]
sub rax, [rbx+20h]
mov ebp, esi
sar rax, 3
mov rsi, 0AAAAAAAAAAAAAAABh
imul rsi, rax
call __ZNSt6vectorIS_IPK21llama_grammar_elementSaIS2_EESaIS4_EE7reserveEm; std::vector<std::vector<llama_grammar_element const*>>::reserve(ulong)
mov r12, [rbx+20h]
mov r13, [rbx+28h]
cmp r12, r13
jz loc_A44DA
lea r14, [rbx+8]
lea r15, [rsp+78h+var_60]
loc_A4433:
mov rax, [r12+8]
cmp [r12], rax
jz loc_A44C5
mov rdi, [rax-8]
mov esi, ebp
call _ZL24llama_grammar_match_charPK21llama_grammar_elementj; llama_grammar_match_char(llama_grammar_element const*,uint)
test al, 1
jz short loc_A44C5
mov [rsp+78h+var_68], rdx
mov rsi, [r12]
mov rdx, [r12+8]
add rdx, 0FFFFFFFFFFFFFFF8h
mov rdi, r15
lea rcx, [rsp+78h+var_69]
call __ZNSt6vectorIPK21llama_grammar_elementSaIS2_EEC2IN9__gnu_cxx17__normal_iteratorIPKS2_S4_EEvEET_SB_RKS3_; std::vector<llama_grammar_element const*>::vector<__gnu_cxx::__normal_iterator<llama_grammar_element const* const*,std::vector<llama_grammar_element const*>>,void>(__gnu_cxx::__normal_iterator<llama_grammar_element const* const*,std::vector<llama_grammar_element const*>>,__gnu_cxx::__normal_iterator<llama_grammar_element const* const*,std::vector<llama_grammar_element const*>>,std::allocator<llama_grammar_element const*> const&)
mov rax, [rsp+78h+var_68]
cmp dword ptr [rax], 2
jb short loc_A449E
mov rsi, [rsp+78h+var_58]
cmp rsi, [rsp+78h+var_50]
jz short loc_A4491
mov [rsi], rax
add [rsp+78h+var_58], 8
jmp short loc_A449E
loc_A4491:
mov rdi, r15
lea rdx, [rsp+78h+var_68]
call __ZNSt6vectorIPK21llama_grammar_elementSaIS2_EE17_M_realloc_insertIJRKS2_EEEvN9__gnu_cxx17__normal_iteratorIPS2_S4_EEDpOT_; std::vector<llama_grammar_element const*>::_M_realloc_insert<llama_grammar_element const* const&>(__gnu_cxx::__normal_iterator<llama_grammar_element const**,std::vector<llama_grammar_element const*>>,llama_grammar_element const* const&)
loc_A449E:
mov rdi, r14
mov rsi, r15
lea rdx, [rsp+78h+var_48]
call _ZL27llama_grammar_advance_stackRKSt6vectorIS_I21llama_grammar_elementSaIS0_EESaIS2_EERKS_IPKS0_SaIS8_EERS_ISA_SaISA_EE; llama_grammar_advance_stack(std::vector<std::vector<llama_grammar_element>> const&,std::vector const&<llama_grammar_element const*,std::allocator<std::vector const&>>,std::vector&<llama_grammar_element const*,std::allocator<llama_grammar_element const*>>)
mov rdi, [rsp+78h+var_60]; void *
test rdi, rdi
jz short loc_A44C5
mov rsi, [rsp+78h+var_50]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A44C5:
add r12, 18h
cmp r12, r13
jnz loc_A4433
mov r12, [rbx+20h]
mov r13, [rbx+28h]
loc_A44DA:
mov rax, [rbx+30h]
lea r14, [rsp+78h+var_48]
movaps xmm0, xmmword ptr [r14]
movups xmmword ptr [rbx+20h], xmm0
mov rcx, [r14+10h]
mov [rbx+30h], rcx
lea rdi, [rsp+78h+var_60]
mov [rdi], r12
mov [rdi+8], r13
mov [rdi+10h], rax
xorps xmm0, xmm0
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+10h], 0
call __ZNSt6vectorIS_IPK21llama_grammar_elementSaIS2_EESaIS4_EED2Ev; std::vector<std::vector<llama_grammar_element const*>>::~vector()
mov rdi, r14
call __ZNSt6vectorIS_IPK21llama_grammar_elementSaIS2_EESaIS4_EED2Ev; std::vector<std::vector<llama_grammar_element const*>>::~vector()
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_A454E
jmp short loc_A454E
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
test rdi, rdi
jz short loc_A4551
mov rsi, [rsp+arg_20]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4551
loc_A454E:
mov rbx, rax
loc_A4551:
lea rdi, [rsp+arg_28]
call __ZNSt6vectorIS_IPK21llama_grammar_elementSaIS2_EESaIS4_EED2Ev; std::vector<std::vector<llama_grammar_element const*>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
long long llama_grammar_accept(_QWORD *a1, unsigned int a2)
{
char *v2; // r12
char *v3; // r13
long long v4; // rax
_DWORD *v5; // rdx
char *v6; // rax
char v8; // [rsp+Fh] [rbp-69h] BYREF
_DWORD *v9; // [rsp+10h] [rbp-68h] BYREF
void *v10; // [rsp+18h] [rbp-60h] BYREF
char *v11; // [rsp+20h] [rbp-58h]
char *v12; // [rsp+28h] [rbp-50h]
__int128 v13; // [rsp+30h] [rbp-48h] BYREF
long long v14; // [rsp+40h] [rbp-38h]
v13 = 0LL;
v14 = 0LL;
std::vector<std::vector<llama_grammar_element const*>>::reserve(
&v13,
0xAAAAAAAAAAAAAAABLL * ((long long)(a1[5] - a1[4]) >> 3));
v2 = (char *)a1[4];
v3 = (char *)a1[5];
if ( v2 != v3 )
{
do
{
v4 = *((_QWORD *)v2 + 1);
if ( *(_QWORD *)v2 != v4 && (llama_grammar_match_char(*(_QWORD *)(v4 - 8), a2) & 1) != 0 )
{
v9 = v5;
std::vector<llama_grammar_element const*>::vector<__gnu_cxx::__normal_iterator<llama_grammar_element const* const*,std::vector<llama_grammar_element const*>>,void>(
&v10,
*(_QWORD *)v2,
*((_QWORD *)v2 + 1) - 8LL,
&v8);
if ( *v9 >= 2u )
{
if ( v11 == v12 )
{
std::vector<llama_grammar_element const*>::_M_realloc_insert<llama_grammar_element const* const&>(
&v10,
v11,
&v9);
}
else
{
*(_QWORD *)v11 = v9;
v11 += 8;
}
}
llama_grammar_advance_stack(a1 + 1, &v10, &v13);
if ( v10 )
operator delete(v10, v12 - (_BYTE *)v10);
}
v2 += 24;
}
while ( v2 != v3 );
v2 = (char *)a1[4];
v3 = (char *)a1[5];
}
v6 = (char *)a1[6];
*((_OWORD *)a1 + 2) = v13;
a1[6] = v14;
v10 = v2;
v11 = v3;
v12 = v6;
v13 = 0LL;
v14 = 0LL;
((void (*)(void))std::vector<std::vector<llama_grammar_element const*>>::~vector)();
return std::vector<std::vector<llama_grammar_element const*>>::~vector(&v13);
}
|
llama_grammar_accept:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RBX + 0x28]
SUB RAX,qword ptr [RBX + 0x20]
MOV EBP,ESI
SAR RAX,0x3
MOV RSI,-0x5555555555555555
IMUL RSI,RAX
LAB_001a4414:
CALL 0x00168230
MOV R12,qword ptr [RBX + 0x20]
MOV R13,qword ptr [RBX + 0x28]
CMP R12,R13
JZ 0x001a44da
LEA R14,[RBX + 0x8]
LEA R15,[RSP + 0x18]
LAB_001a4433:
MOV RAX,qword ptr [R12 + 0x8]
CMP qword ptr [R12],RAX
JZ 0x001a44c5
MOV RDI,qword ptr [RAX + -0x8]
LAB_001a4446:
MOV ESI,EBP
CALL 0x001a4563
TEST AL,0x1
JZ 0x001a44c5
MOV qword ptr [RSP + 0x10],RDX
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
ADD RDX,-0x8
LAB_001a4463:
MOV RDI,R15
LEA RCX,[RSP + 0xf]
CALL 0x00164d00
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX],0x2
JC 0x001a449e
MOV RSI,qword ptr [RSP + 0x20]
CMP RSI,qword ptr [RSP + 0x28]
JZ 0x001a4491
MOV qword ptr [RSI],RAX
ADD qword ptr [RSP + 0x20],0x8
JMP 0x001a449e
LAB_001a4491:
MOV RDI,R15
LEA RDX,[RSP + 0x10]
CALL 0x001653a0
LAB_001a449e:
MOV RDI,R14
MOV RSI,R15
LEA RDX,[RSP + 0x30]
CALL 0x001a45fa
LAB_001a44ae:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x001a44c5
MOV RSI,qword ptr [RSP + 0x28]
SUB RSI,RDI
CALL 0x001681a0
LAB_001a44c5:
ADD R12,0x18
CMP R12,R13
JNZ 0x001a4433
MOV R12,qword ptr [RBX + 0x20]
MOV R13,qword ptr [RBX + 0x28]
LAB_001a44da:
MOV RAX,qword ptr [RBX + 0x30]
LEA R14,[RSP + 0x30]
MOVAPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x30],RCX
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],R13
MOV qword ptr [RDI + 0x10],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0x10],0x0
CALL 0x0016b6a0
MOV RDI,R14
CALL 0x0016b6a0
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* llama_grammar_accept(llama_grammar*, unsigned int) */
void llama_grammar_accept(llama_grammar *param_1,uint param_2)
{
long *plVar1;
long *plVar2;
int1 auVar3 [16];
int1 local_69;
uint *local_68;
long *local_60;
long *local_58;
int8 *local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
/* try { // try from 001a4414 to 001a4418 has its CatchHandler @ 001a452e */
std::
vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
::reserve((vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
*)&local_48,
(*(long *)(param_1 + 0x28) - *(long *)(param_1 + 0x20) >> 3) * -0x5555555555555555);
plVar1 = *(long **)(param_1 + 0x20);
plVar2 = *(long **)(param_1 + 0x28);
if (plVar1 != plVar2) {
do {
if (*plVar1 != plVar1[1]) {
/* try { // try from 001a4446 to 001a444c has its CatchHandler @ 001a454e */
auVar3 = llama_grammar_match_char(*(llama_grammar_element **)(plVar1[1] + -8),param_2);
if ((auVar3 & (int1 [16])0x1) != (int1 [16])0x0) {
/* try { // try from 001a4463 to 001a446f has its CatchHandler @ 001a4530 */
local_68 = auVar3._8_8_;
std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>::
vector<__gnu_cxx::__normal_iterator<llama_grammar_element_const*const*,std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>,void>
((vector *)&local_60,*plVar1,plVar1[1] + -8,&local_69);
if (1 < *local_68) {
if (local_58 == local_50) {
/* try { // try from 001a4491 to 001a44ad has its CatchHandler @ 001a4532 */
std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>
::_M_realloc_insert<llama_grammar_element_const*const&>
((vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>
*)&local_60,local_58,&local_68);
}
else {
*local_58 = (long)local_68;
local_58 = local_58 + 1;
}
}
llama_grammar_advance_stack
((vector *)(param_1 + 8),(vector *)&local_60,(vector *)&local_48);
if (local_60 != (long *)0x0) {
operator_delete(local_60,(long)local_50 - (long)local_60);
}
}
}
plVar1 = plVar1 + 3;
} while (plVar1 != plVar2);
plVar1 = *(long **)(param_1 + 0x20);
plVar2 = *(long **)(param_1 + 0x28);
}
local_50 = *(int8 **)(param_1 + 0x30);
*(int8 *)(param_1 + 0x20) = local_48;
*(int8 *)(param_1 + 0x28) = uStack_40;
*(int8 *)(param_1 + 0x30) = local_38;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
local_60 = plVar1;
local_58 = plVar2;
std::
vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
::~vector((vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
*)&local_60);
std::
vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
::~vector((vector<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>,std::allocator<std::vector<llama_grammar_element_const*,std::allocator<llama_grammar_element_const*>>>>
*)&local_48);
return;
}
|
|
9,692 |
my_hash_sort_utf16_nopad
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_utf16_nopad(CHARSET_INFO *cs,
const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res= mb_wc(cs, &wc, (uchar *) s, (uchar *) e)) > 0)
{
my_tosort_utf16(uni_plane, &wc);
MY_HASH_ADD_16(m1, m2, wc);
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_utf16_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq (%rcx), %rbx
movq %r8, -0x48(%rbp)
movq (%r8), %r14
testq %rdx, %rdx
jle 0x5b9c1
movq %rdx, %r15
movq %rsi, %r12
movq 0x78(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
addq %rsi, %r15
movq %rdi, %r13
leaq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq *-0x50(%rbp)
testl %eax, %eax
jle 0x5b9c1
movq -0x38(%rbp), %rdx
movl $0xfffd, %esi # imm = 0xFFFD
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rdx
movq %r13, %rdi
ja 0x5b96a
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq %rdx, %rcx
shrq $0x8, %rcx
movq (%rsi,%rcx,8), %rsi
testq %rsi, %rsi
je 0x5b976
movzbl %dl, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rsi,%rcx,4), %esi
movq %rsi, -0x38(%rbp)
movl %esi, %ecx
shrl $0x8, %ecx
movq %rsi, %rdx
movl %ebx, %esi
andl $0x3f, %esi
addq %r14, %rsi
movzbl %dl, %edx
imulq %rsi, %rdx
movq %rbx, %rsi
shlq $0x8, %rsi
addq %rdx, %rsi
xorq %rbx, %rsi
movl %esi, %edx
andl $0x3f, %edx
addq %r14, %rdx
addq $0x3, %rdx
imulq %rcx, %rdx
movq %rsi, %rbx
shlq $0x8, %rbx
addq %rdx, %rbx
xorq %rsi, %rbx
addq $0x6, %r14
movl %eax, %eax
addq %rax, %r12
cmpq %r15, %r12
jb 0x5b91a
movq -0x40(%rbp), %rax
movq %rbx, (%rax)
movq -0x48(%rbp), %rax
movq %r14, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_sort_utf16_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_40], rcx
mov rbx, [rcx]
mov [rbp+var_48], r8
mov r14, [r8]
test rdx, rdx
jle loc_5B9C1
mov r15, rdx
mov r12, rsi
mov rax, [rdi+78h]
mov [rbp+var_30], rax
mov rax, [rdi+0B8h]
mov rax, [rax+28h]
mov [rbp+var_50], rax
add r15, rsi
loc_5B91A:
mov r13, rdi
lea rsi, [rbp+var_38]
mov rdx, r12
mov rcx, r15
call [rbp+var_50]
test eax, eax
jle loc_5B9C1
mov rdx, [rbp+var_38]
mov esi, 0FFFDh
mov rcx, [rbp+var_30]
cmp rdx, [rcx]
mov rdi, r13
ja short loc_5B96A
mov rcx, [rbp+var_30]
mov rsi, [rcx+8]
mov rcx, rdx
shr rcx, 8
mov rsi, [rsi+rcx*8]
test rsi, rsi
jz short loc_5B976
movzx ecx, dl
lea rcx, [rcx+rcx*2]
mov esi, [rsi+rcx*4+8]
loc_5B96A:
mov [rbp+var_38], rsi
mov ecx, esi
shr ecx, 8
mov rdx, rsi
loc_5B976:
mov esi, ebx
and esi, 3Fh
add rsi, r14
movzx edx, dl
imul rdx, rsi
mov rsi, rbx
shl rsi, 8
add rsi, rdx
xor rsi, rbx
mov edx, esi
and edx, 3Fh
add rdx, r14
add rdx, 3
imul rdx, rcx
mov rbx, rsi
shl rbx, 8
add rbx, rdx
xor rbx, rsi
add r14, 6
mov eax, eax
add r12, rax
cmp r12, r15
jb loc_5B91A
loc_5B9C1:
mov rax, [rbp+var_40]
mov [rax], rbx
mov rax, [rbp+var_48]
mov [rax], r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * my_hash_sort_utf16_nopad(long long a1, unsigned long long a2, long long a3, long long *a4, _QWORD *a5)
{
long long v5; // rbx
long long v6; // r14
unsigned long long v7; // r12
unsigned long long v8; // r15
int v9; // eax
unsigned __int8 v10; // dl
long long v11; // rsi
unsigned long long v12; // rcx
long long v13; // rsi
long long v14; // rsi
_QWORD *result; // rax
long long ( *v16)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+0h] [rbp-50h]
unsigned long long v19; // [rsp+18h] [rbp-38h] BYREF
unsigned long long *v20; // [rsp+20h] [rbp-30h]
v5 = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = a2;
v20 = *(unsigned long long **)(a1 + 120);
v16 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v8 = a2 + a3;
while ( 1 )
{
v9 = v16(a1, &v19, v7, v8);
if ( v9 <= 0 )
goto LABEL_9;
v10 = v19;
v11 = 65533LL;
if ( v19 > *v20 )
goto LABEL_7;
v12 = v19 >> 8;
v13 = *(_QWORD *)(v20[1] + 8 * (v19 >> 8));
if ( v13 )
break;
LABEL_8:
v14 = v5 ^ ((v6 + (v5 & 0x3F)) * v10 + (v5 << 8));
v5 = v14 ^ (v12 * (v6 + (((unsigned __int8)v5 ^ (unsigned __int8)((v6 + (v5 & 0x3F)) * v10)) & 0x3F) + 3)
+ (v14 << 8));
v6 += 6LL;
v7 += (unsigned int)v9;
if ( v7 >= v8 )
goto LABEL_9;
}
v11 = *(unsigned int *)(v13 + 12LL * (unsigned __int8)v19 + 8);
LABEL_7:
v19 = v11;
v12 = (unsigned int)v11 >> 8;
v10 = v11;
goto LABEL_8;
}
LABEL_9:
*a4 = v5;
result = a5;
*a5 = v6;
return result;
}
|
my_hash_sort_utf16_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x40],RCX
MOV RBX,qword ptr [RCX]
MOV qword ptr [RBP + -0x48],R8
MOV R14,qword ptr [R8]
TEST RDX,RDX
JLE 0x0015b9c1
MOV R15,RDX
MOV R12,RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x50],RAX
ADD R15,RSI
LAB_0015b91a:
MOV R13,RDI
LEA RSI,[RBP + -0x38]
MOV RDX,R12
MOV RCX,R15
CALL qword ptr [RBP + -0x50]
TEST EAX,EAX
JLE 0x0015b9c1
MOV RDX,qword ptr [RBP + -0x38]
MOV ESI,0xfffd
MOV RCX,qword ptr [RBP + -0x30]
CMP RDX,qword ptr [RCX]
MOV RDI,R13
JA 0x0015b96a
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x8]
MOV RCX,RDX
SHR RCX,0x8
MOV RSI,qword ptr [RSI + RCX*0x8]
TEST RSI,RSI
JZ 0x0015b976
MOVZX ECX,DL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RSI + RCX*0x4 + 0x8]
LAB_0015b96a:
MOV qword ptr [RBP + -0x38],RSI
MOV ECX,ESI
SHR ECX,0x8
MOV RDX,RSI
LAB_0015b976:
MOV ESI,EBX
AND ESI,0x3f
ADD RSI,R14
MOVZX EDX,DL
IMUL RDX,RSI
MOV RSI,RBX
SHL RSI,0x8
ADD RSI,RDX
XOR RSI,RBX
MOV EDX,ESI
AND EDX,0x3f
ADD RDX,R14
ADD RDX,0x3
IMUL RDX,RCX
MOV RBX,RSI
SHL RBX,0x8
ADD RBX,RDX
XOR RBX,RSI
ADD R14,0x6
MOV EAX,EAX
ADD R12,RAX
CMP R12,R15
JC 0x0015b91a
LAB_0015b9c1:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RBX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_hash_sort_utf16_nopad(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
code *pcVar1;
long lVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
ulong local_40;
ulong *local_38;
uVar6 = *param_4;
lVar7 = *param_5;
if (0 < param_3) {
local_38 = *(ulong **)(param_1 + 0x78);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
uVar8 = param_3 + param_2;
do {
uVar3 = (*pcVar1)(param_1,&local_40,param_2,uVar8);
if ((int)uVar3 < 1) break;
uVar5 = 0xfffd;
if (*local_38 < local_40) {
LAB_0015b96a:
uVar4 = uVar5 >> 8;
local_40 = uVar5;
}
else {
uVar4 = local_40 >> 8;
lVar2 = *(long *)(local_38[1] + uVar4 * 8);
if (lVar2 != 0) {
uVar5 = (ulong)*(uint *)(lVar2 + 8 + (local_40 & 0xff) * 0xc);
goto LAB_0015b96a;
}
}
uVar6 = uVar6 * 0x100 + (local_40 & 0xff) * ((ulong)((uint)uVar6 & 0x3f) + lVar7) ^ uVar6;
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar7 + 3) * uVar4 ^ uVar6;
lVar7 = lVar7 + 6;
param_2 = param_2 + uVar3;
} while (param_2 < uVar8);
}
*param_4 = uVar6;
*param_5 = lVar7;
return;
}
|
|
9,693 |
fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/common.cpp
|
bool fs_validate_filename(const std::string & filename) {
if (!filename.length()) {
// Empty filename invalid
return false;
}
if (filename.length() > 255) {
// Limit at common largest possible filename on Linux filesystems
// to avoid unnecessary further validation
// (On systems with smaller limits it will be caught by the OS)
return false;
}
std::u32string filename_utf32;
try {
#if defined(__clang__)
// disable C++17 deprecation warning for std::codecvt_utf8
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
filename_utf32 = converter.from_bytes(filename);
// If the reverse conversion mismatches, it means overlong UTF-8 sequences were used,
// or invalid encodings were encountered. Reject such attempts
std::string filename_reencoded = converter.to_bytes(filename_utf32);
if (filename_reencoded != filename) {
return false;
}
} catch (const std::exception &) {
return false;
}
// Check for forbidden codepoints:
// - Control characters
// - Unicode equivalents of illegal characters
// - UTF-16 surrogate pairs
// - UTF-8 replacement character
// - Byte order mark (BOM)
// - Illegal characters: / \ : * ? " < > |
for (char32_t c : filename_utf32) {
if (c <= 0x1F // Control characters (C0)
|| c == 0x7F // Control characters (DEL)
|| (c >= 0x80 && c <= 0x9F) // Control characters (C1)
|| c == 0xFF0E // Fullwidth Full Stop (period equivalent)
|| c == 0x2215 // Division Slash (forward slash equivalent)
|| c == 0x2216 // Set Minus (backslash equivalent)
|| (c >= 0xD800 && c <= 0xDFFF) // UTF-16 surrogate pairs
|| c == 0xFFFD // Replacement Character (UTF-8)
|| c == 0xFEFF // Byte Order Mark (BOM)
|| c == '/' || c == '\\' || c == ':' || c == '*' // Illegal characters
|| c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
return false;
}
}
// Reject any leading or trailing ' ', or any trailing '.', these are stripped on Windows and will cause a different filename
// Unicode and other whitespace is not affected, only 0x20 space
if (filename.front() == ' ' || filename.back() == ' ' || filename.back() == '.') {
return false;
}
// Reject any ".." (currently stricter than necessary, it should be fine to just check for == ".." instead)
if (filename.find("..") != std::string::npos) {
return false;
}
// Reject "."
if (filename == ".") {
return false;
}
return true;
}
|
O2
|
cpp
|
fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq $-0x100, %rax
addq 0x8(%rdi), %rax
cmpq $-0xff, %rax
jae 0x3f3ce
xorl %r14d, %r14d
jmp 0x3f463
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x4323c
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x4329a
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x432b6
movq %r15, %rdi
callq 0x43360
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x43370
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4338c
movl %eax, %ebp
movq %r14, %rdi
callq 0x22f98
leaq 0x48(%rsp), %rdi
callq 0x43396
testb %bpl, %bpl
je 0x3f474
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x43360
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0x2, %rcx
xorl %edx, %edx
movabsq $0x400000035002101, %rsi # imm = 0x400000035002101
cmpq %rdx, %rcx
je 0x3f527
movl (%rax,%rdx), %edi
xorl %r14d, %r14d
cmpl $0x20, %edi
jb 0x3f459
cmpl $0x7f, %edi
je 0x3f459
movl %edi, %r8d
andl $-0x20, %r8d
cmpl $0x80, %r8d
je 0x3f459
xorl %r14d, %r14d
leal -0x2215(%rdi), %r8d
cmpl $0x2, %r8d
jb 0x3f459
cmpl $0xff0e, %edi # imm = 0xFF0E
je 0x3f459
movl %edi, %r8d
andl $0xfffff800, %r8d # imm = 0xFFFFF800
cmpl $0xd800, %r8d # imm = 0xD800
je 0x3f456
xorl %r14d, %r14d
leal -0x22(%rdi), %r8d
cmpl $0x3a, %r8d
ja 0x3f4fd
btq %r8, %rsi
jb 0x3f459
cmpl $0x7c, %edi
je 0x3f459
cmpl $0xfeff, %edi # imm = 0xFEFF
je 0x3f459
addq $0x4, %rdx
cmpl $0xfffd, %edi # imm = 0xFFFD
jne 0x3f48e
jmp 0x3f459
movq (%rbx), %rax
cmpb $0x20, (%rax)
je 0x3f456
movq 0x8(%rbx), %rcx
movzbl -0x1(%rax,%rcx), %eax
xorl %r14d, %r14d
cmpl $0x20, %eax
je 0x3f459
cmpl $0x2e, %eax
je 0x3f459
leaq 0x5d911(%rip), %rsi # 0x9ce69
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22f50
cmpq $-0x1, %rax
jne 0x3f459
leaq 0x5d8f4(%rip), %rsi # 0x9ce6a
movq %rbx, %rdi
callq 0x29b97
movl %eax, %r14d
xorb $0x1, %r14b
jmp 0x3f459
jmp 0x3f58c
movq %rdx, %r14
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x43396
jmp 0x3f5a4
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3f5bf
movq %rbx, %rdi
callq 0x22300
callq 0x22ca0
jmp 0x3f456
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x43360
movq %rbx, %rdi
callq 0x22da0
|
_Z20fs_validate_filenameRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 0A8h
mov rax, 0FFFFFFFFFFFFFF00h
add rax, [rdi+8]
cmp rax, 0FFFFFFFFFFFFFF01h
jnb short loc_3F3CE
xor r14d, r14d
jmp loc_3F463
loc_3F3CE:
mov rbx, rdi
lea rax, [rsp+0C8h+var_B0]
mov [rax-10h], rax
and qword ptr [rax-8], 0
and dword ptr [rax], 0
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEEC2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(void)
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_80]
mov rdx, rbx
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE10from_bytesERKNS_12basic_stringIcSt11char_traitsIcES5_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(std::string const&)
lea r14, [rsp+0C8h+var_C0]
lea r15, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEaSEOS4_; std::basic_string<char32_t>::operator=(std::basic_string<char32_t>&&)
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_80]
mov rdx, r14
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE8to_bytesERKNS_12basic_stringIDiSt11char_traitsIDiES4_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(std::basic_string<char32_t> const&)
lea r14, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, rbx
call _ZStneIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator!=<char>(std::string const&,std::string const&)
mov ebp, eax
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
test bpl, bpl
jz short loc_3F474
loc_3F456:
xor r14d, r14d
loc_3F459:
lea rdi, [rsp+0C8h+var_C0]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
loc_3F463:
mov eax, r14d
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3F474:
mov rax, [rsp+0C8h+var_C0]
mov rcx, [rsp+0C8h+var_B8]
shl rcx, 2
xor edx, edx
mov rsi, 400000035002101h
loc_3F48E:
cmp rcx, rdx
jz loc_3F527
mov edi, [rax+rdx]
xor r14d, r14d
cmp edi, 20h ; ' '
jb short loc_3F459
cmp edi, 7Fh
jz short loc_3F459
mov r8d, edi
and r8d, 0FFFFFFE0h
cmp r8d, 80h
jz short loc_3F459
xor r14d, r14d
lea r8d, [rdi-2215h]
cmp r8d, 2
jb short loc_3F459
cmp edi, 0FF0Eh
jz short loc_3F459
mov r8d, edi
and r8d, 0FFFFF800h
cmp r8d, 0D800h
jz loc_3F456
xor r14d, r14d
lea r8d, [rdi-22h]
cmp r8d, 3Ah ; ':'
ja short loc_3F4FD
bt rsi, r8
jb loc_3F459
loc_3F4FD:
cmp edi, 7Ch ; '|'
jz loc_3F459
cmp edi, 0FEFFh
jz loc_3F459
add rdx, 4
cmp edi, 0FFFDh
jnz loc_3F48E
jmp loc_3F459
loc_3F527:
mov rax, [rbx]
cmp byte ptr [rax], 20h ; ' '
jz loc_3F456
mov rcx, [rbx+8]
movzx eax, byte ptr [rax+rcx-1]
xor r14d, r14d
cmp eax, 20h ; ' '
jz loc_3F459
cmp eax, 2Eh ; '.'
jz loc_3F459
lea rsi, asc_9CE69; ".."
xor r14d, r14d
mov rdi, rbx
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz loc_3F459
lea rsi, asc_9CE69+1; "."
mov rdi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov r14d, eax
xor r14b, 1
jmp loc_3F459
jmp short $+2
loc_3F58C:
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+0C8h+var_80]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
jmp short loc_3F5A4
mov r14, rdx
mov rbx, rax
loc_3F5A4:
cmp r14d, 1
jnz short loc_3F5BF
mov rdi, rbx; void *
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_3F456
mov rbx, rax
loc_3F5BF:
lea rdi, [rsp+0C8h+var_C0]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
mov rdi, rbx
call __Unwind_Resume
|
long long fs_validate_filename(_QWORD *a1)
{
unsigned int v1; // r14d
char v3; // bp
long long v5; // rdx
long long v6; // rsi
unsigned int v7; // edi
unsigned long long v8; // r8
int v9; // eax
unsigned int v10; // eax
int *v11; // [rsp+8h] [rbp-C0h] BYREF
long long v12; // [rsp+10h] [rbp-B8h]
int v13; // [rsp+18h] [rbp-B0h] BYREF
_BYTE v14[32]; // [rsp+28h] [rbp-A0h] BYREF
_BYTE v15[128]; // [rsp+48h] [rbp-80h] BYREF
if ( (unsigned long long)(a1[1] - 256LL) >= 0xFFFFFFFFFFFFFF01LL )
{
v11 = &v13;
v12 = 0LL;
v13 = 0;
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(v15);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(
v14,
v15,
a1);
std::basic_string<char32_t>::operator=(&v11, v14);
std::basic_string<char32_t>::~basic_string(v14);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(
v14,
v15,
&v11);
v3 = std::operator!=<char>(v14, a1);
std::string::~string(v14);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert(v15);
if ( v3 )
goto LABEL_4;
v5 = 0LL;
v6 = 0x400000035002101LL;
while ( v12 != v5 )
{
v7 = v11[v5];
v1 = 0;
if ( v7 >= 0x20 && v7 != 127 && (v7 & 0xFFFFFFE0) != 0x80 )
{
v1 = 0;
if ( v7 - 8725 >= 2 && v7 != 65294 )
{
if ( (v7 & 0xFFFFF800) == 0xD800 )
goto LABEL_4;
v1 = 0;
v8 = v7 - 34;
if ( ((unsigned int)v8 > 0x3A || !_bittest64(&v6, v8)) && v7 != 124 && v7 != 65279 )
{
++v5;
if ( v7 != 65533 )
continue;
}
}
}
goto LABEL_5;
}
if ( *(_BYTE *)*a1 == 32 )
{
LABEL_4:
v1 = 0;
}
else
{
v9 = *(unsigned __int8 *)(*a1 + a1[1] - 1LL);
v1 = 0;
if ( v9 != 32 && v9 != 46 )
{
v1 = 0;
if ( std::string::find(a1, "..", 0LL) == -1 )
{
LOBYTE(v10) = std::operator==<char>((long long)a1);
v1 = v10;
LOBYTE(v1) = v10 ^ 1;
}
}
}
LABEL_5:
std::basic_string<char32_t>::~basic_string(&v11);
}
else
{
return 0;
}
return v1;
}
|
fs_validate_filename:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV RAX,-0x100
ADD RAX,qword ptr [RDI + 0x8]
CMP RAX,-0xff
JNC 0x0013f3ce
XOR R14D,R14D
JMP 0x0013f463
LAB_0013f3ce:
MOV RBX,RDI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
AND dword ptr [RAX],0x0
LAB_0013f3e2:
LEA RDI,[RSP + 0x48]
CALL 0x0014323c
LAB_0013f3ec:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
MOV RDX,RBX
CALL 0x0014329a
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R14
MOV RSI,R15
CALL 0x001432b6
MOV RDI,R15
CALL 0x00143360
LAB_0013f41b:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x48]
MOV RDX,R14
CALL 0x00143370
LAB_0013f42d:
LEA R14,[RSP + 0x28]
MOV RDI,R14
MOV RSI,RBX
CALL 0x0014338c
MOV EBP,EAX
MOV RDI,R14
CALL 0x00122f98
LEA RDI,[RSP + 0x48]
CALL 0x00143396
TEST BPL,BPL
JZ 0x0013f474
LAB_0013f456:
XOR R14D,R14D
LAB_0013f459:
LEA RDI,[RSP + 0x8]
CALL 0x00143360
LAB_0013f463:
MOV EAX,R14D
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013f474:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
SHL RCX,0x2
XOR EDX,EDX
MOV RSI,0x400000035002101
LAB_0013f48e:
CMP RCX,RDX
JZ 0x0013f527
MOV EDI,dword ptr [RAX + RDX*0x1]
XOR R14D,R14D
CMP EDI,0x20
JC 0x0013f459
CMP EDI,0x7f
JZ 0x0013f459
MOV R8D,EDI
AND R8D,0xffffffe0
CMP R8D,0x80
JZ 0x0013f459
XOR R14D,R14D
LEA R8D,[RDI + -0x2215]
CMP R8D,0x2
JC 0x0013f459
CMP EDI,0xff0e
JZ 0x0013f459
MOV R8D,EDI
AND R8D,0xfffff800
CMP R8D,0xd800
JZ 0x0013f456
XOR R14D,R14D
LEA R8D,[RDI + -0x22]
CMP R8D,0x3a
JA 0x0013f4fd
BT RSI,R8
JC 0x0013f459
LAB_0013f4fd:
CMP EDI,0x7c
JZ 0x0013f459
CMP EDI,0xfeff
JZ 0x0013f459
ADD RDX,0x4
CMP EDI,0xfffd
JNZ 0x0013f48e
JMP 0x0013f459
LAB_0013f527:
MOV RAX,qword ptr [RBX]
CMP byte ptr [RAX],0x20
JZ 0x0013f456
MOV RCX,qword ptr [RBX + 0x8]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
XOR R14D,R14D
CMP EAX,0x20
JZ 0x0013f459
CMP EAX,0x2e
JZ 0x0013f459
LEA RSI,[0x19ce69]
XOR R14D,R14D
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00122f50
CMP RAX,-0x1
JNZ 0x0013f459
LEA RSI,[0x19ce6a]
MOV RDI,RBX
CALL 0x00129b97
MOV R14D,EAX
XOR R14B,0x1
JMP 0x0013f459
|
/* fs_validate_filename(std::__cxx11::string const&) */
ulong fs_validate_filename(string *param_1)
{
char cVar1;
uint uVar2;
bool bVar3;
int7 extraout_var;
long lVar4;
ulong uVar5;
int4 *local_c0;
long local_b8;
int4 local_b0 [4];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_a0 [32];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_80 [96];
if (*(long *)(param_1 + 8) - 0x100U < 0xffffffffffffff01) {
uVar5 = 0;
}
else {
local_c0 = local_b0;
local_b8 = 0;
local_b0[0] = 0;
/* try { // try from 0013f3e2 to 0013f3eb has its CatchHandler @ 0013f59e */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::wstring_convert(local_80);
/* try { // try from 0013f3ec to 0013f3fd has its CatchHandler @ 0013f58c */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::from_bytes(local_a0,(string *)local_80);
std::__cxx11::u32string::operator=((u32string *)&local_c0,(u32string *)local_a0);
std::__cxx11::u32string::~u32string((u32string *)local_a0);
/* try { // try from 0013f41b to 0013f42c has its CatchHandler @ 0013f58a */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::to_bytes(local_a0,(u32string *)local_80);
bVar3 = std::operator!=((string *)local_a0,param_1);
std::__cxx11::string::~string((string *)local_a0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::~wstring_convert(local_80);
if (bVar3) {
LAB_0013f456:
uVar5 = 0;
}
else {
lVar4 = 0;
while (local_b8 << 2 != lVar4) {
uVar2 = *(uint *)((long)local_c0 + lVar4);
uVar5 = 0;
if ((((uVar2 < 0x20) || (uVar2 == 0x7f)) || ((uVar2 & 0xffffffe0) == 0x80)) ||
((uVar5 = 0, uVar2 - 0x2215 < 2 || (uVar2 == 0xff0e)))) goto LAB_0013f459;
if ((uVar2 & 0xfffff800) == 0xd800) goto LAB_0013f456;
uVar5 = 0;
if (((uVar2 - 0x22 < 0x3b) &&
((0x400000035002101U >> ((ulong)(uVar2 - 0x22) & 0x3f) & 1) != 0)) ||
((uVar2 == 0x7c || ((uVar2 == 0xfeff || (lVar4 = lVar4 + 4, uVar2 == 0xfffd))))))
goto LAB_0013f459;
}
if (**(char **)param_1 == ' ') goto LAB_0013f456;
cVar1 = (*(char **)param_1)[*(long *)(param_1 + 8) + -1];
uVar5 = 0;
if ((cVar1 != ' ') && (cVar1 != '.')) {
uVar5 = 0;
lVar4 = std::__cxx11::string::find((char *)param_1,0x19ce69);
if (lVar4 == -1) {
bVar3 = std::operator==(param_1,".");
uVar5 = CONCAT71(extraout_var,bVar3) & 0xffffffff ^ 1;
}
}
}
LAB_0013f459:
std::__cxx11::u32string::~u32string((u32string *)&local_c0);
}
return uVar5;
}
|
|
9,694 |
safe_hash_init
|
eloqsql/mysys/my_safehash.c
|
my_bool safe_hash_init(SAFE_HASH *hash, uint elements,
uchar *default_value)
{
DBUG_ENTER("safe_hash_init");
if (my_hash_init(key_memory_SAFE_HASH_ENTRY, &hash->hash, &my_charset_bin,
elements, 0, 0, (my_hash_get_key) safe_hash_entry_get,
(void (*)(void*)) safe_hash_entry_free, 0))
{
hash->default_value= 0;
DBUG_RETURN(1);
}
mysql_rwlock_init(key_SAFEHASH_mutex, &hash->mutex);
hash->default_value= default_value;
hash->root= 0;
DBUG_RETURN(0);
}
|
O0
|
c
|
safe_hash_init:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xb8404a(%rip), %rax # 0xc81c64
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x98, %rsi
movl -0x14(%rbp), %eax
movl %eax, %r8d
xorl %edx, %edx
leaq 0x1c44da(%rip), %rcx # 0x2c2110
xorl %eax, %eax
movl %eax, %r9d
leaq 0x8e(%rip), %r10 # 0xfdcd0
leaq 0xb7(%rip), %rax # 0xfdd00
movq $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
callq 0xdd440
cmpb $0x0, %al
je 0xfdc8a
movq -0x10(%rbp), %rax
movq $0x0, 0x108(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xfdcbe
leaq 0xb83677(%rip), %rax # 0xc81308
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xfdd20
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x110(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
safe_hash_init:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
lea rax, key_memory_SAFE_HASH_ENTRY
mov edi, [rax]
mov rsi, [rbp+var_10]
add rsi, 98h
mov eax, [rbp+var_14]
mov r8d, eax
xor edx, edx
lea rcx, my_charset_bin
xor eax, eax
mov r9d, eax
lea r10, safe_hash_entry_get
lea rax, safe_hash_entry_free
mov [rsp+50h+var_50], 0
mov [rsp+50h+var_48], r10
mov [rsp+50h+var_40], 0
mov [rsp+50h+var_38], rax
mov [rsp+50h+var_30], 0
call my_hash_init2
cmp al, 0
jz short loc_FDC8A
mov rax, [rbp+var_10]
mov qword ptr [rax+108h], 0
mov [rbp+var_1], 1
jmp short loc_FDCBE
loc_FDC8A:
lea rax, key_SAFEHASH_mutex
mov edi, [rax]
mov rsi, [rbp+var_10]
call inline_mysql_rwlock_init_2
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+108h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+110h], 0
mov [rbp+var_1], 0
loc_FDCBE:
mov al, [rbp+var_1]
add rsp, 50h
pop rbp
retn
|
char safe_hash_init(long long a1, unsigned int a2, long long a3)
{
if ( my_hash_init2(
key_memory_SAFE_HASH_ENTRY,
a1 + 152,
0,
(long long)&my_charset_bin,
a2,
0LL,
0LL,
(long long)safe_hash_entry_get,
0LL,
(long long)safe_hash_entry_free,
0) )
{
*(_QWORD *)(a1 + 264) = 0LL;
return 1;
}
else
{
inline_mysql_rwlock_init_2(key_SAFEHASH_mutex, a1);
*(_QWORD *)(a1 + 264) = a3;
*(_QWORD *)(a1 + 272) = 0LL;
return 0;
}
}
|
safe_hash_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
LEA RAX,[0xd81c64]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x98
MOV EAX,dword ptr [RBP + -0x14]
MOV R8D,EAX
XOR EDX,EDX
LEA RCX,[0x3c2110]
XOR EAX,EAX
MOV R9D,EAX
LEA R10,[0x1fdcd0]
LEA RAX,[0x1fdd00]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV dword ptr [RSP + 0x20],0x0
CALL 0x001dd440
CMP AL,0x0
JZ 0x001fdc8a
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x108],0x0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001fdcbe
LAB_001fdc8a:
LEA RAX,[0xd81308]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001fdd20
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x108],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x110],0x0
MOV byte ptr [RBP + -0x1],0x0
LAB_001fdcbe:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x50
POP RBP
RET
|
bool safe_hash_init(long param_1,int4 param_2,int8 param_3)
{
char cVar1;
bool local_9;
cVar1 = my_hash_init2(key_memory_SAFE_HASH_ENTRY,param_1 + 0x98,0,my_charset_bin,param_2,0,0,
safe_hash_entry_get,0,safe_hash_entry_free,0);
if (cVar1 == '\0') {
inline_mysql_rwlock_init(key_SAFEHASH_mutex,param_1);
*(int8 *)(param_1 + 0x108) = param_3;
*(int8 *)(param_1 + 0x110) = 0;
}
else {
*(int8 *)(param_1 + 0x108) = 0;
}
local_9 = cVar1 != '\0';
return local_9;
}
|
|
9,695 |
my_wc_mb_cp932
|
eloqsql/strings/ctype-cp932.c
|
static int
my_wc_mb_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc;
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_cp932[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208(MS) */
return 2;
}
|
O0
|
c
|
my_wc_mb_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x38f5d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x38f45
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x38ff4
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x38ff4
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x38f7e
movq -0x18(%rbp), %rcx
leaq 0x7db4e(%rip), %rax # 0xb6ac0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x38f87
movl $0x0, -0x4(%rbp)
jmp 0x38ff4
cmpl $0xff, -0x2c(%rbp)
jg 0x38fb7
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x38fa3
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x38ff4
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x38ff4
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x38fce
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x38ff4
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
popq %rbp
retq
nopl (%rax)
|
my_wc_mb_cp932:
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
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_38F5D
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_38F45
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_38FF4
loc_38F45:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_38FF4
loc_38F5D:
cmp [rbp+var_18], 0FFFFh
ja short loc_38F7E
mov rcx, [rbp+var_18]
lea rax, unicode_to_cp932
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_38F87
loc_38F7E:
mov [rbp+var_4], 0
jmp short loc_38FF4
loc_38F87:
cmp [rbp+var_2C], 0FFh
jg short loc_38FB7
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_38FA3
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_38FF4
loc_38FA3:
mov eax, [rbp+var_2C]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_38FF4
loc_38FB7:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_38FCE
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_38FF4
loc_38FCE:
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_38FF4:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_cp932(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned __int16 v5; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF && (v5 = unicode_to_cp932[a2]) != 0 )
{
if ( unicode_to_cp932[a2] > 0xFFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = v5;
return 1;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_cp932:
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
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x00138f5d
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00138f45
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00138ff4
LAB_00138f45:
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 0x00138ff4
LAB_00138f5d:
CMP qword ptr [RBP + -0x18],0xffff
JA 0x00138f7e
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x1b6ac0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00138f87
LAB_00138f7e:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00138ff4
LAB_00138f87:
CMP dword ptr [RBP + -0x2c],0xff
JG 0x00138fb7
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00138fa3
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00138ff4
LAB_00138fa3:
MOV EAX,dword ptr [RBP + -0x2c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00138ff4
LAB_00138fb7:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00138fce
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00138ff4
LAB_00138fce:
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_00138ff4:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_cp932(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if ((param_2 < 0x10000) && (uVar1 = *(ushort *)(unicode_to_cp932 + param_2 * 2), uVar1 != 0))
{
if (uVar1 < 0x100) {
if (param_3 < param_4) {
*param_3 = (char)uVar1;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)(uVar1 >> 8);
param_3[1] = (char)uVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
9,696 |
js_new_string16_len
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_new_string16_len(JSContext *ctx, const uint16_t *buf, int len)
{
JSString *str;
str = js_alloc_string(ctx, len, 1);
if (!str)
return JS_EXCEPTION;
memcpy(str->u.str16, buf, len * 2);
return JS_MKPTR(JS_TAG_STRING, str);
}
|
O0
|
c
|
js_new_string16_len:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x1, %edx
callq 0x2fa50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x66a95
movl $0x0, 0x28(%rsp)
movq $0x6, 0x30(%rsp)
jmp 0x66ac4
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %eax
shll %eax
movslq %eax, %rdx
callq 0xe610
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $-0x7, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_new_string16_len:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_24], edx
mov rdi, [rsp+38h+var_18]
mov esi, [rsp+38h+var_24]
mov edx, 1
call js_alloc_string
mov [rsp+38h+var_30], rax
cmp [rsp+38h+var_30], 0
jnz short loc_66A95
mov dword ptr [rsp+38h+var_10], 0
mov [rsp+38h+var_8], 6
jmp short loc_66AC4
loc_66A95:
mov rdi, [rsp+38h+var_30]
add rdi, 18h
mov rsi, [rsp+38h+var_20]
mov eax, [rsp+38h+var_24]
shl eax, 1
movsxd rdx, eax
call _memcpy
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], 0FFFFFFFFFFFFFFF9h
loc_66AC4:
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long js_new_string16_len(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-30h]
long long v6; // [rsp+28h] [rbp-10h]
v4 = js_alloc_string(a1, a3, 1u);
if ( v4 )
{
memcpy(v4 + 24, a2, (int)(2 * a3));
return v4;
}
else
{
LODWORD(v6) = 0;
}
return v6;
}
|
js_new_string16_len:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],EDX
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x14]
MOV EDX,0x1
CALL 0x0012fa50
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00166a95
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x6
JMP 0x00166ac4
LAB_00166a95:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
MOV RSI,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RSP + 0x14]
SHL EAX,0x1
MOVSXD RDX,EAX
CALL 0x0010e610
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],-0x7
LAB_00166ac4:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int1 [16] js_new_string16_len(int8 param_1,void *param_2,int param_3)
{
int1 auVar1 [16];
long lVar2;
int4 local_10;
int4 uStack_c;
int8 local_8;
lVar2 = js_alloc_string(param_1,param_3,1);
if (lVar2 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
memcpy((void *)(lVar2 + 0x18),param_2,(long)(param_3 << 1));
local_10 = (int4)lVar2;
uStack_c = (int4)((ulong)lVar2 >> 0x20);
local_8 = 0xfffffffffffffff9;
}
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
|
|
9,697 |
js_new_string16_len
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_new_string16_len(JSContext *ctx, const uint16_t *buf, int len)
{
JSString *str;
str = js_alloc_string(ctx, len, 1);
if (!str)
return JS_EXCEPTION;
memcpy(str->u.str16, buf, len * 2);
return JS_MKPTR(JS_TAG_STRING, str);
}
|
O1
|
c
|
js_new_string16_len:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %esi
movl $0x1, %edx
callq 0x24bcf
testq %rax, %rax
je 0x417d4
movq %rax, %r15
movq %rax, %rdi
addq $0x18, %rdi
addl %ebx, %ebx
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe620
movq %r15, 0x8(%rsp)
movq $-0x7, %rdx
jmp 0x417e1
movl $0x0, 0x8(%rsp)
movl $0x6, %edx
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
js_new_string16_len:
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, edx
mov r14, rsi
mov esi, edx
mov edx, 1
call js_alloc_string
test rax, rax
jz short loc_417D4
mov r15, rax
mov rdi, rax
add rdi, 18h
add ebx, ebx
mov rsi, r14
mov rdx, rbx
call _memcpy
mov [rsp+28h+var_20], r15
mov rdx, 0FFFFFFFFFFFFFFF9h
jmp short loc_417E1
loc_417D4:
mov dword ptr [rsp+28h+var_20], 0
mov edx, 6
loc_417E1:
mov rax, [rsp+28h+var_20]
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
long long js_new_string16_len(long long a1, long long a2, unsigned int a3)
{
long long v4; // rax
long long v5; // r15
long long v7; // [rsp+8h] [rbp-20h]
v4 = js_alloc_string(a1, a3, 1u);
if ( v4 )
{
v5 = v4;
memcpy(v4 + 24, a2, 2 * a3);
return v5;
}
else
{
LODWORD(v7) = 0;
}
return v7;
}
|
js_new_string16_len:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,EDX
MOV R14,RSI
MOV ESI,EDX
MOV EDX,0x1
CALL 0x00124bcf
TEST RAX,RAX
JZ 0x001417d4
MOV R15,RAX
MOV RDI,RAX
ADD RDI,0x18
ADD EBX,EBX
MOV RSI,R14
MOV RDX,RBX
CALL 0x0010e620
MOV qword ptr [RSP + 0x8],R15
MOV RDX,-0x7
JMP 0x001417e1
LAB_001417d4:
MOV dword ptr [RSP + 0x8],0x0
MOV EDX,0x6
LAB_001417e1:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
int1 [16] js_new_string16_len(int8 param_1,void *param_2,int param_3)
{
ulong uVar1;
int8 uVar2;
int1 auVar3 [16];
int8 local_20;
uVar1 = js_alloc_string(param_1,param_3,1);
if (uVar1 == 0) {
local_20 = local_20 & 0xffffffff00000000;
uVar2 = 6;
}
else {
memcpy((void *)(uVar1 + 0x18),param_2,(ulong)(uint)(param_3 * 2));
uVar2 = 0xfffffffffffffff9;
local_20 = uVar1;
}
auVar3._8_8_ = uVar2;
auVar3._0_8_ = local_20;
return auVar3;
}
|
|
9,698 |
js_new_string16_len
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_new_string16_len(JSContext *ctx, const uint16_t *buf, int len)
{
JSString *str;
str = js_alloc_string(ctx, len, 1);
if (!str)
return JS_EXCEPTION;
memcpy(str->u.str16, buf, len * 2);
return JS_MKPTR(JS_TAG_STRING, str);
}
|
O2
|
c
|
js_new_string16_len:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
pushq $0x1
popq %rdx
movl %r14d, %esi
callq 0x1e8f5
testq %rax, %rax
je 0x39bdb
movq %rax, %rbx
movq %rax, %rdi
addq $0x18, %rdi
addl %r14d, %r14d
movq %r15, %rsi
movq %r14, %rdx
callq 0xe630
pushq $-0x7
popq %rdx
jmp 0x39be0
pushq $0x6
popq %rdx
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
js_new_string16_len:
push r15
push r14
push rbx
mov r14d, edx
mov r15, rsi
push 1
pop rdx
mov esi, r14d
call js_alloc_string
test rax, rax
jz short loc_39BDB
mov rbx, rax
mov rdi, rax
add rdi, 18h
add r14d, r14d
mov rsi, r15
mov rdx, r14
call _memcpy
push 0FFFFFFFFFFFFFFF9h
pop rdx
jmp short loc_39BE0
loc_39BDB:
push 6
pop rdx
xor ebx, ebx
loc_39BE0:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
|
long long js_new_string16_len(long long a1, long long a2, unsigned int a3)
{
long long v4; // rax
long long v5; // rbx
v4 = js_alloc_string(a1, a3, 1LL);
if ( !v4 )
return 0LL;
v5 = v4;
memcpy(v4 + 24, a2, 2 * a3);
return v5;
}
|
js_new_string16_len:
PUSH R15
PUSH R14
PUSH RBX
MOV R14D,EDX
MOV R15,RSI
PUSH 0x1
POP RDX
MOV ESI,R14D
CALL 0x0011e8f5
TEST RAX,RAX
JZ 0x00139bdb
MOV RBX,RAX
MOV RDI,RAX
ADD RDI,0x18
ADD R14D,R14D
MOV RSI,R15
MOV RDX,R14
CALL 0x0010e630
PUSH -0x7
POP RDX
JMP 0x00139be0
LAB_00139bdb:
PUSH 0x6
POP RDX
XOR EBX,EBX
LAB_00139be0:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
int1 [16] js_new_string16_len(int8 param_1,void *param_2,int param_3)
{
long lVar1;
int8 uVar2;
int1 auVar3 [16];
lVar1 = js_alloc_string(param_1,param_3,1);
if (lVar1 == 0) {
uVar2 = 6;
lVar1 = 0;
}
else {
memcpy((void *)(lVar1 + 0x18),param_2,(ulong)(uint)(param_3 * 2));
uVar2 = 0xfffffffffffffff9;
}
auVar3._8_8_ = uVar2;
auVar3._0_8_ = lVar1;
return auVar3;
}
|
|
9,699 |
ValueToString[abi:cxx11](long)
|
Dolphin-anty/Source/Core/Common/StringUtil.cpp
|
std::string ValueToString(s64 value)
{
return std::to_string(value);
}
|
O3
|
cpp
|
ValueToString[abi:cxx11](long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
negq %r15
cmovsq %rsi, %r15
movl $0x1, %r12d
cmpq $0xa, %r15
jb 0x137d7
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x137ce
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x137d4
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x137d7
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x13796
addl $-0x3, %r12d
jmp 0x137d7
addl $-0x2, %r12d
jmp 0x137d7
decl %r12d
shrq $0x3f, %r14
leal (%r14,%r12), %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x14d90
addq (%rbx), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x14bec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_Z13ValueToStringB5cxx11l:
push r15
push r14
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov r15, rsi
neg r15
cmovs r15, rsi
mov r12d, 1
cmp r15, 0Ah
jb short loc_137D7
mov r12d, 4
mov rsi, 346DC5D63886594Bh
mov rcx, r15
loc_13796:
cmp rcx, 63h ; 'c'
jbe short loc_137CE
cmp rcx, 3E7h
jbe short loc_137D4
cmp rcx, 2710h
jb short loc_137D7
mov rax, rcx
mul rsi
shr rdx, 0Bh
add r12d, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_13796
add r12d, 0FFFFFFFDh
jmp short loc_137D7
loc_137CE:
add r12d, 0FFFFFFFEh
jmp short loc_137D7
loc_137D4:
dec r12d
loc_137D7:
shr r14, 3Fh
lea esi, [r14+r12]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
mov edx, 2Dh ; '-'
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r14, [rbx]
mov rdi, r14
mov esi, r12d
mov rdx, r15
call _ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
_QWORD * ValueToString[abi:cxx11](_QWORD *a1, long long a2)
{
unsigned long long v2; // r15
unsigned int v3; // r12d
unsigned long long v4; // rcx
bool v5; // cc
v2 = -a2;
if ( a2 > 0 )
v2 = a2;
v3 = 1;
if ( v2 >= 0xA )
{
v3 = 4;
v4 = v2;
while ( 1 )
{
if ( v4 <= 0x63 )
{
v3 -= 2;
goto LABEL_12;
}
if ( v4 <= 0x3E7 )
break;
if ( v4 < 0x2710 )
goto LABEL_12;
v3 += 4;
v5 = v4 <= 0x1869F;
v4 /= 0x2710uLL;
if ( v5 )
{
v3 -= 3;
goto LABEL_12;
}
}
--v3;
}
LABEL_12:
*a1 = a1 + 2;
std::string::_M_construct(a1, ((unsigned long long)a2 >> 63) + v3, 45LL);
std::__detail::__to_chars_10_impl<unsigned long>(*a1 + ((unsigned long long)a2 >> 63), v3, v2);
return a1;
}
|
ValueToString[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSI
NEG R15
CMOVS R15,RSI
MOV R12D,0x1
CMP R15,0xa
JC 0x001137d7
MOV R12D,0x4
MOV RSI,0x346dc5d63886594b
MOV RCX,R15
LAB_00113796:
CMP RCX,0x63
JBE 0x001137ce
CMP RCX,0x3e7
JBE 0x001137d4
CMP RCX,0x2710
JC 0x001137d7
MOV RAX,RCX
MUL RSI
SHR RDX,0xb
ADD R12D,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x00113796
ADD R12D,-0x3
JMP 0x001137d7
LAB_001137ce:
ADD R12D,-0x2
JMP 0x001137d7
LAB_001137d4:
DEC R12D
LAB_001137d7:
SHR R14,0x3f
LEA ESI,[R14 + R12*0x1]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RDI,RBX
MOV EDX,0x2d
CALL 0x00114d90
ADD R14,qword ptr [RBX]
MOV RDI,R14
MOV ESI,R12D
MOV RDX,R15
CALL 0x00114bec
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ValueToString[abi:cxx11](long) */
long ValueToString_abi_cxx11_(long param_1)
{
bool bVar1;
uint uVar2;
ulong uVar3;
ulong in_RSI;
uint uVar4;
ulong uVar5;
uVar5 = -in_RSI;
if (0 < (long)in_RSI) {
uVar5 = in_RSI;
}
uVar4 = 1;
if (9 < uVar5) {
uVar3 = uVar5;
uVar2 = 4;
do {
uVar4 = uVar2;
if (uVar3 < 100) {
uVar4 = uVar4 - 2;
goto LAB_001137d7;
}
if (uVar3 < 1000) {
uVar4 = uVar4 - 1;
goto LAB_001137d7;
}
if (uVar3 < 10000) goto LAB_001137d7;
bVar1 = 99999 < uVar3;
uVar3 = uVar3 / 10000;
uVar2 = uVar4 + 4;
} while (bVar1);
uVar4 = uVar4 + 1;
}
LAB_001137d7:
*(long *)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct
((string *)param_1,(ulong)(uVar4 - (int)((long)in_RSI >> 0x3f)),'-');
std::__detail::__to_chars_10_impl<unsigned_long>
((char *)(*(long *)param_1 - ((long)in_RSI >> 0x3f)),uVar4,uVar5);
return param_1;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.