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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
30,000 | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned __int128>(char*, unsigned __int128, int) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
out -= 2;
copy2(out, digits2(static_cast<size_t>(value % 100)));
value /= 100;
}
if (value < 10) {
*--out = static_cast<Char>('0' + value);
return {out, end};
}
out -= 2;
copy2(out, digits2(static_cast<size_t>(value)));
return {out, end};
} | O0 | c | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned __int128>(char*, unsigned __int128, int):
subq $0xb8, %rsp
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdx
movq %rdi, 0x68(%rsp)
movq %rdx, 0x58(%rsp)
movq %rax, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xce190
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movb %al, 0x4b(%rsp)
leaq 0x4b(%rsp), %rdi
leaq 0x81b9b(%rip), %rsi # 0x14fdf1
callq 0x8f990
movl 0x4c(%rsp), %ecx
movq 0x68(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
subq $0x64, %rcx
sbbq $0x0, %rax
jb 0xce328
jmp 0xce293
movq 0x68(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
movl $0x64, %edx
movq %rdx, 0x10(%rsp)
callq 0x15c50
movq %rax, %rdi
callq 0x8f9e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rsi, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rsi
movw (%rsi), %si
movw %si, (%rax)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x15220
movq %rdx, 0x58(%rsp)
movq %rax, 0x50(%rsp)
jmp 0xce279
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rcx
xorl %eax, %eax
movl $0x9, %edx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0xce37a
jmp 0xce343
movb 0x50(%rsp), %cl
addb $0x30, %cl
movq 0x68(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x68(%rsp)
movb %cl, -0x1(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0xce3df
movq 0x68(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x8f9e0
movq (%rsp), %rcx
movq %rcx, 0xa0(%rsp)
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
| _ZN3fmt3v106detail14format_decimalIcoEENS1_21format_decimal_resultIPT_EES5_T0_i:
sub rsp, 0B8h
mov [rsp+0B8h+var_48], rsi
mov [rsp+0B8h+var_40], rdx
mov rax, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_40]
mov [rsp+0B8h+var_50], rdi
mov [rsp+0B8h+var_60], rdx
mov [rsp+0B8h+var_68], rax
mov [rsp+0B8h+var_6C], ecx
mov eax, [rsp+0B8h+var_6C]
mov [rsp+0B8h+var_94], eax
mov rax, [rsp+0B8h+var_68]
mov rcx, [rsp+0B8h+var_60]
mov qword ptr [rsp+0B8h+var_80], rcx
mov [rsp+0B8h+var_88], rax
mov rdi, [rsp+0B8h+var_88]; this
mov rsi, qword ptr [rsp+0B8h+var_80]; unsigned __int128
call _ZN3fmt3v106detail12count_digitsEo; fmt::v10::detail::count_digits(unsigned __int128)
mov ecx, eax
mov eax, [rsp+0B8h+var_94]
cmp eax, ecx
setnl al
and al, 1
mov [rsp+0B8h+var_6D], al
lea rdi, [rsp+0B8h+var_6D]
lea rsi, aInvalidDigitCo; "invalid digit count"
call _ZN3fmt3v106detail13ignore_unusedIJbA20_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [20]>(bool,char [20] const&)
mov ecx, [rsp+0B8h+var_6C]
mov rax, [rsp+0B8h+var_50]
movsxd rcx, ecx
add rax, rcx
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_90], rax
loc_CE279:
mov rcx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_60]
sub rcx, 64h ; 'd'
sbb rax, 0
jb loc_CE328
jmp short $+2
loc_CE293:
mov rax, [rsp+0B8h+var_50]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_B0], rax
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_60]; unsigned __int64
xor eax, eax
mov ecx, eax
mov [rsp+0B8h+var_A0], rcx
mov edx, 64h ; 'd'
mov [rsp+0B8h+var_A8], rdx
call ___umodti3
mov rdi, rax; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rsi, [rsp+0B8h+var_B0]
mov rdx, [rsp+0B8h+var_A8]
mov rcx, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_8], rsi
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_8]
mov rsi, [rsp+0B8h+var_10]
mov si, [rsi]
mov [rax], si
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_60]
call ___udivti3
mov [rsp+0B8h+var_60], rdx
mov [rsp+0B8h+var_68], rax
jmp loc_CE279
loc_CE328:
mov rsi, [rsp+0B8h+var_68]; unsigned __int64
mov rcx, [rsp+0B8h+var_60]
xor eax, eax
mov edx, 9
sub rdx, rsi
sbb rax, rcx
jb short loc_CE37A
jmp short $+2
loc_CE343:
mov cl, byte ptr [rsp+0B8h+var_68]
add cl, 30h ; '0'
mov rax, [rsp+0B8h+var_50]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+0B8h+var_50], rdx
mov [rax-1], cl
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_30], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_28], rax
jmp short loc_CE3DF
loc_CE37A:
mov rax, [rsp+0B8h+var_50]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_B8], rax
mov rdi, [rsp+0B8h+var_68]; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+0B8h+var_B8]
mov [rsp+0B8h+var_18], rcx
mov [rsp+0B8h+var_20], rax
mov rax, [rsp+0B8h+var_18]
mov rcx, [rsp+0B8h+var_20]
mov cx, [rcx]
mov [rax], cx
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_30], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_28], rax
loc_CE3DF:
mov rax, [rsp+0B8h+var_30]
mov rdx, [rsp+0B8h+var_28]
add rsp, 0B8h
retn
| _WORD * fmt::v10::detail::format_decimal<char,unsigned __int128>(
long long a1,
fmt::v10::detail *a2,
long long a3,
int a4,
long long a5,
long long a6)
{
fmt::v10::detail *v6; // rax
unsigned __int128 v7; // rax
unsigned __int128 v10; // [rsp+50h] [rbp-68h]
_WORD *v11; // [rsp+68h] [rbp-50h]
*((_QWORD *)&v10 + 1) = a3;
*(_QWORD *)&v10 = a2;
fmt::v10::detail::count_digits(a2, a3, a3, a3, a5, a6);
fmt::v10::detail::ignore_unused<bool,char [20]>();
v11 = (_WORD *)(a4 + a1);
while ( v10 >= 0x64 )
{
--v11;
v6 = (fmt::v10::detail *)__umodti3(v10, *((_QWORD *)&v10 + 1));
*v11 = *(_WORD *)fmt::v10::detail::digits2(v6);
*(_QWORD *)&v7 = __udivti3(v10, *((_QWORD *)&v10 + 1), 100LL, 0LL);
v10 = v7;
}
if ( 9 < v10 )
{
*(v11 - 1) = *(_WORD *)fmt::v10::detail::digits2((fmt::v10::detail *)v10);
return v11 - 1;
}
else
{
*((_BYTE *)v11 - 1) = v10 + 48;
return (_WORD *)((char *)v11 - 1);
}
}
| format_decimal<char,unsigned__int128>:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x70],RSI
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x4c],ECX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x24],EAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001ce190
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,ECX
SETGE AL
AND AL,0x1
MOV byte ptr [RSP + 0x4b],AL
LEA RDI,[RSP + 0x4b]
LEA RSI,[0x24fdf1]
CALL 0x0018f990
MOV ECX,dword ptr [RSP + 0x4c]
MOV RAX,qword ptr [RSP + 0x68]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x28],RAX
LAB_001ce279:
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x58]
SUB RCX,0x64
SBB RAX,0x0
JC 0x001ce328
JMP 0x001ce293
LAB_001ce293:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
XOR EAX,EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x18],RCX
MOV EDX,0x64
MOV qword ptr [RSP + 0x10],RDX
CALL 0x00115c50
MOV RDI,RAX
CALL 0x0018f9e0
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xb0],RSI
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV SI,word ptr [RSI]
MOV word ptr [RAX],SI
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00115220
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001ce279
LAB_001ce328:
MOV RSI,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
XOR EAX,EAX
MOV EDX,0x9
SUB RDX,RSI
SBB RAX,RCX
JC 0x001ce37a
JMP 0x001ce343
LAB_001ce343:
MOV CL,byte ptr [RSP + 0x50]
ADD CL,0x30
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x68],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001ce3df
LAB_001ce37a:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x0018f9e0
MOV RCX,qword ptr [RSP]
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0x98]
MOV CX,word ptr [RCX]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],RAX
LAB_001ce3df:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0xb8
RET
|
/* fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned
__int128>(char*, unsigned __int128, int) */
int1 [16] __thiscall
fmt::v10::detail::format_decimal<char,unsigned__int128>
(detail *this,char *param_1,uint param_2,int param_3)
{
int1 auVar1 [16];
int iVar2;
detail *pdVar3;
detail *pdVar4;
ulong uVar5;
int2 *puVar6;
int4 in_register_00000014;
int1 auVar7 [16];
bool local_6d;
int local_6c;
int1 local_68 [16];
detail *local_50;
char *local_48;
int8 local_40;
detail *local_30;
int2 *local_10;
detail *local_8;
local_68._8_8_ = CONCAT44(in_register_00000014,param_2);
local_6c = param_3;
local_68._0_8_ = param_1;
local_50 = this;
local_48 = param_1;
local_40 = local_68._8_8_;
iVar2 = count_digits((detail *)param_1,param_2);
local_6d = iVar2 <= param_3;
ignore_unused<bool,char[20]>(&local_6d,"invalid digit count");
auVar7._8_8_ = local_68._8_8_;
auVar7._0_8_ = local_68._0_8_;
pdVar3 = local_50 + local_6c;
local_50 = pdVar3;
while (local_68._8_8_ = auVar7._8_8_, local_68._0_8_ = auVar7._0_8_,
(ulong)((ulong)local_68._0_8_ < 100) <= (ulong)local_68._8_8_) {
pdVar4 = local_50 + -2;
local_50 = pdVar4;
uVar5 = __umodti3(local_68._0_8_,local_68._8_8_);
local_68 = auVar7;
local_10 = (int2 *)digits2(uVar5);
*(int2 *)pdVar4 = *local_10;
local_8 = pdVar4;
auVar7 = __udivti3(local_68._0_8_,local_68._8_8_,100,0);
}
if (local_68._8_8_ == 0 && (ulong)(9 < (ulong)local_68._0_8_) <= (ulong)-local_68._8_8_) {
local_68[0] = auVar7[0];
local_30 = local_50 + -1;
local_50[-1] = (detail)(local_68[0] + '0');
}
else {
pdVar4 = local_50 + -2;
local_50 = pdVar4;
puVar6 = (int2 *)digits2(local_68._0_8_);
local_68 = auVar7;
*(int2 *)pdVar4 = *puVar6;
local_30 = local_50;
}
auVar1._8_8_ = pdVar3;
auVar1._0_8_ = local_30;
return auVar1;
}
| |
30,001 | mi_cmp_static_record | eloqsql/storage/myisam/mi_statrec.c | int _mi_cmp_static_record(register MI_INFO *info, register const uchar *old)
{
DBUG_ENTER("_mi_cmp_static_record");
if (info->opt_flag & WRITE_CACHE_USED)
{
if (flush_io_cache(&info->rec_cache))
{
DBUG_RETURN(-1);
}
info->rec_cache.seek_not_done=1; /* We have done a seek */
}
if ((info->opt_flag & READ_CHECK_USED))
{ /* If check isn't disabled */
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
info->lastpos,
MYF(MY_NABP)))
DBUG_RETURN(-1);
if (memcmp(info->rec_buff, old,
(uint) info->s->base.reclength))
{
DBUG_DUMP("read",old,info->s->base.reclength);
DBUG_DUMP("disk",info->rec_buff,info->s->base.reclength);
my_errno=HA_ERR_RECORD_CHANGED; /* Record have changed */
DBUG_RETURN(1);
}
}
DBUG_RETURN(0);
} | O3 | c | mi_cmp_static_record:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1c8(%rdi), %ecx
testb $0x10, %cl
je 0x87127
leaq 0x220(%r14), %rdi
movl $0x1, %esi
callq 0x95561
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x871a0
movl $0x1, 0x300(%r14)
movl 0x1c8(%r14), %ecx
xorl %eax, %eax
testb $0x4, %cl
je 0x871a0
movl $0x1, 0x300(%r14)
movq (%r14), %rax
movq 0x120(%r14), %rsi
movq 0x140(%rax), %rdx
movq 0x170(%r14), %rcx
movl $0x4, %r8d
movq %r14, %rdi
callq *0x2e0(%rax)
movq %rax, %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x871a0
movq (%r14), %rax
movq 0x120(%r14), %rdi
movl 0x140(%rax), %edx
movq %rbx, %rsi
callq 0x29560
movl %eax, %ecx
movl $0x0, %eax
testl %ecx, %ecx
je 0x871a0
callq 0xa1b22
movl $0x7b, (%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _mi_cmp_static_record:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+1C8h]
test cl, 10h
jz short loc_87127
lea rdi, [r14+220h]
mov esi, 1
call my_b_flush_io_cache
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz loc_871A0
mov dword ptr [r14+300h], 1
mov ecx, [r14+1C8h]
loc_87127:
xor eax, eax
test cl, 4
jz short loc_871A0
mov dword ptr [r14+300h], 1
mov rax, [r14]
mov rsi, [r14+120h]
mov rdx, [rax+140h]
mov rcx, [r14+170h]
mov r8d, 4
mov rdi, r14
call qword ptr [rax+2E0h]
mov rcx, rax
mov eax, 0FFFFFFFFh
test rcx, rcx
jnz short loc_871A0
mov rax, [r14]
mov rdi, [r14+120h]
mov edx, [rax+140h]
mov rsi, rbx
call _bcmp
mov ecx, eax
mov eax, 0
test ecx, ecx
jz short loc_871A0
call _my_thread_var
mov dword ptr [rax], 7Bh ; '{'
mov eax, 1
loc_871A0:
pop rbx
pop r14
pop rbp
retn
| long long mi_cmp_static_record(_QWORD *a1, const char *a2)
{
int v3; // ecx
int v4; // ecx
long long result; // rax
long long v6; // rcx
long long v7; // rdi
int v8; // ecx
v3 = *((_DWORD *)a1 + 114);
if ( (v3 & 0x10) != 0 )
{
v4 = my_b_flush_io_cache(a1 + 68, 1LL);
result = 0xFFFFFFFFLL;
if ( v4 )
return result;
*((_DWORD *)a1 + 192) = 1;
v3 = *((_DWORD *)a1 + 114);
}
result = 0LL;
if ( (v3 & 4) != 0 )
{
*((_DWORD *)a1 + 192) = 1;
v6 = (*(long long ( **)(_QWORD *, _QWORD, _QWORD, _QWORD, long long))(*a1 + 736LL))(
a1,
a1[36],
*(_QWORD *)(*a1 + 320LL),
a1[46],
4LL);
result = 0xFFFFFFFFLL;
if ( !v6 )
{
v7 = a1[36];
v8 = bcmp(v7, a2, *(unsigned int *)(*a1 + 320LL));
result = 0LL;
if ( v8 )
{
*(_DWORD *)my_thread_var(v7, a2) = 123;
return 1LL;
}
}
}
return result;
}
| _mi_cmp_static_record:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x1c8]
TEST CL,0x10
JZ 0x00187127
LEA RDI,[R14 + 0x220]
MOV ESI,0x1
CALL 0x00195561
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x001871a0
MOV dword ptr [R14 + 0x300],0x1
MOV ECX,dword ptr [R14 + 0x1c8]
LAB_00187127:
XOR EAX,EAX
TEST CL,0x4
JZ 0x001871a0
MOV dword ptr [R14 + 0x300],0x1
MOV RAX,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x120]
MOV RDX,qword ptr [RAX + 0x140]
MOV RCX,qword ptr [R14 + 0x170]
MOV R8D,0x4
MOV RDI,R14
CALL qword ptr [RAX + 0x2e0]
MOV RCX,RAX
MOV EAX,0xffffffff
TEST RCX,RCX
JNZ 0x001871a0
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [R14 + 0x120]
MOV EDX,dword ptr [RAX + 0x140]
MOV RSI,RBX
CALL 0x00129560
MOV ECX,EAX
MOV EAX,0x0
TEST ECX,ECX
JZ 0x001871a0
CALL 0x001a1b22
MOV dword ptr [RAX],0x7b
MOV EAX,0x1
LAB_001871a0:
POP RBX
POP R14
POP RBP
RET
|
int8 _mi_cmp_static_record(long *param_1,void *param_2)
{
uint uVar1;
int iVar2;
long lVar3;
int8 uVar4;
int4 *puVar5;
uVar1 = *(uint *)(param_1 + 0x39);
if ((uVar1 & 0x10) != 0) {
iVar2 = my_b_flush_io_cache(param_1 + 0x44,1);
if (iVar2 != 0) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x60) = 1;
uVar1 = *(uint *)(param_1 + 0x39);
}
uVar4 = 0;
if ((uVar1 & 4) != 0) {
*(int4 *)(param_1 + 0x60) = 1;
lVar3 = (**(code **)(*param_1 + 0x2e0))
(param_1,param_1[0x24],*(int8 *)(*param_1 + 0x140),param_1[0x2e],4);
uVar4 = 0xffffffff;
if (lVar3 == 0) {
iVar2 = bcmp((void *)param_1[0x24],param_2,(ulong)*(uint *)(*param_1 + 0x140));
uVar4 = 0;
if (iVar2 != 0) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x7b;
uVar4 = 1;
}
}
}
return uVar4;
}
| |
30,002 | mult | eloqsql/strings/dtoa.c | static Bigint *mult(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int k, wa, wb, wc;
ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
ULong y;
ULLong carry, z;
if (a->wds < b->wds)
{
c= a;
a= b;
b= c;
}
k= a->k;
wa= a->wds;
wb= b->wds;
wc= wa + wb;
if (wc > a->maxwds)
k++;
c= Balloc(k, alloc);
for (x= c->p.x, xa= x + wc; x < xa; x++)
*x= 0;
xa= a->p.x;
xae= xa + wa;
xb= b->p.x;
xbe= xb + wb;
xc0= c->p.x;
for (; xb < xbe; xc0++)
{
if ((y= *xb++))
{
x= xa;
xc= xc0;
carry= 0;
do
{
z= *x++ * (ULLong)y + *xc + carry;
carry= z >> 32;
*xc++= (ULong) (z & FFFFFFFF);
}
while (x < xae);
*xc= (ULong) carry;
}
}
for (xc0= c->p.x, xc= xc0 + wc; wc > 0 && !*--xc; --wc) ;
c->wds= wc;
return c;
} | O0 | c | mult:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x7477f
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x747bb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x742e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x7480b
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x747e9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x74914
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x50(%rbp)
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, %eax
je 0x74901
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl -0x6c(%rbp), %ecx
imulq %rcx, %rax
movq -0x60(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
addq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x78(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x80(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x74895
movq -0x78(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
jmp 0x74903
movq -0x68(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
jmp 0x74852
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x30(%rbp)
movb %al, -0x81(%rbp)
jle 0x7495e
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x60(%rbp)
cmpl $0x0, -0x4(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x7496a
jmp 0x74977
jmp 0x7496c
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x74932
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| mult:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov rcx, [rbp+var_10]
cmp eax, [rcx+14h]
jge short loc_7477F
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
mov rax, [rbp+var_20]
mov [rbp+var_10], rax
loc_7477F:
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov [rbp+var_28], eax
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_2C], eax
mov eax, [rbp+var_28]
add eax, [rbp+var_2C]
mov [rbp+var_30], eax
mov eax, [rbp+var_30]
mov rcx, [rbp+var_8]
cmp eax, [rcx+0Ch]
jle short loc_747BB
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
loc_747BB:
mov edi, [rbp+var_24]
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movsxd rcx, [rbp+var_30]
shl rcx, 2
add rax, rcx
mov [rbp+var_40], rax
loc_747E9:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_7480B
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
add rax, 4
mov [rbp+var_38], rax
jmp short loc_747E9
loc_7480B:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_28]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_2C]
shl rcx, 2
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_68], rax
loc_74852:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
jnb loc_74914
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 4
mov [rbp+var_50], rcx
mov eax, [rax]
mov [rbp+var_6C], eax
cmp eax, 0
jz loc_74901
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
mov rax, [rbp+var_68]
mov [rbp+var_60], rax
mov [rbp+var_78], 0
loc_74895:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov eax, [rax]
mov ecx, [rbp+var_6C]
imul rax, rcx
mov rcx, [rbp+var_60]
mov ecx, [rcx]
add rax, rcx
add rax, [rbp+var_78]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
shr rax, 20h
mov [rbp+var_78], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_80]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_74895
mov rax, [rbp+var_78]
mov ecx, eax
mov rax, [rbp+var_60]
mov [rax], ecx
loc_74901:
jmp short $+2
loc_74903:
mov rax, [rbp+var_68]
add rax, 4
mov [rbp+var_68], rax
jmp loc_74852
loc_74914:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
movsxd rcx, [rbp+var_30]
shl rcx, 2
add rax, rcx
mov [rbp+var_60], rax
loc_74932:
xor eax, eax
cmp [rbp+var_30], 0
mov [rbp+var_81], al
jle short loc_7495E
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_60], rcx
cmp dword ptr [rax-4], 0
setnz al
xor al, 0FFh
mov [rbp+var_81], al
loc_7495E:
mov al, [rbp+var_81]
test al, 1
jnz short loc_7496A
jmp short loc_74977
loc_7496A:
jmp short $+2
loc_7496C:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
jmp short loc_74932
loc_74977:
mov ecx, [rbp+var_30]
mov rax, [rbp+var_20]
mov [rax+14h], ecx
mov rax, [rbp+var_20]
add rsp, 90h
pop rbp
retn
| long long mult(unsigned int **a1, unsigned int **a2, long long a3)
{
unsigned int *v3; // rax
unsigned int *v4; // rax
_DWORD *v5; // rax
long long v6; // rax
char v8; // [rsp+Fh] [rbp-81h]
unsigned long long v9; // [rsp+10h] [rbp-80h]
unsigned long long v10; // [rsp+18h] [rbp-78h]
unsigned int v11; // [rsp+24h] [rbp-6Ch]
_DWORD *v12; // [rsp+28h] [rbp-68h]
_DWORD *v13; // [rsp+30h] [rbp-60h]
long long v14; // [rsp+30h] [rbp-60h]
unsigned long long v15; // [rsp+38h] [rbp-58h]
unsigned int *v16; // [rsp+40h] [rbp-50h]
unsigned long long v17; // [rsp+48h] [rbp-48h]
unsigned long long v18; // [rsp+50h] [rbp-40h]
unsigned int *v19; // [rsp+50h] [rbp-40h]
_DWORD *v20; // [rsp+58h] [rbp-38h]
unsigned int *v21; // [rsp+58h] [rbp-38h]
int v22; // [rsp+60h] [rbp-30h]
int v23; // [rsp+64h] [rbp-2Ch]
int v24; // [rsp+68h] [rbp-28h]
int v25; // [rsp+6Ch] [rbp-24h]
long long v26; // [rsp+70h] [rbp-20h]
unsigned int **v27; // [rsp+80h] [rbp-10h]
unsigned int **v28; // [rsp+88h] [rbp-8h]
v28 = a1;
v27 = a2;
if ( *((_DWORD *)a1 + 5) < *((_DWORD *)a2 + 5) )
{
v28 = a2;
v27 = a1;
}
v25 = *((_DWORD *)v28 + 2);
v24 = *((_DWORD *)v28 + 5);
v23 = *((_DWORD *)v27 + 5);
v22 = v23 + v24;
if ( v23 + v24 > *((_DWORD *)v28 + 3) )
++v25;
v26 = Balloc(v25, a3);
v20 = *(_DWORD **)v26;
v18 = 4LL * v22 + *(_QWORD *)v26;
while ( (unsigned long long)v20 < v18 )
*v20++ = 0;
v19 = *v28;
v17 = (unsigned long long)&(*v28)[v24];
v16 = *v27;
v15 = (unsigned long long)&(*v27)[v23];
v12 = *(_DWORD **)v26;
while ( (unsigned long long)v16 < v15 )
{
v3 = v16++;
v11 = *v3;
if ( *v3 )
{
v21 = v19;
v13 = v12;
v10 = 0LL;
do
{
v4 = v21++;
v9 = v10 + (unsigned int)*v13 + v11 * (unsigned long long)*v4;
v10 = HIDWORD(v9);
v5 = v13++;
*v5 = v9;
}
while ( (unsigned long long)v21 < v17 );
*v13 = HIDWORD(v9);
}
++v12;
}
v14 = 4LL * v22 + *(_QWORD *)v26;
while ( 1 )
{
v8 = 0;
if ( v22 > 0 )
{
v6 = v14;
v14 -= 4LL;
v8 = ~(*(_DWORD *)(v6 - 4) != 0);
}
if ( (v8 & 1) == 0 )
break;
--v22;
}
*(_DWORD *)(v26 + 20) = v22;
return v26;
}
| mult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x14]
JGE 0x0017477f
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017477f:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0xc]
JLE 0x001747bb
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
LAB_001747bb:
MOV EDI,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001742e0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RCX,dword ptr [RBP + -0x30]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001747e9:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0017480b
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001747e9
LAB_0017480b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVSXD RCX,dword ptr [RBP + -0x28]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
LAB_00174852:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
JNC 0x00174914
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x50],RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x6c],EAX
CMP EAX,0x0
JZ 0x00174901
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x78],0x0
LAB_00174895:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x6c]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RCX]
ADD RAX,RCX
ADD RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x20
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x80]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x60],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00174895
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
LAB_00174901:
JMP 0x00174903
LAB_00174903:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x4
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00174852
LAB_00174914:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOVSXD RCX,dword ptr [RBP + -0x30]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_00174932:
XOR EAX,EAX
CMP dword ptr [RBP + -0x30],0x0
MOV byte ptr [RBP + -0x81],AL
JLE 0x0017495e
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x60],RCX
CMP dword ptr [RAX + -0x4],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x81],AL
LAB_0017495e:
MOV AL,byte ptr [RBP + -0x81]
TEST AL,0x1
JNZ 0x0017496a
JMP 0x00174977
LAB_0017496a:
JMP 0x0017496c
LAB_0017496c:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00174932
LAB_00174977:
MOV ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x90
POP RBP
RET
|
long * mult(int8 *param_1,int8 *param_2,int8 param_3)
{
int iVar1;
int iVar2;
uint uVar3;
uint *puVar4;
uint *puVar5;
long *plVar6;
int4 *puVar7;
ulong uVar8;
uint *puVar9;
uint *puVar10;
bool bVar11;
ulong local_80;
uint *local_70;
uint *local_68;
uint *local_58;
uint *local_40;
int local_38;
int local_2c;
int8 *local_18;
int8 *local_10;
local_18 = param_2;
local_10 = param_1;
if (*(int *)((long)param_1 + 0x14) < *(int *)((long)param_2 + 0x14)) {
local_18 = param_1;
local_10 = param_2;
}
local_2c = *(int *)(local_10 + 1);
iVar1 = *(int *)((long)local_10 + 0x14);
iVar2 = *(int *)((long)local_18 + 0x14);
local_38 = iVar1 + iVar2;
if (*(int *)((long)local_10 + 0xc) < local_38) {
local_2c = local_2c + 1;
}
plVar6 = (long *)Balloc(local_2c,param_3);
local_40 = (uint *)*plVar6;
puVar7 = local_40 + local_38;
for (; local_40 < puVar7; local_40 = local_40 + 1) {
*local_40 = 0;
}
puVar4 = (uint *)*local_10;
puVar5 = (uint *)*local_18;
local_70 = (uint *)*plVar6;
local_58 = puVar5;
while (local_58 < puVar5 + iVar2) {
uVar3 = *local_58;
if (uVar3 != 0) {
local_68 = local_70;
local_80 = 0;
local_40 = puVar4;
do {
puVar9 = local_40 + 1;
uVar8 = (ulong)*local_40 * (ulong)uVar3 + (ulong)*local_68 + local_80;
local_80 = uVar8 >> 0x20;
puVar10 = local_68 + 1;
*local_68 = (uint)uVar8;
local_68 = puVar10;
local_40 = puVar9;
} while (puVar9 < puVar4 + iVar1);
*puVar10 = (uint)(uVar8 >> 0x20);
}
local_70 = local_70 + 1;
local_58 = local_58 + 1;
}
local_68 = (uint *)(*plVar6 + (long)local_38 * 4);
while( true ) {
bVar11 = false;
if (0 < local_38) {
bVar11 = *(int *)((long)local_68 + -4) == 0;
local_68 = (uint *)((long)local_68 + -4);
}
if (!bVar11) break;
local_38 = local_38 + -1;
}
*(int *)((long)plVar6 + 0x14) = local_38;
return plVar6;
}
| |
30,003 | emit_label | bluesky950520[P]quickjs/quickjs.c | static int emit_label(JSParseState *s, int label)
{
if (label >= 0) {
emit_op(s, OP_label);
emit_u32(s, label);
s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
return s->cur_func->byte_code.size - 4;
} else {
return -1;
}
} | O0 | c | emit_label:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0xa5d95
movq 0x8(%rsp), %rdi
movl $0xb5, %esi
callq 0x9bc60
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xa6210
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x140(%rax), %rax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x170(%rax), %rax
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x140(%rax), %rax
subq $0x4, %rax
movl %eax, 0x14(%rsp)
jmp 0xa5d9d
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| emit_label:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_14], esi
cmp [rsp+18h+var_14], 0
jl short loc_A5D95
mov rdi, [rsp+18h+var_10]
mov esi, 0B5h
call emit_op
mov rdi, [rsp+18h+var_10]
mov esi, [rsp+18h+var_14]
call emit_u32
mov rax, [rsp+18h+var_10]
mov rax, [rax+90h]
mov rax, [rax+140h]
mov ecx, eax
mov rax, [rsp+18h+var_10]
mov rax, [rax+90h]
mov rax, [rax+170h]
movsxd rdx, [rsp+18h+var_14]
imul rdx, 18h
add rax, rdx
mov [rax+4], ecx
mov rax, [rsp+18h+var_10]
mov rax, [rax+90h]
mov rax, [rax+140h]
sub rax, 4
mov [rsp+18h+var_4], eax
jmp short loc_A5D9D
loc_A5D95:
mov [rsp+18h+var_4], 0FFFFFFFFh
loc_A5D9D:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long emit_label(long long a1, int a2)
{
if ( a2 < 0 )
{
return (unsigned int)-1;
}
else
{
emit_op(a1, 181);
emit_u32(a1, (unsigned int)a2);
*(_DWORD *)(24LL * a2 + *(_QWORD *)(*(_QWORD *)(a1 + 144) + 368LL) + 4) = *(_QWORD *)(*(_QWORD *)(a1 + 144) + 320LL);
return (unsigned int)(*(_QWORD *)(*(_QWORD *)(a1 + 144) + 320LL) - 4);
}
}
| emit_label:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x4],ESI
CMP dword ptr [RSP + 0x4],0x0
JL 0x001a5d95
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0xb5
CALL 0x0019bc60
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x4]
CALL 0x001a6210
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RAX + 0x140]
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RAX + 0x170]
MOVSXD RDX,dword ptr [RSP + 0x4]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RAX + 0x140]
SUB RAX,0x4
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001a5d9d
LAB_001a5d95:
MOV dword ptr [RSP + 0x14],0xffffffff
LAB_001a5d9d:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
int emit_label(long param_1,int param_2)
{
int4 local_4;
if (param_2 < 0) {
local_4 = -1;
}
else {
emit_op(param_1,0xb5);
emit_u32(param_1,param_2);
*(int *)(*(long *)(*(long *)(param_1 + 0x90) + 0x170) + (long)param_2 * 0x18 + 4) =
(int)*(int8 *)(*(long *)(param_1 + 0x90) + 0x140);
local_4 = (int)*(int8 *)(*(long *)(param_1 + 0x90) + 0x140) + -4;
}
return local_4;
}
| |
30,004 | emit_label | bluesky950520[P]quickjs/quickjs.c | static int emit_label(JSParseState *s, int label)
{
if (label >= 0) {
emit_op(s, OP_label);
emit_u32(s, label);
s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
return s->cur_func->byte_code.size - 4;
} else {
return -1;
}
} | O3 | c | emit_label:
testl %esi, %esi
js 0x66bc3
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x90(%rdi), %rax
movl $0x138, %r15d # imm = 0x138
leaq (%rax,%r15), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0xb5, %esi
callq 0x1b1c5
addq 0x90(%r14), %r15
leaq 0xc(%rsp), %rsi
movl %ebx, (%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x1b116
movq 0x90(%r14), %rax
movl 0x140(%rax), %ecx
movq 0x170(%rax), %rax
movl %ebx, %edx
leaq (%rdx,%rdx,2), %rdx
movl %ecx, 0x4(%rax,%rdx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| emit_label:
test esi, esi
js short locret_66BC3
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, esi
mov r14, rdi
mov rax, [rdi+90h]
mov r15d, 138h
lea rdi, [rax+r15]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 0B5h
call dbuf_putc
add r15, [r14+90h]
lea rsi, [rsp+28h+var_1C]
mov [rsi], ebx
mov edx, 4
mov rdi, r15
call dbuf_put
mov rax, [r14+90h]
mov ecx, [rax+140h]
mov rax, [rax+170h]
mov edx, ebx
lea rdx, [rdx+rdx*2]
mov [rax+rdx*8+4], ecx
add rsp, 10h
pop rbx
pop r14
pop r15
locret_66BC3:
retn
| long long emit_label(long long a1, int a2)
{
long long v2; // rax
_QWORD *v3; // r15
long long v4; // rax
int v5; // ecx
long long result; // rax
int v7[7]; // [rsp+0h] [rbp-1Ch] BYREF
if ( a2 >= 0 )
{
v2 = *(_QWORD *)(a1 + 144);
*(_DWORD *)(v2 + 360) = *(_DWORD *)(v2 + 320);
dbuf_putc((_QWORD *)(v2 + 312), 181);
v3 = (_QWORD *)(*(_QWORD *)(a1 + 144) + 312LL);
v7[0] = a2;
dbuf_put(v3, (long long)v7, 4LL);
v4 = *(_QWORD *)(a1 + 144);
v5 = *(_DWORD *)(v4 + 320);
result = *(_QWORD *)(v4 + 368);
*(_DWORD *)(result + 24LL * (unsigned int)a2 + 4) = v5;
}
return result;
}
| emit_label:
TEST ESI,ESI
JS 0x00166bc3
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,ESI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x90]
MOV R15D,0x138
LEA RDI,[RAX + R15*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0xb5
CALL 0x0011b1c5
ADD R15,qword ptr [R14 + 0x90]
LEA RSI,[RSP + 0xc]
MOV dword ptr [RSI],EBX
MOV EDX,0x4
MOV RDI,R15
CALL 0x0011b116
MOV RAX,qword ptr [R14 + 0x90]
MOV ECX,dword ptr [RAX + 0x140]
MOV RAX,qword ptr [RAX + 0x170]
MOV EDX,EBX
LEA RDX,[RDX + RDX*0x2]
MOV dword ptr [RAX + RDX*0x8 + 0x4],ECX
ADD RSP,0x10
POP RBX
POP R14
POP R15
LAB_00166bc3:
RET
|
void emit_label(long param_1,uint param_2)
{
long lVar1;
uint local_1c;
if (-1 < (int)param_2) {
lVar1 = *(long *)(param_1 + 0x90);
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
dbuf_putc(lVar1 + 0x138,0xb5);
local_1c = param_2;
dbuf_put(*(long *)(param_1 + 0x90) + 0x138,&local_1c,4);
*(int4 *)(*(long *)(*(long *)(param_1 + 0x90) + 0x170) + 4 + (ulong)param_2 * 0x18) =
*(int4 *)(*(long *)(param_1 + 0x90) + 0x140);
}
return;
}
| |
30,005 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O0 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0x14eb20
movq 0x18(%rsp), %rdi
leaq 0x1535f5(%rip), %rax # 0x2a1fc0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
movq 0x78(%rsp), %rsi
callq 0x1126f0
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, 0x10(%rsp)
movq 0x70(%rsp), %rsi
callq 0x14eb30
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x1151c0
testb $0x1, %al
jne 0x14eb03
movb $0x1, 0x23(%rsp)
movl $0x10, %edi
callq 0x5a690
movq 0x18(%rsp), %rsi
movq %rax, (%rsp)
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x112e90
jmp 0x14ea42
leaq 0xc3d0e(%rip), %rsi # 0x212757
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x622f0
jmp 0x14ea5a
movq (%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5a4d0
jmp 0x14ea6a
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x154536(%rip), %rsi # 0x2a2fb0
movq 0x1544f7(%rip), %rdx # 0x2a2f78
callq 0x5ab00
jmp 0x14eb15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x14eacd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x14eac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5b598
leaq 0x30(%rsp), %rdi
callq 0x5b598
testb $0x1, 0x23(%rsp)
jne 0x14ead6
jmp 0x14eadf
movq (%rsp), %rdi
callq 0x5af90
movq 0x10(%rsp), %rdi
callq 0x14d640
movq 0x8(%rsp), %rdi
callq 0x112960
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x14eb60
jmp 0x14eb0b
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
nop
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov rdi, [rsp+88h+var_8]
mov [rsp+88h+var_70], rdi
add rdi, 8
call _ZNSt23enable_shared_from_thisIN5minja7ContextEEC2Ev; std::enable_shared_from_this<minja::Context>::enable_shared_from_this(void)
mov rdi, [rsp+88h+var_70]
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
add rdi, 18h
mov [rsp+88h+var_80], rdi
mov rsi, [rsp+88h+var_10]
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
mov rdi, [rsp+88h+var_70]
add rdi, 68h ; 'h'
mov [rsp+88h+var_78], rdi
mov rsi, [rsp+88h+var_18]
call _ZNSt10shared_ptrIN5minja7ContextEEC2ERKS2_; std::shared_ptr<minja::Context>::shared_ptr(std::shared_ptr<minja::Context> const&)
mov rdi, [rsp+88h+var_70]
add rdi, 18h; this
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
test al, 1
jnz loc_14EB03
mov [rsp+88h+var_65], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+88h+var_70]
mov [rsp+88h+var_88], rax
add rsi, 18h
lea rdi, [rsp+88h+var_58]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_14EA42:
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+88h+var_38]
lea rdx, [rsp+88h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_14EA5A:
mov rdi, [rsp+88h+var_88]
lea rsi, [rsp+88h+var_38]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_14EA6A:
mov rdi, [rsp+88h+var_88]; void *
mov [rsp+88h+var_65], 0
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_14EB15
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
jmp short loc_14EACD
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
jmp short loc_14EAC3
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_14EAC3:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_14EACD:
test [rsp+arg_1B], 1
jnz short loc_14EAD6
jmp short loc_14EADF
loc_14EAD6:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_14EADF:
mov rdi, [rsp+arg_8]
call _ZNSt10shared_ptrIN5minja7ContextEED2Ev; std::shared_ptr<minja::Context>::~shared_ptr()
mov rdi, [rsp+arg_0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, [rsp+arg_10]
add rdi, 8
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
jmp short loc_14EB0B
loc_14EB03:
add rsp, 88h
retn
loc_14EB0B:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
loc_14EB15:
nop word ptr [rax+rax+00000000h]
nop
| bool minja::Context::Context(_QWORD *a1, long long a2, long long a3)
{
bool result; // al
void *exception; // [rsp+0h] [rbp-88h]
_BYTE v5[32]; // [rsp+30h] [rbp-58h] BYREF
_BYTE v6[32]; // [rsp+50h] [rbp-38h] BYREF
long long v7; // [rsp+70h] [rbp-18h]
long long v8; // [rsp+78h] [rbp-10h]
_QWORD *v9; // [rsp+80h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
std::enable_shared_from_this<minja::Context>::enable_shared_from_this(a1 + 1);
*a1 = &`vtable for'minja::Context + 2;
minja::Value::Value((long long)(a1 + 3), v8);
std::shared_ptr<minja::Context>::shared_ptr(a1 + 13, v7);
result = minja::Value::is_object((minja::Value *)(a1 + 3));
if ( !result )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v5, (long long)(a1 + 3), 0xFFFFFFFF, 0);
std::operator+<char>((long long)v6, (long long)"Context values must be an object: ", (long long)v5);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| |||
30,006 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O3 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x8e633(%rip), %rax # 0x12b140
addq $0x10, %rax
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x30(%rdi)
movups 0x10(%rsi), %xmm0
movq %r13, 0x18(%rsi)
movups %xmm0, 0x28(%rdi)
movq %r13, 0x10(%rsi)
movq %r13, 0x40(%rdi)
movups 0x20(%rsi), %xmm0
movq %r13, 0x28(%rsi)
movups %xmm0, 0x38(%rdi)
movq %r13, 0x20(%rsi)
movq %r13, 0x50(%rdi)
movups 0x30(%rsi), %xmm0
movq %r13, 0x38(%rsi)
movups %xmm0, 0x48(%rdi)
movq %r13, 0x30(%rsi)
leaq 0x58(%rdi), %r12
leaq 0x40(%rsi), %rdi
movups 0x40(%rsi), %xmm0
movups %xmm0, 0x58(%rbx)
xorl %esi, %esi
callq 0x58a58
movb $0x0, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %r12, %rdi
movl $0x1, %esi
callq 0x58a58
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x9cbad
movq 0x8f3e9(%rip), %rcx # 0x12bf88
cmpb $0x0, (%rcx)
je 0x9cba9
incl 0x8(%rax)
jmp 0x9cbad
lock
incl 0x8(%rax)
cmpq $0x0, 0x38(%rbx)
je 0x9cbc3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r14
movl $0x10, %edi
callq 0x1a460
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x867a2
leaq 0x54181(%rip), %rsi # 0xf0d70
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x78e69
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x1ae50
xorl %ebp, %ebp
movq 0x8f3d9(%rip), %rsi # 0x12bff0
movq 0x8f342(%rip), %rdx # 0x12bf60
movq %r15, %rdi
callq 0x1af40
movq %rax, %r12
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc44
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0x9cc89
jmp 0x9cc91
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0x9cc89
movq %rax, %r12
movq %r15, %rdi
callq 0x1a690
movq 0x70(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x9cca3
callq 0x6d8f8
movq %r14, %rdi
callq 0x86480
movq %rbx, %rdi
callq 0x9ccbc
movq %r12, %rdi
callq 0x1afd0
nop
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
movups xmmword ptr [rdi+18h], xmm0
xor r13d, r13d
mov [rdi+30h], r13
movups xmm0, xmmword ptr [rsi+10h]
mov [rsi+18h], r13
movups xmmword ptr [rdi+28h], xmm0
mov [rsi+10h], r13
mov [rdi+40h], r13
movups xmm0, xmmword ptr [rsi+20h]
mov [rsi+28h], r13
movups xmmword ptr [rdi+38h], xmm0
mov [rsi+20h], r13
mov [rdi+50h], r13
movups xmm0, xmmword ptr [rsi+30h]
mov [rsi+38h], r13
movups xmmword ptr [rdi+48h], xmm0
mov [rsi+30h], r13
lea r12, [rdi+58h]
lea rdi, [rsi+40h]
movups xmm0, xmmword ptr [rsi+40h]
movups xmmword ptr [rbx+58h], xmm0
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 byte ptr [r15+40h], 0
mov [r15+48h], r13
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [r14]
mov [rbx+68h], rax
mov rax, [r14+8]
mov [rbx+70h], rax
test rax, rax
jz short loc_9CBAD
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_9CBA9
inc dword ptr [rax+8]
jmp short loc_9CBAD
loc_9CBA9:
lock inc dword ptr [rax+8]
loc_9CBAD:
cmp qword ptr [rbx+38h], 0
jz short loc_9CBC3
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9CBC3:
lea r14, [rbx+18h]
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r12, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9CC44
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9CC44:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9CC5F
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9CC5F:
test bpl, bpl
jnz short loc_9CC89
jmp short loc_9CC91
mov r12, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9CC89
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9CC89
mov r12, rax
loc_9CC89:
mov rdi, r15; void *
call ___cxa_free_exception
loc_9CC91:
mov rdi, [rbx+70h]
add rbx, 8
test rdi, rdi
jz short loc_9CCA3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9CCA3:
mov rdi, r14; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
mov rdi, r12
call __Unwind_Resume
| long long minja::Context::Context(long long a1, long long a2, _QWORD *a3)
{
__int128 v4; // xmm0
__int128 v5; // xmm0
__int128 v6; // xmm0
long long result; // rax
void *exception; // r15
_BYTE v9[16]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v10[16]; // [rsp+28h] [rbp-50h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'minja::Context + 2;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
v4 = *(_OWORD *)(a2 + 16);
*(_QWORD *)(a2 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = v4;
*(_QWORD *)(a2 + 16) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
v5 = *(_OWORD *)(a2 + 32);
*(_QWORD *)(a2 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = v5;
*(_QWORD *)(a2 + 32) = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v6 = *(_OWORD *)(a2 + 48);
*(_QWORD *)(a2 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = v6;
*(_QWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a2 + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a2 + 64));
*(_BYTE *)(a2 + 64) = 0;
*(_QWORD *)(a2 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 88));
*(_QWORD *)(a1 + 104) = *a3;
result = a3[1];
*(_QWORD *)(a1 + 112) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
if ( !*(_QWORD *)(a1 + 56) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, a1 + 24, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Context values must be an object: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| Context:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x22b140]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS xmmword ptr [RDI + 0x18],XMM0
XOR R13D,R13D
MOV qword ptr [RDI + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x10]
MOV qword ptr [RSI + 0x18],R13
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RSI + 0x10],R13
MOV qword ptr [RDI + 0x40],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x20]
MOV qword ptr [RSI + 0x28],R13
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV qword ptr [RSI + 0x20],R13
MOV qword ptr [RDI + 0x50],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x30]
MOV qword ptr [RSI + 0x38],R13
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RSI + 0x30],R13
LEA R12,[RDI + 0x58]
LEA RDI,[RSI + 0x40]
MOVUPS XMM0,xmmword ptr [RSI + 0x40]
MOVUPS xmmword ptr [RBX + 0x58],XMM0
XOR ESI,ESI
CALL 0x00158a58
MOV byte ptr [R15 + 0x40],0x0
MOV qword ptr [R15 + 0x48],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x00158a58
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x0019cbad
MOV RCX,qword ptr [0x0022bf88]
CMP byte ptr [RCX],0x0
JZ 0x0019cba9
INC dword ptr [RAX + 0x8]
JMP 0x0019cbad
LAB_0019cba9:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019cbad:
CMP qword ptr [RBX + 0x38],0x0
JZ 0x0019cbc3
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019cbc3:
LEA R14,[RBX + 0x18]
MOV EDI,0x10
CALL 0x0011a460
MOV R15,RAX
LAB_0019cbd4:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001867a2
LAB_0019cbe8:
LEA RSI,[0x1f0d70]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00178e69
MOV BPL,0x1
LAB_0019cc01:
LEA RSI,[RSP + 0x28]
MOV RDI,R15
CALL 0x0011ae50
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,R15
CALL 0x0011af40
|
/* minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) */
void __thiscall minja::Context::Context(Context *this,Value *param_1,shared_ptr *param_2)
{
long lVar1;
int8 uVar2;
runtime_error *this_00;
int1 local_70 [32];
string local_50 [32];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__Context_0022b150;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x18);
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(this + 0x28) = *(int8 *)(param_1 + 0x10);
*(int8 *)(this + 0x30) = uVar2;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(this + 0x40) = 0;
uVar2 = *(int8 *)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(this + 0x38) = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x40) = uVar2;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(this + 0x50) = 0;
uVar2 = *(int8 *)(param_1 + 0x38);
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x30);
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)(param_1 + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x40);
*(int8 *)(this + 0x60) = uVar2;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)param_1 + '@'));
param_1[0x40] = (Value)0x0;
*(int8 *)(param_1 + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + 'X'));
*(int8 *)(this + 0x68) = *(int8 *)param_2;
lVar1 = *(long *)(param_2 + 8);
*(long *)(this + 0x70) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
if (*(long *)(this + 0x38) != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019cbd4 to 0019cbe7 has its CatchHandler @ 0019cc86 */
Value::dump_abi_cxx11_((int)local_70,(bool)((char)this + '\x18'));
/* try { // try from 0019cbe8 to 0019cbfd has its CatchHandler @ 0019cc66 */
std::operator+((char *)local_50,(string *)"Context values must be an object: ");
/* try { // try from 0019cc01 to 0019cc25 has its CatchHandler @ 0019cc26 */
std::runtime_error::runtime_error(this_00,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
| |
30,007 | my_string_repertoire | eloqsql/strings/ctype.c | my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
} | O3 | c | my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x98(%rdi)
jne 0xdc667
testb $0x20, 0xd(%r15)
jne 0xdc667
movl $0x1, %eax
testq %rbx, %rbx
jle 0xdc6cd
addq %r14, %rbx
cmpb $0x0, (%r14)
js 0xdc6da
incq %r14
cmpq %rbx, %r14
jb 0xdc657
jmp 0xdc6cd
addq %r14, %rbx
movq 0xb8(%r15), %rax
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xdc6c3
cmpq $0x7f, -0x28(%rbp)
ja 0xdc6c3
leaq -0x28(%rbp), %r12
movq %r14, %rcx
movl %eax, %r14d
addq %rcx, %r14
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xdc6c3
cmpq $0x80, -0x28(%rbp)
jb 0xdc693
movzbl %cl, %eax
leal 0x1(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %eax
jmp 0xdc6cd
| my_string_repertoire:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
cmp dword ptr [rdi+98h], 1
jnz short loc_DC667
test byte ptr [r15+0Dh], 20h
jnz short loc_DC667
mov eax, 1
test rbx, rbx
jle short loc_DC6CD
add rbx, r14
loc_DC657:
cmp byte ptr [r14], 0
js short loc_DC6DA
inc r14
cmp r14, rbx
jb short loc_DC657
jmp short loc_DC6CD
loc_DC667:
add rbx, r14
mov rax, [r15+0B8h]
lea rsi, [rbp+var_28]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_DC6C3
cmp [rbp+var_28], 7Fh
ja short loc_DC6C3
lea r12, [rbp+var_28]
loc_DC693:
mov rcx, r14
mov r14d, eax
add r14, rcx
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_DC6C3
cmp [rbp+var_28], 80h
jb short loc_DC693
loc_DC6C3:
movzx eax, cl
lea eax, ds:1[rax*2]
loc_DC6CD:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_DC6DA:
mov eax, 3
jmp short loc_DC6CD
| long long my_string_repertoire(long long a1, char *a2, long long a3)
{
char *v3; // r14
long long result; // rax
char *v5; // rbx
int v6; // eax
bool v7; // cl
_QWORD v8[5]; // [rsp+8h] [rbp-28h] BYREF
v3 = a2;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_BYTE *)(a1 + 13) & 0x20) != 0 )
{
v5 = &a2[a3];
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
a2,
&a2[a3]);
v7 = v6 > 0;
if ( v6 > 0 && v8[0] <= 0x7FuLL )
{
do
{
v3 += (unsigned int)v6;
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
v3,
v5);
v7 = v6 > 0;
}
while ( v6 > 0 && v8[0] < 0x80uLL );
}
return 2 * (unsigned int)v7 + 1;
}
else
{
result = 1LL;
if ( a3 > 0 )
{
while ( *v3 >= 0 )
{
if ( ++v3 >= &a2[a3] )
return result;
}
return 3LL;
}
}
return result;
}
| my_string_repertoire:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CMP dword ptr [RDI + 0x98],0x1
JNZ 0x001dc667
TEST byte ptr [R15 + 0xd],0x20
JNZ 0x001dc667
MOV EAX,0x1
TEST RBX,RBX
JLE 0x001dc6cd
ADD RBX,R14
LAB_001dc657:
CMP byte ptr [R14],0x0
JS 0x001dc6da
INC R14
CMP R14,RBX
JC 0x001dc657
JMP 0x001dc6cd
LAB_001dc667:
ADD RBX,R14
MOV RAX,qword ptr [R15 + 0xb8]
LEA RSI,[RBP + -0x28]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001dc6c3
CMP qword ptr [RBP + -0x28],0x7f
JA 0x001dc6c3
LEA R12,[RBP + -0x28]
LAB_001dc693:
MOV RCX,R14
MOV R14D,EAX
ADD R14,RCX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001dc6c3
CMP qword ptr [RBP + -0x28],0x80
JC 0x001dc693
LAB_001dc6c3:
MOVZX EAX,CL
LEA EAX,[0x1 + RAX*0x2]
LAB_001dc6cd:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001dc6da:
MOV EAX,0x3
JMP 0x001dc6cd
|
char my_string_repertoire(long param_1,char *param_2,long param_3)
{
char cVar1;
uint uVar2;
bool bVar3;
char *pcVar4;
ulong local_30;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(byte *)(param_1 + 0xd) & 0x20) == 0)) {
cVar1 = '\x01';
if (0 < param_3) {
pcVar4 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return '\x03';
}
param_2 = param_2 + 1;
} while (param_2 < pcVar4);
}
}
else {
pcVar4 = param_2 + param_3;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((0 < (int)uVar2) && (local_30 < 0x80)) {
do {
param_2 = param_2 + uVar2;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((int)uVar2 < 1) break;
} while (local_30 < 0x80);
}
cVar1 = bVar3 * '\x02' + '\x01';
}
return cVar1;
}
| |
30,008 | my_casedn_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_casedn_utf8mb4(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_casedn_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0xc3f0a
jmp 0xc3f0c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0xc3f3c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xc3a80
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xc3f45
jmp 0xc3f98
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc7ee0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xc3ab0
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0xc3f71
jmp 0xc3f98
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xc3f0c
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_casedn_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_C3F0A:
jmp short $+2
loc_C3F0C:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_C3F3C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_C3F3C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_C3F45
jmp short loc_C3F98
loc_C3F45:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_wc_mb_utf8mb4
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_C3F71
jmp short loc_C3F98
loc_C3F71:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_C3F0C
loc_C3F98:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casedn_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_mb_wc_utf8mb4(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_tolower_utf8mb4(v8, v14);
v12 = my_wc_mb_utf8mb4(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_casedn_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001c3f0a
LAB_001c3f0a:
JMP 0x001c3f0c
LAB_001c3f0c:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x001c3f3c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001c3a80
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_001c3f3c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x001c3f45
JMP 0x001c3f98
LAB_001c3f45:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x001c7ee0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x001c3ab0
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x001c3f71
JMP 0x001c3f98
LAB_001c3f71:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001c3f0c
LAB_001c3f98:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_utf8mb4(uVar1,&local_38);
iVar3 = my_wc_mb_utf8mb4(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
| |
30,009 | thr_print_lock | eloqsql/mysys/thr_lock.c | static void thr_print_lock(const char* name,struct st_lock_list *list)
{
THR_LOCK_DATA *data,**prev;
uint count=0;
if (list->data)
{
printf("%-10s: ",name);
prev= &list->data;
for (data=list->data; data && count++ < MAX_LOCKS ; data=data->next)
{
printf("%p (%lu:%d); ", data, (ulong) data->owner->thread_id,
(int) data->type);
if (data->prev != prev)
printf("\nWarning: prev didn't point at previous lock\n");
prev= &data->next;
}
puts("");
if (prev != list->last)
printf("Warning: last didn't point at last lock\n");
}
} | O3 | c | thr_print_lock:
cmpq $0x0, (%rsi)
je 0xa3e94
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x387ae(%rip), %rsi # 0xdc597
movl $0x1, %edi
xorl %eax, %eax
callq 0x29810
movq (%rbx), %r12
movq %rbx, %r14
testq %r12, %r12
je 0xa3e62
movl $0x3e9, %r13d # imm = 0x3E9
leaq 0x38792(%rip), %r15 # 0xdc59f
movq %rbx, %r14
decl %r13d
je 0xa3e62
movq (%r12), %rax
movq 0x8(%rax), %rcx
movl 0x40(%r12), %r8d
movl $0x1, %edi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x29810
cmpq %r14, 0x10(%r12)
je 0xa3e4e
movl $0x1, %edi
leaq 0x38766(%rip), %rsi # 0xdc5ad
xorl %eax, %eax
callq 0x29810
movq %r12, %r14
movq 0x8(%r12), %rax
addq $0x8, %r14
movq %rax, %r12
testq %rax, %rax
jne 0xa3e10
movl $0xa, %edi
callq 0x29900
cmpq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
je 0xa3e94
leaq 0x38753(%rip), %rsi # 0xdc5db
movl $0x1, %edi
xorl %eax, %eax
jmp 0x29810
retq
nopl (%rax)
| thr_print_lock:
cmp qword ptr [rsi], 0
jz locret_A3E94
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov rdx, rdi
lea rsi, a10s; "%-10s: "
mov edi, 1
xor eax, eax
call ___printf_chk
mov r12, [rbx]
mov r14, rbx
test r12, r12
jz short loc_A3E62
mov r13d, 3E9h
lea r15, aPLuD; "%p (%lu:%d); "
mov r14, rbx
loc_A3E10:
dec r13d
jz short loc_A3E62
mov rax, [r12]
mov rcx, [rax+8]
mov r8d, [r12+40h]
mov edi, 1
mov rsi, r15
mov rdx, r12
xor eax, eax
call ___printf_chk
cmp [r12+10h], r14
jz short loc_A3E4E
mov edi, 1
lea rsi, aWarningPrevDid; "\nWarning: prev didn't point at previou"...
xor eax, eax
call ___printf_chk
loc_A3E4E:
mov r14, r12
mov rax, [r12+8]
add r14, 8
mov r12, rax
test rax, rax
jnz short loc_A3E10
loc_A3E62:
mov edi, 0Ah
call _putchar
cmp r14, [rbx+8]
lea rsp, [rsp+8]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jz short locret_A3E94
lea rsi, aWarningLastDid; "Warning: last didn't point at last lock"...
mov edi, 1
xor eax, eax
jmp ___printf_chk
locret_A3E94:
retn
| long long thr_print_lock(const char *a1, _QWORD *a2)
{
long long v2; // r12
_QWORD *v3; // r14
int v4; // r13d
long long result; // rax
if ( *a2 )
{
__printf_chk(1LL, "%-10s: ", a1);
v2 = *a2;
v3 = a2;
if ( *a2 )
{
v4 = 1001;
v3 = a2;
do
{
if ( !--v4 )
break;
__printf_chk(1LL, "%p (%lu:%d); ", (const void *)v2, *(_QWORD *)(*(_QWORD *)v2 + 8LL), *(_DWORD *)(v2 + 64));
if ( *(_QWORD **)(v2 + 16) != v3 )
__printf_chk(1LL, "\nWarning: prev didn't point at previous lock\n");
v3 = (_QWORD *)(v2 + 8);
v2 = *(_QWORD *)(v2 + 8);
}
while ( v2 );
}
result = putchar(10LL);
if ( v3 != (_QWORD *)a2[1] )
return __printf_chk(1LL, "Warning: last didn't point at last lock\n");
}
return result;
}
| thr_print_lock:
CMP qword ptr [RSI],0x0
JZ 0x001a3e94
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RDX,RDI
LEA RSI,[0x1dc597]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00129810
MOV R12,qword ptr [RBX]
MOV R14,RBX
TEST R12,R12
JZ 0x001a3e62
MOV R13D,0x3e9
LEA R15,[0x1dc59f]
MOV R14,RBX
LAB_001a3e10:
DEC R13D
JZ 0x001a3e62
MOV RAX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0x8]
MOV R8D,dword ptr [R12 + 0x40]
MOV EDI,0x1
MOV RSI,R15
MOV RDX,R12
XOR EAX,EAX
CALL 0x00129810
CMP qword ptr [R12 + 0x10],R14
JZ 0x001a3e4e
MOV EDI,0x1
LEA RSI,[0x1dc5ad]
XOR EAX,EAX
CALL 0x00129810
LAB_001a3e4e:
MOV R14,R12
MOV RAX,qword ptr [R12 + 0x8]
ADD R14,0x8
MOV R12,RAX
TEST RAX,RAX
JNZ 0x001a3e10
LAB_001a3e62:
MOV EDI,0xa
CALL 0x00129900
CMP R14,qword ptr [RBX + 0x8]
LEA RSP,[RSP + 0x8]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JZ 0x001a3e94
LEA RSI,[0x1dc5db]
MOV EDI,0x1
XOR EAX,EAX
JMP 0x00129810
LAB_001a3e94:
RET
|
void thr_print_lock(int8 param_1,long *param_2)
{
long *plVar1;
long *plVar2;
int iVar3;
long *plVar4;
if (*param_2 != 0) {
__printf_chk(1,"%-10s: ",param_1);
plVar4 = param_2;
if ((long *)*param_2 != (long *)0x0) {
iVar3 = 0x3e9;
plVar2 = (long *)*param_2;
do {
iVar3 = iVar3 + -1;
if (iVar3 == 0) break;
__printf_chk(1,"%p (%lu:%d); ",plVar2,*(int8 *)(*plVar2 + 8),(int)plVar2[8]);
if ((long *)plVar2[2] != plVar4) {
__printf_chk(1,"\nWarning: prev didn\'t point at previous lock\n");
}
plVar1 = plVar2 + 1;
plVar4 = plVar2 + 1;
plVar2 = (long *)*plVar1;
} while ((long *)*plVar1 != (long *)0x0);
}
putchar(10);
if (plVar4 != (long *)param_2[1]) {
__printf_chk(1,"Warning: last didn\'t point at last lock\n");
return;
}
}
return;
}
| |
30,010 | common_init() | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O2 | cpp | common_init():
pushq %rax
leaq 0x44f4(%rip), %rdi # 0x28f5c
xorl %esi, %esi
callq 0x20c70
leaq 0xad5ca(%rip), %rax # 0xd2040
cmpl $0x0, (%rax)
js 0x24ac6
callq 0x71166
leaq 0xad0a9(%rip), %rcx # 0xd1b30
movl (%rcx), %ecx
leaq 0xad0a8(%rip), %rdx # 0xd1b38
movq (%rdx), %r8
leaq 0xad0a6(%rip), %rdx # 0xd1b40
movq (%rdx), %r9
leaq 0xad0a4(%rip), %r10 # 0xd1b48
leaq 0x693ca(%rip), %r11 # 0x8de75
leaq 0x693ef(%rip), %rdx # 0x8dea1
pushq $0x2
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
pushq %r11
pushq (%r10)
callq 0x711fe
popq %rax
popq %rcx
popq %rax
retq
| _Z11common_initv:
push rax
lea rdi, _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv; common_init(void)::$_0::__invoke(ggml_log_level,char const*,void *)
xor esi, esi
call _llama_log_set
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_24AC6
call _Z15common_log_mainv; common_log_main(void)
lea rcx, LLAMA_BUILD_NUMBER
mov ecx, [rcx]
lea rdx, LLAMA_COMMIT
mov r8, [rdx]
lea rdx, LLAMA_COMPILER
mov r9, [rdx]
lea r10, LLAMA_BUILD_TARGET
lea r11, aEndIndexOutOfB+19h; ""
lea rdx, aBuildDSWithSFo; "build: %d (%s) with %s for %s%s\n"
push 2
pop rsi
mov rdi, rax
xor eax, eax
push r11
push qword ptr [r10]
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
pop rax
pop rcx
loc_24AC6:
pop rax
retn
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> common_init(void)
{
int v0; // eax
llama_log_set(common_init(void)::$_0::__invoke, 0LL);
if ( common_log_verbosity_thold >= 0 )
{
v0 = common_log_main();
common_log_add(
v0,
2,
(unsigned int)"build: %d (%s) with %s for %s%s\n",
LLAMA_BUILD_NUMBER,
LLAMA_COMMIT[0],
LLAMA_COMPILER[0]);
}
}
| common_init:
PUSH RAX
LEA RDI,[0x128f5c]
XOR ESI,ESI
CALL 0x00120c70
LEA RAX,[0x1d2040]
CMP dword ptr [RAX],0x0
JS 0x00124ac6
CALL 0x00171166
LEA RCX,[0x1d1b30]
MOV ECX,dword ptr [RCX]
LEA RDX,[0x1d1b38]
MOV R8,qword ptr [RDX]
LEA RDX,[0x1d1b40]
MOV R9,qword ptr [RDX]
LEA R10,[0x1d1b48]
LEA R11,[0x18de75]
LEA RDX,[0x18dea1]
PUSH 0x2
POP RSI
MOV RDI,RAX
XOR EAX,EAX
PUSH R11
PUSH qword ptr [R10]
CALL 0x001711fe
POP RAX
POP RCX
LAB_00124ac6:
POP RAX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_init() */
int8 common_init(void)
{
int8 in_RAX;
int8 uVar1;
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,LLAMA_COMMIT,
LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return in_RAX;
}
| |
30,011 | ma_control_file_end | eloqsql/storage/maria/ma_control_file.c | int ma_control_file_end(void)
{
int close_error;
DBUG_ENTER("ma_control_file_end");
if (control_file_fd < 0) /* already closed */
DBUG_RETURN(0);
#ifndef _WIN32
(void) my_lock(control_file_fd, F_UNLCK, 0L, F_TO_EOF,
MYF(MY_SEEK_NOT_DONE | MY_FORCE_LOCK));
#endif
close_error= mysql_file_close(control_file_fd, MYF(MY_WME));
/*
As mysql_file_close() frees structures even if close() fails, we do the
same, i.e. we mark the file as closed in all cases.
*/
control_file_fd= -1;
/*
As this module owns these variables, closing the module forbids access to
them (just a safety):
*/
last_checkpoint_lsn= LSN_IMPOSSIBLE;
last_logno= FILENO_IMPOSSIBLE;
max_trid_in_control_file= recovery_failures= 0;
DBUG_RETURN(close_error);
} | O0 | c | ma_control_file_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x26ec11(%rip) # 0x2bd3c0
jge 0x4e7bc
jmp 0x4e7b3
movl $0x0, -0x4(%rbp)
jmp 0x4e82f
movl 0x26ebfe(%rip), %edi # 0x2bd3c0
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0xa0, %r8d
movq %rcx, %rdx
callq 0xf3530
movl 0x26ebe1(%rip), %edx # 0x2bd3c0
leaq 0x1030fe(%rip), %rdi # 0x1518e4
movl $0x24d, %esi # imm = 0x24D
movl $0x10, %ecx
callq 0x4ec70
movl %eax, -0x8(%rbp)
movl $0xffffffff, 0x26ebbe(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x42995b(%rip) # 0x478168
movl $0x0, 0x429959(%rip) # 0x478170
movb $0x0, 0x429962(%rip) # 0x478180
movq $0x0, 0x42994f(%rip) # 0x478178
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ma_control_file_end:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:control_file_fd, 0
jge short loc_4E7BC
jmp short $+2
loc_4E7B3:
mov [rbp+var_4], 0
jmp short loc_4E82F
loc_4E7BC:
mov edi, cs:control_file_fd
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 0A0h
mov rdx, rcx
call my_lock
mov edx, cs:control_file_fd
lea rdi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 24Dh
mov ecx, 10h
call inline_mysql_file_close_1
mov [rbp+var_8], eax
mov cs:control_file_fd, 0FFFFFFFFh
mov cs:last_checkpoint_lsn, 0
mov cs:last_logno, 0
mov cs:recovery_failures, 0
mov cs:max_trid_in_control_file, 0
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_4E82F:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| long long ma_control_file_end()
{
unsigned int v1; // [rsp+8h] [rbp-8h]
if ( control_file_fd >= 0 )
{
my_lock((unsigned int)control_file_fd, 2LL, 0LL, 0LL, 160LL);
v1 = inline_mysql_file_close_1(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
589LL,
(unsigned int)control_file_fd,
16LL);
control_file_fd = -1;
last_checkpoint_lsn = 0LL;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0LL;
return v1;
}
else
{
return 0;
}
}
| ma_control_file_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP dword ptr [0x003bd3c0],0x0
JGE 0x0014e7bc
JMP 0x0014e7b3
LAB_0014e7b3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014e82f
LAB_0014e7bc:
MOV EDI,dword ptr [0x003bd3c0]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0xa0
MOV RDX,RCX
CALL 0x001f3530
MOV EDX,dword ptr [0x003bd3c0]
LEA RDI,[0x2518e4]
MOV ESI,0x24d
MOV ECX,0x10
CALL 0x0014ec70
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [0x003bd3c0],0xffffffff
MOV qword ptr [0x00578168],0x0
MOV dword ptr [0x00578170],0x0
MOV byte ptr [0x00578180],0x0
MOV qword ptr [0x00578178],0x0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014e82f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 ma_control_file_end(void)
{
int4 local_c;
if (control_file_fd < 0) {
local_c = 0;
}
else {
my_lock(control_file_fd,2,0,0,0xa0);
local_c = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_control_file.c",
0x24d,control_file_fd,0x10);
control_file_fd = -1;
last_checkpoint_lsn = 0;
last_logno = 0;
recovery_failures = 0;
max_trid_in_control_file = 0;
}
return local_c;
}
| |
30,012 | google::protobuf::internal::RepeatedFieldWrapper<long>::Add(void*, void const*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/reflection_internal.h | void Add(Field* data, const Value* value) const override {
MutableRepeatedField(data)->Add(ConvertToT(value));
} | O3 | c | google::protobuf::internal::RepeatedFieldWrapper<long>::Add(void*, void const*) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x80(%rax)
movl (%rbx), %r14d
cmpl 0x4(%rbx), %r14d
jne 0xa0bd0
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x82d3c
movq 0x8(%rbx), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r14,8)
jmp 0xa0bde
movq 0x8(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
leal 0x1(%r14), %ebp
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| _ZNK6google8protobuf8internal20RepeatedFieldWrapperIdE3AddEPvPKv:
push rbp
push r14
push rbx
sub rsp, 10h
mov rbx, rsi
mov rax, [rdi]
mov rsi, rdx
call qword ptr [rax+80h]
mov r14d, [rbx]
cmp r14d, [rbx+4]
jnz short loc_A0BD0
lea ebp, [r14+1]
mov rdi, rbx
mov esi, ebp
movsd [rsp+28h+var_20], xmm0
call _ZN6google8protobuf13RepeatedFieldIdE7ReserveEi; google::protobuf::RepeatedField<double>::Reserve(int)
mov rax, [rbx+8]
movsd xmm0, [rsp+28h+var_20]
movsd qword ptr [rax+r14*8], xmm0
jmp short loc_A0BDE
loc_A0BD0:
mov rax, [rbx+8]
movsd qword ptr [rax+r14*8], xmm0
lea ebp, [r14+1]
loc_A0BDE:
mov [rbx], ebp
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long google::protobuf::internal::RepeatedFieldWrapper<double>::Add(
long long a1,
int *a2,
long long a3,
double a4)
{
long long v4; // r14
int v5; // ebp
long long result; // rax
(*(void ( **)(long long, long long))(*(_QWORD *)a1 + 128LL))(a1, a3);
v4 = (unsigned int)*a2;
if ( (_DWORD)v4 == a2[1] )
{
v5 = v4 + 1;
google::protobuf::RepeatedField<double>::Reserve(a2, v4 + 1);
result = *((_QWORD *)a2 + 1);
*(double *)(result + 8 * v4) = a4;
}
else
{
result = *((_QWORD *)a2 + 1);
*(double *)(result + 8 * v4) = a4;
v5 = v4 + 1;
}
*a2 = v5;
return result;
}
| Add:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV RAX,qword ptr [RDI]
MOV RSI,RDX
CALL qword ptr [RAX + 0x80]
MOV R14D,dword ptr [RBX]
CMP R14D,dword ptr [RBX + 0x4]
JNZ 0x001a0bd0
LEA EBP,[R14 + 0x1]
MOV RDI,RBX
MOV ESI,EBP
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x00182d3c
MOV RAX,qword ptr [RBX + 0x8]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RAX + R14*0x8],XMM0
JMP 0x001a0bde
LAB_001a0bd0:
MOV RAX,qword ptr [RBX + 0x8]
MOVSD qword ptr [RAX + R14*0x8],XMM0
LEA EBP,[R14 + 0x1]
LAB_001a0bde:
MOV dword ptr [RBX],EBP
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::internal::RepeatedFieldWrapper<double>::Add(void*, void const*) const */
void __thiscall
google::protobuf::internal::RepeatedFieldWrapper<double>::Add
(RepeatedFieldWrapper<double> *this,void *param_1,void *param_2)
{
uint uVar1;
int8 uVar2;
uVar2 = (**(code **)(*(long *)this + 0x80))(this,param_2);
/* WARNING: Load size is inaccurate */
uVar1 = *param_1;
if (uVar1 == *(uint *)((long)param_1 + 4)) {
RepeatedField<double>::Reserve((RepeatedField<double> *)param_1,uVar1 + 1);
*(int8 *)(*(long *)((long)param_1 + 8) + (ulong)uVar1 * 8) = uVar2;
}
else {
*(int8 *)(*(long *)((long)param_1 + 8) + (ulong)uVar1 * 8) = uVar2;
}
*(uint *)param_1 = uVar1 + 1;
return;
}
| |
30,013 | my_once_alloc | eloqsql/mysys/my_once.c | void* my_once_alloc(size_t Size, myf MyFlags)
{
size_t get_size, max_left;
uchar* point;
reg1 USED_MEM *next;
reg2 USED_MEM **prev;
Size= ALIGN_SIZE(Size);
prev= &my_once_root_block;
max_left=0;
for (next=my_once_root_block ; next && next->left < Size ; next= next->next)
{
if (next->left > max_left)
max_left=next->left;
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= Size+ALIGN_SIZE(sizeof(USED_MEM));
if (max_left*4 < my_once_extra && get_size < my_once_extra)
get_size=my_once_extra; /* Normal alloc */
if ((next = (USED_MEM*) malloc(get_size)) == 0)
{
my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), get_size);
return((uchar*) 0);
}
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));
next->next= 0;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
}
point= (uchar*) ((char*) next+ (next->size-next->left));
next->left-= Size;
if (MyFlags & MY_ZEROFILL)
bzero(point, Size);
return((void*) point);
} | O0 | c | my_once_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
leaq 0x35fe05(%rip), %rax # 0x386250
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x35fdf2(%rip), %rax # 0x386250
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
je 0x26483
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2648c
jmp 0x264bb
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0x264a6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x26465
cmpq $0x0, -0x38(%rbp)
jne 0x26594
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x2, %rax
leaq 0x1a7e9f(%rip), %rcx # 0x1ce380
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x26507
movq -0x20(%rbp), %rax
leaq 0x1a7e8d(%rip), %rcx # 0x1ce380
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x26507
leaq 0x1a7e7f(%rip), %rax # 0x1ce380
movl (%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x243c0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x2655e
callq 0x24040
movl (%rax), %eax
movl %eax, -0x48(%rbp)
callq 0x26ab0
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0x26551
movq -0x20(%rbp), %rdx
movl $0x5, %edi
movl $0x1004, %esi # imm = 0x1004
movb $0x0, %al
callq 0x2e5f0
movq $0x0, -0x8(%rbp)
jmp 0x265e7
jmp 0x26560
jmp 0x26562
movq -0x38(%rbp), %rax
movq $0x0, (%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)
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 -0x10(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x265df
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x24180
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_once_alloc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
lea rax, my_once_root_block
mov [rbp+var_40], rax
mov [rbp+var_28], 0
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_38], rax
loc_26465:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_41], al
jz short loc_26483
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
setb al
mov [rbp+var_41], al
loc_26483:
mov al, [rbp+var_41]
test al, 1
jnz short loc_2648C
jmp short loc_264BB
loc_2648C:
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_28]
jbe short loc_264A6
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_264A6:
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_26465
loc_264BB:
cmp [rbp+var_38], 0
jnz loc_26594
mov rax, [rbp+var_10]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
shl rax, 2
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_26507
mov rax, [rbp+var_20]
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_26507
lea rax, my_once_extra
mov eax, [rax]
mov [rbp+var_20], rax
loc_26507:
mov rdi, [rbp+var_20]
call _malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_2655E
call ___errno_location
mov eax, [rax]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 18h
cmp rax, 0
jz short loc_26551
mov rdx, [rbp+var_20]
mov edi, 5
mov esi, 1004h
mov al, 0
call my_error
loc_26551:
mov [rbp+var_8], 0
jmp loc_265E7
loc_2655E:
jmp short $+2
loc_26560:
jmp short $+2
loc_26562:
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
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
loc_26594:
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_10]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rax, [rbp+var_18]
and rax, 20h
cmp rax, 0
jz short loc_265DF
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
xor esi, esi
call _memset
loc_265DF:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_265E7:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| char * my_once_alloc(long long a1, char a2)
{
int v2; // r8d
int v3; // r9d
int v5; // [rsp+8h] [rbp-48h]
bool v6; // [rsp+Fh] [rbp-41h]
_QWORD *v7; // [rsp+10h] [rbp-40h]
_QWORD *i; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned long long v10; // [rsp+28h] [rbp-28h]
unsigned long long v11; // [rsp+30h] [rbp-20h]
unsigned long long v12; // [rsp+40h] [rbp-10h]
v12 = (a1 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v7 = &my_once_root_block;
v10 = 0LL;
for ( i = (_QWORD *)my_once_root_block; ; i = (_QWORD *)*i )
{
v6 = 0;
if ( i )
v6 = i[1] < v12;
if ( !v6 )
break;
if ( i[1] > v10 )
v10 = i[1];
v7 = i;
}
if ( !i )
{
v11 = v12 + 24;
if ( 4 * v10 < my_once_extra && v11 < my_once_extra )
v11 = my_once_extra;
i = (_QWORD *)malloc(v11);
if ( !i )
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a2 & 0x18) != 0 )
my_error(5, 4100, v11, v5, v2, v3);
return 0LL;
}
*i = 0LL;
i[2] = v11;
i[1] = v11 - 24;
*v7 = i;
}
v9 = (char *)i + i[2] - i[1];
i[1] -= v12;
if ( (a2 & 0x20) != 0 )
memset(v9, 0LL, v12);
return v9;
}
| my_once_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0x486250]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x28],0x0
LEA RAX,[0x486250]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_00126465:
XOR EAX,EAX
CMP qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x00126483
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
MOV byte ptr [RBP + -0x41],AL
LAB_00126483:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0012648c
JMP 0x001264bb
LAB_0012648c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001264a6
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001264a6:
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 0x00126465
LAB_001264bb:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00126594
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x2
LEA RCX,[0x2ce380]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x00126507
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x2ce380]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x00126507
LEA RAX,[0x2ce380]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_00126507:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001243c0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x0012655e
CALL 0x00124040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x00126ab0
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x18
CMP RAX,0x0
JZ 0x00126551
MOV RDX,qword ptr [RBP + -0x20]
MOV EDI,0x5
MOV ESI,0x1004
MOV AL,0x0
CALL 0x0012e5f0
LAB_00126551:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001265e7
LAB_0012655e:
JMP 0x00126560
LAB_00126560:
JMP 0x00126562
LAB_00126562:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
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
LAB_00126594:
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 + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x20
CMP RAX,0x0
JZ 0x001265df
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00124180
LAB_001265df:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001265e7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
void * my_once_alloc(long param_1,ulong param_2)
{
int iVar1;
ulong __n;
int *piVar2;
void *__s;
bool bVar3;
int8 *local_48;
int8 *local_40;
ulong local_30;
size_t local_28;
__n = param_1 + 7U & 0xfffffffffffffff8;
local_48 = &my_once_root_block;
local_30 = 0;
local_40 = my_once_root_block;
while( true ) {
bVar3 = false;
if (local_40 != (int8 *)0x0) {
bVar3 = (ulong)local_40[1] < __n;
}
if (!bVar3) break;
if (local_30 < (ulong)local_40[1]) {
local_30 = local_40[1];
}
local_48 = local_40;
local_40 = (int8 *)*local_40;
}
if (local_40 == (int8 *)0x0) {
local_28 = __n + 0x18;
if ((local_30 << 2 < (ulong)my_once_extra) && (local_28 < my_once_extra)) {
local_28 = (size_t)my_once_extra;
}
local_40 = (int8 *)malloc(local_28);
if (local_40 == (int8 *)0x0) {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_2 & 0x18) != 0) {
my_error(5,0x1004,local_28);
}
return (void *)0x0;
}
*local_40 = 0;
local_40[2] = local_28;
local_40[1] = local_28 - 0x18;
*local_48 = local_40;
}
__s = (void *)((long)local_40 + (local_40[2] - local_40[1]));
local_40[1] = local_40[1] - __n;
if ((param_2 & 0x20) != 0) {
memset(__s,0,__n);
}
return __s;
}
| |
30,014 | get_defaults_options | eloqsql/mysys/my_default.c | int get_defaults_options(char **argv)
{
static char file_buffer[FN_REFLEN];
static char extra_file_buffer[FN_REFLEN];
char **orig_argv= argv;
argv++; /* Skip program name */
my_defaults_file= my_defaults_group_suffix= my_defaults_extra_file= 0;
my_no_defaults= my_print_defaults= FALSE;
if (*argv && !strcmp(*argv, "--no-defaults"))
{
my_no_defaults= 1;
argv++;
}
else
for(; *argv; argv++)
{
if (!my_defaults_file && is_prefix(*argv, "--defaults-file="))
my_defaults_file= *argv + sizeof("--defaults-file=")-1;
else
if (!my_defaults_extra_file && is_prefix(*argv, "--defaults-extra-file="))
my_defaults_extra_file= *argv + sizeof("--defaults-extra-file=")-1;
else
if (!my_defaults_group_suffix && is_prefix(*argv, "--defaults-group-suffix="))
my_defaults_group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
else
break;
}
if (*argv && !strcmp(*argv, "--print-defaults"))
{
my_print_defaults= 1;
my_defaults_mark_files= FALSE;
argv++;
}
if (! my_defaults_group_suffix)
my_defaults_group_suffix= getenv("MYSQL_GROUP_SUFFIX");
if (my_defaults_extra_file && my_defaults_extra_file != extra_file_buffer)
{
my_realpath(extra_file_buffer, my_defaults_extra_file, MYF(0));
my_defaults_extra_file= extra_file_buffer;
}
if (my_defaults_file && my_defaults_file != file_buffer)
{
my_realpath(file_buffer, my_defaults_file, MYF(0));
my_defaults_file= file_buffer;
}
return (int)(argv - orig_argv);
} | O3 | c | get_defaults_options:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %rbx
leaq 0xba82c7(%rip), %r15 # 0xc5af58
xorl %eax, %eax
movq %rax, (%r15)
leaq 0xba82b3(%rip), %r14 # 0xc5af50
movq %rax, (%r14)
leaq 0xba82a1(%rip), %r13 # 0xc5af48
movq %rax, (%r13)
leaq 0xba8290(%rip), %rcx # 0xc5af42
movb %al, (%rcx)
leaq 0xba8286(%rip), %rcx # 0xc5af41
movb %al, (%rcx)
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0xb2da0
leaq 0x55e4f(%rip), %rsi # 0x108b24
movq %r12, %rdi
callq 0x2b7d0
testl %eax, %eax
je 0xb2d5e
cmpq $0x0, (%r13)
je 0xb2d11
cmpq $0x0, (%r15)
je 0xb2d2e
cmpq $0x0, (%r14)
jne 0xb2d70
movq (%rbx), %rdi
leaq 0x55e5c(%rip), %rsi # 0x108b5a
callq 0xfa460
movl $0x18, %ecx
movq %r14, %rdx
testl %eax, %eax
jne 0xb2d49
jmp 0xb2d70
movq %r12, %rdi
leaq 0x55e17(%rip), %rsi # 0x108b32
callq 0xfa460
movl $0x10, %ecx
movq %r13, %rdx
testl %eax, %eax
jne 0xb2d49
jmp 0xb2ce8
movq (%rbx), %rdi
leaq 0x55e0b(%rip), %rsi # 0x108b43
callq 0xfa460
movl $0x16, %ecx
movq %r15, %rdx
testl %eax, %eax
je 0xb2cee
addq (%rbx), %rcx
movq %rcx, (%rdx)
movq 0x8(%rbx), %r12
addq $0x8, %rbx
testq %r12, %r12
jne 0xb2ce1
jmp 0xb2da0
leaq 0xba81dc(%rip), %rax # 0xc5af41
movb $0x1, (%rax)
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb2da0
leaq 0x55df4(%rip), %rsi # 0x108b73
callq 0x2b7d0
testl %eax, %eax
jne 0xb2da0
leaq 0xba81b3(%rip), %rax # 0xc5af42
movb $0x1, (%rax)
leaq 0xba81a7(%rip), %rax # 0xc5af40
movb $0x0, (%rax)
addq $0x8, %rbx
leaq 0xba81a9(%rip), %r14 # 0xc5af50
cmpq $0x0, (%r14)
jne 0xb2dbc
leaq 0x55dd0(%rip), %rdi # 0x108b84
callq 0x2b700
movq %rax, (%r14)
leaq 0xba8195(%rip), %r14 # 0xc5af58
movq (%r14), %rsi
testq %rsi, %rsi
sete %al
leaq 0xba838d(%rip), %r15 # 0xc5b160
cmpq %r15, %rsi
sete %cl
orb %al, %cl
jne 0xb2dea
movq %r15, %rdi
xorl %edx, %edx
callq 0xc4f9d
movq %r15, (%r14)
leaq 0xba8157(%rip), %r14 # 0xc5af48
movq (%r14), %rsi
testq %rsi, %rsi
sete %al
leaq 0xba815f(%rip), %r15 # 0xc5af60
cmpq %r15, %rsi
sete %cl
orb %al, %cl
jne 0xb2e18
movq %r15, %rdi
xorl %edx, %edx
callq 0xc4f9d
movq %r15, (%r14)
subq -0x30(%rbp), %rbx
shrq $0x3, %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| get_defaults_options:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
lea rbx, [rdi+8]
lea r15, my_defaults_extra_file
xor eax, eax
mov [r15], rax
lea r14, my_defaults_group_suffix
mov [r14], rax
lea r13, my_defaults_file
mov [r13+0], rax
lea rcx, my_print_defaults
mov [rcx], al
lea rcx, my_no_defaults
mov [rcx], al
mov [rbp+var_30], rdi
mov r12, [rdi+8]
test r12, r12
jz loc_B2DA0
lea rsi, aNoDefaults; "--no-defaults"
mov rdi, r12
call _strcmp
test eax, eax
jz short loc_B2D5E
loc_B2CE1:
cmp qword ptr [r13+0], 0
jz short loc_B2D11
loc_B2CE8:
cmp qword ptr [r15], 0
jz short loc_B2D2E
loc_B2CEE:
cmp qword ptr [r14], 0
jnz short loc_B2D70
mov rdi, [rbx]
lea rsi, aDefaultsGroupS; "--defaults-group-suffix="
call is_prefix
mov ecx, 18h
mov rdx, r14
test eax, eax
jnz short loc_B2D49
jmp short loc_B2D70
loc_B2D11:
mov rdi, r12
lea rsi, aDefaultsFile; "--defaults-file="
call is_prefix
mov ecx, 10h
mov rdx, r13
test eax, eax
jnz short loc_B2D49
jmp short loc_B2CE8
loc_B2D2E:
mov rdi, [rbx]
lea rsi, aDefaultsExtraF; "--defaults-extra-file="
call is_prefix
mov ecx, 16h
mov rdx, r15
test eax, eax
jz short loc_B2CEE
loc_B2D49:
add rcx, [rbx]
mov [rdx], rcx
mov r12, [rbx+8]
add rbx, 8
test r12, r12
jnz short loc_B2CE1
jmp short loc_B2DA0
loc_B2D5E:
lea rax, my_no_defaults
mov byte ptr [rax], 1
mov rax, [rbp+var_30]
lea rbx, [rax+10h]
loc_B2D70:
mov rdi, [rbx]
test rdi, rdi
jz short loc_B2DA0
lea rsi, aPrintDefaults; "--print-defaults"
call _strcmp
test eax, eax
jnz short loc_B2DA0
lea rax, my_print_defaults
mov byte ptr [rax], 1
lea rax, my_defaults_mark_files
mov byte ptr [rax], 0
add rbx, 8
loc_B2DA0:
lea r14, my_defaults_group_suffix
cmp qword ptr [r14], 0
jnz short loc_B2DBC
lea rdi, aMysqlGroupSuff; "MYSQL_GROUP_SUFFIX"
call _getenv
mov [r14], rax
loc_B2DBC:
lea r14, my_defaults_extra_file
mov rsi, [r14]
test rsi, rsi
setz al
lea r15, get_defaults_options_extra_file_buffer
cmp rsi, r15
setz cl
or cl, al
jnz short loc_B2DEA
mov rdi, r15
xor edx, edx
call my_realpath
mov [r14], r15
loc_B2DEA:
lea r14, my_defaults_file
mov rsi, [r14]
test rsi, rsi
setz al
lea r15, get_defaults_options_file_buffer
cmp rsi, r15
setz cl
or cl, al
jnz short loc_B2E18
mov rdi, r15
xor edx, edx
call my_realpath
mov [r14], r15
loc_B2E18:
sub rbx, [rbp+var_30]
shr rbx, 3
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long get_defaults_options(long long a1)
{
_QWORD *v1; // rbx
long long v2; // r12
int v3; // eax
long long v4; // rcx
_QWORD *v5; // rdx
int v6; // eax
int v7; // eax
v1 = (_QWORD *)(a1 + 8);
my_defaults_extra_file = 0LL;
my_defaults_group_suffix = 0LL;
my_defaults_file = 0LL;
my_print_defaults = 0;
my_no_defaults = 0;
v2 = *(_QWORD *)(a1 + 8);
if ( v2 )
{
if ( !(unsigned int)strcmp(*(_QWORD *)(a1 + 8), "--no-defaults") )
{
my_no_defaults = 1;
v1 = (_QWORD *)(a1 + 16);
}
else
{
while ( 1 )
{
if ( my_defaults_file || (v6 = is_prefix(v2, "--defaults-file="), v4 = 16LL, v5 = &my_defaults_file, !v6) )
{
if ( my_defaults_extra_file
|| (v7 = is_prefix(*v1, "--defaults-extra-file="), v4 = 22LL, v5 = &my_defaults_extra_file, !v7) )
{
if ( my_defaults_group_suffix )
break;
v3 = is_prefix(*v1, "--defaults-group-suffix=");
v4 = 24LL;
v5 = &my_defaults_group_suffix;
if ( !v3 )
break;
}
}
*v5 = *v1 + v4;
v2 = v1[1];
++v1;
if ( !v2 )
goto LABEL_17;
}
}
if ( *v1 && !(unsigned int)strcmp(*v1, "--print-defaults") )
{
my_print_defaults = 1;
my_defaults_mark_files = 0;
++v1;
}
}
LABEL_17:
if ( !my_defaults_group_suffix )
my_defaults_group_suffix = getenv("MYSQL_GROUP_SUFFIX");
if ( my_defaults_extra_file != 0LL && my_defaults_extra_file != (_QWORD)&get_defaults_options_extra_file_buffer )
{
my_realpath(&get_defaults_options_extra_file_buffer, my_defaults_extra_file, 0LL);
my_defaults_extra_file = &get_defaults_options_extra_file_buffer;
}
if ( my_defaults_file != 0LL && my_defaults_file != (_QWORD)&get_defaults_options_file_buffer )
{
my_realpath(&get_defaults_options_file_buffer, my_defaults_file, 0LL);
my_defaults_file = &get_defaults_options_file_buffer;
}
return (unsigned int)(((unsigned long long)v1 - a1) >> 3);
}
| get_defaults_options:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
LEA RBX,[RDI + 0x8]
LEA R15,[0xd5af58]
XOR EAX,EAX
MOV qword ptr [R15],RAX
LEA R14,[0xd5af50]
MOV qword ptr [R14],RAX
LEA R13,[0xd5af48]
MOV qword ptr [R13],RAX
LEA RCX,[0xd5af42]
MOV byte ptr [RCX],AL
LEA RCX,[0xd5af41]
MOV byte ptr [RCX],AL
MOV qword ptr [RBP + -0x30],RDI
MOV R12,qword ptr [RDI + 0x8]
TEST R12,R12
JZ 0x001b2da0
LEA RSI,[0x208b24]
MOV RDI,R12
CALL 0x0012b7d0
TEST EAX,EAX
JZ 0x001b2d5e
LAB_001b2ce1:
CMP qword ptr [R13],0x0
JZ 0x001b2d11
LAB_001b2ce8:
CMP qword ptr [R15],0x0
JZ 0x001b2d2e
LAB_001b2cee:
CMP qword ptr [R14],0x0
JNZ 0x001b2d70
MOV RDI,qword ptr [RBX]
LEA RSI,[0x208b5a]
CALL 0x001fa460
MOV ECX,0x18
MOV RDX,R14
TEST EAX,EAX
JNZ 0x001b2d49
JMP 0x001b2d70
LAB_001b2d11:
MOV RDI,R12
LEA RSI,[0x208b32]
CALL 0x001fa460
MOV ECX,0x10
MOV RDX,R13
TEST EAX,EAX
JNZ 0x001b2d49
JMP 0x001b2ce8
LAB_001b2d2e:
MOV RDI,qword ptr [RBX]
LEA RSI,[0x208b43]
CALL 0x001fa460
MOV ECX,0x16
MOV RDX,R15
TEST EAX,EAX
JZ 0x001b2cee
LAB_001b2d49:
ADD RCX,qword ptr [RBX]
MOV qword ptr [RDX],RCX
MOV R12,qword ptr [RBX + 0x8]
ADD RBX,0x8
TEST R12,R12
JNZ 0x001b2ce1
JMP 0x001b2da0
LAB_001b2d5e:
LEA RAX,[0xd5af41]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x30]
LEA RBX,[RAX + 0x10]
LAB_001b2d70:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x001b2da0
LEA RSI,[0x208b73]
CALL 0x0012b7d0
TEST EAX,EAX
JNZ 0x001b2da0
LEA RAX,[0xd5af42]
MOV byte ptr [RAX],0x1
LEA RAX,[0xd5af40]
MOV byte ptr [RAX],0x0
ADD RBX,0x8
LAB_001b2da0:
LEA R14,[0xd5af50]
CMP qword ptr [R14],0x0
JNZ 0x001b2dbc
LEA RDI,[0x208b84]
CALL 0x0012b700
MOV qword ptr [R14],RAX
LAB_001b2dbc:
LEA R14,[0xd5af58]
MOV RSI,qword ptr [R14]
TEST RSI,RSI
SETZ AL
LEA R15,[0xd5b160]
CMP RSI,R15
SETZ CL
OR CL,AL
JNZ 0x001b2dea
MOV RDI,R15
XOR EDX,EDX
CALL 0x001c4f9d
MOV qword ptr [R14],R15
LAB_001b2dea:
LEA R14,[0xd5af48]
MOV RSI,qword ptr [R14]
TEST RSI,RSI
SETZ AL
LEA R15,[0xd5af60]
CMP RSI,R15
SETZ CL
OR CL,AL
JNZ 0x001b2e18
MOV RDI,R15
XOR EDX,EDX
CALL 0x001c4f9d
MOV qword ptr [R14],R15
LAB_001b2e18:
SUB RBX,qword ptr [RBP + -0x30]
SHR RBX,0x3
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong get_defaults_options(long param_1)
{
int iVar1;
long lVar2;
long *plVar3;
long *plVar4;
char *__s1;
plVar4 = (long *)(param_1 + 8);
my_defaults_extra_file = (int1 *)0x0;
my_defaults_group_suffix = (char *)0x0;
my_defaults_file = (int1 *)0x0;
my_print_defaults = 0;
my_no_defaults = 0;
__s1 = *(char **)(param_1 + 8);
if (__s1 != (char *)0x0) {
iVar1 = strcmp(__s1,"--no-defaults");
if (iVar1 == 0) {
my_no_defaults = 1;
plVar4 = (long *)(param_1 + 0x10);
LAB_001b2d70:
if (((char *)*plVar4 != (char *)0x0) &&
(iVar1 = strcmp((char *)*plVar4,"--print-defaults"), iVar1 == 0)) {
my_print_defaults = 1;
my_defaults_mark_files = 0;
plVar4 = plVar4 + 1;
}
}
else {
do {
if (my_defaults_file == (int1 *)0x0) {
iVar1 = is_prefix(__s1,"--defaults-file=");
lVar2 = 0x10;
plVar3 = (long *)&my_defaults_file;
if (iVar1 == 0) goto LAB_001b2ce8;
}
else {
LAB_001b2ce8:
if (my_defaults_extra_file == (int1 *)0x0) {
iVar1 = is_prefix(*plVar4,"--defaults-extra-file=");
lVar2 = 0x16;
plVar3 = (long *)&my_defaults_extra_file;
if (iVar1 != 0) goto LAB_001b2d49;
}
if (my_defaults_group_suffix != (char *)0x0) goto LAB_001b2d70;
iVar1 = is_prefix(*plVar4,"--defaults-group-suffix=");
lVar2 = 0x18;
plVar3 = (long *)&my_defaults_group_suffix;
if (iVar1 == 0) goto LAB_001b2d70;
}
LAB_001b2d49:
*plVar3 = lVar2 + *plVar4;
__s1 = (char *)plVar4[1];
plVar4 = plVar4 + 1;
} while (__s1 != (char *)0x0);
}
}
if (my_defaults_group_suffix == (char *)0x0) {
my_defaults_group_suffix = getenv("MYSQL_GROUP_SUFFIX");
}
if (my_defaults_extra_file != get_defaults_options_extra_file_buffer &&
my_defaults_extra_file != (int1 *)0x0) {
my_realpath(get_defaults_options_extra_file_buffer,my_defaults_extra_file,0);
my_defaults_extra_file = get_defaults_options_extra_file_buffer;
}
if (my_defaults_file != get_defaults_options_file_buffer && my_defaults_file != (int1 *)0x0)
{
my_realpath(get_defaults_options_file_buffer,my_defaults_file,0);
my_defaults_file = get_defaults_options_file_buffer;
}
return (ulong)((long)plVar4 - param_1) >> 3 & 0xffffffff;
}
| |
30,015 | Item_func_spatial_collection::fix_length_and_dec() | eloqsql/sql/item_geofunc.h | bool fix_length_and_dec() override
{
if (Item_geometry_func::fix_length_and_dec())
return TRUE;
for (unsigned int i= 0; i < arg_count; ++i)
{
if (args[i]->fixed() && args[i]->field_type() != MYSQL_TYPE_GEOMETRY)
{
String str;
args[i]->print(&str, QT_NO_DATA_EXPANSION);
str.append('\0');
my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "non geometric",
str.ptr());
return TRUE;
}
}
return FALSE;
} | O0 | c | Item_func_spatial_collection::fix_length_and_dec():
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x978750
testb $0x1, %al
jne 0x7dafdf
jmp 0x7dafe8
movb $0x1, -0x1(%rbp)
jmp 0x7db0e2
movl $0x0, -0x14(%rbp)
movq -0x50(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x88(%rcx), %eax
jae 0x7db0de
movq -0x50(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x4c24c0
testb $0x1, %al
jne 0x7db01f
jmp 0x7db0ce
movq -0x50(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x5376a0
cmpl $0xff, %eax
je 0x7db0ce
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x48e0b0
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rsi
movq 0x70(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x220(%rax), %rax
movl $0x200, %edx # imm = 0x200
callq *%rax
jmp 0x7db071
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x48ddd0
jmp 0x7db07e
leaq -0x30(%rbp), %rdi
callq 0x48dc40
movq %rax, -0x60(%rbp)
jmp 0x7db08d
movq -0x60(%rbp), %rcx
leaq 0x5ccf68(%rip), %rdx # 0xda8000
xorl %eax, %eax
movl %eax, %esi
movl $0x557, %edi # imm = 0x557
callq 0xc12b50
jmp 0x7db0a8
movb $0x1, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48e100
jmp 0x7db0e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x48e100
jmp 0x7db0ed
jmp 0x7db0d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7dafef
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x433ff0
nopw %cs:(%rax,%rax)
| _ZN28Item_func_spatial_collection18fix_length_and_decEv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]; this
mov [rbp+var_50], rdi
call _ZN18Item_geometry_func18fix_length_and_decEv; Item_geometry_func::fix_length_and_dec(void)
test al, 1
jnz short loc_7DAFDF
jmp short loc_7DAFE8
loc_7DAFDF:
mov [rbp+var_1], 1
jmp loc_7DB0E2
loc_7DAFE8:
mov [rbp+var_14], 0
loc_7DAFEF:
mov rcx, [rbp+var_50]
mov eax, [rbp+var_14]
cmp eax, [rcx+88h]
jnb loc_7DB0DE
mov rax, [rbp+var_50]
mov rax, [rax+70h]
mov ecx, [rbp+var_14]
mov rdi, [rax+rcx*8]; this
call _ZNK4Item5fixedEv; Item::fixed(void)
test al, 1
jnz short loc_7DB01F
jmp loc_7DB0CE
loc_7DB01F:
mov rax, [rbp+var_50]
mov rax, [rax+70h]
mov ecx, [rbp+var_14]
mov rdi, [rax+rcx*8]; this
call _ZNK4Item10field_typeEv; Item::field_type(void)
cmp eax, 0FFh
jz loc_7DB0CE
lea rdi, [rbp+var_38]; this
mov [rbp+var_58], rdi
call _ZN6StringC2Ev; String::String(void)
mov rax, [rbp+var_50]
mov rsi, [rbp+var_58]
mov rax, [rax+70h]
mov ecx, [rbp+var_14]
mov rdi, [rax+rcx*8]
mov rax, [rdi]
mov rax, [rax+220h]
mov edx, 200h
call rax
jmp short $+2
loc_7DB071:
lea rdi, [rbp+var_38]; this
xor esi, esi; char
call _ZN6String6appendEc; String::append(char)
jmp short $+2
loc_7DB07E:
lea rdi, [rbp+var_30]; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_60], rax
jmp short $+2
loc_7DB08D:
mov rcx, [rbp+var_60]
lea rdx, aNonGeometric; "non geometric"
xor eax, eax
mov esi, eax
mov edi, 557h
call my_error
jmp short $+2
loc_7DB0A8:
mov [rbp+var_1], 1
lea rdi, [rbp+var_38]; void *
call _ZN6StringD2Ev; String::~String()
jmp short loc_7DB0E2
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_38]; void *
call _ZN6StringD2Ev; String::~String()
jmp short loc_7DB0ED
loc_7DB0CE:
jmp short $+2
loc_7DB0D0:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_7DAFEF
loc_7DB0DE:
mov [rbp+var_1], 0
loc_7DB0E2:
mov al, [rbp+var_1]
and al, 1
add rsp, 60h
pop rbp
retn
loc_7DB0ED:
mov rdi, [rbp+var_40]
call __Unwind_Resume
| char Item_func_spatial_collection::fix_length_and_dec(Item_func_spatial_collection *this)
{
long long v1; // rdi
int v2; // r8d
int v3; // r9d
int v5; // [rsp+0h] [rbp-60h]
char v6[8]; // [rsp+28h] [rbp-38h] BYREF
_BYTE v7[28]; // [rsp+30h] [rbp-30h] BYREF
unsigned int i; // [rsp+4Ch] [rbp-14h]
Item_geometry_func *v9; // [rsp+50h] [rbp-10h]
char v10; // [rsp+5Fh] [rbp-1h]
v9 = this;
if ( (Item_geometry_func::fix_length_and_dec(this) & 1) != 0 )
{
v10 = 1;
}
else
{
for ( i = 0; i < *((_DWORD *)this + 34); ++i )
{
if ( Item::fixed(*(Item **)(*((_QWORD *)this + 14) + 8LL * i))
&& (unsigned int)Item::field_type(*(Item **)(*((_QWORD *)this + 14) + 8LL * i)) != 255 )
{
String::String((String *)v6);
v1 = *(_QWORD *)(*((_QWORD *)this + 14) + 8LL * i);
(*(void ( **)(long long, char *, long long))(*(_QWORD *)v1 + 544LL))(v1, v6, 512LL);
String::append((String *)v6, 0);
v5 = Binary_string::ptr((Binary_string *)v7);
my_error(1367, 0, (unsigned int)"non geometric", v5, v2, v3);
v10 = 1;
String::~String(v6);
return v10 & 1;
}
}
v10 = 0;
}
return v10 & 1;
}
| find_underlying_table:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RAX + 0x100]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x007daffd
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x198],0x0
JNZ 0x007daffd
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x007db070
LAB_007daffd:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x198],0x0
JNZ 0x007db015
MOV qword ptr [RBP + -0x8],0x0
JMP 0x007db070
LAB_007db015:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x198]
CALL 0x005c17d0
MOV RDI,RAX
CALL 0x0068cf90
MOV qword ptr [RBP + -0x20],RAX
LAB_007db031:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x007db068
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x007dafc0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x007db059
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x007db070
LAB_007db059:
JMP 0x007db05b
LAB_007db05b:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x007db031
LAB_007db068:
MOV qword ptr [RBP + -0x8],0x0
LAB_007db070:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* TABLE_LIST::find_underlying_table(TABLE*) */
TABLE_LIST * __thiscall TABLE_LIST::find_underlying_table(TABLE_LIST *this,TABLE *param_1)
{
st_select_lex *this_00;
TABLE_LIST *pTVar1;
TABLE_LIST *local_28;
TABLE_LIST *local_10;
if ((*(TABLE **)(this + 0x100) != param_1) || (local_10 = this, *(long *)(this + 0x198) != 0)) {
if (*(long *)(this + 0x198) == 0) {
local_10 = (TABLE_LIST *)0x0;
}
else {
this_00 = (st_select_lex *)LEX::first_select_lex(*(LEX **)(this + 0x198));
for (local_28 = (TABLE_LIST *)st_select_lex::get_table_list(this_00);
local_28 != (TABLE_LIST *)0x0; local_28 = *(TABLE_LIST **)local_28) {
pTVar1 = (TABLE_LIST *)find_underlying_table(local_28,param_1);
if (pTVar1 != (TABLE_LIST *)0x0) {
return pTVar1;
}
}
local_10 = (TABLE_LIST *)0x0;
}
}
return local_10;
}
| |
30,016 | Update_rows_compressed_log_event::print(_IO_FILE*, st_print_event_info*) | eloqsql/sql/log_event_client.cc | bool
Update_rows_compressed_log_event::print(FILE *file,
PRINT_EVENT_INFO *print_event_info)
{
uchar *new_buf;
ulong len;
bool is_malloc= false;
if(!row_log_event_uncompress(glob_description_event,
checksum_alg == BINLOG_CHECKSUM_ALG_CRC32,
temp_buf, UINT_MAX32, NULL, 0, &is_malloc,
&new_buf, &len))
{
free_temp_buf();
register_temp_buf(new_buf, true);
if (Rows_log_event::print_helper(file, print_event_info,
"Update_compressed_rows"))
goto err;
}
else
{
if (my_b_printf(&print_event_info->head_cache,
"ERROR: uncompress update_compressed_rows failed\n"))
goto err;
}
return 0;
err:
return 1;
} | O3 | cpp | Update_rows_compressed_log_event::print(_IO_FILE*, st_print_event_info*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x19(%rbp), %rax
movb $0x0, (%rax)
movq 0x394364(%rip), %rdi # 0x3e6470
xorl %esi, %esi
cmpl $0x1, 0x88(%r15)
sete %sil
movq 0x10(%r15), %rdx
subq $0x8, %rsp
leaq -0x30(%rbp), %r10
leaq -0x28(%rbp), %r11
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
pushq %rax
callq 0x4779f
addq $0x20, %rsp
testl %eax, %eax
je 0x52168
addq $0x4e8, %rbx # imm = 0x4E8
leaq 0x68645(%rip), %rsi # 0xba79a
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7dd8d
testb %al, %al
jne 0x521a3
jmp 0x521ab
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x5217d
cmpb $0x1, 0x18(%r15)
jne 0x5217d
callq 0x84732
movq -0x28(%rbp), %rax
movq %rax, 0x10(%r15)
movb $0x1, 0x18(%r15)
leaq 0x685f2(%rip), %rcx # 0xba783
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x50d0c
testb %al, %al
je 0x521a8
movb $0x1, %r14b
jmp 0x521ab
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN32Update_rows_compressed_log_event5printEP8_IO_FILEP19st_print_event_info:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea rax, [rbp+var_19]
mov byte ptr [rax], 0
mov rdi, cs:_ZL22glob_description_event; Format_description_log_event *
xor esi, esi
cmp dword ptr [r15+88h], 1
setz sil; bool
mov rdx, [r15+10h]; unsigned __int8 *
sub rsp, 8
lea r10, [rbp+var_30]
lea r11, [rbp+var_28]
mov ecx, 0FFFFFFFFh; unsigned __int64
xor r8d, r8d; unsigned __int8 *
xor r9d, r9d; unsigned __int64
push r10; unsigned __int64 *
push r11; unsigned __int8 **
push rax; bool *
call _Z24row_log_event_uncompressPK28Format_description_log_eventbPKhmPhmPbPS4_Pm; row_log_event_uncompress(Format_description_log_event const*,bool,uchar const*,ulong,uchar *,ulong,bool *,uchar **,ulong *)
add rsp, 20h
test eax, eax
jz short loc_52168
add rbx, 4E8h
lea rsi, aErrorUncompres_1; "ERROR: uncompress update_compressed_row"...
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call my_b_printf
test al, al
jnz short loc_521A3
jmp short loc_521AB
loc_52168:
mov rdi, [r15+10h]
test rdi, rdi
jz short loc_5217D
cmp byte ptr [r15+18h], 1
jnz short loc_5217D
call my_free
loc_5217D:
mov rax, [rbp+var_28]
mov [r15+10h], rax
mov byte ptr [r15+18h], 1
lea rcx, aUpdateCompress; "Update_compressed_rows"
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _ZN14Rows_log_event12print_helperEP8_IO_FILEP19st_print_event_infoPKc; Rows_log_event::print_helper(_IO_FILE *,st_print_event_info *,char const*)
test al, al
jz short loc_521A8
loc_521A3:
mov r14b, 1
jmp short loc_521AB
loc_521A8:
xor r14d, r14d
loc_521AB:
mov eax, r14d
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long Update_rows_compressed_log_event::print(long long a1, long long a2, long long a3)
{
unsigned int v4; // r14d
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rdi
unsigned long long v12; // [rsp+0h] [rbp-30h] BYREF
unsigned __int8 *v13; // [rsp+8h] [rbp-28h] BYREF
bool v14; // [rsp+17h] [rbp-19h] BYREF
v4 = a2;
v14 = 0;
if ( (unsigned int)row_log_event_uncompress(
(const Format_description_log_event *)glob_description_event,
*(_DWORD *)(a1 + 136) == 1,
*(const unsigned __int8 **)(a1 + 16),
0xFFFFFFFFuLL,
0LL,
0LL,
&v14,
&v13,
&v12) )
{
v4 = 0;
if ( !(unsigned __int8)my_b_printf(
(int)a3 + 1256,
(unsigned int)"ERROR: uncompress update_compressed_rows failed\n",
v6,
v7,
v8,
v9) )
return v4;
}
else
{
v10 = *(_QWORD *)(a1 + 16);
if ( v10 && *(_BYTE *)(a1 + 24) == 1 )
my_free(v10);
*(_QWORD *)(a1 + 16) = v13;
*(_BYTE *)(a1 + 24) = 1;
if ( !Rows_log_event::print_helper(a1, a2, a3, (int)"Update_compressed_rows") )
return 0;
}
LOBYTE(v4) = 1;
return v4;
}
| print:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA RAX,[RBP + -0x19]
MOV byte ptr [RAX],0x0
MOV RDI,qword ptr [0x004e6470]
XOR ESI,ESI
CMP dword ptr [R15 + 0x88],0x1
SETZ SIL
MOV RDX,qword ptr [R15 + 0x10]
SUB RSP,0x8
LEA R10,[RBP + -0x30]
LEA R11,[RBP + -0x28]
MOV ECX,0xffffffff
XOR R8D,R8D
XOR R9D,R9D
PUSH R10
PUSH R11
PUSH RAX
CALL 0x0014779f
ADD RSP,0x20
TEST EAX,EAX
JZ 0x00152168
ADD RBX,0x4e8
LEA RSI,[0x1ba79a]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0017dd8d
TEST AL,AL
JNZ 0x001521a3
JMP 0x001521ab
LAB_00152168:
MOV RDI,qword ptr [R15 + 0x10]
TEST RDI,RDI
JZ 0x0015217d
CMP byte ptr [R15 + 0x18],0x1
JNZ 0x0015217d
CALL 0x00184732
LAB_0015217d:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [R15 + 0x10],RAX
MOV byte ptr [R15 + 0x18],0x1
LEA RCX,[0x1ba783]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00150d0c
TEST AL,AL
JZ 0x001521a8
LAB_001521a3:
MOV R14B,0x1
JMP 0x001521ab
LAB_001521a8:
XOR R14D,R14D
LAB_001521ab:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* Update_rows_compressed_log_event::print(_IO_FILE*, st_print_event_info*) */
ulong __thiscall
Update_rows_compressed_log_event::print
(Update_rows_compressed_log_event *this,_IO_FILE *param_1,st_print_event_info *param_2)
{
char cVar1;
int iVar2;
ulong local_38;
uchar *local_30;
bool local_21;
local_21 = false;
iVar2 = row_log_event_uncompress
(glob_description_event,*(int *)(this + 0x88) == 1,*(uchar **)(this + 0x10),
0xffffffff,(uchar *)0x0,0,&local_21,&local_30,&local_38);
if (iVar2 == 0) {
if ((*(long *)(this + 0x10) != 0) && (this[0x18] == (Update_rows_compressed_log_event)0x1)) {
my_free();
}
*(uchar **)(this + 0x10) = local_30;
this[0x18] = (Update_rows_compressed_log_event)0x1;
cVar1 = Rows_log_event::print_helper
((Rows_log_event *)this,param_1,param_2,"Update_compressed_rows");
if (cVar1 == '\0') {
param_1 = (_IO_FILE *)0x0;
goto LAB_001521ab;
}
}
else {
param_1 = (_IO_FILE *)0x0;
cVar1 = my_b_printf(param_2 + 0x4e8,"ERROR: uncompress update_compressed_rows failed\n");
if (cVar1 == '\0') goto LAB_001521ab;
}
param_1 = (_IO_FILE *)CONCAT71((int7)((ulong)param_1 >> 8),1);
LAB_001521ab:
return (ulong)param_1 & 0xffffffff;
}
| |
30,017 | mi_unmap_file | eloqsql/storage/myisam/mi_packrec.c | void _mi_unmap_file(MI_INFO *info)
{
DBUG_ASSERT(info->s->options & HA_OPTION_COMPRESS_RECORD);
(void) my_munmap((char*) info->s->file_map, info->s->mmaped_length);
if (myisam_mmap_size != SIZE_T_MAX)
{
mysql_mutex_lock(&THR_LOCK_myisam_mmap);
myisam_mmap_used-= info->s->mmaped_length;
mysql_mutex_unlock(&THR_LOCK_myisam_mmap);
}
} | O3 | c | mi_unmap_file:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x270(%rax), %rdi
movq 0x4d0(%rax), %rsi
callq 0x28200
leaq 0x2f95a9(%rip), %rax # 0x334a68
cmpq $-0x1, (%rax)
je 0x3b50c
leaq 0x37b7fc(%rip), %r14 # 0x3b6cc8
cmpq $0x0, 0x40(%r14)
jne 0x3b511
leaq 0x37b7ee(%rip), %rdi # 0x3b6cc8
callq 0x285a0
movq (%rbx), %rax
movq 0x4d0(%rax), %rax
leaq 0x3729d0(%rip), %rcx # 0x3adec0
subq %rax, (%rcx)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0x3b518
leaq 0x37b7c5(%rip), %rdi # 0x3b6cc8
popq %rbx
popq %r14
popq %rbp
jmp 0x28280
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2987f
jmp 0x3b4df
leaq 0x2fb3a9(%rip), %rax # 0x3368c8
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3b4fc
| _mi_unmap_file:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rax, [rdi]
mov rdi, [rax+270h]
mov rsi, [rax+4D0h]
call _munmap
lea rax, myisam_mmap_size
cmp qword ptr [rax], 0FFFFFFFFFFFFFFFFh
jz short loc_3B50C
lea r14, THR_LOCK_myisam_mmap
cmp qword ptr [r14+40h], 0
jnz short loc_3B511
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_lock
loc_3B4DF:
mov rax, [rbx]
mov rax, [rax+4D0h]
lea rcx, myisam_mmap_used
sub [rcx], rax
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_3B518
loc_3B4FC:
lea rdi, THR_LOCK_myisam_mmap
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_3B50C:
pop rbx
pop r14
pop rbp
retn
loc_3B511:
call _mi_unmap_file_cold_1
jmp short loc_3B4DF
loc_3B518:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_3B4FC
| _QWORD * mi_unmap_file(long long a1)
{
_QWORD *result; // rax
munmap(*(_QWORD *)(*(_QWORD *)a1 + 624LL), *(_QWORD *)(*(_QWORD *)a1 + 1232LL));
result = &myisam_mmap_size;
if ( myisam_mmap_size != -1LL )
{
if ( THR_LOCK_myisam_mmap[8] )
mi_unmap_file_cold_1();
else
pthread_mutex_lock(THR_LOCK_myisam_mmap);
myisam_mmap_used -= *(_QWORD *)(*(_QWORD *)a1 + 1232LL);
if ( THR_LOCK_myisam_mmap[8] )
(*((void (**)(void))PSI_server + 44))();
return (_QWORD *)pthread_mutex_unlock(THR_LOCK_myisam_mmap);
}
return result;
}
| _mi_unmap_file:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RAX + 0x270]
MOV RSI,qword ptr [RAX + 0x4d0]
CALL 0x00128200
LEA RAX,[0x434a68]
CMP qword ptr [RAX],-0x1
JZ 0x0013b50c
LEA R14,[0x4b6cc8]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x0013b511
LEA RDI,[0x4b6cc8]
CALL 0x001285a0
LAB_0013b4df:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x4d0]
LEA RCX,[0x4adec0]
SUB qword ptr [RCX],RAX
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x0013b518
LAB_0013b4fc:
LEA RDI,[0x4b6cc8]
POP RBX
POP R14
POP RBP
JMP 0x00128280
LAB_0013b50c:
POP RBX
POP R14
POP RBP
RET
LAB_0013b511:
CALL 0x0012987f
JMP 0x0013b4df
LAB_0013b518:
LEA RAX,[0x4368c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013b4fc
|
void _mi_unmap_file(long *param_1)
{
munmap(*(void **)(*param_1 + 0x270),*(size_t *)(*param_1 + 0x4d0));
if (myisam_mmap_size != -1) {
if (THR_LOCK_myisam_mmap._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
}
else {
_mi_unmap_file_cold_1();
}
myisam_mmap_used = myisam_mmap_used - *(long *)(*param_1 + 0x4d0);
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam_mmap);
return;
}
return;
}
| |
30,018 | ggml_backend_cpu_buffer_from_ptr | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | ggml_backend_buffer_t ggml_backend_cpu_buffer_from_ptr(void * ptr, size_t size) {
GGML_ASSERT((uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && "buffer pointer must be aligned");
return ggml_backend_buffer_init(ggml_backend_cpu_buffer_from_ptr_type(), ggml_backend_cpu_buffer_from_ptr_i, ptr, size);
} | O2 | cpp | ggml_backend_cpu_buffer_from_ptr:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testb $0x1f, %r14b
jne 0x2e8c2
movq %rsi, %rbx
pushq $0x68
popq %rdi
callq 0x1e7e0
leaq 0x4438e(%rip), %rsi # 0x72c28
pushq $0x9
popq %rcx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x460ce(%rip), %rcx # 0x74978
movq %rcx, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %rbx, 0x58(%rax)
andl $0x0, 0x60(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22ebb(%rip), %rdi # 0x51784
leaq 0x1fd05(%rip), %rdx # 0x4e5d5
leaq 0x236ed(%rip), %rcx # 0x51fc4
movl $0x7d0, %esi # imm = 0x7D0
xorl %eax, %eax
callq 0x1f9b0
| ggml_backend_cpu_buffer_from_ptr:
push r14
push rbx
push rax
mov r14, rdi
test r14b, 1Fh
jnz short loc_2E8C2
mov rbx, rsi
push 68h ; 'h'
pop rdi; unsigned __int64
call __Znwm; operator new(ulong)
lea rsi, _ZL34ggml_backend_cpu_buffer_from_ptr_i; ggml_backend_cpu_buffer_from_ptr_i
push 9
pop rcx
mov rdi, rax
rep movsq
lea rcx, _ZZL37ggml_backend_cpu_buffer_from_ptr_typevE28ggml_backend_cpu_buffer_type; ggml_backend_cpu_buffer_from_ptr_type(void)::ggml_backend_cpu_buffer_type
mov [rax+48h], rcx
mov [rax+50h], r14
mov [rax+58h], rbx
and dword ptr [rax+60h], 0
add rsp, 8
pop rbx
pop r14
retn
loc_2E8C2:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aUintptrTPtrTen; "(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 "...
mov esi, 7D0h
xor eax, eax
call _ggml_abort
| long long ggml_backend_cpu_buffer_from_ptr(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
long long result; // rax
if ( (a1 & 0x1F) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
2000,
(long long)"GGML_ASSERT(%s) failed",
(long long)"(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && \"buffer pointer must be aligned\"",
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v14);
result = operator new(0x68uLL);
qmemcpy((void *)result, &ggml_backend_cpu_buffer_from_ptr_i, 0x48uLL);
*(_QWORD *)(result + 72) = ggml_backend_cpu_buffer_from_ptr_type(void)::ggml_backend_cpu_buffer_type;
*(_QWORD *)(result + 80) = a1;
*(_QWORD *)(result + 88) = a2;
*(_DWORD *)(result + 96) = 0;
return result;
}
| ggml_backend_cpu_buffer_from_ptr:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
TEST R14B,0x1f
JNZ 0x0012e8c2
MOV RBX,RSI
PUSH 0x68
POP RDI
CALL 0x0011e7e0
LEA RSI,[0x172c28]
PUSH 0x9
POP RCX
MOV RDI,RAX
MOVSQ.REP RDI,RSI
LEA RCX,[0x174978]
MOV qword ptr [RAX + 0x48],RCX
MOV qword ptr [RAX + 0x50],R14
MOV qword ptr [RAX + 0x58],RBX
AND dword ptr [RAX + 0x60],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0012e8c2:
LEA RDI,[0x151784]
LEA RDX,[0x14e5d5]
LEA RCX,[0x151fc4]
MOV ESI,0x7d0
XOR EAX,EAX
CALL 0x0011f9b0
|
void ggml_backend_cpu_buffer_from_ptr(ulong param_1,int8 param_2)
{
int8 *puVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
byte bVar5;
bVar5 = 0;
if ((param_1 & 0x1f) == 0) {
puVar1 = (int8 *)operator_new(0x68);
puVar3 = &ggml_backend_cpu_buffer_from_ptr_i;
puVar4 = puVar1;
for (lVar2 = 9; lVar2 != 0; lVar2 = lVar2 + -1) {
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar5 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar5 * -2 + 1;
}
puVar1[9] = ggml_backend_cpu_buffer_from_ptr_type()::ggml_backend_cpu_buffer_type;
puVar1[10] = param_1;
puVar1[0xb] = param_2;
*(int4 *)(puVar1 + 0xc) = 0;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,2000,"GGML_ASSERT(%s) failed",
"(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && \"buffer pointer must be aligned\"");
}
| |
30,019 | ggml_backend_cpu_buffer_from_ptr | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | ggml_backend_buffer_t ggml_backend_cpu_buffer_from_ptr(void * ptr, size_t size) {
GGML_ASSERT((uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && "buffer pointer must be aligned");
return ggml_backend_buffer_init(ggml_backend_cpu_buffer_from_ptr_type(), ggml_backend_cpu_buffer_from_ptr_i, ptr, size);
} | O3 | cpp | ggml_backend_cpu_buffer_from_ptr:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testb $0x1f, %r14b
jne 0x29252
movq %rsi, %rbx
movl $0x68, %edi
callq 0x17080
leaq 0x44a03(%rip), %rsi # 0x6dc28
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x45f51(%rip), %rcx # 0x6f188
movq %rcx, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %rbx, 0x58(%rax)
movl $0x0, 0x60(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x265bb(%rip), %rdi # 0x4f814
leaq 0x23405(%rip), %rdx # 0x4c665
leaq 0x26ded(%rip), %rcx # 0x50054
movl $0x7d0, %esi # imm = 0x7D0
xorl %eax, %eax
callq 0x17cd0
| ggml_backend_cpu_buffer_from_ptr:
push r14
push rbx
push rax
mov r14, rdi
test r14b, 1Fh
jnz short loc_29252
mov rbx, rsi
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
lea rsi, _ZL34ggml_backend_cpu_buffer_from_ptr_i; ggml_backend_cpu_buffer_from_ptr_i
mov ecx, 9
mov rdi, rax
rep movsq
lea rcx, _ZZL37ggml_backend_cpu_buffer_from_ptr_typevE28ggml_backend_cpu_buffer_type; ggml_backend_cpu_buffer_from_ptr_type(void)::ggml_backend_cpu_buffer_type
mov [rax+48h], rcx
mov [rax+50h], r14
mov [rax+58h], rbx
mov dword ptr [rax+60h], 0
add rsp, 8
pop rbx
pop r14
retn
loc_29252:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aUintptrTPtrTen; "(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 "...
mov esi, 7D0h
xor eax, eax
call _ggml_abort
| long long ggml_backend_cpu_buffer_from_ptr(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long result; // rax
if ( (a1 & 0x1F) != 0 )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
2000,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && \"buffer pointer must be aligned\"",
a5,
a6);
result = operator new(0x68uLL);
qmemcpy((void *)result, &ggml_backend_cpu_buffer_from_ptr_i, 0x48uLL);
*(_QWORD *)(result + 72) = ggml_backend_cpu_buffer_from_ptr_type(void)::ggml_backend_cpu_buffer_type;
*(_QWORD *)(result + 80) = a1;
*(_QWORD *)(result + 88) = a2;
*(_DWORD *)(result + 96) = 0;
return result;
}
| ggml_backend_cpu_buffer_from_ptr:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
TEST R14B,0x1f
JNZ 0x00129252
MOV RBX,RSI
MOV EDI,0x68
CALL 0x00117080
LEA RSI,[0x16dc28]
MOV ECX,0x9
MOV RDI,RAX
MOVSQ.REP RDI,RSI
LEA RCX,[0x16f188]
MOV qword ptr [RAX + 0x48],RCX
MOV qword ptr [RAX + 0x50],R14
MOV qword ptr [RAX + 0x58],RBX
MOV dword ptr [RAX + 0x60],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00129252:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x150054]
MOV ESI,0x7d0
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_backend_cpu_buffer_from_ptr(ulong param_1,int8 param_2)
{
int8 *puVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
byte bVar5;
bVar5 = 0;
if ((param_1 & 0x1f) == 0) {
puVar1 = (int8 *)operator_new(0x68);
puVar3 = &ggml_backend_cpu_buffer_from_ptr_i;
puVar4 = puVar1;
for (lVar2 = 9; lVar2 != 0; lVar2 = lVar2 + -1) {
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar5 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar5 * -2 + 1;
}
puVar1[9] = ggml_backend_cpu_buffer_from_ptr_type()::ggml_backend_cpu_buffer_type;
puVar1[10] = param_1;
puVar1[0xb] = param_2;
*(int4 *)(puVar1 + 0xc) = 0;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,2000,"GGML_ASSERT(%s) failed",
"(uintptr_t)ptr % TENSOR_ALIGNMENT == 0 && \"buffer pointer must be aligned\"");
}
| |
30,020 | Catch::TestSpec::Pattern::~Pattern() | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | TestSpec::Pattern::~Pattern() = default; | O3 | cpp | Catch::TestSpec::Pattern::~Pattern():
leaq 0xd611d(%rip), %rax # 0x12d408
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x5730d
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x17150
retq
| _ZN5Catch8TestSpec7PatternD2Ev:
lea rax, _ZTVN5Catch8TestSpec7PatternE; `vtable for'Catch::TestSpec::Pattern
add rax, 10h
mov [rdi], rax
mov rax, [rdi+8]
add rdi, 18h
cmp rax, rdi
jz short locret_5730D
mov rsi, [rdi]
inc rsi; unsigned __int64
mov rdi, rax; void *
jmp __ZdlPvm; operator delete(void *,ulong)
locret_5730D:
retn
| void Catch::TestSpec::Pattern::~Pattern(Catch::TestSpec::Pattern *this)
{
_QWORD *v1; // rax
_QWORD *v2; // rdi
*(_QWORD *)this = &`vtable for'Catch::TestSpec::Pattern + 2;
v1 = (_QWORD *)*((_QWORD *)this + 1);
v2 = (_QWORD *)((char *)this + 24);
if ( v1 != v2 )
operator delete(v1, *v2 + 1LL);
}
| ~Pattern:
LEA RAX,[0x22d408]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RDI + 0x8]
ADD RDI,0x18
CMP RAX,RDI
JZ 0x0015730d
MOV RSI,qword ptr [RDI]
INC RSI
MOV RDI,RAX
JMP 0x00117150
LAB_0015730d:
RET
|
/* Catch::TestSpec::Pattern::~Pattern() */
void __thiscall Catch::TestSpec::Pattern::~Pattern(Pattern *this)
{
*(int ***)this = &PTR__Pattern_0022d418;
if (*(Pattern **)(this + 8) != this + 0x18) {
operator_delete(*(Pattern **)(this + 8),*(long *)(this + 0x18) + 1);
return;
}
return;
}
| |
30,021 | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const | BhuvanGudi[P]LexiParse/src/generation.hpp | void operator()(const NodeBinExprSub* sub) const
{
gen.gen_expr(sub->rhs);
gen.gen_expr(sub->lhs);
gen.pop("rax");
gen.pop("rbx");
gen.m_output << " sub rax, rbx\n";
gen.push("rax");
} | O1 | cpp | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x505b(%rip), %r12 # 0xcd38
movq %r15, %rdi
callq *(%r12,%rax,8)
movq (%rbx), %rax
movq (%r14), %rsi
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x8(%rsp), %rdi
callq *(%r12,%rax,8)
movq (%rbx), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1738(%rip), %rsi # 0x9445
leaq 0x1734(%rip), %rdx # 0x9448
leaq 0x8(%rsp), %rdi
callq 0x73ac
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x75ea
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7d42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %r14
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1727(%rip), %rsi # 0x947b
leaq 0x1723(%rip), %rdx # 0x947e
callq 0x73ac
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x75ea
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7d84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x170c(%rip), %rsi # 0x949e
movl $0x11, %edx
callq 0x2230
movq (%rbx), %rbx
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1697(%rip), %rsi # 0x9445
leaq 0x1693(%rip), %rdx # 0x9448
callq 0x73ac
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7786
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7dde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7df2
jmp 0x7e0e
jmp 0x7df2
jmp 0x7e0e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7e11
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x7e11
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22d0
nop
| _ZZN9Generator12gen_bin_exprEPK11NodeBinExprENK14BinExprVisitorclEPK14NodeBinExprSub:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov rsi, [rsi+8]
lea r15, [rsp+48h+var_40]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea r12, _ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE; std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
mov rdi, r15
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD38h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov rax, [rbx]
mov rsi, [r14]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea rdi, [rsp+48h+var_40]
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD38h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov r14, [rbx]
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aRax; "rax"
lea rdx, aRax+3; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7D42
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7D42:
mov r14, [rbx]
lea rdi, [rsp+48h+var_40]
mov [rdi], r15
lea rsi, aRbx; "rbx"
lea rdx, aRbx+3; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7D84
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7D84:
mov rdi, [rbx]
add rdi, 28h ; '('
lea rsi, aSubRaxRbx; " sub rax, rbx\n"
mov edx, 11h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rbx]
lea rdi, [rsp+48h+var_40]
mov [rdi], r15
lea rsi, aRax; "rax"
lea rdx, aRax+3; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, rbx
call _ZN9Generator4pushERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::push(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7DDE
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7DDE:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_7DF2
jmp short loc_7E0E
jmp short loc_7DF2
jmp short loc_7E0E
loc_7DF2:
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_7E11
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7E11
loc_7E0E:
mov rbx, rax
loc_7E11:
mov rdi, rbx
call __Unwind_Resume
| void Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(void **a1, long long *a2)
{
long long v3; // rsi
long long v4; // rsi
void *v5; // r14
void *v6; // r14
void *v7; // rbx
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
_QWORD v9[6]; // [rsp+18h] [rbp-30h] BYREF
v3 = a2[1];
v8[0] = *a1;
((void ( *)(long long *, long long))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v3 + 8)))(
(long long *)v8,
v3);
v4 = *a2;
v8[0] = *a1;
((void ( *)(long long *, long long))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v4 + 8)))(
(long long *)v8,
v4);
v5 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>((long long *)v8, "rax", (long long)"");
Generator::pop((long long)v5, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
v6 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>((long long *)v8, "rbx", (long long)"");
Generator::pop((long long)v6, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
std::__ostream_insert<char,std::char_traits<char>>((char *)*a1 + 40, " sub rax, rbx\n", 17LL);
v7 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>((long long *)v8, "rax", (long long)"");
Generator::push((long long)v7, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
}
| operator():
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RSI + 0x8]
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA R12,[0x10cd38]
MOV RDI,R15
CALL qword ptr [R12 + RAX*0x8]
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [R14]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA RDI,[RSP + 0x8]
CALL qword ptr [R12 + RAX*0x8]
MOV R14,qword ptr [RBX]
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_00107d06:
LEA RSI,[0x109445]
LEA RDX,[0x109448]
LEA RDI,[RSP + 0x8]
CALL 0x001073ac
LAB_00107d1e:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001075ea
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00107d42
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00107d42:
MOV R14,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],R15
LAB_00107d4d:
LEA RSI,[0x10947b]
LEA RDX,[0x10947e]
CALL 0x001073ac
LAB_00107d60:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001075ea
LAB_00107d6d:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00107d84
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00107d84:
MOV RDI,qword ptr [RBX]
ADD RDI,0x28
LEA RSI,[0x10949e]
MOV EDX,0x11
CALL 0x00102230
MOV RBX,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],R15
LAB_00107da7:
LEA RSI,[0x109445]
LEA RDX,[0x109448]
CALL 0x001073ac
LAB_00107dba:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00107786
LAB_00107dc7:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00107dde
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00107dde:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Generator::gen_bin_expr(NodeBinExpr
const*)::BinExprVisitor::TEMPNAMEPLACEHOLDERVALUE(NodeBinExprSub const*) const */
void __thiscall
Generator::gen_bin_expr(NodeBinExpr_const*)::BinExprVisitor::operator()
(BinExprVisitor *this,NodeBinExprSub *param_1)
{
Generator *pGVar1;
long *local_40 [2];
long local_30 [2];
local_40[0] = *(long **)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)(param_1 + 8) + 8) * 8))(local_40);
local_40[0] = *(long **)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)param_1 + 8) * 8))(local_40);
pGVar1 = *(Generator **)this;
/* try { // try from 00107d06 to 00107d1d has its CatchHandler @ 00107e0e */
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_00109445,&DAT_00109448);
/* try { // try from 00107d1e to 00107d2a has its CatchHandler @ 00107df2 */
pop(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
pGVar1 = *(Generator **)this;
local_40[0] = local_30;
/* try { // try from 00107d4d to 00107d5f has its CatchHandler @ 00107df0 */
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_0010947b,&DAT_0010947e);
/* try { // try from 00107d60 to 00107d6c has its CatchHandler @ 00107dee */
pop(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(*(long *)this + 0x28)," sub rax, rbx\n",0x11);
pGVar1 = *(Generator **)this;
local_40[0] = local_30;
/* try { // try from 00107da7 to 00107db9 has its CatchHandler @ 00107dec */
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_00109445,&DAT_00109448);
/* try { // try from 00107dba to 00107dc6 has its CatchHandler @ 00107dea */
push(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return;
}
| |
30,022 | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const | BhuvanGudi[P]LexiParse/src/generation.hpp | void operator()(const NodeBinExprSub* sub) const
{
gen.gen_expr(sub->rhs);
gen.gen_expr(sub->lhs);
gen.pop("rax");
gen.pop("rbx");
gen.m_output << " sub rax, rbx\n";
gen.push("rax");
} | O2 | cpp | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x68b9(%rip), %r12 # 0xcd40
movq %r15, %rdi
callq *(%r12,%rax,8)
movq (%rbx), %rax
movq (%r14), %rsi
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x8(%rsp), %rdi
callq *(%r12,%rax,8)
movq (%rbx), %r14
leaq 0x1f6b(%rip), %rsi # 0x8419
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5e6e
leaq 0x8(%rsp), %rdi
callq 0x27ea
movq (%rbx), %r14
leaq 0x1f71(%rip), %rsi # 0x844f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5e6e
leaq 0x8(%rsp), %rdi
callq 0x27ea
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x1f60(%rip), %rsi # 0x8472
callq 0x21a0
movq (%rbx), %rbx
leaq 0x1ef8(%rip), %rsi # 0x8419
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x43bc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fa6
leaq 0x8(%rsp), %rdi
callq 0x27ea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x655b
jmp 0x656a
jmp 0x655b
jmp 0x656a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ea
jmp 0x656d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2270
| _ZZN9Generator12gen_bin_exprEPK11NodeBinExprENK14BinExprVisitorclEPK14NodeBinExprSub:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov rsi, [rsi+8]
lea r15, [rsp+48h+var_40]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea r12, _ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE; std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
mov rdi, r15
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD40h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov rax, [rbx]
mov rsi, [r14]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea rdi, [rsp+48h+var_40]
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD40h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov r14, [rbx]
lea rsi, aRax; "rax"
lea rdi, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov r14, [rbx]
lea rsi, aRbx; "rbx"
lea rdi, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rbx]
add rdi, 28h ; '('
lea rsi, aSubRaxRbx; " sub rax, rbx\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rbx, [rbx]
lea rsi, aRax; "rax"
lea rdi, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, [rsp+48h+var_40]
mov rdi, rbx
call _ZN9Generator4pushERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::push(std::string const&)
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_655B
jmp short loc_656A
jmp short loc_655B
jmp short loc_656A
loc_655B:
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_656D
loc_656A:
mov rbx, rax
loc_656D:
mov rdi, rbx
call __Unwind_Resume
| long long Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(long long *a1, long long *a2)
{
long long v3; // rsi
long long v4; // rsi
long long v5; // r14
long long v6; // rdx
long long v7; // r14
long long v8; // rdx
long long v9; // rdx
long long v10; // rbx
long long v11; // rdx
long long result; // rax
_QWORD v13[8]; // [rsp+8h] [rbp-40h] BYREF
v3 = a2[1];
v13[0] = *a1;
((void ( *)(_QWORD *))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v3 + 8)))(v13);
v4 = *a2;
v13[0] = *a1;
((void ( *)(_QWORD *))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v4 + 8)))(v13);
v5 = *a1;
std::string::basic_string<std::allocator<char>>(v13, (long long)"rax");
Generator::pop(v5, (long long)v13, v6);
std::string::~string();
v7 = *a1;
std::string::basic_string<std::allocator<char>>(v13, (long long)"rbx");
Generator::pop(v7, (long long)v13, v8);
std::string::~string();
std::operator<<<std::char_traits<char>>(*a1 + 40, " sub rax, rbx\n", v9);
v10 = *a1;
std::string::basic_string<std::allocator<char>>(v13, (long long)"rax");
result = Generator::push(v10, (long long)v13, v11);
std::string::~string();
return result;
}
| operator():
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RSI + 0x8]
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA R12,[0x10cd40]
MOV RDI,R15
CALL qword ptr [R12 + RAX*0x8]
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [R14]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA RDI,[RSP + 0x8]
CALL qword ptr [R12 + RAX*0x8]
MOV R14,qword ptr [RBX]
LAB_001064a7:
LEA RSI,[0x108419]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_001064bd:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00105e6e
LEA RDI,[RSP + 0x8]
CALL 0x001027ea
MOV R14,qword ptr [RBX]
LAB_001064d7:
LEA RSI,[0x10844f]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_001064ed:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00105e6e
LAB_001064fa:
LEA RDI,[RSP + 0x8]
CALL 0x001027ea
MOV RDI,qword ptr [RBX]
ADD RDI,0x28
LEA RSI,[0x108472]
CALL 0x001021a0
MOV RBX,qword ptr [RBX]
LAB_0010651a:
LEA RSI,[0x108419]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x001043bc
LAB_00106530:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00105fa6
LAB_0010653d:
LEA RDI,[RSP + 0x8]
CALL 0x001027ea
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Generator::gen_bin_expr(NodeBinExpr
const*)::BinExprVisitor::TEMPNAMEPLACEHOLDERVALUE(NodeBinExprSub const*) const */
void __thiscall
Generator::gen_bin_expr(NodeBinExpr_const*)::BinExprVisitor::operator()
(BinExprVisitor *this,NodeBinExprSub *param_1)
{
Generator *pGVar1;
allocator local_41;
int8 local_40 [4];
local_40[0] = *(int8 *)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)(param_1 + 8) + 8) * 8))(local_40);
local_40[0] = *(int8 *)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)param_1 + 8) * 8))(local_40);
pGVar1 = *(Generator **)this;
/* try { // try from 001064a7 to 001064bc has its CatchHandler @ 0010656a */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,"rax",&local_41);
/* try { // try from 001064bd to 001064c9 has its CatchHandler @ 0010655b */
pop(pGVar1,(string *)local_40);
std::__cxx11::string::~string((string *)local_40);
pGVar1 = *(Generator **)this;
/* try { // try from 001064d7 to 001064ec has its CatchHandler @ 00106559 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,"rbx",&local_41);
/* try { // try from 001064ed to 001064f9 has its CatchHandler @ 00106557 */
pop(pGVar1,(string *)local_40);
std::__cxx11::string::~string((string *)local_40);
std::operator<<((ostream *)(*(long *)this + 0x28)," sub rax, rbx\n");
pGVar1 = *(Generator **)this;
/* try { // try from 0010651a to 0010652f has its CatchHandler @ 00106555 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,"rax",&local_41);
/* try { // try from 00106530 to 0010653c has its CatchHandler @ 00106553 */
push(pGVar1,(string *)local_40);
std::__cxx11::string::~string((string *)local_40);
return;
}
| |
30,023 | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const | BhuvanGudi[P]LexiParse/src/generation.hpp | void operator()(const NodeBinExprSub* sub) const
{
gen.gen_expr(sub->rhs);
gen.gen_expr(sub->lhs);
gen.pop("rax");
gen.pop("rbx");
gen.m_output << " sub rax, rbx\n";
gen.push("rax");
} | O3 | cpp | Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(NodeBinExprSub const*) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x56b9(%rip), %r12 # 0xcd38
movq %r15, %rdi
callq *(%r12,%rax,8)
movq (%rbx), %rax
movq (%r14), %rsi
movq %rax, (%r15)
movzbl 0x8(%rsi), %eax
leaq 0x8(%rsp), %rdi
callq *(%r12,%rax,8)
movq (%rbx), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1db6(%rip), %rsi # 0x9465
leaq 0x1db2(%rip), %rdx # 0x9468
leaq 0x8(%rsp), %rdi
callq 0x6d44
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6f88
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x76e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %r14
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1da5(%rip), %rsi # 0x949b
leaq 0x1da1(%rip), %rdx # 0x949e
callq 0x6d44
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6f88
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7726
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x1d8a(%rip), %rsi # 0x94be
movl $0x11, %edx
callq 0x2230
movq (%rbx), %rbx
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1d15(%rip), %rsi # 0x9465
leaq 0x1d11(%rip), %rdx # 0x9468
callq 0x6d44
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7124
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7780
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7794
jmp 0x77b0
jmp 0x7794
jmp 0x77b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x77b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x77b3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22d0
nop
| _ZZN9Generator12gen_bin_exprEPK11NodeBinExprENK14BinExprVisitorclEPK14NodeBinExprSub:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov rsi, [rsi+8]
lea r15, [rsp+48h+var_40]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea r12, _ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE; std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
mov rdi, r15
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD38h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov rax, [rbx]
mov rsi, [r14]
mov [r15], rax
movzx eax, byte ptr [rsi+8]
lea rdi, [rsp+48h+var_40]
call ds:(_ZNSt8__detail9__variant12__gen_vtableINS0_21__deduce_visit_resultIvEERZN9Generator8gen_exprEPK8NodeExprE11ExprVisitorJRKSt7variantIJP8NodeTermP11NodeBinExprEEEE9_S_vtableE - 0CD38h)[r12+rax*8]; std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<std::__detail::__variant::__deduce_visit_result<void> (*)(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)>,std::integer_sequence<ulong,0ul>>::__visit_invoke(Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&)
mov r14, [rbx]
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aRax; "rax"
lea rdx, aRax+3; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_76E4
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76E4:
mov r14, [rbx]
lea rdi, [rsp+48h+var_40]
mov [rdi], r15
lea rsi, aRbx; "rbx"
lea rdx, aRbx+3; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, r14
call _ZN9Generator3popERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::pop(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7726
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7726:
mov rdi, [rbx]
add rdi, 28h ; '('
lea rsi, aSubRaxRbx; " sub rax, rbx\n"
mov edx, 11h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rbx]
lea rdi, [rsp+48h+var_40]
mov [rdi], r15
lea rsi, aRax; "rax"
lea rdx, aRax+3; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+48h+var_40]
mov rdi, rbx
call _ZN9Generator4pushERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Generator::push(std::string const&)
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7780
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7780:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short loc_7794
jmp short loc_77B0
jmp short loc_7794
jmp short loc_77B0
loc_7794:
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_77B3
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_77B3
loc_77B0:
mov rbx, rax
loc_77B3:
mov rdi, rbx
call __Unwind_Resume
| void Generator::gen_bin_expr(NodeBinExpr const*)::BinExprVisitor::operator()(void **a1, long long *a2)
{
long long v3; // rsi
long long v4; // rsi
void *v5; // r14
void *v6; // r14
void *v7; // rbx
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
_QWORD v9[6]; // [rsp+18h] [rbp-30h] BYREF
v3 = a2[1];
v8[0] = *a1;
((void ( *)(long long *, long long))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v3 + 8)))(
(long long *)v8,
v3);
v4 = *a2;
v8[0] = *a1;
((void ( *)(long long *, long long))*(&std::__detail::__variant::__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr const*)::ExprVisitor &,std::variant<NodeTerm *,NodeBinExpr *> const&>::_S_vtable
+ *(unsigned __int8 *)(v4 + 8)))(
(long long *)v8,
v4);
v5 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>(v8, "rax", (long long)"");
Generator::pop((long long)v5, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
v6 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>(v8, "rbx", (long long)"");
Generator::pop((long long)v6, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
std::__ostream_insert<char,std::char_traits<char>>((char *)*a1 + 40, " sub rax, rbx\n", 17LL);
v7 = *a1;
v8[0] = v9;
std::string::_M_construct<char const*>(v8, "rax", (long long)"");
Generator::push((long long)v7, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
}
| operator():
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RSI + 0x8]
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA R12,[0x10cd38]
MOV RDI,R15
CALL qword ptr [R12 + RAX*0x8]
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [R14]
MOV qword ptr [R15],RAX
MOVZX EAX,byte ptr [RSI + 0x8]
LEA RDI,[RSP + 0x8]
CALL qword ptr [R12 + RAX*0x8]
MOV R14,qword ptr [RBX]
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001076a8:
LEA RSI,[0x109465]
LEA RDX,[0x109468]
LEA RDI,[RSP + 0x8]
CALL 0x00106d44
LAB_001076c0:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00106f88
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001076e4
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_001076e4:
MOV R14,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],R15
LAB_001076ef:
LEA RSI,[0x10949b]
LEA RDX,[0x10949e]
CALL 0x00106d44
LAB_00107702:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00106f88
LAB_0010770f:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00107726
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00107726:
MOV RDI,qword ptr [RBX]
ADD RDI,0x28
LEA RSI,[0x1094be]
MOV EDX,0x11
CALL 0x00102230
MOV RBX,qword ptr [RBX]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],R15
LAB_00107749:
LEA RSI,[0x109465]
LEA RDX,[0x109468]
CALL 0x00106d44
LAB_0010775c:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00107124
LAB_00107769:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00107780
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00102200
LAB_00107780:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Generator::gen_bin_expr(NodeBinExpr
const*)::BinExprVisitor::TEMPNAMEPLACEHOLDERVALUE(NodeBinExprSub const*) const */
void __thiscall
Generator::gen_bin_expr(NodeBinExpr_const*)::BinExprVisitor::operator()
(BinExprVisitor *this,NodeBinExprSub *param_1)
{
Generator *pGVar1;
long *local_40 [2];
long local_30 [2];
local_40[0] = *(long **)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)(param_1 + 8) + 8) * 8))(local_40);
local_40[0] = *(long **)this;
(**(code **)(std::__detail::__variant::
__gen_vtable<std::__detail::__variant::__deduce_visit_result<void>,Generator::gen_expr(NodeExpr_const*)::ExprVisitor&,std::variant<NodeTerm*,NodeBinExpr*>const&>
::_S_vtable + (ulong)*(byte *)(*(long *)param_1 + 8) * 8))(local_40);
pGVar1 = *(Generator **)this;
/* try { // try from 001076a8 to 001076bf has its CatchHandler @ 001077b0 */
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_00109465,&DAT_00109468);
/* try { // try from 001076c0 to 001076cc has its CatchHandler @ 00107794 */
pop(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
pGVar1 = *(Generator **)this;
local_40[0] = local_30;
/* try { // try from 001076ef to 00107701 has its CatchHandler @ 00107792 */
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_0010949b,&DAT_0010949e);
/* try { // try from 00107702 to 0010770e has its CatchHandler @ 00107790 */
pop(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(*(long *)this + 0x28)," sub rax, rbx\n",0x11);
pGVar1 = *(Generator **)this;
local_40[0] = local_30;
/* try { // try from 00107749 to 0010775b has its CatchHandler @ 0010778e */
std::__cxx11::string::_M_construct<char_const*>(local_40,&DAT_00109465,&DAT_00109468);
/* try { // try from 0010775c to 00107768 has its CatchHandler @ 0010778c */
push(pGVar1,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return;
}
| |
30,024 | list_walk | eloqsql/mysys/list.c | int list_walk(LIST *list, list_walk_action action, uchar* argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list=list_rest(list);
}
return 0;
} | O3 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x9bf84
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jne 0x9bf82
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x9bf67
jmp 0x9bf84
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| list_walk:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor ebx, ebx
test rdi, rdi
jz short loc_9BF84
mov r14, rdx
mov r15, rsi
mov r12, rdi
loc_9BF67:
mov rdi, [r12+10h]
mov rsi, r14
call r15
test eax, eax
jnz short loc_9BF82
mov r12, [r12+8]
test r12, r12
jnz short loc_9BF67
jmp short loc_9BF84
loc_9BF82:
mov ebx, eax
loc_9BF84:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v3; // ebx
long long v5; // r12
unsigned int v6; // eax
v3 = 0;
if ( a1 )
{
v5 = a1;
while ( 1 )
{
v6 = a2(*(_QWORD *)(v5 + 16), a3);
if ( v6 )
break;
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
return v3;
}
return v6;
}
return v3;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR EBX,EBX
TEST RDI,RDI
JZ 0x0019bf84
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LAB_0019bf67:
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,R14
CALL R15
TEST EAX,EAX
JNZ 0x0019bf82
MOV R12,qword ptr [R12 + 0x8]
TEST R12,R12
JNZ 0x0019bf67
JMP 0x0019bf84
LAB_0019bf82:
MOV EBX,EAX
LAB_0019bf84:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
if (param_1 != 0) {
do {
iVar1 = (*param_2)(*(int8 *)(param_1 + 0x10),param_3);
if (iVar1 != 0) {
return iVar1;
}
param_1 = *(long *)(param_1 + 8);
} while (param_1 != 0);
}
return 0;
}
| |
30,025 | testing::internal::FilePath::FileOrDirectoryExists() const | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-filepath.cc | bool FilePath::FileOrDirectoryExists() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif // GTEST_OS_WINDOWS_MOBILE
} | O0 | cpp | testing::internal::FilePath::FileOrDirectoryExists() const:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x163a0
movq 0x8(%rsp), %rdi
callq 0x1f1e0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xebd00
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK7testing8internal8FilePath21FileOrDirectoryExistsEv:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_A0], rax
lea rdi, [rsp+0A8h+var_98]
xor esi, esi
mov edx, 90h
call _memset
mov rdi, [rsp+0A8h+var_A0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
lea rsi, [rsp+0A8h+var_98]
call _ZN7testing8internal5posix4StatEPKcP4stat; testing::internal::posix::Stat(char const*,stat *)
cmp eax, 0
setz al
and al, 1
add rsp, 0A8h
retn
| bool testing::internal::FilePath::FileOrDirectoryExists(testing::internal::FilePath *this)
{
long long v1; // rax
_BYTE v3[144]; // [rsp+10h] [rbp-98h] BYREF
testing::internal::FilePath *v4; // [rsp+A0h] [rbp-8h]
v4 = this;
memset(v3, 0LL, sizeof(v3));
v1 = std::string::c_str((long long)this);
return (unsigned int)testing::internal::posix::Stat(v1, v3) == 0;
}
| FileOrDirectoryExists:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
MOV EDX,0x90
CALL 0x001163a0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011f1e0
MOV RDI,RAX
LEA RSI,[RSP + 0x10]
CALL 0x001ebd00
CMP EAX,0x0
SETZ AL
AND AL,0x1
ADD RSP,0xa8
RET
|
/* testing::internal::FilePath::FileOrDirectoryExists() const */
bool __thiscall testing::internal::FilePath::FileOrDirectoryExists(FilePath *this)
{
int iVar1;
char *pcVar2;
stat local_98;
FilePath *local_8;
local_8 = this;
memset(&local_98,0,0x90);
pcVar2 = (char *)std::__cxx11::string::c_str((string *)this);
iVar1 = posix::Stat(pcVar2,&local_98);
return iVar1 == 0;
}
| |
30,026 | mi_decrement_open_count | eloqsql/storage/myisam/mi_locking.c | int _mi_decrement_open_count(MI_INFO *info)
{
uchar buff[2];
register MYISAM_SHARE *share=info->s;
int lock_error=0,write_error=0;
if (share->global_changed)
{
uint old_lock=info->lock_type;
share->global_changed=0;
lock_error= my_disable_locking ? 0 : mi_lock_database(info,F_WRLCK);
/* Its not fatal even if we couldn't get the lock ! */
if (share->state.open_count > 0)
{
share->state.open_count--;
mi_int2store(buff,share->state.open_count);
write_error= (mysql_file_pwrite(share->kfile, buff, sizeof(buff),
sizeof(share->state.header),
MYF(MY_NABP)) != 0);
}
if (!lock_error && !my_disable_locking)
lock_error=mi_lock_database(info,old_lock);
}
return MY_TEST(lock_error || write_error);
} | O0 | c | mi_decrement_open_count:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x380(%rax)
je 0xb145c
movq -0x8(%rbp), %rax
movl 0x1f4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x380(%rax)
leaq 0xbd1bd3(%rip), %rax # 0xc82f68
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb13a4
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb13b5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xafcd0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xec(%rax)
jbe 0xb1439
movq -0x18(%rbp), %rax
movl 0xec(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xec(%rax)
movq -0x18(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0x9(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
movl 0x350(%rax), %edx
leaq -0xa(%rbp), %rcx
leaq 0xa2505(%rip), %rdi # 0x153911
movl $0x28c, %esi # imm = 0x28C
movl $0x2, %r8d
movl $0x18, %r9d
movq $0x4, (%rsp)
callq 0xb11d0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xb145a
leaq 0xbd1b22(%rip), %rax # 0xc82f68
cmpb $0x0, (%rax)
jne 0xb145a
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xafcd0
movl %eax, -0x1c(%rbp)
jmp 0xb145c
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2d(%rbp)
jne 0xb1471
cmpl $0x0, -0x20(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _mi_decrement_open_count:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
mov [rbp+var_20], 0
mov rax, [rbp+var_18]
cmp byte ptr [rax+380h], 0
jz loc_B145C
mov rax, [rbp+var_8]
mov eax, [rax+1F4h]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov byte ptr [rax+380h], 0
lea rax, my_disable_locking
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_B13A4
xor eax, eax
mov [rbp+var_2C], eax
jmp short loc_B13B5
loc_B13A4:
mov rdi, [rbp+var_8]
mov esi, 1
call mi_lock_database
mov [rbp+var_2C], eax
loc_B13B5:
mov eax, [rbp+var_2C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
cmp dword ptr [rax+0ECh], 0
jbe short loc_B1439
mov rax, [rbp+var_18]
mov ecx, [rax+0ECh]
add ecx, 0FFFFFFFFh
mov [rax+0ECh], ecx
mov rax, [rbp+var_18]
mov eax, [rax+0ECh]
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
mov [rbp+var_9], al
mov eax, [rbp+var_28]
shr eax, 8
mov [rbp+var_A], al
mov rax, [rbp+var_18]
mov edx, [rax+350h]
lea rcx, [rbp+var_A]
lea rdi, aWorkspaceLlm4b_27; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 28Ch
mov r8d, 2
mov r9d, 18h
mov [rsp+40h+var_40], 4
call inline_mysql_file_pwrite_1
cmp rax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_20], eax
loc_B1439:
cmp [rbp+var_1C], 0
jnz short loc_B145A
lea rax, my_disable_locking
cmp byte ptr [rax], 0
jnz short loc_B145A
mov rdi, [rbp+var_8]
mov esi, [rbp+var_24]
call mi_lock_database
mov [rbp+var_1C], eax
loc_B145A:
jmp short $+2
loc_B145C:
mov al, 1
cmp [rbp+var_1C], 0
mov [rbp+var_2D], al
jnz short loc_B1471
cmp [rbp+var_20], 0
setnz al
mov [rbp+var_2D], al
loc_B1471:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
add rsp, 40h
pop rbp
retn
| _BOOL8 mi_decrement_open_count(_DWORD *a1)
{
__int16 v1; // kr00_2
bool v3; // [rsp+13h] [rbp-2Dh]
int v4; // [rsp+14h] [rbp-2Ch]
unsigned int v5; // [rsp+1Ch] [rbp-24h]
BOOL v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
long long v8; // [rsp+28h] [rbp-18h]
_BYTE v9[2]; // [rsp+36h] [rbp-Ah] BYREF
_DWORD *v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v8 = *(_QWORD *)a1;
v7 = 0;
v6 = 0;
if ( *(_BYTE *)(*(_QWORD *)a1 + 896LL) )
{
v5 = v10[125];
*(_BYTE *)(v8 + 896) = 0;
if ( my_disable_locking )
v4 = 0;
else
v4 = mi_lock_database(v10, (_BYTE *)&dword_0 + 1);
v7 = v4;
if ( *(_DWORD *)(v8 + 236) )
{
v1 = --*(_DWORD *)(v8 + 236);
v9[0] = HIBYTE(v1);
v9[1] = v1;
v6 = inline_mysql_file_pwrite_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x28Cu,
*(_DWORD *)(v8 + 848),
(long long)v9,
2LL,
24LL,
4LL) != 0;
}
if ( !v4 && !my_disable_locking )
v7 = mi_lock_database(v10, (const char *)v5);
}
v3 = 1;
if ( !v7 )
return v6;
return v3;
}
| _mi_decrement_open_count:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x380],0x0
JZ 0x001b145c
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1f4]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x380],0x0
LEA RAX,[0xd82f68]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001b13a4
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001b13b5
LAB_001b13a4:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x001afcd0
MOV dword ptr [RBP + -0x2c],EAX
LAB_001b13b5:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0xec],0x0
JBE 0x001b1439
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0xec]
ADD ECX,-0x1
MOV dword ptr [RAX + 0xec],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xec]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x9],AL
MOV EAX,dword ptr [RBP + -0x28]
SHR EAX,0x8
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0x350]
LEA RCX,[RBP + -0xa]
LEA RDI,[0x253911]
MOV ESI,0x28c
MOV R8D,0x2
MOV R9D,0x18
MOV qword ptr [RSP],0x4
CALL 0x001b11d0
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x20],EAX
LAB_001b1439:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001b145a
LEA RAX,[0xd82f68]
CMP byte ptr [RAX],0x0
JNZ 0x001b145a
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x24]
CALL 0x001afcd0
MOV dword ptr [RBP + -0x1c],EAX
LAB_001b145a:
JMP 0x001b145c
LAB_001b145c:
MOV AL,0x1
CMP dword ptr [RBP + -0x1c],0x0
MOV byte ptr [RBP + -0x2d],AL
JNZ 0x001b1471
CMP dword ptr [RBP + -0x20],0x0
SETNZ AL
MOV byte ptr [RBP + -0x2d],AL
LAB_001b1471:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
ADD RSP,0x40
POP RBP
RET
|
bool _mi_decrement_open_count(long *param_1)
{
int4 uVar1;
long lVar2;
bool bVar3;
int local_34;
int local_24;
int1 local_12;
int1 local_11;
long *local_10;
lVar2 = *param_1;
local_24 = 0;
bVar3 = false;
if (*(char *)(lVar2 + 0x380) != '\0') {
uVar1 = *(int4 *)((long)param_1 + 500);
*(int1 *)(lVar2 + 0x380) = 0;
local_10 = param_1;
if (my_disable_locking == '\0') {
local_34 = mi_lock_database(param_1,1);
}
else {
local_34 = 0;
}
local_24 = local_34;
if (*(int *)(lVar2 + 0xec) != 0) {
*(int *)(lVar2 + 0xec) = *(int *)(lVar2 + 0xec) + -1;
local_11 = (int1)*(int4 *)(lVar2 + 0xec);
local_12 = (int1)((uint)*(int4 *)(lVar2 + 0xec) >> 8);
lVar2 = inline_mysql_file_pwrite
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x28c,*(int4 *)(lVar2 + 0x350),&local_12,2,0x18,4);
bVar3 = lVar2 != 0;
}
if ((local_34 == 0) && (my_disable_locking == '\0')) {
local_24 = mi_lock_database(local_10,uVar1);
}
}
return local_24 != 0 || bVar3;
}
| |
30,027 | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool) | monkey531[P]llama/common/common.cpp | std::string common_detokenize(const struct llama_vocab * vocab, const std::vector<llama_token> & tokens, bool special) {
std::string text;
text.resize(std::max(text.capacity(), tokens.size()));
int32_t n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
if (n_chars < 0) {
text.resize(-n_chars);
n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
GGML_ASSERT(n_chars <= (int32_t)text.size()); // whitespace trimming is performed after per-token detokenization
}
text.resize(n_chars);
// NOTE: the original tokenizer decodes bytes after collecting the pieces.
return text;
} | O2 | cpp | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x2, %rax
cmpq $0x10, %rax
pushq $0xf
popq %rsi
cmovaeq %rax, %rsi
callq 0x24e10
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movzbl %bpl, %ebp
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x240c0
testl %eax, %eax
jns 0x59184
negl %eax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24e10
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x240c0
cmpl 0x8(%rbx), %eax
jg 0x5919d
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x24e10
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5bc89(%rip), %rdi # 0xb4e2d
leaq 0x58f5b(%rip), %rdx # 0xb2106
leaq 0x5c320(%rip), %rcx # 0xb54d2
movl $0x6e2, %esi # imm = 0x6E2
xorl %eax, %eax
callq 0x250e0
jmp 0x591c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x25478
movq %r14, %rdi
callq 0x251e0
| _Z17common_detokenizeB5cxx11PK11llama_vocabRKSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rdx+8]
sub rax, [rdx]
sar rax, 2
cmp rax, 10h
push 0Fh
pop rsi
cmovnb rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
movzx ebp, bpl
mov [rsp+28h+var_28], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
test eax, eax
jns short loc_59184
neg eax
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
mov [rsp+28h+var_28], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
cmp eax, [rbx+8]
jg short loc_5919D
loc_59184:
movsxd rsi, eax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5919D:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsInt32TTe; "n_chars <= (int32_t)text.size()"
mov esi, 6E2h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_591C0:
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_detokenize[abi:cxx11](_QWORD *a1, long long a2, _QWORD *a3, unsigned __int8 a4)
{
long long v4; // rax
long long v8; // rsi
int v9; // eax
long long v10; // rdx
long long v12; // r14
long long v13; // [rsp+0h] [rbp-28h]
long long v14; // [rsp+0h] [rbp-28h]
HIDWORD(v13) = HIDWORD(v4);
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v8 = 15LL;
if ( (unsigned long long)((long long)(a3[1] - *a3) >> 2) >= 0x10 )
v8 = (long long)(a3[1] - *a3) >> 2;
std::string::resize(a1, v8, a3);
LODWORD(v13) = a4;
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v13);
if ( v9 < 0 )
{
std::string::resize(a1, (unsigned int)-v9, v10);
LODWORD(v14) = a4;
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v14);
if ( v9 > *((_DWORD *)a1 + 2) )
{
v12 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1762LL,
"GGML_ASSERT(%s) failed",
"n_chars <= (int32_t)text.size()");
std::string::~string(a1);
_Unwind_Resume(v12);
}
}
std::string::resize(a1, v9, v10);
return a1;
}
| common_detokenize[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RDX + 0x8]
SUB RAX,qword ptr [RDX]
SAR RAX,0x2
CMP RAX,0x10
PUSH 0xf
POP RSI
CMOVNC RSI,RAX
LAB_0015911f:
CALL 0x00124e10
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
LAB_00159139:
MOVZX EBP,BPL
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x001240c0
TEST EAX,EAX
JNS 0x00159184
NEG EAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00124e10
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x001240c0
CMP EAX,dword ptr [RBX + 0x8]
JG 0x0015919d
LAB_00159184:
MOVSXD RSI,EAX
MOV RDI,RBX
CALL 0x00124e10
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015919d:
LEA RDI,[0x1b4e2d]
LEA RDX,[0x1b2106]
LEA RCX,[0x1b54d2]
MOV ESI,0x6e2
XOR EAX,EAX
CALL 0x001250e0
|
/* common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int> > const&,
bool) */
llama_vocab * common_detokenize_abi_cxx11_(llama_vocab *param_1,vector *param_2,bool param_3)
{
int iVar1;
int8 in_RAX;
int4 uVar2;
int4 in_ECX;
int7 in_register_00000011;
long *plVar3;
ulong uVar4;
uVar2 = (int4)((ulong)in_RAX >> 0x20);
plVar3 = (long *)CONCAT71(in_register_00000011,param_3);
*(llama_vocab **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (llama_vocab)0x0;
/* try { // try from 0015911f to 00159123 has its CatchHandler @ 001591be */
std::__cxx11::string::resize((ulong)param_1);
/* try { // try from 00159139 to 001591bd has its CatchHandler @ 001591c0 */
uVar4 = CONCAT44(uVar2,in_ECX) & 0xffffffff000000ff;
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,uVar4);
uVar2 = (int4)(uVar4 >> 0x20);
if (iVar1 < 0) {
std::__cxx11::string::resize((ulong)param_1);
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,
*(int8 *)param_1,*(int4 *)(param_1 + 8),0,
CONCAT44(uVar2,in_ECX) & 0xffffffff000000ff);
if (*(int *)(param_1 + 8) < iVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x6e2
,"GGML_ASSERT(%s) failed","n_chars <= (int32_t)text.size()");
}
}
std::__cxx11::string::resize((ulong)param_1);
return param_1;
}
| |
30,028 | js_string_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
return js_thisStringValue(ctx, this_val);
} | O1 | c | js_string_toString:
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
cmpl $-0x1, %edx
je 0x7cdf2
cmpl $-0x7, %edx
jne 0x7ce16
movq %rsi, %rbx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x7ce2b
movq 0x8(%rsp), %rax
incl (%rax)
jmp 0x7ce2b
movq (%rsp), %rcx
movb $0x1, %al
cmpw $0x5, 0x6(%rcx)
jne 0x7ce12
movq 0x38(%rcx), %rdx
cmpl $-0x7, %edx
jne 0x7ce12
movq 0x30(%rcx), %rbx
incl (%rbx)
xorl %eax, %eax
jmp 0x7ce12
testb %al, %al
je 0x7ce2b
leaq 0x22ddf(%rip), %rsi # 0x9fbfc
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22567
movl $0x6, %edx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| js_string_toString:
push rbx
sub rsp, 10h
mov [rsp+18h+var_18], rsi
cmp edx, 0FFFFFFFFh
jz short loc_7CDF2
cmp edx, 0FFFFFFF9h
jnz short loc_7CE16
mov rbx, rsi
mov [rsp+18h+var_10], rsi
cmp edx, 0FFFFFFF7h
jb short loc_7CE2B
mov rax, [rsp+18h+var_10]
inc dword ptr [rax]
jmp short loc_7CE2B
loc_7CDF2:
mov rcx, [rsp+18h+var_18]
mov al, 1
cmp word ptr [rcx+6], 5
jnz short loc_7CE12
mov rdx, [rcx+38h]
cmp edx, 0FFFFFFF9h
jnz short loc_7CE12
mov rbx, [rcx+30h]
inc dword ptr [rbx]
xor eax, eax
jmp short $+2
loc_7CE12:
test al, al
jz short loc_7CE2B
loc_7CE16:
lea rsi, aNotAString; "not a string"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_7CE2B:
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _DWORD * js_string_toString(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v14; // rbx
char v15; // al
if ( (_DWORD)a3 != -1 )
{
if ( (_DWORD)a3 == -7 )
{
v14 = (_DWORD *)a2;
++*(_DWORD *)a2;
return v14;
}
LABEL_8:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a string", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a2);
return v14;
}
a4 = a2;
v15 = 1;
if ( *(_WORD *)(a2 + 6) == 5 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -7 )
{
v14 = *(_DWORD **)(a2 + 48);
++*v14;
v15 = 0;
}
}
if ( v15 )
goto LABEL_8;
return v14;
}
| js_string_toString:
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP],RSI
CMP EDX,-0x1
JZ 0x0017cdf2
CMP EDX,-0x7
JNZ 0x0017ce16
MOV RBX,RSI
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x0017ce2b
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
JMP 0x0017ce2b
LAB_0017cdf2:
MOV RCX,qword ptr [RSP]
MOV AL,0x1
CMP word ptr [RCX + 0x6],0x5
JNZ 0x0017ce12
MOV RDX,qword ptr [RCX + 0x38]
CMP EDX,-0x7
JNZ 0x0017ce12
MOV RBX,qword ptr [RCX + 0x30]
INC dword ptr [RBX]
XOR EAX,EAX
JMP 0x0017ce12
LAB_0017ce12:
TEST AL,AL
JZ 0x0017ce2b
LAB_0017ce16:
LEA RSI,[0x19fbfc]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00122567
MOV EDX,0x6
LAB_0017ce2b:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
int1 [16] js_string_toString(int8 param_1,int *param_2,int8 param_3)
{
bool bVar1;
int *unaff_RBX;
int1 auVar2 [16];
if ((int)param_3 == -1) {
bVar1 = true;
if ((*(short *)((long)param_2 + 6) == 5) &&
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 == -7)) {
unaff_RBX = *(int **)(param_2 + 0xc);
*unaff_RBX = *unaff_RBX + 1;
bVar1 = false;
}
if (!bVar1) goto LAB_0017ce2b;
}
else if ((int)param_3 == -7) {
*param_2 = *param_2 + 1;
unaff_RBX = param_2;
goto LAB_0017ce2b;
}
unaff_RBX = (int *)0x0;
JS_ThrowTypeError(param_1,"not a string");
param_3 = 6;
LAB_0017ce2b:
auVar2._8_8_ = param_3;
auVar2._0_8_ = unaff_RBX;
return auVar2;
}
| |
30,029 | js_string_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
return js_thisStringValue(ctx, this_val);
} | O2 | c | js_string_toString:
pushq %rbx
movq %rsi, %rbx
cmpl $-0x1, %edx
je 0x68e19
cmpl $-0x7, %edx
jne 0x68e2f
incl (%rbx)
jmp 0x68e42
cmpw $0x5, 0x6(%rbx)
jne 0x68e2f
movq 0x38(%rbx), %rdx
cmpl $-0x7, %edx
jne 0x68e2f
movq 0x30(%rbx), %rbx
jmp 0x68e15
leaq 0x1dd16(%rip), %rsi # 0x86b4c
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %rdx
movq %rbx, %rax
popq %rbx
retq
| js_string_toString:
push rbx
mov rbx, rsi
cmp edx, 0FFFFFFFFh
jz short loc_68E19
cmp edx, 0FFFFFFF9h
jnz short loc_68E2F
loc_68E15:
inc dword ptr [rbx]
jmp short loc_68E42
loc_68E19:
cmp word ptr [rbx+6], 5
jnz short loc_68E2F
mov rdx, [rbx+38h]
cmp edx, 0FFFFFFF9h
jnz short loc_68E2F
mov rbx, [rbx+30h]
jmp short loc_68E15
loc_68E2F:
lea rsi, aNotAString; "not a string"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_68E42:
mov rax, rbx
pop rbx
retn
| _DWORD * js_string_toString(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v14; // rbx
char v16; // [rsp+0h] [rbp-8h]
v14 = (_DWORD *)a2;
if ( (_DWORD)a3 == -1 )
{
if ( *(_WORD *)(a2 + 6) == 5 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -7 )
{
v14 = *(_DWORD **)(a2 + 48);
goto LABEL_3;
}
}
LABEL_7:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a string", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
return v14;
}
if ( (_DWORD)a3 != -7 )
goto LABEL_7;
LABEL_3:
++*v14;
return v14;
}
| js_string_toString:
PUSH RBX
MOV RBX,RSI
CMP EDX,-0x1
JZ 0x00168e19
CMP EDX,-0x7
JNZ 0x00168e2f
LAB_00168e15:
INC dword ptr [RBX]
JMP 0x00168e42
LAB_00168e19:
CMP word ptr [RBX + 0x6],0x5
JNZ 0x00168e2f
MOV RDX,qword ptr [RBX + 0x38]
CMP EDX,-0x7
JNZ 0x00168e2f
MOV RBX,qword ptr [RBX + 0x30]
JMP 0x00168e15
LAB_00168e2f:
LEA RSI,[0x186b4c]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP RDX
LAB_00168e42:
MOV RAX,RBX
POP RBX
RET
|
int1 [16] js_string_toString(int8 param_1,int *param_2,int8 param_3)
{
int1 auVar1 [16];
if ((int)param_3 == -1) {
if ((*(short *)((long)param_2 + 6) != 5) ||
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 != -7)) goto LAB_00168e2f;
param_2 = *(int **)(param_2 + 0xc);
}
else if ((int)param_3 != -7) {
LAB_00168e2f:
param_2 = (int *)0x0;
JS_ThrowTypeError(param_1,"not a string");
param_3 = 6;
goto LAB_00168e42;
}
*param_2 = *param_2 + 1;
LAB_00168e42:
auVar1._8_8_ = param_3;
auVar1._0_8_ = param_2;
return auVar1;
}
| |
30,030 | testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-port.cc | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker = severity == GTEST_INFO ? "[ INFO ]"
: severity == GTEST_WARNING ? "[WARNING]"
: severity == GTEST_ERROR ? "[ ERROR ]"
: "[ FATAL ]";
GetStream() << ::std::endl
<< marker << " " << FormatFileLocation(file, line).c_str()
<< ": ";
} | O0 | cpp | testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int):
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x8c(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x8c(%rsp)
jne 0xb90c0
leaq 0x59b1c(%rip), %rax # 0x112bd5
movq %rax, 0x30(%rsp)
jmp 0xb9112
cmpl $0x1, 0x8c(%rsp)
jne 0xb90d8
leaq 0x59b0e(%rip), %rax # 0x112bdf
movq %rax, 0x28(%rsp)
jmp 0xb9108
cmpl $0x2, 0x8c(%rsp)
jne 0xb90f0
leaq 0x59b00(%rip), %rax # 0x112be9
movq %rax, 0x20(%rsp)
jmp 0xb90fe
leaq 0x59afc(%rip), %rax # 0x112bf3
movq %rax, 0x20(%rsp)
jmp 0xb90fe
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
callq 0x1ea10
movq %rax, %rdi
movq 0xbee00(%rip), %rsi # 0x177f30
callq 0x14720
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x146a0
movq %rax, %rdi
leaq 0x5a197(%rip), %rsi # 0x1132e3
callq 0x146a0
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb8c90
movq 0x8(%rsp), %rdi
callq 0x1acc0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x146a0
movq %rax, 0x18(%rsp)
jmp 0xb918f
movq 0x18(%rsp), %rdi
leaq 0x5ac9c(%rip), %rsi # 0x113e37
callq 0x146a0
jmp 0xb91a2
leaq 0x50(%rsp), %rdi
callq 0x1aac0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1aac0
movq 0x48(%rsp), %rdi
callq 0x14c80
nopw %cs:(%rax,%rax)
| _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci:
sub rsp, 98h
mov qword ptr [rsp+98h+var_8], rdi; int
mov [rsp+98h+var_C], esi
mov qword ptr [rsp+98h+var_18], rdx; int
mov [rsp+98h+var_1C], ecx
mov rax, qword ptr [rsp+98h+var_8]
mov [rsp+98h+var_60], rax; int
mov ecx, [rsp+98h+var_C]
mov [rax], ecx
cmp [rsp+98h+var_C], 0
jnz short loc_B90C0
lea rax, aInfo_0; "[ INFO ]"
mov qword ptr [rsp+98h+var_68], rax
jmp short loc_B9112
loc_B90C0:
cmp [rsp+98h+var_C], 1
jnz short loc_B90D8
lea rax, aWarning; "[WARNING]"
mov qword ptr [rsp+98h+var_70], rax
jmp short loc_B9108
loc_B90D8:
cmp [rsp+98h+var_C], 2
jnz short loc_B90F0
lea rax, aError_0; "[ ERROR ]"
mov qword ptr [rsp+98h+var_78], rax; char
jmp short loc_B90FE
loc_B90F0:
lea rax, aFatal; "[ FATAL ]"
mov qword ptr [rsp+98h+var_78], rax
jmp short $+2
loc_B90FE:
mov rax, qword ptr [rsp+98h+var_78]
mov qword ptr [rsp+98h+var_70], rax; int
loc_B9108:
mov rax, qword ptr [rsp+98h+var_70]
mov qword ptr [rsp+98h+var_68], rax; int
loc_B9112:
mov rdi, [rsp+98h+var_60]; this
mov rax, qword ptr [rsp+98h+var_68]
mov qword ptr [rsp+98h+var_28], rax; int
call _ZN7testing8internal8GTestLog9GetStreamEv; testing::internal::GTestLog::GetStream(void)
mov rdi, rax
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
mov rdi, rax
mov rsi, qword ptr [rsp+98h+var_28]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
lea rsi, asc_1132E1+2; " "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov qword ptr [rsp+98h+var_88], rax; int
mov rsi, qword ptr [rsp+98h+var_18]
mov edx, [rsp+98h+var_1C]
lea rdi, [rsp+98h+var_48]; __int64
mov qword ptr [rsp+98h+var_90], rdi; int
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
mov rdi, qword ptr [rsp+98h+var_90]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, qword ptr [rsp+98h+var_88]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+98h+var_80], rax
jmp short $+2
loc_B918F:
mov rdi, [rsp+98h+var_80]
lea rsi, asc_113E36+1; ": "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_B91A2:
lea rdi, [rsp+98h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 98h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_40]
call __Unwind_Resume
| void testing::internal::GTestLog::GTestLog(testing::internal::GTestLog *a1, int a2, long long a3, int a4)
{
void *Stream; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
int v8[2]; // [rsp+10h] [rbp-88h]
long long v9; // [rsp+18h] [rbp-80h]
const char *v10; // [rsp+20h] [rbp-78h]
const char *v11; // [rsp+28h] [rbp-70h]
const char *v12; // [rsp+30h] [rbp-68h]
long long v13[4]; // [rsp+50h] [rbp-48h] BYREF
int v14[2]; // [rsp+70h] [rbp-28h]
int v15; // [rsp+7Ch] [rbp-1Ch]
int v16[2]; // [rsp+80h] [rbp-18h]
int v17; // [rsp+8Ch] [rbp-Ch]
int v18[2]; // [rsp+90h] [rbp-8h]
*(_QWORD *)v18 = a1;
v17 = a2;
*(_QWORD *)v16 = a3;
v15 = a4;
*(_DWORD *)a1 = a2;
if ( v17 )
{
if ( v17 == 1 )
{
v11 = "[WARNING]";
}
else
{
if ( v17 == 2 )
v10 = "[ ERROR ]";
else
v10 = "[ FATAL ]";
v11 = v10;
}
v12 = v11;
}
else
{
v12 = "[ INFO ]";
}
*(_QWORD *)v14 = v12;
Stream = testing::internal::GTestLog::GetStream(a1);
v5 = std::ostream::operator<<(Stream, &std::endl<char,std::char_traits<char>>);
v6 = std::operator<<<std::char_traits<char>>(v5, v12);
*(_QWORD *)v8 = std::operator<<<std::char_traits<char>>(v6, " ");
testing::internal::FormatFileLocation[abi:cxx11](v13, *(long long *)v16, v15);
v7 = std::string::c_str((long long)v13);
v9 = std::operator<<<std::char_traits<char>>(*(_QWORD *)v8, v7);
std::operator<<<std::char_traits<char>>(v9, ": ");
std::string::~string(v13);
}
| GTestLog:
SUB RSP,0x98
MOV qword ptr [RSP + 0x90],RDI
MOV dword ptr [RSP + 0x8c],ESI
MOV qword ptr [RSP + 0x80],RDX
MOV dword ptr [RSP + 0x7c],ECX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x38],RAX
MOV ECX,dword ptr [RSP + 0x8c]
MOV dword ptr [RAX],ECX
CMP dword ptr [RSP + 0x8c],0x0
JNZ 0x001b90c0
LEA RAX,[0x212bd5]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001b9112
LAB_001b90c0:
CMP dword ptr [RSP + 0x8c],0x1
JNZ 0x001b90d8
LEA RAX,[0x212bdf]
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001b9108
LAB_001b90d8:
CMP dword ptr [RSP + 0x8c],0x2
JNZ 0x001b90f0
LEA RAX,[0x212be9]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001b90fe
LAB_001b90f0:
LEA RAX,[0x212bf3]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001b90fe
LAB_001b90fe:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RAX
LAB_001b9108:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x30],RAX
LAB_001b9112:
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x70],RAX
CALL 0x0011ea10
MOV RDI,RAX
MOV RSI,qword ptr [0x00277f30]
CALL 0x00114720
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x001146a0
MOV RDI,RAX
LEA RSI,[0x2132e3]
CALL 0x001146a0
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP + 0x80]
MOV EDX,dword ptr [RSP + 0x7c]
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001b8c90
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011acc0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
LAB_001b9183:
CALL 0x001146a0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001b918f
LAB_001b918f:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x213e37]
CALL 0x001146a0
LAB_001b91a0:
JMP 0x001b91a2
LAB_001b91a2:
LEA RDI,[RSP + 0x50]
CALL 0x0011aac0
ADD RSP,0x98
RET
|
/* testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) */
void __thiscall
testing::internal::GTestLog::GTestLog(GTestLog *this,int param_2,char *param_3,int param_4)
{
ostream *poVar1;
char *pcVar2;
char *local_78;
char *local_70;
char *local_68;
internal local_48 [32];
char *local_28;
int local_1c;
char *local_18;
int local_c;
GTestLog *local_8;
*(int *)this = param_2;
if (param_2 == 0) {
local_68 = "[ INFO ]";
}
else {
if (param_2 == 1) {
local_70 = "[WARNING]";
}
else {
if (param_2 == 2) {
local_78 = "[ ERROR ]";
}
else {
local_78 = "[ FATAL ]";
}
local_70 = local_78;
}
local_68 = local_70;
}
local_28 = local_68;
local_1c = param_4;
local_18 = param_3;
local_c = param_2;
local_8 = this;
poVar1 = (ostream *)GetStream();
poVar1 = (ostream *)
std::ostream::operator<<
(poVar1,(_func_ostream_ptr_ostream_ptr *)
PTR_endl<char,std_char_traits<char>>_00277f30);
poVar1 = std::operator<<(poVar1,local_28);
poVar1 = std::operator<<(poVar1," ");
FormatFileLocation_abi_cxx11_(local_48,local_18,local_1c);
pcVar2 = (char *)std::__cxx11::string::c_str((string *)local_48);
/* try { // try from 001b9183 to 001b919f has its CatchHandler @ 001b91b4 */
poVar1 = std::operator<<(poVar1,pcVar2);
std::operator<<(poVar1,": ");
std::__cxx11::string::~string((string *)local_48);
return;
}
| |
30,031 | ModbusTcpServer::close() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpServer_unix.cpp | StatusCode ModbusTcpServer::close()
{
ModbusTcpServerPrivateUnix *d = d_unix(d_ptr);
if (isOpen())
d->socket->close();
d->cmdClose = true;
for (ModbusServerPort *c : d->connections)
c->close();
switch (d->state)
{
case STATE_WAIT_FOR_CLOSE:
for (ModbusServerPort *c : d->connections)
{
c->process();
if (!c->isStateClosed())
return Status_Processing;
}
break;
default:
return Status_Processing;
}
return Status_Good;
} | O0 | cpp | ModbusTcpServer::close():
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x8(%rax), %rdi
callq 0x26480
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x26101
jmp 0x26111
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x22900
movq -0x18(%rbp), %rax
movb $0x1, 0x6c(%rax)
movq -0x18(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dcf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dd20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dd50
testb $0x1, %al
jne 0x26154
jmp 0x26179
leaq -0x28(%rbp), %rdi
callq 0x1dd80
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
leaq -0x28(%rbp), %rdi
callq 0x1ddb0
jmp 0x26141
movq -0x18(%rbp), %rax
movl 0x68(%rax), %eax
subl $0x9, %eax
jne 0x26201
jmp 0x26187
movq -0x18(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1dcf0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1dd20
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1dd50
testb $0x1, %al
jne 0x261c2
jmp 0x261ff
leaq -0x48(%rbp), %rdi
callq 0x1dd80
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x58(%rbp), %rdi
callq 0x1cac0
testb $0x1, %al
jne 0x261f2
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x26211
jmp 0x261f4
leaq -0x48(%rbp), %rdi
callq 0x1ddb0
jmp 0x261af
jmp 0x2620a
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x26211
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN15ModbusTcpServer5closeEv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_60], rax
mov rdi, [rax+8]
call _ZN6Modbus6d_unixEP19ModbusObjectPrivate; Modbus::d_unix(ModbusObjectPrivate *)
mov rdi, [rbp+var_60]
mov [rbp+var_18], rax
mov rax, [rdi]
call qword ptr [rax+30h]
test al, 1
jnz short loc_26101
jmp short loc_26111
loc_26101:
mov rax, [rbp+var_18]
mov rdi, [rax+0D8h]; this
call _ZN15ModbusTcpSocket5closeEv; ModbusTcpSocket::close(void)
loc_26111:
mov rax, [rbp+var_18]
mov byte ptr [rax+6Ch], 1
mov rax, [rbp+var_18]
add rax, 0C0h
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _ZNSt7__cxx114listIP16ModbusServerPortSaIS2_EE5beginEv; std::list<ModbusServerPort *>::begin(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZNSt7__cxx114listIP16ModbusServerPortSaIS2_EE3endEv; std::list<ModbusServerPort *>::end(void)
mov [rbp+var_30], rax
loc_26141:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
call _ZStneRKSt14_List_iteratorIP16ModbusServerPortES4_; std::operator!=(std::_List_iterator<ModbusServerPort *> const&,std::_List_iterator<ModbusServerPort *> const&)
test al, 1
jnz short loc_26154
jmp short loc_26179
loc_26154:
lea rdi, [rbp+var_28]
call _ZNKSt14_List_iteratorIP16ModbusServerPortEdeEv; std::_List_iterator<ModbusServerPort *>::operator*(void)
mov rax, [rax]
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
mov rax, [rdi]
call qword ptr [rax+28h]
lea rdi, [rbp+var_28]
call _ZNSt14_List_iteratorIP16ModbusServerPortEppEv; std::_List_iterator<ModbusServerPort *>::operator++(void)
jmp short loc_26141
loc_26179:
mov rax, [rbp+var_18]
mov eax, [rax+68h]
sub eax, 9
jnz short loc_26201
jmp short $+2
loc_26187:
mov rax, [rbp+var_18]
add rax, 0C0h
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
call _ZNSt7__cxx114listIP16ModbusServerPortSaIS2_EE5beginEv; std::list<ModbusServerPort *>::begin(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_40]
call _ZNSt7__cxx114listIP16ModbusServerPortSaIS2_EE3endEv; std::list<ModbusServerPort *>::end(void)
mov [rbp+var_50], rax
loc_261AF:
lea rdi, [rbp+var_48]
lea rsi, [rbp+var_50]
call _ZStneRKSt14_List_iteratorIP16ModbusServerPortES4_; std::operator!=(std::_List_iterator<ModbusServerPort *> const&,std::_List_iterator<ModbusServerPort *> const&)
test al, 1
jnz short loc_261C2
jmp short loc_261FF
loc_261C2:
lea rdi, [rbp+var_48]
call _ZNKSt14_List_iteratorIP16ModbusServerPortEdeEv; std::_List_iterator<ModbusServerPort *>::operator*(void)
mov rax, [rax]
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
mov rax, [rdi]
call qword ptr [rax+48h]
mov rdi, [rbp+var_58]; this
call _ZNK16ModbusServerPort13isStateClosedEv; ModbusServerPort::isStateClosed(void)
test al, 1
jnz short loc_261F2
mov [rbp+var_4], 80000000h
jmp short loc_26211
loc_261F2:
jmp short $+2
loc_261F4:
lea rdi, [rbp+var_48]
call _ZNSt14_List_iteratorIP16ModbusServerPortEppEv; std::_List_iterator<ModbusServerPort *>::operator++(void)
jmp short loc_261AF
loc_261FF:
jmp short loc_2620A
loc_26201:
mov [rbp+var_4], 80000000h
jmp short loc_26211
loc_2620A:
mov [rbp+var_4], 0
loc_26211:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long ModbusTcpServer::close(Modbus **this, ModbusObjectPrivate *a2)
{
long long v2; // rax
ModbusObjectPrivate **v4; // [rsp+8h] [rbp-58h]
long long v5; // [rsp+10h] [rbp-50h] BYREF
_QWORD *v6; // [rsp+18h] [rbp-48h] BYREF
long long v7; // [rsp+20h] [rbp-40h]
long long v8; // [rsp+28h] [rbp-38h]
long long v9; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v10[2]; // [rsp+38h] [rbp-28h] BYREF
long long v11; // [rsp+48h] [rbp-18h]
Modbus **v12; // [rsp+50h] [rbp-10h]
v12 = this;
v11 = Modbus::d_unix(this[1], a2);
if ( ((*((long long ( **)(Modbus **))*this + 6))(this) & 1) != 0 )
ModbusTcpSocket::close(*(ModbusTcpSocket **)(v11 + 216));
*(_BYTE *)(v11 + 108) = 1;
v10[1] = (_QWORD *)(v11 + 192);
v10[0] = (_QWORD *)std::list<ModbusServerPort *>::begin((_QWORD *)(v11 + 192));
v9 = std::list<ModbusServerPort *>::end(v11 + 192);
while ( std::operator!=(v10, &v9) )
{
v8 = *(_QWORD *)std::_List_iterator<ModbusServerPort *>::operator*(v10);
(*(void ( **)(long long))(*(_QWORD *)v8 + 40LL))(v8);
std::_List_iterator<ModbusServerPort *>::operator++(v10);
}
if ( *(_DWORD *)(v11 + 104) == 9 )
{
v7 = v11 + 192;
v6 = (_QWORD *)std::list<ModbusServerPort *>::begin((_QWORD *)(v11 + 192));
v5 = std::list<ModbusServerPort *>::end(v7);
while ( std::operator!=(&v6, &v5) )
{
v2 = std::_List_iterator<ModbusServerPort *>::operator*(&v6);
v4 = *(ModbusObjectPrivate ***)v2;
(*(void (**)(void))(**(_QWORD **)v2 + 72LL))();
if ( (ModbusServerPort::isStateClosed(v4) & 1) == 0 )
return 0x80000000;
std::_List_iterator<ModbusServerPort *>::operator++(&v6);
}
return 0;
}
else
{
return 0x80000000;
}
}
| close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00126480
MOV RDI,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x30]
TEST AL,0x1
JNZ 0x00126101
JMP 0x00126111
LAB_00126101:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0xd8]
CALL 0x00122900
LAB_00126111:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x6c],0x1
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0xc0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0011dcf0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0011dd20
MOV qword ptr [RBP + -0x30],RAX
LAB_00126141:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL 0x0011dd50
TEST AL,0x1
JNZ 0x00126154
JMP 0x00126179
LAB_00126154:
LEA RDI,[RBP + -0x28]
CALL 0x0011dd80
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
LEA RDI,[RBP + -0x28]
CALL 0x0011ddb0
JMP 0x00126141
LAB_00126179:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x68]
SUB EAX,0x9
JNZ 0x00126201
JMP 0x00126187
LAB_00126187:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0xc0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x0011dcf0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x0011dd20
MOV qword ptr [RBP + -0x50],RAX
LAB_001261af:
LEA RDI,[RBP + -0x48]
LEA RSI,[RBP + -0x50]
CALL 0x0011dd50
TEST AL,0x1
JNZ 0x001261c2
JMP 0x001261ff
LAB_001261c2:
LEA RDI,[RBP + -0x48]
CALL 0x0011dd80
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x0011cac0
TEST AL,0x1
JNZ 0x001261f2
MOV dword ptr [RBP + -0x4],0x80000000
JMP 0x00126211
LAB_001261f2:
JMP 0x001261f4
LAB_001261f4:
LEA RDI,[RBP + -0x48]
CALL 0x0011ddb0
JMP 0x001261af
LAB_001261ff:
JMP 0x0012620a
LAB_00126201:
MOV dword ptr [RBP + -0x4],0x80000000
JMP 0x00126211
LAB_0012620a:
MOV dword ptr [RBP + -0x4],0x0
LAB_00126211:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
/* ModbusTcpServer::close() */
int4 __thiscall ModbusTcpServer::close(ModbusTcpServer *this)
{
ModbusServerPort *this_00;
ulong uVar1;
int8 *puVar2;
int8 local_58;
int8 local_50;
list<ModbusServerPort*,std::allocator<ModbusServerPort*>> *local_48;
long *local_40;
int8 local_38;
int8 local_30;
list<ModbusServerPort*,std::allocator<ModbusServerPort*>> *local_28;
long local_20;
ModbusTcpServer *local_18;
int4 local_c;
local_18 = this;
local_20 = Modbus::d_unix(*(ModbusObjectPrivate **)(this + 8));
uVar1 = (**(code **)(*(long *)this + 0x30))();
if ((uVar1 & 1) != 0) {
ModbusTcpSocket::close(*(ModbusTcpSocket **)(local_20 + 0xd8));
}
*(int1 *)(local_20 + 0x6c) = 1;
local_28 = (list<ModbusServerPort*,std::allocator<ModbusServerPort*>> *)(local_20 + 0xc0);
local_30 = std::__cxx11::list<ModbusServerPort*,std::allocator<ModbusServerPort*>>::begin
(local_28);
local_38 = std::__cxx11::list<ModbusServerPort*,std::allocator<ModbusServerPort*>>::end(local_28);
while (uVar1 = std::operator!=((_List_iterator *)&local_30,(_List_iterator *)&local_38),
(uVar1 & 1) != 0) {
puVar2 = (int8 *)
std::_List_iterator<ModbusServerPort*>::operator*
((_List_iterator<ModbusServerPort*> *)&local_30);
local_40 = (long *)*puVar2;
(**(code **)(*local_40 + 0x28))();
std::_List_iterator<ModbusServerPort*>::operator++
((_List_iterator<ModbusServerPort*> *)&local_30);
}
if (*(int *)(local_20 + 0x68) == 9) {
local_48 = (list<ModbusServerPort*,std::allocator<ModbusServerPort*>> *)(local_20 + 0xc0);
local_50 = std::__cxx11::list<ModbusServerPort*,std::allocator<ModbusServerPort*>>::begin
(local_48);
local_58 = std::__cxx11::list<ModbusServerPort*,std::allocator<ModbusServerPort*>>::end
(local_48);
while (uVar1 = std::operator!=((_List_iterator *)&local_50,(_List_iterator *)&local_58),
(uVar1 & 1) != 0) {
puVar2 = (int8 *)
std::_List_iterator<ModbusServerPort*>::operator*
((_List_iterator<ModbusServerPort*> *)&local_50);
this_00 = (ModbusServerPort *)*puVar2;
(**(code **)(*(long *)this_00 + 0x48))();
uVar1 = ModbusServerPort::isStateClosed(this_00);
if ((uVar1 & 1) == 0) {
return 0x80000000;
}
std::_List_iterator<ModbusServerPort*>::operator++
((_List_iterator<ModbusServerPort*> *)&local_50);
}
local_c = 0;
}
else {
local_c = 0x80000000;
}
return local_c;
}
| |
30,032 | ModbusTcpServer::close() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpServer_unix.cpp | StatusCode ModbusTcpServer::close()
{
ModbusTcpServerPrivateUnix *d = d_unix(d_ptr);
if (isOpen())
d->socket->close();
d->cmdClose = true;
for (ModbusServerPort *c : d->connections)
c->close();
switch (d->state)
{
case STATE_WAIT_FOR_CLOSE:
for (ModbusServerPort *c : d->connections)
{
c->process();
if (!c->isStateClosed())
return Status_Processing;
}
break;
default:
return Status_Processing;
}
return Status_Good;
} | O1 | cpp | ModbusTcpServer::close():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %r14
callq *0x30(%rax)
testb %al, %al
je 0x17c04
movq 0xd8(%r14), %rbx
movl (%rbx), %edi
callq 0x55a0
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x6c(%r14)
leaq 0xc0(%r14), %r15
movq 0xc0(%r14), %rbx
cmpq %r15, %rbx
je 0x17c2b
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rbx
jmp 0x17c17
movl $0x80000000, %ebx # imm = 0x80000000
cmpl $0x9, 0x68(%r14)
jne 0x17c61
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x17c5f
movq 0x10(%r12), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq %r14, %rdi
callq 0xefb6
testb %al, %al
jne 0x17c3a
jmp 0x17c61
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN15ModbusTcpServer5closeEv:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rdi]
mov r14, [rdi+8]
call qword ptr [rax+30h]
test al, al
jz short loc_17C04
mov rbx, [r14+0D8h]
mov edi, [rbx]
call _close
mov dword ptr [rbx], 0FFFFFFFFh
loc_17C04:
mov byte ptr [r14+6Ch], 1
lea r15, [r14+0C0h]
mov rbx, [r14+0C0h]
loc_17C17:
cmp rbx, r15
jz short loc_17C2B
mov rdi, [rbx+10h]
mov rax, [rdi]
call qword ptr [rax+28h]
mov rbx, [rbx]
jmp short loc_17C17
loc_17C2B:
mov ebx, 80000000h
cmp dword ptr [r14+68h], 9
jnz short loc_17C61
mov r12, r15
loc_17C3A:
mov r12, [r12]
cmp r12, r15
jz short loc_17C5F
mov r14, [r12+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+48h]
mov rdi, r14; this
call _ZNK16ModbusServerPort13isStateClosedEv; ModbusServerPort::isStateClosed(void)
test al, al
jnz short loc_17C3A
jmp short loc_17C61
loc_17C5F:
xor ebx, ebx
loc_17C61:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ModbusTcpServer::close(ModbusTcpServer *this)
{
long long v1; // r14
_DWORD *v2; // rbx
long long **v3; // r15
long long **i; // rbx
unsigned int v5; // ebx
long long **v6; // r12
ModbusServerPort *v7; // r14
v1 = *((_QWORD *)this + 1);
if ( (*(unsigned __int8 ( **)(ModbusTcpServer *))(*(_QWORD *)this + 48LL))(this) )
{
v2 = *(_DWORD **)(v1 + 216);
close((unsigned int)*v2);
*v2 = -1;
}
*(_BYTE *)(v1 + 108) = 1;
v3 = (long long **)(v1 + 192);
for ( i = *(long long ***)(v1 + 192); i != v3; i = (long long **)*i )
(*(void ( **)(long long *))(*i[2] + 40))(i[2]);
v5 = 0x80000000;
if ( *(_DWORD *)(v1 + 104) == 9 )
{
v6 = (long long **)(v1 + 192);
while ( 1 )
{
v6 = (long long **)*v6;
if ( v6 == v3 )
break;
v7 = (ModbusServerPort *)v6[2];
(*(void ( **)(ModbusServerPort *))(*(_QWORD *)v7 + 72LL))(v7);
if ( !ModbusServerPort::isStateClosed(v7) )
return v5;
}
return 0;
}
return v5;
}
| close:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x00117c04
MOV RBX,qword ptr [R14 + 0xd8]
MOV EDI,dword ptr [RBX]
CALL 0x001055a0
MOV dword ptr [RBX],0xffffffff
LAB_00117c04:
MOV byte ptr [R14 + 0x6c],0x1
LEA R15,[R14 + 0xc0]
MOV RBX,qword ptr [R14 + 0xc0]
LAB_00117c17:
CMP RBX,R15
JZ 0x00117c2b
MOV RDI,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
MOV RBX,qword ptr [RBX]
JMP 0x00117c17
LAB_00117c2b:
MOV EBX,0x80000000
CMP dword ptr [R14 + 0x68],0x9
JNZ 0x00117c61
MOV R12,R15
LAB_00117c3a:
MOV R12,qword ptr [R12]
CMP R12,R15
JZ 0x00117c5f
MOV R14,qword ptr [R12 + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x48]
MOV RDI,R14
CALL 0x0010efb6
TEST AL,AL
JNZ 0x00117c3a
JMP 0x00117c61
LAB_00117c5f:
XOR EBX,EBX
LAB_00117c61:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ModbusTcpServer::close() */
int8 __thiscall ModbusTcpServer::close(ModbusTcpServer *this)
{
int8 *puVar1;
long lVar2;
int *piVar3;
ModbusServerPort *this_00;
char cVar4;
int8 *puVar5;
lVar2 = *(long *)(this + 8);
cVar4 = (**(code **)(*(long *)this + 0x30))();
if (cVar4 != '\0') {
piVar3 = *(int **)(lVar2 + 0xd8);
::close(*piVar3);
*piVar3 = -1;
}
*(int1 *)(lVar2 + 0x6c) = 1;
puVar1 = (int8 *)(lVar2 + 0xc0);
for (puVar5 = *(int8 **)(lVar2 + 0xc0); puVar5 != puVar1; puVar5 = (int8 *)*puVar5) {
(**(code **)(*(long *)puVar5[2] + 0x28))();
}
puVar5 = puVar1;
if (*(int *)(lVar2 + 0x68) == 9) {
do {
puVar5 = (int8 *)*puVar5;
if (puVar5 == puVar1) {
return 0;
}
this_00 = (ModbusServerPort *)puVar5[2];
(**(code **)(*(long *)this_00 + 0x48))(this_00);
cVar4 = ModbusServerPort::isStateClosed(this_00);
} while (cVar4 != '\0');
}
return 0x80000000;
}
| |
30,033 | ModbusTcpServer::close() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpServer_unix.cpp | StatusCode ModbusTcpServer::close()
{
ModbusTcpServerPrivateUnix *d = d_unix(d_ptr);
if (isOpen())
d->socket->close();
d->cmdClose = true;
for (ModbusServerPort *c : d->connections)
c->close();
switch (d->state)
{
case STATE_WAIT_FOR_CLOSE:
for (ModbusServerPort *c : d->connections)
{
c->process();
if (!c->isStateClosed())
return Status_Processing;
}
break;
default:
return Status_Processing;
}
return Status_Good;
} | O2 | cpp | ModbusTcpServer::close():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %r14
callq *0x30(%rax)
testb %al, %al
je 0x11500
movq 0xd8(%r14), %rdi
callq 0xf916
movb $0x1, 0x6c(%r14)
leaq 0xc0(%r14), %r15
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x11523
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x1150f
movl $0x80000000, %ebx # imm = 0x80000000
cmpl $0x9, 0x68(%r14)
jne 0x11559
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x11557
movq 0x10(%r12), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq %r14, %rdi
callq 0xd50e
testb %al, %al
jne 0x11532
jmp 0x11559
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN15ModbusTcpServer5closeEv:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rdi]
mov r14, [rdi+8]
call qword ptr [rax+30h]
test al, al
jz short loc_11500
mov rdi, [r14+0D8h]; this
call _ZN15ModbusTcpSocket5closeEv; ModbusTcpSocket::close(void)
loc_11500:
mov byte ptr [r14+6Ch], 1
lea r15, [r14+0C0h]
mov rbx, r15
loc_1150F:
mov rbx, [rbx]
cmp rbx, r15
jz short loc_11523
mov rdi, [rbx+10h]
mov rax, [rdi]
call qword ptr [rax+28h]
jmp short loc_1150F
loc_11523:
mov ebx, 80000000h
cmp dword ptr [r14+68h], 9
jnz short loc_11559
mov r12, r15
loc_11532:
mov r12, [r12]
cmp r12, r15
jz short loc_11557
mov r14, [r12+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+48h]
mov rdi, r14; this
call _ZNK16ModbusServerPort13isStateClosedEv; ModbusServerPort::isStateClosed(void)
test al, al
jnz short loc_11532
jmp short loc_11559
loc_11557:
xor ebx, ebx
loc_11559:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ModbusTcpServer::close(ModbusTcpServer *this)
{
long long v1; // r14
long long **v2; // r15
long long **i; // rbx
unsigned int v4; // ebx
long long **v5; // r12
ModbusServerPort *v6; // r14
v1 = *((_QWORD *)this + 1);
if ( (*(unsigned __int8 ( **)(ModbusTcpServer *))(*(_QWORD *)this + 48LL))(this) )
ModbusTcpSocket::close(*(ModbusTcpSocket **)(v1 + 216));
*(_BYTE *)(v1 + 108) = 1;
v2 = (long long **)(v1 + 192);
for ( i = (long long **)(v1 + 192); ; (*(void ( **)(long long *))(*i[2] + 40))(i[2]) )
{
i = (long long **)*i;
if ( i == v2 )
break;
}
v4 = 0x80000000;
if ( *(_DWORD *)(v1 + 104) == 9 )
{
v5 = (long long **)(v1 + 192);
while ( 1 )
{
v5 = (long long **)*v5;
if ( v5 == v2 )
break;
v6 = (ModbusServerPort *)v5[2];
(*(void ( **)(ModbusServerPort *))(*(_QWORD *)v6 + 72LL))(v6);
if ( !ModbusServerPort::isStateClosed(v6) )
return v4;
}
return 0;
}
return v4;
}
| close:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x00111500
MOV RDI,qword ptr [R14 + 0xd8]
CALL 0x0010f916
LAB_00111500:
MOV byte ptr [R14 + 0x6c],0x1
LEA R15,[R14 + 0xc0]
MOV RBX,R15
LAB_0011150f:
MOV RBX,qword ptr [RBX]
CMP RBX,R15
JZ 0x00111523
MOV RDI,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
JMP 0x0011150f
LAB_00111523:
MOV EBX,0x80000000
CMP dword ptr [R14 + 0x68],0x9
JNZ 0x00111559
MOV R12,R15
LAB_00111532:
MOV R12,qword ptr [R12]
CMP R12,R15
JZ 0x00111557
MOV R14,qword ptr [R12 + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x48]
MOV RDI,R14
CALL 0x0010d50e
TEST AL,AL
JNZ 0x00111532
JMP 0x00111559
LAB_00111557:
XOR EBX,EBX
LAB_00111559:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ModbusTcpServer::close() */
int8 __thiscall ModbusTcpServer::close(ModbusTcpServer *this)
{
long *plVar1;
long lVar2;
ModbusServerPort *this_00;
char cVar3;
long *plVar4;
lVar2 = *(long *)(this + 8);
cVar3 = (**(code **)(*(long *)this + 0x30))();
if (cVar3 != '\0') {
ModbusTcpSocket::close(*(ModbusTcpSocket **)(lVar2 + 0xd8));
}
*(int1 *)(lVar2 + 0x6c) = 1;
plVar1 = (long *)(lVar2 + 0xc0);
plVar4 = plVar1;
while (plVar4 = (long *)*plVar4, plVar4 != plVar1) {
(**(code **)(*(long *)plVar4[2] + 0x28))();
}
plVar4 = plVar1;
if (*(int *)(lVar2 + 0x68) == 9) {
do {
plVar4 = (long *)*plVar4;
if (plVar4 == plVar1) {
return 0;
}
this_00 = (ModbusServerPort *)plVar4[2];
(**(code **)(*(long *)this_00 + 0x48))(this_00);
cVar3 = ModbusServerPort::isStateClosed(this_00);
} while (cVar3 != '\0');
}
return 0x80000000;
}
| |
30,034 | ModbusTcpServer::close() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpServer_unix.cpp | StatusCode ModbusTcpServer::close()
{
ModbusTcpServerPrivateUnix *d = d_unix(d_ptr);
if (isOpen())
d->socket->close();
d->cmdClose = true;
for (ModbusServerPort *c : d->connections)
c->close();
switch (d->state)
{
case STATE_WAIT_FOR_CLOSE:
for (ModbusServerPort *c : d->connections)
{
c->process();
if (!c->isStateClosed())
return Status_Processing;
}
break;
default:
return Status_Processing;
}
return Status_Good;
} | O3 | cpp | ModbusTcpServer::close():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %r14
callq *0x30(%rax)
testb %al, %al
je 0x179ec
movq 0xd8(%r14), %rbx
movl (%rbx), %edi
callq 0x55a0
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x6c(%r14)
leaq 0xc0(%r14), %r15
movq 0xc0(%r14), %rbx
cmpq %r15, %rbx
je 0x17a13
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rbx
jmp 0x179ff
movl $0x80000000, %ebx # imm = 0x80000000
cmpl $0x9, 0x68(%r14)
jne 0x17a49
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x17a47
movq 0x10(%r12), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq %r14, %rdi
callq 0xf016
testb %al, %al
jne 0x17a22
jmp 0x17a49
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN15ModbusTcpServer5closeEv:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rdi]
mov r14, [rdi+8]
call qword ptr [rax+30h]
test al, al
jz short loc_179EC
mov rbx, [r14+0D8h]
mov edi, [rbx]
call _close
mov dword ptr [rbx], 0FFFFFFFFh
loc_179EC:
mov byte ptr [r14+6Ch], 1
lea r15, [r14+0C0h]
mov rbx, [r14+0C0h]
loc_179FF:
cmp rbx, r15
jz short loc_17A13
mov rdi, [rbx+10h]
mov rax, [rdi]
call qword ptr [rax+28h]
mov rbx, [rbx]
jmp short loc_179FF
loc_17A13:
mov ebx, 80000000h
cmp dword ptr [r14+68h], 9
jnz short loc_17A49
mov r12, r15
loc_17A22:
mov r12, [r12]
cmp r12, r15
jz short loc_17A47
mov r14, [r12+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+48h]
mov rdi, r14; this
call _ZNK16ModbusServerPort13isStateClosedEv; ModbusServerPort::isStateClosed(void)
test al, al
jnz short loc_17A22
jmp short loc_17A49
loc_17A47:
xor ebx, ebx
loc_17A49:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ModbusTcpServer::close(ModbusTcpServer *this)
{
long long v1; // r14
_DWORD *v2; // rbx
long long **v3; // r15
long long **i; // rbx
unsigned int v5; // ebx
long long **v6; // r12
ModbusServerPort *v7; // r14
v1 = *((_QWORD *)this + 1);
if ( (*(unsigned __int8 ( **)(ModbusTcpServer *))(*(_QWORD *)this + 48LL))(this) )
{
v2 = *(_DWORD **)(v1 + 216);
close((unsigned int)*v2);
*v2 = -1;
}
*(_BYTE *)(v1 + 108) = 1;
v3 = (long long **)(v1 + 192);
for ( i = *(long long ***)(v1 + 192); i != v3; i = (long long **)*i )
(*(void ( **)(long long *))(*i[2] + 40))(i[2]);
v5 = 0x80000000;
if ( *(_DWORD *)(v1 + 104) == 9 )
{
v6 = (long long **)(v1 + 192);
while ( 1 )
{
v6 = (long long **)*v6;
if ( v6 == v3 )
break;
v7 = (ModbusServerPort *)v6[2];
(*(void ( **)(ModbusServerPort *))(*(_QWORD *)v7 + 72LL))(v7);
if ( !ModbusServerPort::isStateClosed(v7) )
return v5;
}
return 0;
}
return v5;
}
| close:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
CALL qword ptr [RAX + 0x30]
TEST AL,AL
JZ 0x001179ec
MOV RBX,qword ptr [R14 + 0xd8]
MOV EDI,dword ptr [RBX]
CALL 0x001055a0
MOV dword ptr [RBX],0xffffffff
LAB_001179ec:
MOV byte ptr [R14 + 0x6c],0x1
LEA R15,[R14 + 0xc0]
MOV RBX,qword ptr [R14 + 0xc0]
LAB_001179ff:
CMP RBX,R15
JZ 0x00117a13
MOV RDI,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
MOV RBX,qword ptr [RBX]
JMP 0x001179ff
LAB_00117a13:
MOV EBX,0x80000000
CMP dword ptr [R14 + 0x68],0x9
JNZ 0x00117a49
MOV R12,R15
LAB_00117a22:
MOV R12,qword ptr [R12]
CMP R12,R15
JZ 0x00117a47
MOV R14,qword ptr [R12 + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x48]
MOV RDI,R14
CALL 0x0010f016
TEST AL,AL
JNZ 0x00117a22
JMP 0x00117a49
LAB_00117a47:
XOR EBX,EBX
LAB_00117a49:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ModbusTcpServer::close() */
int8 __thiscall ModbusTcpServer::close(ModbusTcpServer *this)
{
int8 *puVar1;
long lVar2;
int *piVar3;
ModbusServerPort *this_00;
char cVar4;
int8 *puVar5;
lVar2 = *(long *)(this + 8);
cVar4 = (**(code **)(*(long *)this + 0x30))();
if (cVar4 != '\0') {
piVar3 = *(int **)(lVar2 + 0xd8);
::close(*piVar3);
*piVar3 = -1;
}
*(int1 *)(lVar2 + 0x6c) = 1;
puVar1 = (int8 *)(lVar2 + 0xc0);
for (puVar5 = *(int8 **)(lVar2 + 0xc0); puVar5 != puVar1; puVar5 = (int8 *)*puVar5) {
(**(code **)(*(long *)puVar5[2] + 0x28))();
}
puVar5 = puVar1;
if (*(int *)(lVar2 + 0x68) == 9) {
do {
puVar5 = (int8 *)*puVar5;
if (puVar5 == puVar1) {
return 0;
}
this_00 = (ModbusServerPort *)puVar5[2];
(**(code **)(*(long *)this_00 + 0x48))(this_00);
cVar4 = ModbusServerPort::isStateClosed(this_00);
} while (cVar4 != '\0');
}
return 0x80000000;
}
| |
30,035 | yoyo::Message::Message(yoyo::Message&&) | isyoCode[P]yoyologger/test/./../src/logger.hpp | Message(Message&&) = default; | O3 | cpp | yoyo::Message::Message(yoyo::Message&&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rsi), %rdx
leaq 0x18(%rsi), %rax
cmpq %rax, %rdx
je 0x5298
movq %rdx, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
jmp 0x529e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
movb $0x0, 0x18(%r14)
leaq 0x28(%rbx), %rdi
leaq 0x28(%r14), %rsi
callq 0x52d4
movq 0x78(%r14), %rax
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN4yoyo7MessageC2EOS0_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov eax, [rsi]
mov [rdi], eax
lea rcx, [rdi+18h]
mov [rdi+8], rcx
mov rdx, [rsi+8]
lea rax, [rsi+18h]
cmp rdx, rax
jz short loc_5298
mov [rbx+8], rdx
mov rcx, [rax]
mov [rbx+18h], rcx
jmp short loc_529E
loc_5298:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_529E:
mov rcx, [r14+10h]
mov [rbx+10h], rcx
mov [r14+8], rax
mov qword ptr [r14+10h], 0
mov byte ptr [r14+18h], 0
lea rdi, [rbx+28h]
lea rsi, [r14+28h]
call _ZN4yoyo12LocationInfoC2EOS0_; yoyo::LocationInfo::LocationInfo(yoyo::LocationInfo&&)
mov rax, [r14+78h]
mov [rbx+78h], rax
add rsp, 8
pop rbx
pop r14
retn
| long long yoyo::Message::Message(long long a1, long long a2)
{
long long v2; // rdx
_OWORD *v3; // rax
long long result; // rax
*(_DWORD *)a1 = *(_DWORD *)a2;
*(_QWORD *)(a1 + 8) = a1 + 24;
v2 = *(_QWORD *)(a2 + 8);
v3 = (_OWORD *)(a2 + 24);
if ( v2 == a2 + 24 )
{
*(_OWORD *)(a1 + 24) = *v3;
}
else
{
*(_QWORD *)(a1 + 8) = v2;
*(_QWORD *)(a1 + 24) = *(_QWORD *)v3;
}
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16);
*(_QWORD *)(a2 + 8) = v3;
*(_QWORD *)(a2 + 16) = 0LL;
*(_BYTE *)(a2 + 24) = 0;
yoyo::LocationInfo::LocationInfo(a1 + 40, a2 + 40);
result = *(_QWORD *)(a2 + 120);
*(_QWORD *)(a1 + 120) = result;
return result;
}
| Message:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RSI]
MOV dword ptr [RDI],EAX
LEA RCX,[RDI + 0x18]
MOV qword ptr [RDI + 0x8],RCX
MOV RDX,qword ptr [RSI + 0x8]
LEA RAX,[RSI + 0x18]
CMP RDX,RAX
JZ 0x00105298
MOV qword ptr [RBX + 0x8],RDX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX + 0x18],RCX
JMP 0x0010529e
LAB_00105298:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0010529e:
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14 + 0x10],0x0
MOV byte ptr [R14 + 0x18],0x0
LEA RDI,[RBX + 0x28]
LEA RSI,[R14 + 0x28]
CALL 0x001052d4
MOV RAX,qword ptr [R14 + 0x78]
MOV qword ptr [RBX + 0x78],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* yoyo::Message::Message(yoyo::Message&&) */
void __thiscall yoyo::Message::Message(Message *this,Message *param_1)
{
Message *pMVar1;
int8 uVar2;
*(int4 *)this = *(int4 *)param_1;
*(Message **)(this + 8) = this + 0x18;
pMVar1 = param_1 + 0x18;
if (*(Message **)(param_1 + 8) == pMVar1) {
uVar2 = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x18) = *(int8 *)pMVar1;
*(int8 *)(this + 0x20) = uVar2;
}
else {
*(Message **)(this + 8) = *(Message **)(param_1 + 8);
*(int8 *)(this + 0x18) = *(int8 *)pMVar1;
}
*(int8 *)(this + 0x10) = *(int8 *)(param_1 + 0x10);
*(Message **)(param_1 + 8) = pMVar1;
*(int8 *)(param_1 + 0x10) = 0;
param_1[0x18] = (Message)0x0;
LocationInfo::LocationInfo((LocationInfo *)(this + 0x28),(LocationInfo *)(param_1 + 0x28));
*(int8 *)(this + 0x78) = *(int8 *)(param_1 + 0x78);
return;
}
| |
30,036 | js_arguments_define_own_property | bluesky950520[P]quickjs/quickjs.c | static int js_arguments_define_own_property(JSContext *ctx,
JSValue this_obj,
JSAtom prop, JSValue val,
JSValue getter, JSValue setter, int flags)
{
JSObject *p;
uint32_t idx;
p = JS_VALUE_GET_OBJ(this_obj);
/* convert to normal array when redefining an existing numeric field */
if (p->fast_array && JS_AtomIsArrayIndex(ctx, &idx, prop) &&
idx < p->u.array.count) {
if (convert_fast_array_to_array(ctx, p))
return -1;
}
/* run the default define own property */
return JS_DefineProperty(ctx, this_obj, prop, val, getter, setter,
flags | JS_PROP_NO_EXOTIC);
} | O1 | c | js_arguments_define_own_property:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testb $0x8, 0x5(%rsi)
je 0x3eeb1
leaq 0x34(%rsp), %rsi
movq %r13, %rdi
movl %ebp, %edx
callq 0x3d7ed
testl %eax, %eax
je 0x3eeb1
movl 0x34(%rsp), %eax
cmpl 0x40(%r12), %eax
jae 0x3eeb1
movq %r13, %rdi
movq %r12, %rsi
callq 0x267b0
testl %eax, %eax
je 0x3eeb1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x3eef3
movl 0x90(%rsp), %eax
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %rdx
orl $0x20000, %eax # imm = 0x20000
movups (%rcx), %xmm0
movups %xmm0, 0x10(%rsp)
movups (%rdx), %xmm0
movups %xmm0, (%rsp)
movl %eax, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x254b9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_arguments_define_own_property:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r9
mov r14, r8
mov ebp, ecx
mov r15, rdx
mov r12, rsi
mov r13, rdi
test byte ptr [rsi+5], 8
jz short loc_3EEB1
lea rsi, [rsp+68h+var_34]
mov rdi, r13
mov edx, ebp
call JS_AtomIsArrayIndex
test eax, eax
jz short loc_3EEB1
mov eax, [rsp+68h+var_34]
cmp eax, [r12+40h]
jnb short loc_3EEB1
mov rdi, r13
mov rsi, r12
call convert_fast_array_to_array
test eax, eax
jz short loc_3EEB1
mov eax, 0FFFFFFFFh
jmp short loc_3EEF3
loc_3EEB1:
mov eax, [rsp+68h+arg_20]
lea rcx, [rsp+68h+arg_10]
lea rdx, [rsp+68h+arg_0]
or eax, 20000h
movups xmm0, xmmword ptr [rcx]
movups [rsp+68h+var_58], xmm0
movups xmm0, xmmword ptr [rdx]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_48], eax
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov ecx, ebp
mov r8, r14
mov r9, rbx
call JS_DefineProperty
loc_3EEF3:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_arguments_define_own_property(
long long a1,
unsigned long long a2,
long long a3,
unsigned int a4,
long long a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
__m128 a15,
_DWORD *a16,
long long a17,
int a18)
{
_DWORD v23[13]; // [rsp+34h] [rbp-34h] BYREF
if ( (*(_BYTE *)(a2 + 5) & 8) != 0
&& (unsigned int)JS_AtomIsArrayIndex(a1, v23, a4)
&& v23[0] < *(_DWORD *)(a2 + 64)
&& (unsigned int)convert_fast_array_to_array(a1, a2) )
{
return 0xFFFFFFFFLL;
}
else
{
return JS_DefineProperty(
a1,
a2,
a3,
a4,
a5,
a6,
a15,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15.m128_u64[0],
a15.m128_i64[1],
a16,
a17,
a18 | 0x20000u);
}
}
| |||
30,037 | js_arguments_define_own_property | bluesky950520[P]quickjs/quickjs.c | static int js_arguments_define_own_property(JSContext *ctx,
JSValue this_obj,
JSAtom prop, JSValue val,
JSValue getter, JSValue setter, int flags)
{
JSObject *p;
uint32_t idx;
p = JS_VALUE_GET_OBJ(this_obj);
/* convert to normal array when redefining an existing numeric field */
if (p->fast_array && JS_AtomIsArrayIndex(ctx, &idx, prop) &&
idx < p->u.array.count) {
if (convert_fast_array_to_array(ctx, p))
return -1;
}
/* run the default define own property */
return JS_DefineProperty(ctx, this_obj, prop, val, getter, setter,
flags | JS_PROP_NO_EXOTIC);
} | O2 | c | js_arguments_define_own_property:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testb $0x8, 0x5(%rsi)
je 0x37321
leaq 0x34(%rsp), %rsi
movq %r13, %rdi
movl %ebp, %edx
callq 0x36088
testl %eax, %eax
je 0x37321
movl 0x34(%rsp), %eax
cmpl 0x40(%r12), %eax
jae 0x37321
movq %r13, %rdi
movq %r12, %rsi
callq 0x20237
testl %eax, %eax
je 0x37321
pushq $-0x1
popq %rax
jmp 0x37363
movl 0x90(%rsp), %eax
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %rdx
orl $0x20000, %eax # imm = 0x20000
movups (%rcx), %xmm0
movups %xmm0, 0x10(%rsp)
movups (%rdx), %xmm0
movups %xmm0, (%rsp)
movl %eax, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x1f1de
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_arguments_define_own_property:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r9
mov r14, r8
mov ebp, ecx
mov r15, rdx
mov r12, rsi
mov r13, rdi
test byte ptr [rsi+5], 8
jz short loc_37321
lea rsi, [rsp+68h+var_34]
mov rdi, r13
mov edx, ebp
call JS_AtomIsArrayIndex
test eax, eax
jz short loc_37321
mov eax, [rsp+68h+var_34]
cmp eax, [r12+40h]
jnb short loc_37321
mov rdi, r13
mov rsi, r12
call convert_fast_array_to_array
test eax, eax
jz short loc_37321
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_37363
loc_37321:
mov eax, [rsp+68h+arg_20]
lea rcx, [rsp+68h+arg_10]
lea rdx, [rsp+68h+arg_0]
or eax, 20000h
movups xmm0, xmmword ptr [rcx]
movups [rsp+68h+var_58], xmm0
movups xmm0, xmmword ptr [rdx]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_48], eax
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov ecx, ebp
mov r8, r14
mov r9, rbx
call JS_DefineProperty
loc_37363:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_arguments_define_own_property(
long long a1,
long long a2,
long long a3,
unsigned int a4,
_DWORD *a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
__m128 a15,
_DWORD *a16,
unsigned int a17,
int a18)
{
unsigned int v23[13]; // [rsp+34h] [rbp-34h] BYREF
if ( (*(_BYTE *)(a2 + 5) & 8) != 0
&& (unsigned int)JS_AtomIsArrayIndex(a1, (int *)v23, a4)
&& v23[0] < *(_DWORD *)(a2 + 64)
&& (unsigned int)convert_fast_array_to_array(a1, a2) )
{
return -1LL;
}
else
{
return JS_DefineProperty(
a1,
a2,
a3,
a4,
a5,
a6,
a15,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a15.m128_u64[0],
a15.m128_u32[2],
a16,
a17,
a18 | 0x20000u);
}
}
| js_arguments_define_own_property:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,R9
MOV R14,R8
MOV EBP,ECX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
TEST byte ptr [RSI + 0x5],0x8
JZ 0x00137321
LEA RSI,[RSP + 0x34]
MOV RDI,R13
MOV EDX,EBP
CALL 0x00136088
TEST EAX,EAX
JZ 0x00137321
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,dword ptr [R12 + 0x40]
JNC 0x00137321
MOV RDI,R13
MOV RSI,R12
CALL 0x00120237
TEST EAX,EAX
JZ 0x00137321
PUSH -0x1
POP RAX
JMP 0x00137363
LAB_00137321:
MOV EAX,dword ptr [RSP + 0x90]
LEA RCX,[RSP + 0x80]
LEA RDX,[RSP + 0x70]
OR EAX,0x20000
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x20],EAX
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV ECX,EBP
MOV R8,R14
MOV R9,RBX
CALL 0x0011f1de
LAB_00137363:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
js_arguments_define_own_property
(int8 param_1,long param_2,int8 param_3,int4 param_4,int8 param_5,
int8 param_6,int4 param_7,int4 param_8,int8 param_9,
int8 param_10,uint param_11)
{
int iVar1;
int8 uVar2;
uint local_34;
if (((((*(byte *)(param_2 + 5) & 8) != 0) &&
(iVar1 = JS_AtomIsArrayIndex(param_1,&local_34,param_4), iVar1 != 0)) &&
(local_34 < *(uint *)(param_2 + 0x40))) &&
(iVar1 = convert_fast_array_to_array(param_1,param_2), iVar1 != 0)) {
return 0xffffffffffffffff;
}
uVar2 = JS_DefineProperty(param_1,param_2,param_3,param_4,param_5,param_6,param_7,param_8,param_9,
param_10,param_11 | 0x20000);
return uVar2;
}
| |
30,038 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O3 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x6f339(%rip), %rax # 0xea2b0
addq $0x10, %rax
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x30(%rdi)
movups 0x10(%rsi), %xmm0
movq %r13, 0x18(%rsi)
movups %xmm0, 0x28(%rdi)
movq %r13, 0x10(%rsi)
movq %r13, 0x40(%rdi)
movups 0x20(%rsi), %xmm0
movq %r13, 0x28(%rsi)
movups %xmm0, 0x38(%rdi)
movq %r13, 0x20(%rsi)
movq %r13, 0x50(%rdi)
movups 0x30(%rsi), %xmm0
movq %r13, 0x38(%rsi)
movups %xmm0, 0x48(%rdi)
movq %r13, 0x30(%rsi)
leaq 0x58(%rdi), %r12
leaq 0x40(%rsi), %rdi
movups 0x40(%rsi), %xmm0
movups %xmm0, 0x58(%rbx)
xorl %esi, %esi
callq 0x31156
movb $0x0, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %r12, %rdi
movl $0x1, %esi
callq 0x31156
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x7b017
movq 0x6ff8f(%rip), %rcx # 0xeaf98
cmpb $0x0, (%rcx)
je 0x7b013
incl 0x8(%rax)
jmp 0x7b017
lock
incl 0x8(%rax)
cmpq $0x0, 0x38(%rbx)
je 0x7b02d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r14
movl $0x10, %edi
callq 0x19370
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x65b66
leaq 0x40316(%rip), %rsi # 0xbb36f
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3f43f
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x19ae0
xorl %ebp, %ebp
movq 0x6ff6f(%rip), %rsi # 0xeaff0
movq 0x6fee8(%rip), %rdx # 0xeaf70
movq %r15, %rdi
callq 0x19ba0
movq %rax, %r12
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b0ae
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b0c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196d0
testb %bpl, %bpl
jne 0x7b0f3
jmp 0x7b0fb
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b0f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196d0
jmp 0x7b0f3
movq %rax, %r12
movq %r15, %rdi
callq 0x19510
movq 0x70(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x7b10d
callq 0x309ec
movq %r14, %rdi
callq 0x65844
movq %rbx, %rdi
callq 0x7b126
movq %r12, %rdi
callq 0x19c00
nop
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
movups xmmword ptr [rdi+18h], xmm0
xor r13d, r13d
mov [rdi+30h], r13
movups xmm0, xmmword ptr [rsi+10h]
mov [rsi+18h], r13
movups xmmword ptr [rdi+28h], xmm0
mov [rsi+10h], r13
mov [rdi+40h], r13
movups xmm0, xmmword ptr [rsi+20h]
mov [rsi+28h], r13
movups xmmword ptr [rdi+38h], xmm0
mov [rsi+20h], r13
mov [rdi+50h], r13
movups xmm0, xmmword ptr [rsi+30h]
mov [rsi+38h], r13
movups xmmword ptr [rdi+48h], xmm0
mov [rsi+30h], r13
lea r12, [rdi+58h]
lea rdi, [rsi+40h]
movups xmm0, xmmword ptr [rsi+40h]
movups xmmword ptr [rbx+58h], xmm0
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 byte ptr [r15+40h], 0
mov [r15+48h], r13
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [r14]
mov [rbx+68h], rax
mov rax, [r14+8]
mov [rbx+70h], rax
test rax, rax
jz short loc_7B017
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_7B013
inc dword ptr [rax+8]
jmp short loc_7B017
loc_7B013:
lock inc dword ptr [rax+8]
loc_7B017:
cmp qword ptr [rbx+38h], 0
jz short loc_7B02D
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B02D:
lea r14, [rbx+18h]
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r12, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7B0AE
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B0AE:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7B0C9
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B0C9:
test bpl, bpl
jnz short loc_7B0F3
jmp short loc_7B0FB
mov r12, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7B0F3
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7B0F3
mov r12, rax
loc_7B0F3:
mov rdi, r15; void *
call ___cxa_free_exception
loc_7B0FB:
mov rdi, [rbx+70h]
add rbx, 8
test rdi, rdi
jz short loc_7B10D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7B10D:
mov rdi, r14; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
mov rdi, r12
call __Unwind_Resume
| long long minja::Context::Context(long long a1, long long a2, _QWORD *a3)
{
__int128 v4; // xmm0
__int128 v5; // xmm0
__int128 v6; // xmm0
long long result; // rax
void *exception; // r15
_BYTE v9[16]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v10[16]; // [rsp+28h] [rbp-50h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'minja::Context + 2;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
v4 = *(_OWORD *)(a2 + 16);
*(_QWORD *)(a2 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = v4;
*(_QWORD *)(a2 + 16) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
v5 = *(_OWORD *)(a2 + 32);
*(_QWORD *)(a2 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = v5;
*(_QWORD *)(a2 + 32) = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v6 = *(_OWORD *)(a2 + 48);
*(_QWORD *)(a2 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = v6;
*(_QWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a2 + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a2 + 64));
*(_BYTE *)(a2 + 64) = 0;
*(_QWORD *)(a2 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 88));
*(_QWORD *)(a1 + 104) = *a3;
result = a3[1];
*(_QWORD *)(a1 + 112) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
if ( !*(_QWORD *)(a1 + 56) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, a1 + 24, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Context values must be an object: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| Context:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x1ea2b0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS xmmword ptr [RDI + 0x18],XMM0
XOR R13D,R13D
MOV qword ptr [RDI + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x10]
MOV qword ptr [RSI + 0x18],R13
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RSI + 0x10],R13
MOV qword ptr [RDI + 0x40],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x20]
MOV qword ptr [RSI + 0x28],R13
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV qword ptr [RSI + 0x20],R13
MOV qword ptr [RDI + 0x50],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x30]
MOV qword ptr [RSI + 0x38],R13
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RSI + 0x30],R13
LEA R12,[RDI + 0x58]
LEA RDI,[RSI + 0x40]
MOVUPS XMM0,xmmword ptr [RSI + 0x40]
MOVUPS xmmword ptr [RBX + 0x58],XMM0
XOR ESI,ESI
CALL 0x00131156
MOV byte ptr [R15 + 0x40],0x0
MOV qword ptr [R15 + 0x48],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x00131156
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x0017b017
MOV RCX,qword ptr [0x001eaf98]
CMP byte ptr [RCX],0x0
JZ 0x0017b013
INC dword ptr [RAX + 0x8]
JMP 0x0017b017
LAB_0017b013:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0017b017:
CMP qword ptr [RBX + 0x38],0x0
JZ 0x0017b02d
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b02d:
LEA R14,[RBX + 0x18]
MOV EDI,0x10
CALL 0x00119370
MOV R15,RAX
LAB_0017b03e:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00165b66
LAB_0017b052:
LEA RSI,[0x1bb36f]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0013f43f
MOV BPL,0x1
LAB_0017b06b:
LEA RSI,[RSP + 0x28]
MOV RDI,R15
CALL 0x00119ae0
XOR EBP,EBP
MOV RSI,qword ptr [0x001eaff0]
MOV RDX,qword ptr [0x001eaf70]
MOV RDI,R15
CALL 0x00119ba0
|
/* minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) */
void __thiscall minja::Context::Context(Context *this,Value *param_1,shared_ptr *param_2)
{
long lVar1;
int8 uVar2;
runtime_error *this_00;
int1 local_70 [32];
string local_50 [32];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__Context_001ea2c0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x18);
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(this + 0x28) = *(int8 *)(param_1 + 0x10);
*(int8 *)(this + 0x30) = uVar2;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(this + 0x40) = 0;
uVar2 = *(int8 *)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(this + 0x38) = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x40) = uVar2;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(this + 0x50) = 0;
uVar2 = *(int8 *)(param_1 + 0x38);
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x30);
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)(param_1 + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x40);
*(int8 *)(this + 0x60) = uVar2;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)param_1 + '@'));
param_1[0x40] = (Value)0x0;
*(int8 *)(param_1 + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + 'X'));
*(int8 *)(this + 0x68) = *(int8 *)param_2;
lVar1 = *(long *)(param_2 + 8);
*(long *)(this + 0x70) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001eaf98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
if (*(long *)(this + 0x38) != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017b03e to 0017b051 has its CatchHandler @ 0017b0f0 */
Value::dump_abi_cxx11_((int)local_70,(bool)((char)this + '\x18'));
/* try { // try from 0017b052 to 0017b067 has its CatchHandler @ 0017b0d0 */
std::operator+((char *)local_50,(string *)"Context values must be an object: ");
/* try { // try from 0017b06b to 0017b08f has its CatchHandler @ 0017b090 */
std::runtime_error::runtime_error(this_00,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001eaff0,PTR__runtime_error_001eaf70);
}
| |
30,039 | mi_writeinfo | eloqsql/storage/myisam/mi_locking.c | int _mi_writeinfo(register MI_INFO *info, uint operation)
{
int error,olderror;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_writeinfo");
DBUG_PRINT("info",("operation: %u tot_locks: %u", operation,
share->tot_locks));
error=0;
if (share->tot_locks == 0)
{
olderror=my_errno; /* Remember last error */
if (operation)
{ /* Two threads can't be here */
share->state.process= share->last_process= share->this_process;
share->state.unique= info->last_unique= info->this_unique;
share->state.update_count= info->last_loop= ++info->this_loop;
if ((error=mi_state_info_write(share->kfile, &share->state, 1)))
olderror=my_errno;
#ifdef _WIN32
if (myisam_flush)
{
if (share->file_map)
my_msync(info->dfile, share->file_map, share->mmaped_length, MS_SYNC);
mysql_file_sync(share->kfile, 0);
mysql_file_sync(info->dfile, 0);
}
#endif
}
if (!(operation & WRITEINFO_NO_UNLOCK) &&
my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
MYF(MY_WME | MY_SEEK_NOT_DONE)) && !error)
DBUG_RETURN(1);
my_errno=olderror;
}
else if (operation)
share->changed= 1; /* Mark keyfile changed */
DBUG_RETURN(error);
} | O3 | c | mi_writeinfo:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq (%rdi), %rbx
cmpl $0x0, 0x368(%rbx)
je 0x7c947
xorl %eax, %eax
testl %r15d, %r15d
je 0x7c9f9
movb $0x1, 0x37f(%rbx)
jmp 0x7c9f9
movq %rdi, %r14
callq 0xa1b22
movl (%rax), %r12d
testl %r15d, %r15d
je 0x7c9c1
movq 0x300(%rbx), %rax
movq %rax, 0x308(%rbx)
movq %rax, 0x68(%rbx)
movq 0x150(%r14), %rax
movq %rax, 0x158(%r14)
movq %rax, 0x70(%rbx)
movq 0x160(%r14), %rax
incq %rax
movq %rax, 0x160(%r14)
movq %rax, 0x168(%r14)
movq %rax, 0x78(%rbx)
movl 0x350(%rbx), %edi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x7fdf4
movl %eax, %r14d
testl %eax, %eax
je 0x7c9b9
callq 0xa1b22
movl (%rax), %r12d
testb $0x2, %r15b
je 0x7c9c4
jmp 0x7c9ee
xorl %r14d, %r14d
movl 0x350(%rbx), %edi
movl $0x30, %r8d
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9fb54
testl %r14d, %r14d
jne 0x7c9ee
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x7c9f9
callq 0xa1b22
movl %r12d, (%rax)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _mi_writeinfo:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15d, esi
mov rbx, [rdi]
cmp dword ptr [rbx+368h], 0
jz short loc_7C947
xor eax, eax
test r15d, r15d
jz loc_7C9F9
mov byte ptr [rbx+37Fh], 1
jmp loc_7C9F9
loc_7C947:
mov r14, rdi
call _my_thread_var
mov r12d, [rax]
test r15d, r15d
jz short loc_7C9C1
mov rax, [rbx+300h]
mov [rbx+308h], rax
mov [rbx+68h], rax
mov rax, [r14+150h]
mov [r14+158h], rax
mov [rbx+70h], rax
mov rax, [r14+160h]
inc rax
mov [r14+160h], rax
mov [r14+168h], rax
mov [rbx+78h], rax
mov edi, [rbx+350h]
mov rsi, rbx
mov edx, 1
call mi_state_info_write
mov r14d, eax
test eax, eax
jz short loc_7C9B9
call _my_thread_var
mov r12d, [rax]
loc_7C9B9:
test r15b, 2
jz short loc_7C9C4
jmp short loc_7C9EE
loc_7C9C1:
xor r14d, r14d
loc_7C9C4:
mov edi, [rbx+350h]
mov r8d, 30h ; '0'
mov esi, 2
xor edx, edx
xor ecx, ecx
call my_lock
test r14d, r14d
jnz short loc_7C9EE
mov ecx, eax
mov eax, 1
test ecx, ecx
jnz short loc_7C9F9
loc_7C9EE:
call _my_thread_var
mov [rax], r12d
mov eax, r14d
loc_7C9F9:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long mi_writeinfo(_QWORD *a1, const char *a2)
{
char v2; // r15
long long v3; // rbx
long long result; // rax
int v5; // r12d
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rdi
const char *v10; // rsi
unsigned int v11; // r14d
int v12; // eax
int v13; // ecx
v2 = (char)a2;
v3 = *a1;
if ( *(_DWORD *)(*a1 + 872LL) )
{
result = 0LL;
if ( (_DWORD)a2 )
*(_BYTE *)(v3 + 895) = 1;
return result;
}
v5 = *(_DWORD *)my_thread_var(a1, a2);
if ( (_DWORD)a2 )
{
v6 = *(_QWORD *)(v3 + 768);
*(_QWORD *)(v3 + 776) = v6;
*(_QWORD *)(v3 + 104) = v6;
v7 = a1[42];
a1[43] = v7;
*(_QWORD *)(v3 + 112) = v7;
v8 = a1[44] + 1LL;
a1[44] = v8;
a1[45] = v8;
*(_QWORD *)(v3 + 120) = v8;
v9 = *(unsigned int *)(v3 + 848);
v10 = (const char *)v3;
v11 = mi_state_info_write(v9, v3, 1LL);
if ( v11 )
v5 = *(_DWORD *)my_thread_var(v9, (const char *)v3);
if ( (v2 & 2) != 0 )
goto LABEL_12;
}
else
{
v11 = 0;
}
v9 = *(unsigned int *)(v3 + 848);
v10 = (_BYTE *)(&dword_0 + 2);
v12 = my_lock(v9, 2LL, 0LL, 0LL, 48LL);
if ( v11 || (v13 = v12, result = 1LL, !v13) )
{
LABEL_12:
*(_DWORD *)my_thread_var(v9, v10) = v5;
return v11;
}
return result;
}
| _mi_writeinfo:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,ESI
MOV RBX,qword ptr [RDI]
CMP dword ptr [RBX + 0x368],0x0
JZ 0x0017c947
XOR EAX,EAX
TEST R15D,R15D
JZ 0x0017c9f9
MOV byte ptr [RBX + 0x37f],0x1
JMP 0x0017c9f9
LAB_0017c947:
MOV R14,RDI
CALL 0x001a1b22
MOV R12D,dword ptr [RAX]
TEST R15D,R15D
JZ 0x0017c9c1
MOV RAX,qword ptr [RBX + 0x300]
MOV qword ptr [RBX + 0x308],RAX
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R14 + 0x150]
MOV qword ptr [R14 + 0x158],RAX
MOV qword ptr [RBX + 0x70],RAX
MOV RAX,qword ptr [R14 + 0x160]
INC RAX
MOV qword ptr [R14 + 0x160],RAX
MOV qword ptr [R14 + 0x168],RAX
MOV qword ptr [RBX + 0x78],RAX
MOV EDI,dword ptr [RBX + 0x350]
MOV RSI,RBX
MOV EDX,0x1
CALL 0x0017fdf4
MOV R14D,EAX
TEST EAX,EAX
JZ 0x0017c9b9
CALL 0x001a1b22
MOV R12D,dword ptr [RAX]
LAB_0017c9b9:
TEST R15B,0x2
JZ 0x0017c9c4
JMP 0x0017c9ee
LAB_0017c9c1:
XOR R14D,R14D
LAB_0017c9c4:
MOV EDI,dword ptr [RBX + 0x350]
MOV R8D,0x30
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0019fb54
TEST R14D,R14D
JNZ 0x0017c9ee
MOV ECX,EAX
MOV EAX,0x1
TEST ECX,ECX
JNZ 0x0017c9f9
LAB_0017c9ee:
CALL 0x001a1b22
MOV dword ptr [RAX],R12D
MOV EAX,R14D
LAB_0017c9f9:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int _mi_writeinfo(long *param_1,uint param_2)
{
long lVar1;
int iVar2;
int iVar3;
int4 *puVar4;
long lVar5;
int4 uVar6;
lVar1 = *param_1;
if (*(int *)(lVar1 + 0x368) != 0) {
if (param_2 == 0) {
return 0;
}
*(int1 *)(lVar1 + 0x37f) = 1;
return 0;
}
puVar4 = (int4 *)_my_thread_var();
uVar6 = *puVar4;
if (param_2 == 0) {
iVar2 = 0;
}
else {
*(int8 *)(lVar1 + 0x308) = *(int8 *)(lVar1 + 0x300);
*(int8 *)(lVar1 + 0x68) = *(int8 *)(lVar1 + 0x300);
param_1[0x2b] = param_1[0x2a];
*(long *)(lVar1 + 0x70) = param_1[0x2a];
lVar5 = param_1[0x2c] + 1;
param_1[0x2c] = lVar5;
param_1[0x2d] = lVar5;
*(long *)(lVar1 + 0x78) = lVar5;
iVar2 = mi_state_info_write(*(int4 *)(lVar1 + 0x350),lVar1,1);
if (iVar2 != 0) {
puVar4 = (int4 *)_my_thread_var();
uVar6 = *puVar4;
}
if ((param_2 & 2) != 0) goto LAB_0017c9ee;
}
iVar3 = my_lock(*(int4 *)(lVar1 + 0x350),2,0,0,0x30);
if ((iVar2 == 0) && (iVar3 != 0)) {
return 1;
}
LAB_0017c9ee:
puVar4 = (int4 *)_my_thread_var();
*puVar4 = uVar6;
return iVar2;
}
| |
30,040 | common_log::set_colors(bool) | monkey531[P]llama/common/log.cpp | void set_colors(bool colors) {
pause();
if (colors) {
g_col[COMMON_LOG_COL_DEFAULT] = LOG_COL_DEFAULT;
g_col[COMMON_LOG_COL_BOLD] = LOG_COL_BOLD;
g_col[COMMON_LOG_COL_RED] = LOG_COL_RED;
g_col[COMMON_LOG_COL_GREEN] = LOG_COL_GREEN;
g_col[COMMON_LOG_COL_YELLOW] = LOG_COL_YELLOW;
g_col[COMMON_LOG_COL_BLUE] = LOG_COL_BLUE;
g_col[COMMON_LOG_COL_MAGENTA] = LOG_COL_MAGENTA;
g_col[COMMON_LOG_COL_CYAN] = LOG_COL_CYAN;
g_col[COMMON_LOG_COL_WHITE] = LOG_COL_WHITE;
} else {
for (size_t i = 0; i < g_col.size(); i++) {
g_col[i] = "";
}
}
resume();
} | O1 | cpp | common_log::set_colors(bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x91d72
testl %ebp, %ebp
je 0x9222f
movq 0x64284(%rip), %rax # 0xf6448
leaq 0x32384(%rip), %rcx # 0xc454f
movq %rcx, (%rax)
movq 0x64273(%rip), %rax # 0xf6448
leaq 0x32378(%rip), %rcx # 0xc4554
movq %rcx, 0x8(%rax)
leaq 0x32372(%rip), %rcx # 0xc4559
movq %rcx, 0x10(%rax)
leaq 0x3236d(%rip), %rcx # 0xc455f
movq %rcx, 0x18(%rax)
leaq 0x32368(%rip), %rcx # 0xc4565
movq %rcx, 0x20(%rax)
leaq 0x32363(%rip), %rcx # 0xc456b
movq %rcx, 0x28(%rax)
leaq 0x3235e(%rip), %rcx # 0xc4571
movq %rcx, 0x30(%rax)
leaq 0x32359(%rip), %rcx # 0xc4577
movq %rcx, 0x38(%rax)
leaq 0x32354(%rip), %rcx # 0xc457d
movq %rcx, 0x40(%rax)
jmp 0x92269
movq 0x64212(%rip), %rax # 0xf6448
cmpq %rax, 0x64213(%rip) # 0xf6450
je 0x92269
xorl %ecx, %ecx
leaq 0x2ba39(%rip), %rdx # 0xbdc81
movq %rdx, (%rax,%rcx,8)
incq %rcx
movq 0x641fa(%rip), %rsi # 0xf6450
movq 0x641eb(%rip), %rax # 0xf6448
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rsi, %rcx
jb 0x92248
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x91dfa
nop
| _ZN10common_log10set_colorsEb:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
call _ZN10common_log5pauseEv; common_log::pause(void)
test ebp, ebp
jz short loc_9222F
mov rax, cs:_ZL5g_col; g_col
lea rcx, a0m; "\x1B[0m"
mov [rax], rcx
mov rax, cs:_ZL5g_col; g_col
lea rcx, a1m; "\x1B[1m"
mov [rax+8], rcx
lea rcx, a31m; "\x1B[31m"
mov [rax+10h], rcx
lea rcx, a32m; "\x1B[32m"
mov [rax+18h], rcx
lea rcx, a33m; "\x1B[33m"
mov [rax+20h], rcx
lea rcx, a34m; "\x1B[34m"
mov [rax+28h], rcx
lea rcx, a35m; "\x1B[35m"
mov [rax+30h], rcx
lea rcx, a36m; "\x1B[36m"
mov [rax+38h], rcx
lea rcx, a37m; "\x1B[37m"
mov [rax+40h], rcx
jmp short loc_92269
loc_9222F:
mov rax, cs:_ZL5g_col; g_col
cmp cs:qword_F6450, rax
jz short loc_92269
xor ecx, ecx
lea rdx, aEndIndexOutOfB+19h; ""
loc_92248:
mov [rax+rcx*8], rdx
inc rcx
mov rsi, cs:qword_F6450
mov rax, cs:_ZL5g_col; g_col
sub rsi, rax
sar rsi, 3
cmp rcx, rsi
jb short loc_92248
loc_92269:
mov rdi, rbx; this
add rsp, 8
pop rbx
pop rbp
jmp _ZN10common_log6resumeEv; common_log::resume(void)
| long long common_log::set_colors(common_log *this, int a2)
{
_QWORD *v2; // rax
long long v3; // rax
unsigned long long v4; // rcx
common_log::pause(this);
if ( a2 )
{
*(_QWORD *)g_col = "\x1B[0m";
v2 = (_QWORD *)g_col;
*(_QWORD *)(g_col + 8) = "\x1B[1m";
v2[2] = "\x1B[31m";
v2[3] = "\x1B[32m";
v2[4] = "\x1B[33m";
v2[5] = "\x1B[34m";
v2[6] = "\x1B[35m";
v2[7] = "\x1B[36m";
v2[8] = "\x1B[37m";
}
else
{
v3 = g_col;
if ( qword_F6450 != g_col )
{
v4 = 0LL;
do
{
*(_QWORD *)(v3 + 8 * v4++) = "";
v3 = g_col;
}
while ( v4 < (qword_F6450 - g_col) >> 3 );
}
}
return common_log::resume(this);
}
| set_colors:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x00191d72
TEST EBP,EBP
JZ 0x0019222f
MOV RAX,qword ptr [0x001f6448]
LEA RCX,[0x1c454f]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [0x001f6448]
LEA RCX,[0x1c4554]
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1c4559]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[0x1c455f]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x1c4565]
MOV qword ptr [RAX + 0x20],RCX
LEA RCX,[0x1c456b]
MOV qword ptr [RAX + 0x28],RCX
LEA RCX,[0x1c4571]
MOV qword ptr [RAX + 0x30],RCX
LEA RCX,[0x1c4577]
MOV qword ptr [RAX + 0x38],RCX
LEA RCX,[0x1c457d]
MOV qword ptr [RAX + 0x40],RCX
JMP 0x00192269
LAB_0019222f:
MOV RAX,qword ptr [0x001f6448]
CMP qword ptr [0x001f6450],RAX
JZ 0x00192269
XOR ECX,ECX
LEA RDX,[0x1bdc81]
LAB_00192248:
MOV qword ptr [RAX + RCX*0x8],RDX
INC RCX
MOV RSI,qword ptr [0x001f6450]
MOV RAX,qword ptr [0x001f6448]
SUB RSI,RAX
SAR RSI,0x3
CMP RCX,RSI
JC 0x00192248
LAB_00192269:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00191dfa
|
/* common_log::set_colors(bool) */
void __thiscall common_log::set_colors(common_log *this,bool param_1)
{
int8 *puVar1;
ulong uVar2;
int7 in_register_00000031;
pause(this);
if ((int)CONCAT71(in_register_00000031,param_1) == 0) {
if (DAT_001f6450 != g_col) {
uVar2 = 0;
do {
g_col[uVar2] = "";
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)((long)DAT_001f6450 - (long)g_col >> 3));
}
}
else {
*g_col = &DAT_001c454f;
puVar1 = g_col;
g_col[1] = &DAT_001c4554;
puVar1[2] = &DAT_001c4559;
puVar1[3] = &DAT_001c455f;
puVar1[4] = &DAT_001c4565;
puVar1[5] = &DAT_001c456b;
puVar1[6] = &DAT_001c4571;
puVar1[7] = &DAT_001c4577;
puVar1[8] = &DAT_001c457d;
}
resume(this);
return;
}
| |
30,041 | common_log::set_colors(bool) | monkey531[P]llama/common/log.cpp | void set_colors(bool colors) {
pause();
if (colors) {
g_col[COMMON_LOG_COL_DEFAULT] = LOG_COL_DEFAULT;
g_col[COMMON_LOG_COL_BOLD] = LOG_COL_BOLD;
g_col[COMMON_LOG_COL_RED] = LOG_COL_RED;
g_col[COMMON_LOG_COL_GREEN] = LOG_COL_GREEN;
g_col[COMMON_LOG_COL_YELLOW] = LOG_COL_YELLOW;
g_col[COMMON_LOG_COL_BLUE] = LOG_COL_BLUE;
g_col[COMMON_LOG_COL_MAGENTA] = LOG_COL_MAGENTA;
g_col[COMMON_LOG_COL_CYAN] = LOG_COL_CYAN;
g_col[COMMON_LOG_COL_WHITE] = LOG_COL_WHITE;
} else {
for (size_t i = 0; i < g_col.size(); i++) {
g_col[i] = "";
}
}
resume();
} | O3 | cpp | common_log::set_colors(bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x8f86c
testl %ebp, %ebp
je 0x8fd2b
movq 0x62788(%rip), %rax # 0xf2448
leaq 0x30878(%rip), %rcx # 0xc053f
movq %rcx, (%rax)
movq 0x62777(%rip), %rax # 0xf2448
leaq 0x3086c(%rip), %rcx # 0xc0544
movq %rcx, 0x8(%rax)
leaq 0x30866(%rip), %rcx # 0xc0549
movq %rcx, 0x10(%rax)
leaq 0x30861(%rip), %rcx # 0xc054f
movq %rcx, 0x18(%rax)
leaq 0x3085c(%rip), %rcx # 0xc0555
movq %rcx, 0x20(%rax)
leaq 0x30857(%rip), %rcx # 0xc055b
movq %rcx, 0x28(%rax)
leaq 0x30852(%rip), %rcx # 0xc0561
movq %rcx, 0x30(%rax)
leaq 0x3084d(%rip), %rcx # 0xc0567
movq %rcx, 0x38(%rax)
leaq 0x30848(%rip), %rcx # 0xc056d
movq %rcx, 0x40(%rax)
jmp 0x8fd65
movq 0x62716(%rip), %rax # 0xf2448
cmpq %rax, 0x62717(%rip) # 0xf2450
je 0x8fd65
xorl %ecx, %ecx
leaq 0x29f2d(%rip), %rdx # 0xb9c71
movq %rdx, (%rax,%rcx,8)
incq %rcx
movq 0x626fe(%rip), %rsi # 0xf2450
movq 0x626ef(%rip), %rax # 0xf2448
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rsi, %rcx
jb 0x8fd44
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8f8f4
nop
| _ZN10common_log10set_colorsEb:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
call _ZN10common_log5pauseEv; common_log::pause(void)
test ebp, ebp
jz short loc_8FD2B
mov rax, cs:_ZL5g_col; g_col
lea rcx, a0m; "\x1B[0m"
mov [rax], rcx
mov rax, cs:_ZL5g_col; g_col
lea rcx, a1m; "\x1B[1m"
mov [rax+8], rcx
lea rcx, a31m; "\x1B[31m"
mov [rax+10h], rcx
lea rcx, a32m; "\x1B[32m"
mov [rax+18h], rcx
lea rcx, a33m; "\x1B[33m"
mov [rax+20h], rcx
lea rcx, a34m; "\x1B[34m"
mov [rax+28h], rcx
lea rcx, a35m; "\x1B[35m"
mov [rax+30h], rcx
lea rcx, a36m; "\x1B[36m"
mov [rax+38h], rcx
lea rcx, a37m; "\x1B[37m"
mov [rax+40h], rcx
jmp short loc_8FD65
loc_8FD2B:
mov rax, cs:_ZL5g_col; g_col
cmp cs:qword_F2450, rax
jz short loc_8FD65
xor ecx, ecx
lea rdx, aEndIndexOutOfB+19h; ""
loc_8FD44:
mov [rax+rcx*8], rdx
inc rcx
mov rsi, cs:qword_F2450
mov rax, cs:_ZL5g_col; g_col
sub rsi, rax
sar rsi, 3
cmp rcx, rsi
jb short loc_8FD44
loc_8FD65:
mov rdi, rbx; this
add rsp, 8
pop rbx
pop rbp
jmp _ZN10common_log6resumeEv; common_log::resume(void)
| long long common_log::set_colors(common_log *this, int a2)
{
_QWORD *v2; // rax
long long v3; // rax
unsigned long long v4; // rcx
common_log::pause(this);
if ( a2 )
{
*(_QWORD *)g_col = "\x1B[0m";
v2 = (_QWORD *)g_col;
*(_QWORD *)(g_col + 8) = "\x1B[1m";
v2[2] = "\x1B[31m";
v2[3] = "\x1B[32m";
v2[4] = "\x1B[33m";
v2[5] = "\x1B[34m";
v2[6] = "\x1B[35m";
v2[7] = "\x1B[36m";
v2[8] = "\x1B[37m";
}
else
{
v3 = g_col;
if ( qword_F2450 != g_col )
{
v4 = 0LL;
do
{
*(_QWORD *)(v3 + 8 * v4++) = "";
v3 = g_col;
}
while ( v4 < (qword_F2450 - g_col) >> 3 );
}
}
return common_log::resume(this);
}
| set_colors:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x0018f86c
TEST EBP,EBP
JZ 0x0018fd2b
MOV RAX,qword ptr [0x001f2448]
LEA RCX,[0x1c053f]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [0x001f2448]
LEA RCX,[0x1c0544]
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1c0549]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[0x1c054f]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x1c0555]
MOV qword ptr [RAX + 0x20],RCX
LEA RCX,[0x1c055b]
MOV qword ptr [RAX + 0x28],RCX
LEA RCX,[0x1c0561]
MOV qword ptr [RAX + 0x30],RCX
LEA RCX,[0x1c0567]
MOV qword ptr [RAX + 0x38],RCX
LEA RCX,[0x1c056d]
MOV qword ptr [RAX + 0x40],RCX
JMP 0x0018fd65
LAB_0018fd2b:
MOV RAX,qword ptr [0x001f2448]
CMP qword ptr [0x001f2450],RAX
JZ 0x0018fd65
XOR ECX,ECX
LEA RDX,[0x1b9c71]
LAB_0018fd44:
MOV qword ptr [RAX + RCX*0x8],RDX
INC RCX
MOV RSI,qword ptr [0x001f2450]
MOV RAX,qword ptr [0x001f2448]
SUB RSI,RAX
SAR RSI,0x3
CMP RCX,RSI
JC 0x0018fd44
LAB_0018fd65:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0018f8f4
|
/* common_log::set_colors(bool) */
void __thiscall common_log::set_colors(common_log *this,bool param_1)
{
int8 *puVar1;
ulong uVar2;
int7 in_register_00000031;
pause(this);
if ((int)CONCAT71(in_register_00000031,param_1) == 0) {
if (DAT_001f2450 != g_col) {
uVar2 = 0;
do {
g_col[uVar2] = "";
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)((long)DAT_001f2450 - (long)g_col >> 3));
}
}
else {
*g_col = &DAT_001c053f;
puVar1 = g_col;
g_col[1] = &DAT_001c0544;
puVar1[2] = &DAT_001c0549;
puVar1[3] = &DAT_001c054f;
puVar1[4] = &DAT_001c0555;
puVar1[5] = &DAT_001c055b;
puVar1[6] = &DAT_001c0561;
puVar1[7] = &DAT_001c0567;
puVar1[8] = &DAT_001c056d;
}
resume(this);
return;
}
| |
30,042 | google::protobuf::compiler::ruby::LabelForField[abi:cxx11](google::protobuf::FieldDescriptor const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/ruby/ruby_generator.cc | std::string LabelForField(const FieldDescriptor* field) {
if (field->has_optional_keyword() &&
field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3) {
return "proto3_optional";
}
switch (field->label()) {
case FieldDescriptor::LABEL_OPTIONAL: return "optional";
case FieldDescriptor::LABEL_REQUIRED: return "required";
case FieldDescriptor::LABEL_REPEATED: return "repeated";
default: assert(false); return "";
}
} | O3 | cpp | google::protobuf::compiler::ruby::LabelForField[abi:cxx11](google::protobuf::FieldDescriptor const*):
pushq %rbx
movq %rdi, %rbx
movzbl 0x1(%rsi), %eax
testb $0x2, %al
je 0x73306
movq 0x10(%rsi), %rcx
cmpb $0x3, 0x3(%rcx)
jne 0x73306
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1279e6(%rip), %rsi # 0x19acd8
leaq 0x1279ee(%rip), %rdx # 0x19ace7
movq %rbx, %rdi
callq 0x250b2
movq %rbx, %rax
popq %rbx
retq
shrl $0x5, %eax
andl $0x3, %eax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x1363ee(%rip), %rcx # 0x1a9708
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12727f(%rip), %rdx # 0x19a5a9
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x732fc
leaq 0x13647f(%rip), %rsi # 0x1a97b8
leaq 0x136480(%rip), %rdx # 0x1a97c0
jmp 0x732f9
leaq 0x136478(%rip), %rsi # 0x1a97c1
leaq 0x136479(%rip), %rdx # 0x1a97c9
jmp 0x732f9
leaq 0x127986(%rip), %rsi # 0x19acdf
leaq 0x127987(%rip), %rdx # 0x19ace7
jmp 0x732f9
| _ZN6google8protobuf8compiler4ruby13LabelForFieldB5cxx11EPKNS0_15FieldDescriptorE:
push rbx
mov rbx, rdi
movzx eax, byte ptr [rsi+1]
test al, 2
jz short loc_73306
mov rcx, [rsi+10h]
cmp byte ptr [rcx+3], 3
jnz short loc_73306
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aExperimentalAl+15h; "proto3_optional"
lea rdx, aExperimentalAl+24h; ""
loc_732F9:
mov rdi, rbx
loc_732FC:
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 rax, rbx
pop rbx
retn
loc_73306:
shr eax, 5
and eax, 3
lea rcx, [rbx+10h]
mov [rbx], rcx
lea rcx, jpt_73321
movsxd rax, ds:(jpt_73321 - 1A9708h)[rcx+rax*4]; switch 4 cases
add rax, rcx
jmp rax; switch jump
loc_73323:
lea rdx, asc_19A5A7+2; jumptable 0000000000073321 case 0
mov rdi, rbx
mov rsi, rdx
jmp short loc_732FC
loc_73332:
lea rsi, aRequired; jumptable 0000000000073321 case 2
lea rdx, aRequired+8; ""
jmp short loc_732F9
loc_73342:
lea rsi, aRepeated_0; jumptable 0000000000073321 case 3
lea rdx, aRepeated_0+8; ""
jmp short loc_732F9
loc_73352:
lea rsi, aExperimentalAl+1Ch; jumptable 0000000000073321 case 1
lea rdx, aExperimentalAl+24h; ""
jmp short loc_732F9
| _QWORD * google::protobuf::compiler::ruby::LabelForField[abi:cxx11](_QWORD *a1, long long a2)
{
unsigned int v2; // eax
char *v3; // rsi
char *v4; // rdx
v2 = *(unsigned __int8 *)(a2 + 1);
if ( (v2 & 2) != 0 && *(_BYTE *)(*(_QWORD *)(a2 + 16) + 3LL) == 3 )
{
*a1 = a1 + 2;
v3 = "proto3_optional";
v4 = "";
}
else
{
*a1 = a1 + 2;
switch ( (v2 >> 5) & 3 )
{
case 0u:
v4 = "";
v3 = "";
break;
case 1u:
v3 = "optional";
v4 = "";
break;
case 2u:
v3 = "required";
v4 = (char *)"";
break;
case 3u:
v3 = "repeated";
v4 = (char *)"";
break;
}
}
std::string::_M_construct<char const*>((long long)a1, v3, (long long)v4);
return a1;
}
| LabelForField[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
MOVZX EAX,byte ptr [RSI + 0x1]
TEST AL,0x2
JZ 0x00173306
MOV RCX,qword ptr [RSI + 0x10]
CMP byte ptr [RCX + 0x3],0x3
JNZ 0x00173306
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x29acd8]
LEA RDX,[0x29ace7]
LAB_001732f9:
MOV RDI,RBX
LAB_001732fc:
CALL 0x001250b2
MOV RAX,RBX
POP RBX
RET
LAB_00173306:
SHR EAX,0x5
AND EAX,0x3
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
LEA RCX,[0x2a9708]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RDX,[0x29a5a9]
MOV RDI,RBX
MOV RSI,RDX
JMP 0x001732fc
caseD_2:
LEA RSI,[0x2a97b8]
LEA RDX,[0x2a97c0]
JMP 0x001732f9
caseD_3:
LEA RSI,[0x2a97c1]
LEA RDX,[0x2a97c9]
JMP 0x001732f9
caseD_1:
LEA RSI,[0x29acdf]
LEA RDX,[0x29ace7]
JMP 0x001732f9
|
/* google::protobuf::compiler::ruby::LabelForField[abi:cxx11](google::protobuf::FieldDescriptor
const*) */
ruby * __thiscall
google::protobuf::compiler::ruby::LabelForField_abi_cxx11_(ruby *this,FieldDescriptor *param_1)
{
FieldDescriptor FVar1;
char *pcVar2;
char *pcVar3;
FVar1 = param_1[1];
if ((((byte)FVar1 & 2) == 0) || (*(char *)(*(long *)(param_1 + 0x10) + 3) != '\x03')) {
*(ruby **)this = this + 0x10;
switch((byte)FVar1 >> 5 & 3) {
case 0:
pcVar2 = "";
pcVar3 = pcVar2;
break;
case 1:
pcVar3 = "optional";
pcVar2 = "";
break;
case 2:
pcVar3 = "required";
pcVar2 = "";
break;
case 3:
pcVar3 = "repeated";
pcVar2 = "";
}
}
else {
*(ruby **)this = this + 0x10;
pcVar3 = "proto3_optional";
pcVar2 = "";
}
std::__cxx11::string::_M_construct<char_const*>(this,pcVar3,pcVar2);
return this;
}
| |
30,043 | mi_update_status_with_lock | eloqsql/storage/myisam/mi_locking.c | static void mi_update_status_with_lock(MI_INFO *info)
{
my_bool locked= 0;
if (info->state == &info->save_state)
{
locked= 1;
mysql_mutex_lock(&info->s->lock.mutex);
}
mi_update_status(info);
if (locked)
mysql_mutex_unlock(&info->s->lock.mutex);
} | O0 | c | mi_update_status_with_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xb59cc
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x388, %rdi # imm = 0x388
addq $0x18, %rdi
leaq 0xa992d(%rip), %rsi # 0x15f2ef
movl $0x176, %edx # imm = 0x176
callq 0xb58d0
movq -0x8(%rbp), %rdi
callq 0xb5df0
cmpb $0x0, -0x9(%rbp)
je 0xb59f2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x388, %rdi # imm = 0x388
addq $0x18, %rdi
callq 0xb5d10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mi_update_status_with_lock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_8]
add rcx, 10h
cmp rax, rcx
jnz short loc_B59CC
mov [rbp+var_9], 1
mov rax, [rbp+var_8]
mov rdi, [rax]
add rdi, 388h
add rdi, 18h
lea rsi, aWorkspaceLlm4b_31; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 176h
call inline_mysql_mutex_lock_18
loc_B59CC:
mov rdi, [rbp+var_8]
call mi_update_status
cmp [rbp+var_9], 0
jz short loc_B59F2
mov rax, [rbp+var_8]
mov rdi, [rax]
add rdi, 388h
add rdi, 18h
call inline_mysql_mutex_unlock_19
loc_B59F2:
add rsp, 10h
pop rbp
retn
| long long mi_update_status_with_lock(_QWORD *a1)
{
long long result; // rax
char v2; // [rsp+7h] [rbp-9h]
v2 = 0;
if ( (_QWORD *)a1[1] == a1 + 2 )
{
v2 = 1;
inline_mysql_mutex_lock_18(
*a1 + 928LL,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x176u);
}
result = mi_update_status(a1);
if ( v2 )
return inline_mysql_mutex_unlock_19(*a1 + 928LL);
return result;
}
| mi_update_status_with_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x10
CMP RAX,RCX
JNZ 0x001b59cc
MOV byte ptr [RBP + -0x9],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x388
ADD RDI,0x18
LEA RSI,[0x25f2ef]
MOV EDX,0x176
CALL 0x001b58d0
LAB_001b59cc:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001b5df0
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001b59f2
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0x388
ADD RDI,0x18
CALL 0x001b5d10
LAB_001b59f2:
ADD RSP,0x10
POP RBP
RET
|
void mi_update_status_with_lock(long *param_1)
{
long *plVar1;
plVar1 = (long *)param_1[1];
if (plVar1 == param_1 + 2) {
inline_mysql_mutex_lock
(*param_1 + 0x3a0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",0x176);
}
mi_update_status(param_1);
if (plVar1 == param_1 + 2) {
inline_mysql_mutex_unlock(*param_1 + 0x3a0);
}
return;
}
| |
30,044 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | llama.cpp/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x23890
movq %rax, %rbp
addq 0x8(%r12), %rbp
movq %r15, %rdi
callq 0x23890
addq %rax, %rbp
addq 0x8(%r14), %rbp
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x242f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x23f30
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x236e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23f30
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x236e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xa188a
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x231f0
movq %r14, %rdi
callq 0x23ee0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA10_KcS8_SB_S8_EEET_DpOT0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rsp+38h+var_38], rax
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov rbp, rax
add rbp, [r12+8]
mov rdi, r15
call _strlen
add rbp, rax
add rbp, [r14+8]
mov rdi, rbx
mov rsi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, [rsp+0]
jz short loc_A188A
mov rax, [rsp+0]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A188A:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[10],std::string,char const(&)[10],std::string>(
long long a1,
long long a2,
_QWORD *a3,
long long a4,
_QWORD *a5)
{
long long v8; // rbp
long long v9; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v8 = a3[1] + strlen(a2);
v9 = strlen(a4);
std::string::reserve(a1, a5[1] + v9 + v8);
std::string::append(a1, a2);
std::string::append(a1, *a3, a3[1]);
std::string::append(a1, a4);
std::string::append(a1, *a5, a5[1]);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x00123890
MOV RBP,RAX
ADD RBP,qword ptr [R12 + 0x8]
MOV RDI,R15
CALL 0x00123890
ADD RBP,RAX
ADD RBP,qword ptr [R14 + 0x8]
LAB_001a181c:
MOV RDI,RBX
MOV RSI,RBP
CALL 0x001242f0
MOV RDI,RBX
MOV RSI,R13
CALL 0x00123f30
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x001236e0
MOV RDI,RBX
MOV RSI,R15
CALL 0x00123f30
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x001236e0
LAB_001a185d:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [10], std::__cxx11::string, char const (&) [10], std::__cxx11::string >(char const (&) [10],
std::__cxx11::string&&, char const (&) [10], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[10],std::__cxx11::string,char_const(&)[10],std::__cxx11::string>
(detail *this,char *param_1,string *param_2,char *param_3,string *param_4)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(param_3);
/* try { // try from 001a181c to 001a185c has its CatchHandler @ 001a186f */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_2);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this,*(ulong *)param_4);
return this;
}
| |
30,045 | testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | giladroyz[P]FindPeaks/build_O0/_deps/googletest-src/googletest/src/gtest-internal-inl.h | void OnTestPartResult(const TestPartResult& test_part_result) override {
const char* file_name = test_part_result.file_name();
if (file_name == nullptr) file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
"&message=" + UrlEncode(test_part_result.message()));
} | O0 | c | testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&):
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46a10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x598cd
leaq 0x2207e(%rip), %rax # 0x7b947
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x3b740
movq -0x140(%rbp), %rdx
leaq 0x23269(%rip), %rsi # 0x7cb5b
leaq -0xb8(%rbp), %rdi
callq 0x45410
jmp 0x59900
leaq 0x2326f(%rip), %rdx # 0x7cb76
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x44aa0
jmp 0x5991c
movq -0x10(%rbp), %rdi
callq 0x46a60
movl %eax, -0x10c(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x10c(%rbp), %rsi
callq 0x44bc0
jmp 0x59940
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x44af0
jmp 0x59959
leaq 0x2321d(%rip), %rdx # 0x7cb7d
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x44aa0
jmp 0x5996f
movq -0x10(%rbp), %rdi
callq 0x46a90
movq %rax, %rsi
leaq -0x130(%rbp), %rdi
callq 0x3b740
jmp 0x59989
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq 0x44af0
jmp 0x5999f
movq -0x138(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5a6e0
jmp 0x599b1
leaq -0x38(%rbp), %rdi
callq 0xad98
leaq -0x130(%rbp), %rdi
callq 0xad98
leaq -0x58(%rbp), %rdi
callq 0xad98
leaq -0x78(%rbp), %rdi
callq 0xad98
leaq -0x108(%rbp), %rdi
callq 0xad98
leaq -0x98(%rbp), %rdi
callq 0xad98
leaq -0xb8(%rbp), %rdi
callq 0xad98
leaq -0xd8(%rbp), %rdi
callq 0xad98
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59b03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59af7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59aeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59adf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59ad6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x59ac1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xad98
leaq -0x130(%rbp), %rdi
callq 0xad98
leaq -0x58(%rbp), %rdi
callq 0xad98
leaq -0x78(%rbp), %rdi
callq 0xad98
leaq -0x108(%rbp), %rdi
callq 0xad98
leaq -0x98(%rbp), %rdi
callq 0xad98
leaq -0xb8(%rbp), %rdi
callq 0xad98
leaq -0xd8(%rbp), %rdi
callq 0xad98
movq -0xe0(%rbp), %rdi
callq 0xac00
nopl (%rax,%rax)
| _ZN7testing8internal17StreamingListener16OnTestPartResultERKNS_14TestPartResultE:
push rbp
mov rbp, rsp
sub rsp, 140h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_138], rax
mov rdi, [rbp+var_10]; this
call _ZNK7testing14TestPartResult9file_nameEv; testing::TestPartResult::file_name(void)
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_598CD
lea rax, aSFromSSMsTotal+1Ah; ""
mov [rbp+var_18], rax
loc_598CD:
mov rsi, [rbp+var_18]
lea rdi, [rbp+var_D8]
mov [rbp+var_140], rdi
call _ZN7testing8internal17StreamingListener9UrlEncodeB5cxx11EPKc; testing::internal::StreamingListener::UrlEncode(char const*)
mov rdx, [rbp+var_140]
lea rsi, aEventTestpartr; "event=TestPartResult&file="
lea rdi, [rbp+var_B8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_59900:
lea rdx, aLine_1; "&line="
lea rdi, [rbp+var_98]
lea rsi, [rbp+var_B8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_5991C:
mov rdi, [rbp+var_10]; this
call _ZNK7testing14TestPartResult11line_numberEv; testing::TestPartResult::line_number(void)
mov [rbp+var_10C], eax
lea rdi, [rbp+var_108]
lea rsi, [rbp+var_10C]
call _ZN7testing8internal18StreamableToStringIiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<int>(int const&)
jmp short $+2
loc_59940:
lea rdi, [rbp+var_78]
lea rsi, [rbp+var_98]
lea rdx, [rbp+var_108]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
jmp short $+2
loc_59959:
lea rdx, aMessage_0; "&message="
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_78]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_5996F:
mov rdi, [rbp+var_10]; this
call _ZNK7testing14TestPartResult7messageEv; testing::TestPartResult::message(void)
mov rsi, rax
lea rdi, [rbp+var_130]
call _ZN7testing8internal17StreamingListener9UrlEncodeB5cxx11EPKc; testing::internal::StreamingListener::UrlEncode(char const*)
jmp short $+2
loc_59989:
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_58]
lea rdx, [rbp+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
jmp short $+2
loc_5999F:
mov rdi, [rbp+var_138]
lea rsi, [rbp+var_38]
call _ZN7testing8internal17StreamingListener6SendLnERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::StreamingListener::SendLn(std::string const&)
jmp short $+2
loc_599B1:
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
add rsp, 140h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp loc_59B03
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp loc_59AF7
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp loc_59AEB
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp short loc_59ADF
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp short loc_59AD6
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp short loc_59ACD
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
jmp short loc_59AC1
mov rcx, rax
mov eax, edx
mov [rbp+var_E0], rcx
mov [rbp+var_E4], eax
lea rdi, [rbp+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59AC1:
lea rdi, [rbp+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59ACD:
lea rdi, [rbp+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59AD6:
lea rdi, [rbp+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59ADF:
lea rdi, [rbp+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59AEB:
lea rdi, [rbp+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59AF7:
lea rdi, [rbp+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_59B03:
lea rdi, [rbp+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_E0]
call __Unwind_Resume
| void testing::internal::StreamingListener::OnTestPartResult(
testing::internal::StreamingListener *this,
const testing::TestPartResult *a2)
{
signed __int8 *v2; // rax
_BYTE v3[36]; // [rsp+10h] [rbp-130h] BYREF
int v4; // [rsp+34h] [rbp-10Ch] BYREF
_BYTE v5[36]; // [rsp+38h] [rbp-108h] BYREF
_BYTE v6[32]; // [rsp+68h] [rbp-D8h] BYREF
_BYTE v7[32]; // [rsp+88h] [rbp-B8h] BYREF
_BYTE v8[32]; // [rsp+A8h] [rbp-98h] BYREF
_BYTE v9[32]; // [rsp+C8h] [rbp-78h] BYREF
_BYTE v10[32]; // [rsp+E8h] [rbp-58h] BYREF
_BYTE v11[32]; // [rsp+108h] [rbp-38h] BYREF
signed __int8 *v12; // [rsp+128h] [rbp-18h]
testing::TestPartResult *v13; // [rsp+130h] [rbp-10h]
testing::internal::StreamingListener *v14; // [rsp+138h] [rbp-8h]
v14 = this;
v13 = a2;
v12 = (signed __int8 *)testing::TestPartResult::file_name(a2);
if ( !v12 )
v12 = "";
testing::internal::StreamingListener::UrlEncode[abi:cxx11]((long long)v6, v12);
std::operator+<char>((long long)v7, (long long)"event=TestPartResult&file=", (long long)v6);
std::operator+<char>((long long)v8, (long long)v7, "&line=");
v4 = testing::TestPartResult::line_number(v13);
testing::internal::StreamableToString<int>((long long)v5, (long long)&v4);
std::operator+<char>((long long)v9, (long long)v8, (long long)v5);
std::operator+<char>((long long)v10, (long long)v9, "&message=");
v2 = (signed __int8 *)testing::TestPartResult::message(v13);
testing::internal::StreamingListener::UrlEncode[abi:cxx11]((long long)v3, v2);
std::operator+<char>((long long)v11, (long long)v10, (long long)v3);
testing::internal::StreamingListener::SendLn(this, v11);
std::string::~string(v11);
std::string::~string(v3);
std::string::~string(v10);
std::string::~string(v9);
std::string::~string(v5);
std::string::~string(v8);
std::string::~string(v7);
std::string::~string(v6);
}
| get<1ul,testing::internal::InternalRunDeathTestFlag*,std::default_delete<testing::internal::InternalRunDeathTestFlag>>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001598b0
ADD RSP,0x10
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* std::tuple_element<1ul, std::tuple<testing::internal::InternalRunDeathTestFlag*,
std::default_delete<testing::internal::InternalRunDeathTestFlag> > >::type& std::get<1ul,
testing::internal::InternalRunDeathTestFlag*,
std::default_delete<testing::internal::InternalRunDeathTestFlag>
>(std::tuple<testing::internal::InternalRunDeathTestFlag*,
std::default_delete<testing::internal::InternalRunDeathTestFlag> >&) */
type * std::
get<1ul,testing::internal::InternalRunDeathTestFlag*,std::default_delete<testing::internal::InternalRunDeathTestFlag>>
(tuple *param_1)
{
default_delete *pdVar1;
pdVar1 = __get_helper<1ul,std::default_delete<testing::internal::InternalRunDeathTestFlag>>
((_Tuple_impl *)param_1);
return (type *)pdVar1;
}
| |
30,046 | flux::parser::FunctionDecl::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Decl> FunctionDecl::clone() const {
std::vector<FunctionDecl::Parameter> clonedParameters;
for (const auto& param : parameters) {
clonedParameters.emplace_back(
param.name,
param.type ? static_cast<std::unique_ptr<TypeExpr>>(param.type->clone()) : nullptr);
}
return std::make_unique<FunctionDecl>(
name,
std::move(clonedParameters),
returnType ? static_cast<std::unique_ptr<TypeExpr>>(returnType->clone()) : nullptr,
body->clone(),
range,
isPrototype
);
} | O1 | cpp | flux::parser::FunctionDecl::clone() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsi), %r15
movq 0x40(%rsi), %rbp
cmpq %rbp, %r15
je 0xee84
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0xee54
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
jmp 0xee5d
movq $0x0, 0x30(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1068c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xee7b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %r15
cmpq %rbp, %r15
jne 0xee40
movq 0x50(%r14), %rsi
testq %rsi, %rsi
je 0xee98
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
jmp 0xeea0
movq $0x0, (%rsp)
movq 0x58(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movl $0x68, %edi
callq 0x6270
movq %rax, %r15
movups 0x28(%r14), %xmm0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq 0x20(%rsp), %rdx
movq %rdx, 0x10(%rdi)
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
xorl %esi, %esi
movq %rsi, 0x20(%rsp)
movq (%rsp), %r8
movq %rsi, (%rsp)
movq 0x8(%rsp), %r9
movq %rsi, 0x8(%rsp)
movb 0x60(%r14), %r10b
leaq 0x2bdd4(%rip), %r11 # 0x3ace0
movq %r11, (%r15)
movups 0x8(%r14), %xmm2
movups 0x18(%r14), %xmm3
movups %xmm2, 0x8(%r15)
movups %xmm3, 0x18(%r15)
movups %xmm0, 0x28(%r15)
leaq 0x2b759(%rip), %r11 # 0x3a688
movq %r11, (%r15)
movq %rax, 0x38(%r15)
movq %rcx, 0x40(%r15)
movq %rdx, 0x48(%r15)
movq %rsi, 0x10(%rdi)
movaps %xmm1, (%rdi)
movq %r8, 0x50(%r15)
movq %r9, 0x58(%r15)
movb %r10b, 0x60(%r15)
callq 0x106ce
movq %r15, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xef69
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xef78
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x106ce
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xefd0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xefa9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0xefb7
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xefc6
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0xeff1
movq %rax, %rbx
jmp 0xeff1
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xefe8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x106ce
movq %rbx, %rdi
callq 0x6440
nop
| _ZNK4flux6parser12FunctionDecl5cloneEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+78h+var_68], xmm0
mov [rsp+78h+var_58], 0
mov r15, [rsi+38h]
mov rbp, [rsi+40h]
cmp r15, rbp
jz short loc_EE84
lea r12, [rsp+78h+var_68]
lea r13, [rsp+78h+var_48]
loc_EE40:
mov rsi, [r15+10h]
test rsi, rsi
jz short loc_EE54
mov rax, [rsi]
mov rdi, r13
call qword ptr [rax+18h]
jmp short loc_EE5D
loc_EE54:
mov [rsp+78h+var_48], 0
loc_EE5D:
mov rdi, r12
mov rsi, r15
mov rdx, r13
call _ZNSt6vectorIN4flux6parser12FunctionDecl9ParameterESaIS3_EE12emplace_backIJRKSt17basic_string_viewIcSt11char_traitsIcEESt10unique_ptrINS1_8TypeExprESt14default_deleteISE_EEEEERS3_DpOT_; std::vector<flux::parser::FunctionDecl::Parameter>::emplace_back<std::string_view const&,std::unique_ptr<flux::parser::TypeExpr>>(std::string_view const&,std::unique_ptr<flux::parser::TypeExpr> &&)
mov rdi, [rsp+78h+var_48]
test rdi, rdi
jz short loc_EE7B
mov rax, [rdi]
call qword ptr [rax+8]
loc_EE7B:
add r15, 18h
cmp r15, rbp
jnz short loc_EE40
loc_EE84:
mov rsi, [r14+50h]
test rsi, rsi
jz short loc_EE98
mov rax, [rsi]
mov rdi, rsp
call qword ptr [rax+18h]
jmp short loc_EEA0
loc_EE98:
mov [rsp+78h+var_78], 0
loc_EEA0:
mov rsi, [r14+58h]
mov rax, [rsi]
lea rdi, [rsp+78h+var_70]
call qword ptr [rax+18h]
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
movups xmm0, xmmword ptr [r14+28h]
mov rax, qword ptr [rsp+78h+var_68]
mov rcx, qword ptr [rsp+78h+var_68+8]
lea rdi, [rsp+78h+var_48]
mov [rdi], rax
mov [rdi+8], rcx
mov rdx, [rsp+78h+var_58]
mov [rdi+10h], rdx
xorps xmm1, xmm1
movaps [rsp+78h+var_68], xmm1
xor esi, esi
mov [rsp+78h+var_58], rsi
mov r8, [rsp+78h+var_78]
mov [rsp+78h+var_78], rsi
mov r9, [rsp+78h+var_70]
mov [rsp+78h+var_70], rsi
mov r10b, [r14+60h]
lea r11, off_3ACE0
mov [r15], r11
movups xmm2, xmmword ptr [r14+8]
movups xmm3, xmmword ptr [r14+18h]
movups xmmword ptr [r15+8], xmm2
movups xmmword ptr [r15+18h], xmm3
movups xmmword ptr [r15+28h], xmm0
lea r11, off_3A688
mov [r15], r11
mov [r15+38h], rax
mov [r15+40h], rcx
mov [r15+48h], rdx
mov [rdi+10h], rsi
movaps xmmword ptr [rdi], xmm1
mov [r15+50h], r8
mov [r15+58h], r9
mov [r15+60h], r10b
call _ZNSt6vectorIN4flux6parser12FunctionDecl9ParameterESaIS3_EED2Ev; std::vector<flux::parser::FunctionDecl::Parameter>::~vector()
mov [rbx], r15
mov rdi, [rsp+78h+var_70]
test rdi, rdi
jz short loc_EF69
mov rax, [rdi]
call qword ptr [rax+8]
loc_EF69:
mov rdi, [rsp+78h+var_78]
test rdi, rdi
jz short loc_EF78
mov rax, [rdi]
call qword ptr [rax+8]
loc_EF78:
lea rdi, [rsp+78h+var_68]
call _ZNSt6vectorIN4flux6parser12FunctionDecl9ParameterESaIS3_EED2Ev; std::vector<flux::parser::FunctionDecl::Parameter>::~vector()
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_EFD0
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_EFA9
mov rax, [rdi]
call qword ptr [rax+8]
loc_EFA9:
mov [rsp+arg_0], 0
jmp short loc_EFB7
mov rbx, rax
loc_EFB7:
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_EFC6
mov rax, [rdi]
call qword ptr [rax+8]
loc_EFC6:
mov qword ptr [rsp+0], 0
jmp short loc_EFF1
loc_EFD0:
mov rbx, rax
jmp short loc_EFF1
mov rbx, rax
mov rdi, [rsp+arg_28]
test rdi, rdi
jz short loc_EFE8
mov rax, [rdi]
call qword ptr [rax+8]
loc_EFE8:
mov [rsp+arg_28], 0
loc_EFF1:
lea rdi, [rsp+arg_8]
call _ZNSt6vectorIN4flux6parser12FunctionDecl9ParameterESaIS3_EED2Ev; std::vector<flux::parser::FunctionDecl::Parameter>::~vector()
mov rdi, rbx
call __Unwind_Resume
| flux::parser::FunctionDecl * flux::parser::FunctionDecl::clone(flux::parser::FunctionDecl *this, long long a2)
{
long long v3; // r15
long long i; // rbp
long long v5; // rsi
long long v6; // rsi
long long v7; // r15
__int128 v8; // xmm0
__int128 v9; // kr00_16
long long v10; // rdx
long long v11; // r8
long long v12; // r9
char v13; // r10
__int128 v14; // xmm3
long long v16; // [rsp+0h] [rbp-78h] BYREF
long long v17; // [rsp+8h] [rbp-70h] BYREF
__int128 v18; // [rsp+10h] [rbp-68h] BYREF
long long v19; // [rsp+20h] [rbp-58h]
__int128 v20; // [rsp+30h] [rbp-48h] BYREF
long long v21; // [rsp+40h] [rbp-38h]
v18 = 0LL;
v19 = 0LL;
v3 = *(_QWORD *)(a2 + 56);
for ( i = *(_QWORD *)(a2 + 64); v3 != i; v3 += 24LL )
{
v5 = *(_QWORD *)(v3 + 16);
if ( v5 )
(*(void ( **)(__int128 *))(*(_QWORD *)v5 + 24LL))(&v20);
else
*(_QWORD *)&v20 = 0LL;
std::vector<flux::parser::FunctionDecl::Parameter>::emplace_back<std::string_view const&,std::unique_ptr<flux::parser::TypeExpr>>(
&v18,
v3,
&v20);
if ( (_QWORD)v20 )
(*(void ( **)(_QWORD))(*(_QWORD *)v20 + 8LL))(v20);
}
v6 = *(_QWORD *)(a2 + 80);
if ( v6 )
(*(void ( **)(long long *))(*(_QWORD *)v6 + 24LL))(&v16);
else
v16 = 0LL;
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 88) + 24LL))(&v17);
v7 = operator new(0x68uLL);
v8 = *(_OWORD *)(a2 + 40);
v9 = v18;
v20 = v18;
v10 = v19;
v21 = v19;
v18 = 0LL;
v19 = 0LL;
v11 = v16;
v16 = 0LL;
v12 = v17;
v17 = 0LL;
v13 = *(_BYTE *)(a2 + 96);
*(_QWORD *)v7 = &off_3ACE0;
v14 = *(_OWORD *)(a2 + 24);
*(_OWORD *)(v7 + 8) = *(_OWORD *)(a2 + 8);
*(_OWORD *)(v7 + 24) = v14;
*(_OWORD *)(v7 + 40) = v8;
*(_QWORD *)v7 = off_3A688;
*(_OWORD *)(v7 + 56) = v9;
*(_QWORD *)(v7 + 72) = v10;
v21 = 0LL;
v20 = 0LL;
*(_QWORD *)(v7 + 80) = v11;
*(_QWORD *)(v7 + 88) = v12;
*(_BYTE *)(v7 + 96) = v13;
((void (*)(void))std::vector<flux::parser::FunctionDecl::Parameter>::~vector)();
*(_QWORD *)this = v7;
if ( v17 )
(*(void ( **)(long long))(*(_QWORD *)v17 + 8LL))(v17);
if ( v16 )
(*(void ( **)(long long))(*(_QWORD *)v16 + 8LL))(v16);
std::vector<flux::parser::FunctionDecl::Parameter>::~vector(&v18);
return this;
}
| clone:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV R15,qword ptr [RSI + 0x38]
MOV RBP,qword ptr [RSI + 0x40]
CMP R15,RBP
JZ 0x0010ee84
LEA R12,[RSP + 0x10]
LEA R13,[RSP + 0x30]
LAB_0010ee40:
MOV RSI,qword ptr [R15 + 0x10]
TEST RSI,RSI
JZ 0x0010ee54
MOV RAX,qword ptr [RSI]
LAB_0010ee4c:
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x0010ee5d
LAB_0010ee54:
MOV qword ptr [RSP + 0x30],0x0
LAB_0010ee5d:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
CALL 0x0011068c
LAB_0010ee6b:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0010ee7b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010ee7b:
ADD R15,0x18
CMP R15,RBP
JNZ 0x0010ee40
LAB_0010ee84:
MOV RSI,qword ptr [R14 + 0x50]
TEST RSI,RSI
JZ 0x0010ee98
MOV RAX,qword ptr [RSI]
LAB_0010ee90:
MOV RDI,RSP
CALL qword ptr [RAX + 0x18]
JMP 0x0010eea0
LAB_0010ee98:
MOV qword ptr [RSP],0x0
LAB_0010eea0:
MOV RSI,qword ptr [R14 + 0x58]
MOV RAX,qword ptr [RSI]
LAB_0010eea7:
LEA RDI,[RSP + 0x8]
CALL qword ptr [RAX + 0x18]
LAB_0010eeaf:
MOV EDI,0x68
CALL 0x00106270
LAB_0010eeb9:
MOV R15,RAX
MOVUPS XMM0,xmmword ptr [R14 + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],RCX
MOV RDX,qword ptr [RSP + 0x20]
MOV qword ptr [RDI + 0x10],RDX
XORPS XMM1,XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM1
XOR ESI,ESI
MOV qword ptr [RSP + 0x20],RSI
MOV R8,qword ptr [RSP]
MOV qword ptr [RSP],RSI
MOV R9,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x8],RSI
MOV R10B,byte ptr [R14 + 0x60]
LEA R11,[0x13ace0]
MOV qword ptr [R15],R11
MOVUPS XMM2,xmmword ptr [R14 + 0x8]
MOVUPS XMM3,xmmword ptr [R14 + 0x18]
MOVUPS xmmword ptr [R15 + 0x8],XMM2
MOVUPS xmmword ptr [R15 + 0x18],XMM3
MOVUPS xmmword ptr [R15 + 0x28],XMM0
LEA R11,[0x13a688]
MOV qword ptr [R15],R11
MOV qword ptr [R15 + 0x38],RAX
MOV qword ptr [R15 + 0x40],RCX
MOV qword ptr [R15 + 0x48],RDX
MOV qword ptr [RDI + 0x10],RSI
MOVAPS xmmword ptr [RDI],XMM1
MOV qword ptr [R15 + 0x50],R8
MOV qword ptr [R15 + 0x58],R9
MOV byte ptr [R15 + 0x60],R10B
CALL 0x001106ce
MOV qword ptr [RBX],R15
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0010ef69
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010ef69:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0010ef78
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010ef78:
LEA RDI,[RSP + 0x10]
CALL 0x001106ce
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* flux::parser::FunctionDecl::clone() const */
void flux::parser::FunctionDecl::clone(void)
{
int1 uVar1;
basic_string_view *pbVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
long *plVar8;
long *plVar9;
int8 uVar10;
int8 uVar11;
int8 uVar12;
int8 *puVar13;
long in_RSI;
int8 *in_RDI;
basic_string_view *pbVar14;
long *local_78;
long *local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
long *local_48;
int8 uStack_40;
int8 local_38;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
pbVar14 = *(basic_string_view **)(in_RSI + 0x38);
pbVar2 = *(basic_string_view **)(in_RSI + 0x40);
if (pbVar14 != pbVar2) {
do {
if (*(long **)(pbVar14 + 0x10) == (long *)0x0) {
local_48 = (long *)0x0;
}
else {
/* try { // try from 0010ee4c to 0010ee51 has its CatchHandler @ 0010efd0 */
(**(code **)(**(long **)(pbVar14 + 0x10) + 0x18))((unique_ptr *)&local_48);
}
/* try { // try from 0010ee5d to 0010ee6a has its CatchHandler @ 0010efd5 */
std::
vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
::
emplace_back<std::basic_string_view<char,std::char_traits<char>>const&,std::unique_ptr<flux::parser::TypeExpr,std::default_delete<flux::parser::TypeExpr>>>
((vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
*)&local_68,pbVar14,(unique_ptr *)&local_48);
if (local_48 != (long *)0x0) {
(**(code **)(*local_48 + 8))();
}
pbVar14 = pbVar14 + 0x18;
} while (pbVar14 != pbVar2);
}
if (*(long **)(in_RSI + 0x50) == (long *)0x0) {
local_78 = (long *)0x0;
}
else {
/* try { // try from 0010ee90 to 0010ee95 has its CatchHandler @ 0010ef94 */
(**(code **)(**(long **)(in_RSI + 0x50) + 0x18))(&local_78);
}
/* try { // try from 0010eea7 to 0010eeae has its CatchHandler @ 0010efb4 */
(**(code **)(**(long **)(in_RSI + 0x58) + 0x18))(&local_70);
/* try { // try from 0010eeaf to 0010eeb8 has its CatchHandler @ 0010ef96 */
puVar13 = (int8 *)operator_new(0x68);
uVar12 = local_58;
uVar11 = uStack_60;
uVar10 = local_68;
plVar9 = local_70;
plVar8 = local_78;
uVar3 = *(int8 *)(in_RSI + 0x28);
uVar4 = *(int8 *)(in_RSI + 0x30);
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
local_78 = (long *)0x0;
local_70 = (long *)0x0;
uVar1 = *(int1 *)(in_RSI + 0x60);
*puVar13 = &PTR__Decl_0013ace0;
uVar5 = *(int8 *)(in_RSI + 0x10);
uVar6 = *(int8 *)(in_RSI + 0x18);
uVar7 = *(int8 *)(in_RSI + 0x20);
puVar13[1] = *(int8 *)(in_RSI + 8);
puVar13[2] = uVar5;
puVar13[3] = uVar6;
puVar13[4] = uVar7;
puVar13[5] = uVar3;
puVar13[6] = uVar4;
*puVar13 = &PTR__FunctionDecl_0013a688;
puVar13[7] = uVar10;
puVar13[8] = uVar11;
puVar13[9] = uVar12;
local_38 = 0;
local_48 = (long *)0x0;
uStack_40 = 0;
puVar13[10] = plVar8;
puVar13[0xb] = plVar9;
*(int1 *)(puVar13 + 0xc) = uVar1;
std::
vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
::~vector((vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
*)&local_48);
*in_RDI = puVar13;
if (local_70 != (long *)0x0) {
(**(code **)(*local_70 + 8))();
}
if (local_78 != (long *)0x0) {
(**(code **)(*local_78 + 8))();
}
std::
vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
::~vector((vector<flux::parser::FunctionDecl::Parameter,std::allocator<flux::parser::FunctionDecl::Parameter>>
*)&local_68);
return;
}
| |
30,047 | flux::parser::TypeDecl::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Decl> TypeDecl::clone() const {
return std::make_unique<TypeDecl>(
name,
static_cast<std::unique_ptr<TypeExpr>>(underlyingType->clone()),
range);
} | O2 | cpp | flux::parser::TypeDecl::clone() const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %r15
movq 0x38(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq *0x18(%rax)
addq $0x8, %r14
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xef8c
movq 0x10(%rsp), %rax
andq $0x0, 0x10(%rsp)
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd274
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd296
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x63e0
| _ZNK4flux6parser8TypeDecl5cloneEv:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+28h]
mov rsi, [rsi+38h]
mov rax, [rsi]
lea r12, [rsp+38h+var_30]
mov rdi, r12
call qword ptr [rax+18h]
add r14, 8
lea rdi, [rsp+38h+var_28]
mov rsi, r15
mov rdx, r12
mov rcx, r14
call _ZSt11make_uniqueIN4flux6parser8TypeDeclEJRKSt17basic_string_viewIcSt11char_traitsIcEESt10unique_ptrINS1_8TypeExprESt14default_deleteISA_EERKNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::TypeDecl,std::string_view const&,std::unique_ptr<flux::parser::TypeExpr>,flux::common::SourceRange const&>(std::string_view const&,std::unique_ptr<flux::parser::TypeExpr>,flux::common::SourceRange const&)
mov rax, [rsp+38h+var_28]
and [rsp+38h+var_28], 0
mov [rbx], rax
mov rdi, [rsp+38h+var_30]
test rdi, rdi
jz short loc_D274
mov rax, [rdi]
call qword ptr [rax+8]
loc_D274:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_D296
mov rax, [rdi]
call qword ptr [rax+8]
loc_D296:
mov rdi, rbx
call __Unwind_Resume
| flux::parser::TypeDecl * flux::parser::TypeDecl::clone(flux::parser::TypeDecl *this, long long a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-30h] BYREF
_QWORD v5[5]; // [rsp+10h] [rbp-28h] BYREF
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 56) + 24LL))(&v4);
std::make_unique<flux::parser::TypeDecl,std::string_view const&,std::unique_ptr<flux::parser::TypeExpr>,flux::common::SourceRange const&>(
v5,
a2 + 40,
&v4,
a2 + 8);
v2 = v5[0];
v5[0] = 0LL;
*(_QWORD *)this = v2;
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
return this;
}
| clone:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x28]
MOV RSI,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RSI]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
ADD R14,0x8
LAB_0010d243:
LEA RDI,[RSP + 0x10]
MOV RSI,R15
MOV RDX,R12
MOV RCX,R14
CALL 0x0010ef8c
LAB_0010d256:
MOV RAX,qword ptr [RSP + 0x10]
AND qword ptr [RSP + 0x10],0x0
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0010d274
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010d274:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* flux::parser::TypeDecl::clone() const */
void flux::parser::TypeDecl::clone(void)
{
int8 uVar1;
long in_RSI;
int8 *in_RDI;
long *local_30;
int8 local_28;
(**(code **)(**(long **)(in_RSI + 0x38) + 0x18))((SourceRange *)&local_30);
/* try { // try from 0010d243 to 0010d255 has its CatchHandler @ 0010d283 */
std::
make_unique<flux::parser::TypeDecl,std::basic_string_view<char,std::char_traits<char>>const&,std::unique_ptr<flux::parser::TypeExpr,std::default_delete<flux::parser::TypeExpr>>,flux::common::SourceRange_const&>
((basic_string_view *)&local_28,(unique_ptr *)(in_RSI + 0x28),(SourceRange *)&local_30);
uVar1 = local_28;
local_28 = 0;
*in_RDI = uVar1;
if (local_30 != (long *)0x0) {
(**(code **)(*local_30 + 8))();
}
return;
}
| |
30,048 | pfs_memory_claim_v1 | eloqsql/storage/perfschema/pfs.cc | PSI_memory_key pfs_memory_claim_v1(PSI_memory_key key, size_t size, PSI_thread **owner)
{
PFS_thread ** owner_thread= reinterpret_cast<PFS_thread**>(owner);
assert(owner_thread != NULL);
PFS_memory_class *klass= find_memory_class(key);
if (klass == NULL)
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
/*
Do not check klass->m_enabled.
Do not check flag_global_instrumentation.
If a memory alloc was instrumented,
the corresponding free must be instrumented.
*/
PFS_memory_stat *event_name_array;
PFS_memory_stat *stat;
uint index= klass->m_event_name_index;
PFS_memory_stat_delta delta_buffer;
PFS_memory_stat_delta *delta;
if (flag_thread_instrumentation)
{
PFS_thread *old_thread= sanitize_thread(*owner_thread);
PFS_thread *new_thread= my_thread_get_THR_PFS();
if (old_thread != new_thread)
{
if (old_thread != NULL)
{
event_name_array= old_thread->write_instr_class_memory_stats();
stat= & event_name_array[index];
delta= stat->count_free(size, &delta_buffer);
if (delta != NULL)
{
old_thread->carry_memory_stat_delta(delta, index);
}
}
if (new_thread != NULL)
{
event_name_array= new_thread->write_instr_class_memory_stats();
stat= & event_name_array[index];
delta= stat->count_alloc(size, &delta_buffer);
if (delta != NULL)
{
new_thread->carry_memory_stat_delta(delta, index);
}
}
*owner_thread= new_thread;
}
return key;
}
*owner_thread= NULL;
return key;
} | O3 | cpp | pfs_memory_claim_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebx
callq 0x362cf
testq %rax, %rax
je 0x3e4f8
leaq 0x392800(%rip), %rcx # 0x3d0c40
cmpb $0x1, (%rcx)
jne 0x3e506
movl 0x10(%rax), %eax
movq %rax, -0x30(%rbp)
movq (%r14), %rdi
callq 0x2fd20
movq %rax, %r13
movl 0x391e0b(%rip), %edi # 0x3d026c
callq 0x26540
cmpq %rax, %r13
je 0x3e602
movq %rax, %r15
testq %r13, %r13
je 0x3e54f
cmpb $0x0, 0x4(%r13)
jne 0x3e48f
movq %r13, %rdi
callq 0x40362
movb $0x1, 0x4(%r13)
movq 0x28(%r13), %rax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx,8), %rax
movb $0x1, (%rax)
incq 0x10(%rax)
movdqu 0x20(%rax), %xmm0
movq %r12, %xmm1
shufpd $0x2, 0x42767(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x20(%rax)
addq %r12, 0x38(%rax)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x3e4d8
movq 0x40(%rax), %rdx
subq %r12, %rdx
jae 0x3e50e
pxor %xmm0, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa %xmm0, -0x50(%rbp)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x3e51b
decq %rcx
movq %rcx, 0x30(%rax)
jmp 0x3e523
movq $0x0, (%r14)
xorl %ebx, %ebx
jmp 0x3e602
xorl %r15d, %r15d
jmp 0x3e5ff
decq %rcx
movq %rcx, 0x30(%rax)
movq %rdx, 0x40(%rax)
jmp 0x3e54f
movq $0x1, -0x48(%rbp)
movq 0x40(%rax), %rdx
movq %rdx, %rcx
subq %r12, %rcx
jae 0x3e53b
movq %r12, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
xorl %ecx, %ecx
movq %rcx, 0x40(%rax)
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
movq -0x30(%rbp), %rdx
callq 0x2f8e4
testq %r15, %r15
je 0x3e5ff
cmpb $0x0, 0x4(%r15)
jne 0x3e56c
movq %r15, %rdi
callq 0x40362
movb $0x1, 0x4(%r15)
movq 0x28(%r15), %rax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx,8), %rax
movb $0x1, (%rax)
incq 0x8(%rax)
incq 0x30(%rax)
addq %r12, 0x18(%rax)
addq %r12, 0x40(%rax)
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x3e5a1
movq 0x38(%rax), %rdx
subq %r12, %rdx
jae 0x3e5c1
pxor %xmm0, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa %xmm0, -0x50(%rbp)
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x3e5ce
decq %rcx
movq %rcx, 0x28(%rax)
jmp 0x3e5d6
decq %rcx
movq %rcx, 0x28(%rax)
movq %rdx, 0x38(%rax)
jmp 0x3e5ff
movq $0x1, -0x50(%rbp)
movq 0x38(%rax), %rdx
movq %rdx, %rcx
subq %r12, %rcx
jae 0x3e5eb
subq %rdx, %r12
movq %r12, -0x40(%rbp)
xorl %ecx, %ecx
movq %rcx, 0x38(%rax)
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
movq -0x30(%rbp), %rdx
callq 0x2f8e4
movq %r15, (%r14)
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pfs_memory_claim_v1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdx
mov r12, rsi
mov ebx, edi
call _Z17find_memory_classj; find_memory_class(uint)
test rax, rax
jz loc_3E4F8
lea rcx, flag_thread_instrumentation
cmp byte ptr [rcx], 1
jnz loc_3E506
mov eax, [rax+10h]
mov [rbp+var_30], rax
mov rdi, [r14]; PFS_thread *
call _Z15sanitize_threadP10PFS_thread; sanitize_thread(PFS_thread *)
mov r13, rax
mov edi, cs:THR_PFS
call _pthread_getspecific
cmp r13, rax
jz loc_3E602
mov r15, rax
test r13, r13
jz loc_3E54F
cmp byte ptr [r13+4], 0
jnz short loc_3E48F
mov rdi, r13; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r13+4], 1
loc_3E48F:
mov rax, [r13+28h]
mov rcx, [rbp+var_30]
lea rcx, [rcx+rcx*8]
lea rax, [rax+rcx*8]
mov byte ptr [rax], 1
inc qword ptr [rax+10h]
movdqu xmm0, xmmword ptr [rax+20h]
movq xmm1, r12
shufpd xmm1, cs:xmmword_80C20, 2
paddq xmm1, xmm0
movdqu xmmword ptr [rax+20h], xmm1
add [rax+38h], r12
mov rcx, [rax+30h]
test rcx, rcx
jz short loc_3E4D8
mov rdx, [rax+40h]
sub rdx, r12
jnb short loc_3E50E
loc_3E4D8:
pxor xmm0, xmm0
movdqa [rbp+var_40], xmm0
movdqa [rbp+var_50], xmm0
mov rcx, [rax+30h]
test rcx, rcx
jz short loc_3E51B
dec rcx
mov [rax+30h], rcx
jmp short loc_3E523
loc_3E4F8:
mov qword ptr [r14], 0
xor ebx, ebx
jmp loc_3E602
loc_3E506:
xor r15d, r15d
jmp loc_3E5FF
loc_3E50E:
dec rcx
mov [rax+30h], rcx
mov [rax+40h], rdx
jmp short loc_3E54F
loc_3E51B:
mov qword ptr [rbp+var_50+8], 1
loc_3E523:
mov rdx, [rax+40h]
mov rcx, rdx
sub rcx, r12
jnb short loc_3E53B
mov rcx, r12
sub rcx, rdx
mov qword ptr [rbp+var_40+8], rcx
xor ecx, ecx
loc_3E53B:
mov [rax+40h], rcx
lea rsi, [rbp+var_50]
mov rdi, r13
mov rdx, [rbp+var_30]
call _ZN10PFS_thread23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_3E54F:
test r15, r15
jz loc_3E5FF
cmp byte ptr [r15+4], 0
jnz short loc_3E56C
mov rdi, r15; this
call _ZN20PFS_connection_slice19rebase_memory_statsEv; PFS_connection_slice::rebase_memory_stats(void)
mov byte ptr [r15+4], 1
loc_3E56C:
mov rax, [r15+28h]
mov rcx, [rbp+var_30]
lea rcx, [rcx+rcx*8]
lea rax, [rax+rcx*8]
mov byte ptr [rax], 1
inc qword ptr [rax+8]
inc qword ptr [rax+30h]
add [rax+18h], r12
add [rax+40h], r12
mov rcx, [rax+28h]
test rcx, rcx
jz short loc_3E5A1
mov rdx, [rax+38h]
sub rdx, r12
jnb short loc_3E5C1
loc_3E5A1:
pxor xmm0, xmm0
movdqa [rbp+var_40], xmm0
movdqa [rbp+var_50], xmm0
mov rcx, [rax+28h]
test rcx, rcx
jz short loc_3E5CE
dec rcx
mov [rax+28h], rcx
jmp short loc_3E5D6
loc_3E5C1:
dec rcx
mov [rax+28h], rcx
mov [rax+38h], rdx
jmp short loc_3E5FF
loc_3E5CE:
mov qword ptr [rbp+var_50], 1
loc_3E5D6:
mov rdx, [rax+38h]
mov rcx, rdx
sub rcx, r12
jnb short loc_3E5EB
sub r12, rdx
mov qword ptr [rbp+var_40], r12
xor ecx, ecx
loc_3E5EB:
mov [rax+38h], rcx
lea rsi, [rbp+var_50]
mov rdi, r15
mov rdx, [rbp+var_30]
call _ZN10PFS_thread23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_3E5FF:
mov [r14], r15
loc_3E602:
mov eax, ebx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long pfs_memory_claim_v1(int a1, unsigned long long a2, PFS_thread **a3)
{
unsigned int v4; // ebx
long long memory_class; // rax
PFS_thread *v6; // r13
long long v7; // rax
long long v8; // r15
__m128i *v9; // rax
long long v10; // rcx
unsigned long long v11; // rdx
bool v12; // cf
long long v13; // rdx
long long v14; // rcx
unsigned long long v15; // rcx
long long v16; // rcx
long long v17; // rax
long long v18; // rcx
unsigned long long v19; // rdx
unsigned long long v20; // rdx
long long v21; // rcx
unsigned long long v22; // rcx
unsigned long long v23; // rcx
__int128 v25; // [rsp+0h] [rbp-50h] BYREF
__int128 v26; // [rsp+10h] [rbp-40h]
long long v27; // [rsp+20h] [rbp-30h]
v4 = a1;
memory_class = find_memory_class(a1);
if ( memory_class )
{
if ( flag_thread_instrumentation[0] != 1 )
{
v8 = 0LL;
LABEL_30:
*a3 = (PFS_thread *)v8;
return v4;
}
v27 = *(unsigned int *)(memory_class + 16);
v6 = sanitize_thread(*a3);
v7 = pthread_getspecific((unsigned int)THR_PFS);
if ( v6 != (PFS_thread *)v7 )
{
v8 = v7;
if ( v6 )
{
if ( !*((_BYTE *)v6 + 4) )
{
PFS_connection_slice::rebase_memory_stats(v6);
*((_BYTE *)v6 + 4) = 1;
}
v9 = (__m128i *)(*((_QWORD *)v6 + 5) + 72 * v27);
v9->m128i_i8[0] = 1;
++v9[1].m128i_i64[0];
v9[2] = _mm_add_epi64((__m128i)_mm_shuffle_pd((__m128d)a2, (__m128d)xmmword_80C20, 2), _mm_loadu_si128(v9 + 2));
v9[3].m128i_i64[1] += a2;
v10 = v9[3].m128i_i64[0];
if ( v10 && (v11 = v9[4].m128i_u64[0], v12 = v11 < a2, v13 = v11 - a2, !v12) )
{
v9[3].m128i_i64[0] = v10 - 1;
v9[4].m128i_i64[0] = v13;
}
else
{
v26 = 0LL;
v25 = 0LL;
v14 = v9[3].m128i_i64[0];
if ( v14 )
v9[3].m128i_i64[0] = v14 - 1;
else
*((_QWORD *)&v25 + 1) = 1LL;
v15 = v9[4].m128i_u64[0];
v12 = v15 < a2;
v16 = v15 - a2;
if ( v12 )
{
*((_QWORD *)&v26 + 1) = a2 - v9[4].m128i_i64[0];
v16 = 0LL;
}
v9[4].m128i_i64[0] = v16;
PFS_thread::carry_memory_stat_delta(v6, (unsigned long long *)&v25, v27);
}
}
if ( v8 )
{
if ( !*(_BYTE *)(v8 + 4) )
{
PFS_connection_slice::rebase_memory_stats((PFS_connection_slice *)v8);
*(_BYTE *)(v8 + 4) = 1;
}
v17 = *(_QWORD *)(v8 + 40) + 72 * v27;
*(_BYTE *)v17 = 1;
++*(_QWORD *)(v17 + 8);
++*(_QWORD *)(v17 + 48);
*(_QWORD *)(v17 + 24) += a2;
*(_QWORD *)(v17 + 64) += a2;
v18 = *(_QWORD *)(v17 + 40);
if ( v18 && (v19 = *(_QWORD *)(v17 + 56), v12 = v19 < a2, v20 = v19 - a2, !v12) )
{
*(_QWORD *)(v17 + 40) = v18 - 1;
*(_QWORD *)(v17 + 56) = v20;
}
else
{
v26 = 0LL;
v25 = 0LL;
v21 = *(_QWORD *)(v17 + 40);
if ( v21 )
*(_QWORD *)(v17 + 40) = v21 - 1;
else
*(_QWORD *)&v25 = 1LL;
v22 = *(_QWORD *)(v17 + 56);
v12 = v22 < a2;
v23 = v22 - a2;
if ( v12 )
{
*(_QWORD *)&v26 = a2 - *(_QWORD *)(v17 + 56);
v23 = 0LL;
}
*(_QWORD *)(v17 + 56) = v23;
PFS_thread::carry_memory_stat_delta((_QWORD *)v8, (unsigned long long *)&v25, v27);
}
}
goto LABEL_30;
}
}
else
{
*a3 = 0LL;
return 0;
}
return v4;
}
| pfs_memory_claim_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDX
MOV R12,RSI
MOV EBX,EDI
CALL 0x001362cf
TEST RAX,RAX
JZ 0x0013e4f8
LEA RCX,[0x4d0c40]
CMP byte ptr [RCX],0x1
JNZ 0x0013e506
MOV EAX,dword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [R14]
CALL 0x0012fd20
MOV R13,RAX
MOV EDI,dword ptr [0x004d026c]
CALL 0x00126540
CMP R13,RAX
JZ 0x0013e602
MOV R15,RAX
TEST R13,R13
JZ 0x0013e54f
CMP byte ptr [R13 + 0x4],0x0
JNZ 0x0013e48f
MOV RDI,R13
CALL 0x00140362
MOV byte ptr [R13 + 0x4],0x1
LAB_0013e48f:
MOV RAX,qword ptr [R13 + 0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA RCX,[RCX + RCX*0x8]
LEA RAX,[RAX + RCX*0x8]
MOV byte ptr [RAX],0x1
INC qword ptr [RAX + 0x10]
MOVDQU XMM0,xmmword ptr [RAX + 0x20]
MOVQ XMM1,R12
SHUFPD XMM1,xmmword ptr [0x00180c20],0x2
PADDQ XMM1,XMM0
MOVDQU xmmword ptr [RAX + 0x20],XMM1
ADD qword ptr [RAX + 0x38],R12
MOV RCX,qword ptr [RAX + 0x30]
TEST RCX,RCX
JZ 0x0013e4d8
MOV RDX,qword ptr [RAX + 0x40]
SUB RDX,R12
JNC 0x0013e50e
LAB_0013e4d8:
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RBP + -0x40],XMM0
MOVDQA xmmword ptr [RBP + -0x50],XMM0
MOV RCX,qword ptr [RAX + 0x30]
TEST RCX,RCX
JZ 0x0013e51b
DEC RCX
MOV qword ptr [RAX + 0x30],RCX
JMP 0x0013e523
LAB_0013e4f8:
MOV qword ptr [R14],0x0
XOR EBX,EBX
JMP 0x0013e602
LAB_0013e506:
XOR R15D,R15D
JMP 0x0013e5ff
LAB_0013e50e:
DEC RCX
MOV qword ptr [RAX + 0x30],RCX
MOV qword ptr [RAX + 0x40],RDX
JMP 0x0013e54f
LAB_0013e51b:
MOV qword ptr [RBP + -0x48],0x1
LAB_0013e523:
MOV RDX,qword ptr [RAX + 0x40]
MOV RCX,RDX
SUB RCX,R12
JNC 0x0013e53b
MOV RCX,R12
SUB RCX,RDX
MOV qword ptr [RBP + -0x38],RCX
XOR ECX,ECX
LAB_0013e53b:
MOV qword ptr [RAX + 0x40],RCX
LEA RSI,[RBP + -0x50]
MOV RDI,R13
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0012f8e4
LAB_0013e54f:
TEST R15,R15
JZ 0x0013e5ff
CMP byte ptr [R15 + 0x4],0x0
JNZ 0x0013e56c
MOV RDI,R15
CALL 0x00140362
MOV byte ptr [R15 + 0x4],0x1
LAB_0013e56c:
MOV RAX,qword ptr [R15 + 0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA RCX,[RCX + RCX*0x8]
LEA RAX,[RAX + RCX*0x8]
MOV byte ptr [RAX],0x1
INC qword ptr [RAX + 0x8]
INC qword ptr [RAX + 0x30]
ADD qword ptr [RAX + 0x18],R12
ADD qword ptr [RAX + 0x40],R12
MOV RCX,qword ptr [RAX + 0x28]
TEST RCX,RCX
JZ 0x0013e5a1
MOV RDX,qword ptr [RAX + 0x38]
SUB RDX,R12
JNC 0x0013e5c1
LAB_0013e5a1:
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RBP + -0x40],XMM0
MOVDQA xmmword ptr [RBP + -0x50],XMM0
MOV RCX,qword ptr [RAX + 0x28]
TEST RCX,RCX
JZ 0x0013e5ce
DEC RCX
MOV qword ptr [RAX + 0x28],RCX
JMP 0x0013e5d6
LAB_0013e5c1:
DEC RCX
MOV qword ptr [RAX + 0x28],RCX
MOV qword ptr [RAX + 0x38],RDX
JMP 0x0013e5ff
LAB_0013e5ce:
MOV qword ptr [RBP + -0x50],0x1
LAB_0013e5d6:
MOV RDX,qword ptr [RAX + 0x38]
MOV RCX,RDX
SUB RCX,R12
JNC 0x0013e5eb
SUB R12,RDX
MOV qword ptr [RBP + -0x40],R12
XOR ECX,ECX
LAB_0013e5eb:
MOV qword ptr [RAX + 0x38],RCX
LEA RSI,[RBP + -0x50]
MOV RDI,R15
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0012f8e4
LAB_0013e5ff:
MOV qword ptr [R14],R15
LAB_0013e602:
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint pfs_memory_claim_v1(uint param_1,ulong param_2,int8 *param_3)
{
int1 *puVar1;
ulong uVar2;
int1 auVar3 [16];
long lVar4;
PFS_connection_slice *this;
PFS_connection_slice *this_00;
PFS_memory_stat_delta local_58 [16];
int1 local_48 [16];
ulong local_38;
lVar4 = find_memory_class(param_1);
if (lVar4 == 0) {
*param_3 = 0;
param_1 = 0;
}
else {
if (flag_thread_instrumentation == '\x01') {
local_38 = (ulong)*(uint *)(lVar4 + 0x10);
this = (PFS_connection_slice *)sanitize_thread((PFS_thread *)*param_3);
this_00 = (PFS_connection_slice *)pthread_getspecific(THR_PFS);
if (this == this_00) {
return param_1;
}
if (this != (PFS_connection_slice *)0x0) {
if (this[4] == (PFS_connection_slice)0x0) {
PFS_connection_slice::rebase_memory_stats(this);
this[4] = (PFS_connection_slice)0x1;
}
puVar1 = (int1 *)(*(long *)(this + 0x28) + local_38 * 0x48);
*puVar1 = 1;
*(long *)(puVar1 + 0x10) = *(long *)(puVar1 + 0x10) + 1;
lVar4 = DAT_00180c28 + *(long *)(puVar1 + 0x28);
*(ulong *)(puVar1 + 0x20) = param_2 + *(long *)(puVar1 + 0x20);
*(long *)(puVar1 + 0x28) = lVar4;
*(ulong *)(puVar1 + 0x38) = *(long *)(puVar1 + 0x38) + param_2;
if ((*(long *)(puVar1 + 0x30) == 0) || (*(ulong *)(puVar1 + 0x40) < param_2)) {
local_48 = (int1 [16])0x0;
local_58[0] = (PFS_memory_stat_delta)0x0;
local_58[1] = (PFS_memory_stat_delta)0x0;
local_58[2] = (PFS_memory_stat_delta)0x0;
local_58[3] = (PFS_memory_stat_delta)0x0;
local_58[4] = (PFS_memory_stat_delta)0x0;
local_58[5] = (PFS_memory_stat_delta)0x0;
local_58[6] = (PFS_memory_stat_delta)0x0;
local_58[7] = (PFS_memory_stat_delta)0x0;
local_58[8] = (PFS_memory_stat_delta)0x0;
local_58[9] = (PFS_memory_stat_delta)0x0;
local_58[10] = (PFS_memory_stat_delta)0x0;
local_58[0xb] = (PFS_memory_stat_delta)0x0;
local_58[0xc] = (PFS_memory_stat_delta)0x0;
local_58[0xd] = (PFS_memory_stat_delta)0x0;
local_58[0xe] = (PFS_memory_stat_delta)0x0;
local_58[0xf] = (PFS_memory_stat_delta)0x0;
if (*(long *)(puVar1 + 0x30) == 0) {
local_58 = (PFS_memory_stat_delta [16])(ZEXT816(1) << 0x40);
}
else {
*(long *)(puVar1 + 0x30) = *(long *)(puVar1 + 0x30) + -1;
}
uVar2 = *(ulong *)(puVar1 + 0x40);
lVar4 = uVar2 - param_2;
if (uVar2 < param_2) {
auVar3._8_8_ = 0;
auVar3._0_8_ = param_2 - uVar2;
local_48 = auVar3 << 0x40;
lVar4 = 0;
}
*(long *)(puVar1 + 0x40) = lVar4;
PFS_thread::carry_memory_stat_delta((PFS_thread *)this,local_58,(uint)local_38);
}
else {
*(long *)(puVar1 + 0x30) = *(long *)(puVar1 + 0x30) + -1;
*(ulong *)(puVar1 + 0x40) = *(ulong *)(puVar1 + 0x40) - param_2;
}
}
if (this_00 != (PFS_connection_slice *)0x0) {
if (this_00[4] == (PFS_connection_slice)0x0) {
PFS_connection_slice::rebase_memory_stats(this_00);
this_00[4] = (PFS_connection_slice)0x1;
}
puVar1 = (int1 *)(*(long *)(this_00 + 0x28) + local_38 * 0x48);
*puVar1 = 1;
*(long *)(puVar1 + 8) = *(long *)(puVar1 + 8) + 1;
*(long *)(puVar1 + 0x30) = *(long *)(puVar1 + 0x30) + 1;
*(ulong *)(puVar1 + 0x18) = *(long *)(puVar1 + 0x18) + param_2;
*(ulong *)(puVar1 + 0x40) = *(long *)(puVar1 + 0x40) + param_2;
if ((*(long *)(puVar1 + 0x28) == 0) || (*(ulong *)(puVar1 + 0x38) < param_2)) {
local_48 = (int1 [16])0x0;
local_58[0] = (PFS_memory_stat_delta)0x0;
local_58[1] = (PFS_memory_stat_delta)0x0;
local_58[2] = (PFS_memory_stat_delta)0x0;
local_58[3] = (PFS_memory_stat_delta)0x0;
local_58[4] = (PFS_memory_stat_delta)0x0;
local_58[5] = (PFS_memory_stat_delta)0x0;
local_58[6] = (PFS_memory_stat_delta)0x0;
local_58[7] = (PFS_memory_stat_delta)0x0;
local_58[8] = (PFS_memory_stat_delta)0x0;
local_58[9] = (PFS_memory_stat_delta)0x0;
local_58[10] = (PFS_memory_stat_delta)0x0;
local_58[0xb] = (PFS_memory_stat_delta)0x0;
local_58[0xc] = (PFS_memory_stat_delta)0x0;
local_58[0xd] = (PFS_memory_stat_delta)0x0;
local_58[0xe] = (PFS_memory_stat_delta)0x0;
local_58[0xf] = (PFS_memory_stat_delta)0x0;
if (*(long *)(puVar1 + 0x28) == 0) {
local_58 = (PFS_memory_stat_delta [16])ZEXT816(1);
}
else {
*(long *)(puVar1 + 0x28) = *(long *)(puVar1 + 0x28) + -1;
}
uVar2 = *(ulong *)(puVar1 + 0x38);
lVar4 = uVar2 - param_2;
if (uVar2 < param_2) {
local_48._8_8_ = 0;
local_48._0_8_ = param_2 - uVar2;
lVar4 = 0;
}
*(long *)(puVar1 + 0x38) = lVar4;
PFS_thread::carry_memory_stat_delta((PFS_thread *)this_00,local_58,(uint)local_38);
}
else {
*(long *)(puVar1 + 0x28) = *(long *)(puVar1 + 0x28) + -1;
*(ulong *)(puVar1 + 0x38) = *(ulong *)(puVar1 + 0x38) - param_2;
}
}
}
else {
this_00 = (PFS_connection_slice *)0x0;
}
*param_3 = this_00;
}
return param_1;
}
| |
30,049 | insert_pointer_name(st_pointer_array*, char*) | eloqsql/client/mysqltest.cc | int insert_pointer_name(POINTER_ARRAY *pa,char * name)
{
uint i,length,old_count;
uchar *new_pos;
const char **new_array;
DBUG_ENTER("insert_pointer_name");
if (! pa->typelib.count)
{
if (!(pa->typelib.type_names=(const char **)
my_malloc(PSI_NOT_INSTRUMENTED, ((PC_MALLOC-MALLOC_OVERHEAD)/
(sizeof(char *)+sizeof(*pa->flag))*
(sizeof(char *)+sizeof(*pa->flag))),MYF(MY_WME))))
DBUG_RETURN(-1);
if (!(pa->str= (uchar*) my_malloc(PSI_NOT_INSTRUMENTED, PS_MALLOC - MALLOC_OVERHEAD,
MYF(MY_WME))))
{
my_free(pa->typelib.type_names);
DBUG_RETURN (-1);
}
pa->max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
sizeof(*pa->flag));
pa->flag= (uint8*) (pa->typelib.type_names+pa->max_count);
pa->length=0;
pa->max_length=PS_MALLOC-MALLOC_OVERHEAD;
pa->array_allocs=1;
}
length=(uint) strlen(name)+1;
if (pa->length+length >= pa->max_length)
{
if (!(new_pos= (uchar*) my_realloc(PSI_NOT_INSTRUMENTED, pa->str, pa->length + length + PS_MALLOC,
MYF(MY_WME))))
DBUG_RETURN(1);
if (new_pos != pa->str)
{
my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa->str);
for (i=0 ; i < pa->typelib.count ; i++)
pa->typelib.type_names[i]= ADD_TO_PTR(pa->typelib.type_names[i],diff,
char*);
pa->str=new_pos;
}
pa->max_length= pa->length+length+PS_MALLOC;
}
if (pa->typelib.count >= pa->max_count-1)
{
int len;
pa->array_allocs++;
len=(PC_MALLOC*pa->array_allocs - MALLOC_OVERHEAD);
if (!(new_array=(const char **) my_realloc(PSI_NOT_INSTRUMENTED, pa->typelib.type_names,
len/
(sizeof(uchar*)+sizeof(*pa->flag))*
(sizeof(uchar*)+sizeof(*pa->flag)),
MYF(MY_WME))))
DBUG_RETURN(1);
pa->typelib.type_names=new_array;
old_count=pa->max_count;
pa->max_count=len/(sizeof(uchar*) + sizeof(*pa->flag));
pa->flag= (uint8*) (pa->typelib.type_names+pa->max_count);
memcpy(pa->flag, (pa->typelib.type_names +old_count),
old_count*sizeof(*pa->flag));
}
pa->flag[pa->typelib.count]=0; /* Reset flag */
pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
pa->typelib.type_names[pa->typelib.count]= NullS; /* Put end-mark */
(void) strmov((char*) pa->str + pa->length,name);
pa->length+=length;
DBUG_RETURN(0);
} | O0 | cpp | insert_pointer_name(st_pointer_array*, char*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x73aac
xorl %edi, %edi
movl $0xf3, %esi
movl $0x10, %edx
callq 0xc2350
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x73a2a
jmp 0x73a1e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73cfe
xorl %edi, %edi
movl $0x1f8, %esi # imm = 0x1F8
movl $0x10, %edx
callq 0xc2350
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x73a62
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc26d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73cfe
movq -0x10(%rbp), %rax
movl $0x1b, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x1f8, 0x3c(%rax) # imm = 0x1F8
movq -0x10(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x18(%rbp), %rdi
callq 0x60460
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
addl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jb 0x73b94
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
addl -0x20(%rbp), %eax
addl $0x200, %eax # imm = 0x200
movl %eax, %eax
movl %eax, %edx
xorl %edi, %edi
movl $0x10, %ecx
callq 0xc2520
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x73b11
jmp 0x73b05
movl $0x1, -0x4(%rbp)
jmp 0x73cfe
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x73b7d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x73b71
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
addq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x73b39
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl -0x20(%rbp), %ecx
addl $0x200, %ecx # imm = 0x200
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x34(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jb 0x73c7a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
shll $0x8, %eax
subl $0x8, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x44(%rbp), %rax
movl $0x9, %ecx
xorl %edx, %edx
divq %rcx
imulq $0x9, %rax, %rdx
xorl %edi, %edi
movl $0x10, %ecx
callq 0xc2520
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x73c07
jmp 0x73bfb
movl $0x1, -0x4(%rbp)
jmp 0x73cfe
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x44(%rbp), %rax
movl $0x9, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0x600e0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x60b70
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _Z19insert_pointer_nameP16st_pointer_arrayPc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp dword ptr [rax], 0
jnz loc_73AAC
xor edi, edi
mov esi, 0F3h
mov edx, 10h
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_73A2A
jmp short $+2
loc_73A1E:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_73CFE
loc_73A2A:
xor edi, edi
mov esi, 1F8h
mov edx, 10h
call my_malloc
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jnz short loc_73A62
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
call my_free
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_73CFE
loc_73A62:
mov rax, [rbp+var_10]
mov dword ptr [rax+34h], 1Bh
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov eax, [rax+34h]
shl rax, 3
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+38h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+3Ch], 1F8h
mov rax, [rbp+var_10]
mov dword ptr [rax+30h], 1
loc_73AAC:
mov rdi, [rbp+var_18]
call _strlen
add eax, 1
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov eax, [rax+38h]
add eax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp eax, [rcx+3Ch]
jb loc_73B94
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rax, [rbp+var_10]
mov eax, [rax+38h]
add eax, [rbp+var_20]
add eax, 200h
mov eax, eax
mov edx, eax
xor edi, edi
mov ecx, 10h
call my_realloc
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_73B11
jmp short $+2
loc_73B05:
mov [rbp+var_4], 1
jmp loc_73CFE
loc_73B11:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
cmp rax, [rcx+20h]
jz short loc_73B7D
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_40], rax
mov [rbp+var_1C], 0
loc_73B39:
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
jnb short loc_73B71
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov ecx, [rbp+var_1C]
mov rdx, [rax+rcx*8]
add rdx, [rbp+var_40]
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov ecx, [rbp+var_1C]
mov [rax+rcx*8], rdx
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_73B39
loc_73B71:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
loc_73B7D:
mov rax, [rbp+var_10]
mov ecx, [rax+38h]
add ecx, [rbp+var_20]
add ecx, 200h
mov rax, [rbp+var_10]
mov [rax+3Ch], ecx
loc_73B94:
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+34h]
sub ecx, 1
cmp eax, ecx
jb loc_73C7A
mov rax, [rbp+var_10]
mov ecx, [rax+30h]
add ecx, 1
mov [rax+30h], ecx
mov rax, [rbp+var_10]
mov eax, [rax+30h]
shl eax, 8
sub eax, 8
mov [rbp+var_44], eax
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
movsxd rax, [rbp+var_44]
mov ecx, 9
xor edx, edx
div rcx
imul rdx, rax, 9
xor edi, edi
mov ecx, 10h
call my_realloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_73C07
jmp short $+2
loc_73BFB:
mov [rbp+var_4], 1
jmp loc_73CFE
loc_73C07:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov eax, [rax+34h]
mov [rbp+var_24], eax
movsxd rax, [rbp+var_44]
mov ecx, 9
xor edx, edx
div rcx
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+34h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov eax, [rax+34h]
shl rax, 3
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+28h]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov eax, [rbp+var_24]
shl rax, 3
add rsi, rax
mov eax, [rbp+var_24]
mov edx, eax
shl rdx, 0
call _memcpy
loc_73C7A:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rcx, [rbp+var_10]
mov ecx, [rcx]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
mov rax, [rbp+var_10]
mov eax, [rax+38h]
add rdx, rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rsi, [rbp+var_10]
mov ecx, [rsi]
mov edi, ecx
add edi, 1
mov [rsi], edi
mov ecx, ecx
mov [rax+rcx*8], rdx
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
mov ecx, [rcx]
mov qword ptr [rax+rcx*8], 0
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
mov rax, [rbp+var_10]
mov eax, [rax+38h]
add rdi, rax
mov rsi, [rbp+var_18]
call _stpcpy
mov ecx, [rbp+var_20]
mov rax, [rbp+var_10]
add ecx, [rax+38h]
mov [rax+38h], ecx
mov [rbp+var_4], 0
loc_73CFE:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long insert_pointer_name(unsigned int *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rdx
long long v5; // rax
unsigned int v6; // ecx
int v8; // [rsp+Ch] [rbp-44h]
long long v9; // [rsp+10h] [rbp-40h]
long long v10; // [rsp+18h] [rbp-38h]
long long v11; // [rsp+20h] [rbp-30h]
unsigned int v12; // [rsp+2Ch] [rbp-24h]
int v13; // [rsp+30h] [rbp-20h]
unsigned int i; // [rsp+34h] [rbp-1Ch]
if ( *a1 )
goto LABEL_7;
v2 = my_malloc(0LL, 243LL, 16LL);
*((_QWORD *)a1 + 2) = v2;
if ( v2 )
{
v3 = my_malloc(0LL, 504LL, 16LL);
*((_QWORD *)a1 + 4) = v3;
if ( !v3 )
{
my_free(*((_QWORD *)a1 + 2));
return (unsigned int)-1;
}
a1[13] = 27;
*((_QWORD *)a1 + 5) = 8LL * a1[13] + *((_QWORD *)a1 + 2);
a1[14] = 0;
a1[15] = 504;
a1[12] = 1;
LABEL_7:
v13 = strlen(a2) + 1;
if ( v13 + a1[14] >= a1[15] )
{
v11 = my_realloc(0LL, *((_QWORD *)a1 + 4), v13 + a1[14] + 512, 16LL);
if ( !v11 )
return 1;
if ( v11 != *((_QWORD *)a1 + 4) )
{
v9 = v11 - *((_QWORD *)a1 + 4);
for ( i = 0; i < *a1; ++i )
*(_QWORD *)(*((_QWORD *)a1 + 2) + 8LL * i) += v9;
*((_QWORD *)a1 + 4) = v11;
}
a1[15] = v13 + a1[14] + 512;
}
if ( *a1 >= a1[13] - 1 )
{
v8 = (++a1[12] << 8) - 8;
v10 = my_realloc(0LL, *((_QWORD *)a1 + 2), 9 * (v8 / 9uLL), 16LL);
if ( !v10 )
return 1;
*((_QWORD *)a1 + 2) = v10;
v12 = a1[13];
a1[13] = v8 / 9uLL;
*((_QWORD *)a1 + 5) = 8LL * a1[13] + *((_QWORD *)a1 + 2);
memcpy(*((_QWORD *)a1 + 5), 8LL * v12 + *((_QWORD *)a1 + 2), v12);
}
*(_BYTE *)(*((_QWORD *)a1 + 5) + *a1) = 0;
v4 = a1[14] + *((_QWORD *)a1 + 4);
v5 = *((_QWORD *)a1 + 2);
v6 = (*a1)++;
*(_QWORD *)(v5 + 8LL * v6) = v4;
*(_QWORD *)(*((_QWORD *)a1 + 2) + 8LL * *a1) = 0LL;
stpcpy(a1[14] + *((_QWORD *)a1 + 4), a2);
a1[14] += v13;
return 0;
}
return (unsigned int)-1;
}
| insert_pointer_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX],0x0
JNZ 0x00173aac
XOR EDI,EDI
MOV ESI,0xf3
MOV EDX,0x10
CALL 0x001c2350
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x00173a2a
JMP 0x00173a1e
LAB_00173a1e:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00173cfe
LAB_00173a2a:
XOR EDI,EDI
MOV ESI,0x1f8
MOV EDX,0x10
CALL 0x001c2350
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JNZ 0x00173a62
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x001c26d0
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00173cfe
LAB_00173a62:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x34],0x1b
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x34]
SHL RAX,0x3
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c],0x1f8
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x30],0x1
LAB_00173aac:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00160460
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x38]
ADD EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x3c]
JC 0x00173b94
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x38]
ADD EAX,dword ptr [RBP + -0x20]
ADD EAX,0x200
MOV EAX,EAX
MOV EDX,EAX
XOR EDI,EDI
MOV ECX,0x10
CALL 0x001c2520
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x00173b11
JMP 0x00173b05
LAB_00173b05:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00173cfe
LAB_00173b11:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x20]
JZ 0x00173b7d
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_00173b39:
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
JNC 0x00173b71
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RAX + RCX*0x8]
ADD RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00173b39
LAB_00173b71:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
LAB_00173b7d:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x38]
ADD ECX,dword ptr [RBP + -0x20]
ADD ECX,0x200
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c],ECX
LAB_00173b94:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x34]
SUB ECX,0x1
CMP EAX,ECX
JC 0x00173c7a
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x30]
ADD ECX,0x1
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x30]
SHL EAX,0x8
SUB EAX,0x8
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOVSXD RAX,dword ptr [RBP + -0x44]
MOV ECX,0x9
XOR EDX,EDX
DIV RCX
IMUL RDX,RAX,0x9
XOR EDI,EDI
MOV ECX,0x10
CALL 0x001c2520
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x00173c07
JMP 0x00173bfb
LAB_00173bfb:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00173cfe
LAB_00173c07:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x34]
MOV dword ptr [RBP + -0x24],EAX
MOVSXD RAX,dword ptr [RBP + -0x44]
MOV ECX,0x9
XOR EDX,EDX
DIV RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x34],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x34]
SHL RAX,0x3
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV EAX,dword ptr [RBP + -0x24]
SHL RAX,0x3
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
SHL RDX,0x0
CALL 0x001600e0
LAB_00173c7a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x38]
ADD RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RSI]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI],EDI
MOV ECX,ECX
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x38]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00160b70
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x38],ECX
MOV dword ptr [RBP + -0x4],0x0
LAB_00173cfe:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
/* insert_pointer_name(st_pointer_array*, char*) */
int4 insert_pointer_name(st_pointer_array *param_1,char *param_2)
{
uint uVar1;
long lVar2;
int1 auVar3 [16];
int iVar4;
int iVar5;
long lVar6;
size_t sVar7;
uint local_24;
if (*(int *)param_1 == 0) {
lVar6 = my_malloc(0,0xf3,0x10);
*(long *)(param_1 + 0x10) = lVar6;
if (lVar6 == 0) {
return 0xffffffff;
}
lVar6 = my_malloc(0,0x1f8,0x10);
*(long *)(param_1 + 0x20) = lVar6;
if (lVar6 == 0) {
my_free(*(int8 *)(param_1 + 0x10));
return 0xffffffff;
}
*(int4 *)(param_1 + 0x34) = 0x1b;
*(ulong *)(param_1 + 0x28) = *(long *)(param_1 + 0x10) + (ulong)*(uint *)(param_1 + 0x34) * 8;
*(int4 *)(param_1 + 0x38) = 0;
*(int4 *)(param_1 + 0x3c) = 0x1f8;
*(int4 *)(param_1 + 0x30) = 1;
}
sVar7 = strlen(param_2);
iVar4 = (int)sVar7 + 1;
if (*(uint *)(param_1 + 0x3c) <= (uint)(*(int *)(param_1 + 0x38) + iVar4)) {
lVar6 = my_realloc(0,*(int8 *)(param_1 + 0x20),*(int *)(param_1 + 0x38) + iVar4 + 0x200,
0x10);
if (lVar6 == 0) {
return 1;
}
if (lVar6 != *(long *)(param_1 + 0x20)) {
lVar2 = *(long *)(param_1 + 0x20);
for (local_24 = 0; local_24 < *(uint *)param_1; local_24 = local_24 + 1) {
*(long *)(*(long *)(param_1 + 0x10) + (ulong)local_24 * 8) =
*(long *)(*(long *)(param_1 + 0x10) + (ulong)local_24 * 8) + (lVar6 - lVar2);
}
*(long *)(param_1 + 0x20) = lVar6;
}
*(int *)(param_1 + 0x3c) = *(int *)(param_1 + 0x38) + iVar4 + 0x200;
}
if (*(int *)(param_1 + 0x34) - 1U <= *(uint *)param_1) {
*(int *)(param_1 + 0x30) = *(int *)(param_1 + 0x30) + 1;
iVar5 = *(int *)(param_1 + 0x30) * 0x100 + -8;
lVar6 = my_realloc(0,*(int8 *)(param_1 + 0x10),((ulong)(long)iVar5 / 9) * 9,0x10);
if (lVar6 == 0) {
return 1;
}
*(long *)(param_1 + 0x10) = lVar6;
uVar1 = *(uint *)(param_1 + 0x34);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)iVar5;
*(int *)(param_1 + 0x34) = SUB164(auVar3 / ZEXT816(9),0);
*(ulong *)(param_1 + 0x28) = *(long *)(param_1 + 0x10) + (ulong)*(uint *)(param_1 + 0x34) * 8;
memcpy(*(void **)(param_1 + 0x28),(void *)(*(long *)(param_1 + 0x10) + (ulong)uVar1 * 8),
(ulong)uVar1);
}
*(int1 *)(*(long *)(param_1 + 0x28) + (ulong)*(uint *)param_1) = 0;
uVar1 = *(uint *)param_1;
*(uint *)param_1 = uVar1 + 1;
*(ulong *)(*(long *)(param_1 + 0x10) + (ulong)uVar1 * 8) =
*(long *)(param_1 + 0x20) + (ulong)*(uint *)(param_1 + 0x38);
*(int8 *)(*(long *)(param_1 + 0x10) + (ulong)*(uint *)param_1 * 8) = 0;
stpcpy((char *)(*(long *)(param_1 + 0x20) + (ulong)*(uint *)(param_1 + 0x38)),param_2);
*(int *)(param_1 + 0x38) = iVar4 + *(int *)(param_1 + 0x38);
return 0;
}
| |
30,050 | mysql_local_infile_error | eloqsql/libmariadb/libmariadb/ma_loaddata.c | static
int mysql_local_infile_error(void *ptr, char *error_buf, unsigned int error_buf_len)
{
MYSQL_INFILE_INFO *info = (MYSQL_INFILE_INFO *)ptr;
if (info) {
ma_strmake(error_buf, info->error_msg, error_buf_len);
return(info->error_no);
}
ma_strmake(error_buf, "Unknown error", error_buf_len);
return(CR_UNKNOWN_ERROR);
} | O0 | c | mysql_local_infile_error:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3aa24
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xc, %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x3f200
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3aa40
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0x178a5(%rip), %rsi # 0x522d9
callq 0x3f200
movl $0x7d0, -0x4(%rbp) # imm = 0x7D0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_local_infile_error:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_3AA24
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
add rsi, 0Ch
mov eax, [rbp+var_1C]
mov edx, eax
call ma_strmake
mov rax, [rbp+var_28]
mov eax, [rax+8]
mov [rbp+var_4], eax
jmp short loc_3AA40
loc_3AA24:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_1C]
mov edx, eax
lea rsi, aUnknownError; "Unknown error"
call ma_strmake
mov [rbp+var_4], 7D0h
loc_3AA40:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_local_infile_error(long long a1, long long a2, unsigned int a3)
{
if ( a1 )
{
ma_strmake(a2, a1 + 12, a3);
return *(unsigned int *)(a1 + 8);
}
else
{
ma_strmake(a2, "Unknown error", a3);
return 2000;
}
}
| mysql_local_infile_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013aa24
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0xc
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
CALL 0x0013f200
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013aa40
LAB_0013aa24:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
LEA RSI,[0x1522d9]
CALL 0x0013f200
MOV dword ptr [RBP + -0x4],0x7d0
LAB_0013aa40:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_local_infile_error(long param_1,int8 param_2,int4 param_3)
{
int4 local_c;
if (param_1 == 0) {
ma_strmake(param_2,"Unknown error",param_3);
local_c = 2000;
}
else {
ma_strmake(param_2,param_1 + 0xc,param_3);
local_c = *(int4 *)(param_1 + 8);
}
return local_c;
}
| |
30,051 | native_password_auth_client | eloqsql/libmariadb/plugins/auth/my_auth.c | static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
{
int pkt_len;
uchar *pkt;
if (((MCPVIO_EXT *)vio)->mysql_change_user)
{
/*
in mysql_change_user() the client sends the first packet.
we use the old scramble.
*/
pkt= (uchar*)mysql->scramble_buff;
pkt_len= SCRAMBLE_LENGTH + 1;
}
else
{
/* read the scramble */
if ((pkt_len= vio->read_packet(vio, &pkt)) < 0)
return CR_ERROR;
if (pkt_len != SCRAMBLE_LENGTH + 1)
return CR_SERVER_HANDSHAKE_ERR;
/* save it in MYSQL */
memmove(mysql->scramble_buff, pkt, SCRAMBLE_LENGTH);
mysql->scramble_buff[SCRAMBLE_LENGTH] = 0;
}
if (mysql && mysql->passwd[0])
{
char scrambled[SCRAMBLE_LENGTH + 1];
memset(scrambled, 0, SCRAMBLE_LENGTH + 1);
ma_scramble_41((uchar *)scrambled, (char*)pkt, mysql->passwd);
if (vio->write_packet(vio, (uchar*)scrambled, SCRAMBLE_LENGTH))
return CR_ERROR;
}
else
if (vio->write_packet(vio, 0, 0)) /* no password */
return CR_ERROR;
return CR_OK;
} | O3 | c | native_password_auth_client:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpb $0x0, 0x48(%rdi)
je 0x307ec
leaq 0x48e(%r14), %rax
movq %rax, -0x48(%rbp)
testq %r14, %r14
jne 0x30825
jmp 0x30867
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq *(%rbx)
testl %eax, %eax
js 0x30862
movl $0x7dc, %r15d # imm = 0x7DC
cmpl $0x15, %eax
jne 0x3087e
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movl 0x10(%rax), %eax
movl %eax, 0x49e(%r14)
movups %xmm0, 0x48e(%r14)
movb $0x0, 0x4a2(%r14)
movq 0x2c0(%r14), %rdx
cmpb $0x0, (%rdx)
je 0x30867
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0xd(%r14)
movq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x35402
movq %rbx, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq *0x8(%rbx)
testl %eax, %eax
je 0x30878
xorl %r15d, %r15d
jmp 0x3087e
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x8(%rbx)
testl %eax, %eax
jne 0x3087e
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x3089b
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13510
| native_password_auth_client:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp byte ptr [rdi+48h], 0
jz short loc_307EC
lea rax, [r14+48Eh]
mov [rbp+var_48], rax
test r14, r14
jnz short loc_30825
jmp short loc_30867
loc_307EC:
lea rsi, [rbp+var_48]
mov rdi, rbx
call qword ptr [rbx]
test eax, eax
js short loc_30862
mov r15d, 7DCh
cmp eax, 15h
jnz short loc_3087E
mov rax, [rbp+var_48]
movups xmm0, xmmword ptr [rax]
mov eax, [rax+10h]
mov [r14+49Eh], eax
movups xmmword ptr [r14+48Eh], xmm0
mov byte ptr [r14+4A2h], 0
loc_30825:
mov rdx, [r14+2C0h]
cmp byte ptr [rdx], 0
jz short loc_30867
xorps xmm0, xmm0
lea r14, [rbp+var_40]
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+0Dh], 0
mov rsi, [rbp+var_48]
mov rdi, r14
call ma_scramble_41
mov rdi, rbx
mov rsi, r14
mov edx, 14h
call qword ptr [rbx+8]
test eax, eax
jz short loc_30878
loc_30862:
xor r15d, r15d
jmp short loc_3087E
loc_30867:
xor r15d, r15d
mov rdi, rbx
xor esi, esi
xor edx, edx
call qword ptr [rbx+8]
test eax, eax
jnz short loc_3087E
loc_30878:
mov r15d, 0FFFFFFFFh
loc_3087E:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_3089B
mov eax, r15d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3089B:
call ___stack_chk_fail
| long long native_password_auth_client(long long a1, long long a2)
{
int v2; // eax
unsigned int v3; // r15d
__int128 v4; // xmm0
__int128 *v6; // [rsp+8h] [rbp-48h] BYREF
_BYTE v7[32]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+30h] [rbp-20h]
v8 = __readfsqword(0x28u);
if ( !*(_BYTE *)(a1 + 72) )
{
v2 = (*(long long ( **)(long long, __int128 **))a1)(a1, &v6);
if ( v2 < 0 )
return 0;
v3 = 2012;
if ( v2 != 21 )
return v3;
v4 = *v6;
*(_DWORD *)(a2 + 1182) = *((_DWORD *)v6 + 4);
*(_OWORD *)(a2 + 1166) = v4;
*(_BYTE *)(a2 + 1186) = 0;
LABEL_7:
if ( !**(_BYTE **)(a2 + 704) )
goto LABEL_10;
memset(v7, 0, 21);
ma_scramble_41(v7, v6);
if ( !(*(unsigned int ( **)(long long, _BYTE *, long long))(a1 + 8))(a1, v7, 20LL) )
return (unsigned int)-1;
return 0;
}
v6 = (__int128 *)(a2 + 1166);
if ( a2 )
goto LABEL_7;
LABEL_10:
v3 = 0;
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 8))(a1, 0LL, 0LL) )
return (unsigned int)-1;
return v3;
}
| native_password_auth_client:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP byte ptr [RDI + 0x48],0x0
JZ 0x001307ec
LEA RAX,[R14 + 0x48e]
MOV qword ptr [RBP + -0x48],RAX
TEST R14,R14
JNZ 0x00130825
JMP 0x00130867
LAB_001307ec:
LEA RSI,[RBP + -0x48]
MOV RDI,RBX
CALL qword ptr [RBX]
TEST EAX,EAX
JS 0x00130862
MOV R15D,0x7dc
CMP EAX,0x15
JNZ 0x0013087e
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [R14 + 0x49e],EAX
MOVUPS xmmword ptr [R14 + 0x48e],XMM0
MOV byte ptr [R14 + 0x4a2],0x0
LAB_00130825:
MOV RDX,qword ptr [R14 + 0x2c0]
CMP byte ptr [RDX],0x0
JZ 0x00130867
XORPS XMM0,XMM0
LEA R14,[RBP + -0x40]
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0xd],0x0
MOV RSI,qword ptr [RBP + -0x48]
MOV RDI,R14
CALL 0x00135402
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0x14
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x00130878
LAB_00130862:
XOR R15D,R15D
JMP 0x0013087e
LAB_00130867:
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JNZ 0x0013087e
LAB_00130878:
MOV R15D,0xffffffff
LAB_0013087e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0013089b
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013089b:
CALL 0x00113510
|
int8 native_password_auth_client(int8 *param_1,long param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int iVar5;
int8 uVar6;
long in_FS_OFFSET;
int4 *local_50;
int8 local_48;
int5 uStack_40;
int3 uStack_3b;
int5 uStack_38;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
if (*(char *)(param_1 + 9) == '\0') {
iVar5 = (*(code *)*param_1)(param_1,&local_50);
if (-1 < iVar5) {
uVar6 = 0x7dc;
if (iVar5 != 0x15) goto LAB_0013087e;
uVar1 = *local_50;
uVar2 = local_50[1];
uVar3 = local_50[2];
uVar4 = local_50[3];
*(int4 *)(param_2 + 0x49e) = local_50[4];
*(int4 *)(param_2 + 0x48e) = uVar1;
*(int4 *)(param_2 + 0x492) = uVar2;
*(int4 *)(param_2 + 0x496) = uVar3;
*(int4 *)(param_2 + 0x49a) = uVar4;
*(int1 *)(param_2 + 0x4a2) = 0;
goto LAB_00130825;
}
LAB_00130862:
uVar6 = 0;
goto LAB_0013087e;
}
local_50 = (int4 *)(param_2 + 0x48e);
if (param_2 == 0) {
LAB_00130867:
uVar6 = 0;
iVar5 = (*(code *)param_1[1])(param_1,0,0);
if (iVar5 != 0) goto LAB_0013087e;
}
else {
LAB_00130825:
if (**(char **)(param_2 + 0x2c0) == '\0') goto LAB_00130867;
local_48 = 0;
uStack_40 = 0;
uStack_3b = 0;
uStack_38 = 0;
ma_scramble_41(&local_48,local_50);
iVar5 = (*(code *)param_1[1])(param_1,&local_48,0x14);
if (iVar5 != 0) goto LAB_00130862;
}
uVar6 = 0xffffffff;
LAB_0013087e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_28) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
| |
30,052 | testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | giladroyz[P]FindPeaks/build_O0/_deps/googletest-src/googletest/src/gtest.cc | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
stream->write(segment,
static_cast<std::streamsize>(next_segment - segment));
*stream << "]]>]]><![CDATA[";
segment = next_segment + strlen("]]>");
} else {
*stream << segment;
break;
}
}
*stream << "]]>";
} | O0 | cpp | testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x49f7f(%rip), %rsi # 0x7ba82
callq 0xa600
movq -0x18(%rbp), %rdi
leaq 0x49f62(%rip), %rsi # 0x7ba75
callq 0xa130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x31b59
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0xa930
movq -0x8(%rbp), %rdi
leaq 0x49f33(%rip), %rsi # 0x7ba79
callq 0xa600
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x31b68
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa600
jmp 0x31b6a
jmp 0x31b08
movq -0x8(%rbp), %rdi
leaq 0x49f00(%rip), %rsi # 0x7ba75
callq 0xa600
addq $0x20, %rsp
popq %rbp
retq
| _ZN7testing8internal24XmlUnitTestResultPrinter21OutputXmlCDataSectionEPSoPKc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
lea rsi, aGtCdata+9; "<![CDATA["
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_31B08:
mov rdi, [rbp+var_18]
lea rsi, asc_7BA75; "]]>"
call _strstr
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_31B59
mov rdi, [rbp+var_8]; this
mov rsi, [rbp+var_18]; char *
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax; __int64
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov rdi, [rbp+var_8]
lea rsi, aGtCdata; "]]>]]><![CDATA["
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rax, [rbp+var_20]
add rax, 3
mov [rbp+var_18], rax
jmp short loc_31B68
loc_31B59:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short loc_31B6A
loc_31B68:
jmp short loc_31B08
loc_31B6A:
mov rdi, [rbp+var_8]
lea rsi, asc_7BA75; "]]>"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
add rsp, 20h
pop rbp
retn
| long long testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(
testing::internal::XmlUnitTestResultPrinter *this,
std::ostream *a2,
const char *a3)
{
long long i; // rax
long long v5; // [rsp+0h] [rbp-20h]
char *v6; // [rsp+8h] [rbp-18h]
v6 = (char *)a2;
std::operator<<<std::char_traits<char>>(this, "<![CDATA[");
for ( i = strstr(a2, "]]>"); ; i = strstr(v5 + 3, "]]>") )
{
v5 = i;
if ( !i )
break;
std::ostream::write(this, v6, i - (_QWORD)v6);
std::operator<<<std::char_traits<char>>(this, "]]>]]><![CDATA[");
v6 = (char *)(v5 + 3);
}
std::operator<<<std::char_traits<char>>(this, v6);
return std::operator<<<std::char_traits<char>>(this, "]]>");
}
| OutputXmlCDataSection:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17ba82]
CALL 0x0010a600
LAB_00131b08:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17ba75]
CALL 0x0010a130
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00131b59
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
CALL 0x0010a930
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17ba79]
CALL 0x0010a600
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00131b68
LAB_00131b59:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0010a600
JMP 0x00131b6a
LAB_00131b68:
JMP 0x00131b08
LAB_00131b6a:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17ba75]
CALL 0x0010a600
ADD RSP,0x20
POP RBP
RET
|
/* testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) */
void testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection
(ostream *param_1,char *param_2)
{
char *pcVar1;
char *local_20;
std::operator<<(param_1,"<![CDATA[");
local_20 = param_2;
while( true ) {
pcVar1 = strstr(local_20,"]]>");
if (pcVar1 == (char *)0x0) break;
std::ostream::write((char *)param_1,(long)local_20);
std::operator<<(param_1,"]]>]]><![CDATA[");
local_20 = pcVar1 + 3;
}
std::operator<<(param_1,local_20);
std::operator<<(param_1,"]]>");
return;
}
| |
30,053 | ma_scramble_323 | eloqsql/libmariadb/libmariadb/ma_password.c | char *ma_scramble_323(char *to, const char *message, const char *password)
{
struct rand_struct rand_st;
ulong hash_pass[2], hash_message[2];
if (password && password[0])
{
char extra, *to_start=to;
const char *end_scramble323= message + SCRAMBLE_LENGTH_323;
ma_hash_password(hash_pass,password, (uint) strlen(password));
/* Don't use strlen, could be > SCRAMBLE_LENGTH_323 ! */
ma_hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
ma_randominit(&rand_st, hash_pass[0] ^ hash_message[0],
hash_pass[1] ^ hash_message[1]);
for (; message < end_scramble323; message++)
*to++= (char) (floor(rnd(&rand_st) * 31) + 64);
extra=(char) (floor(rnd(&rand_st) * 31));
while (to_start != to)
*(to_start++)^= extra;
}
*to= 0;
return to;
} | O3 | c | ma_scramble_323:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3970f
movq %rdx, %r15
cmpb $0x0, (%rdx)
je 0x3970f
movq %rsi, %r14
movq %r15, %rdi
callq 0x131c0
movl %eax, %edx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x39360
leaq -0x40(%rbp), %r15
movl $0x8, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x39360
movq (%r15), %rsi
movq 0x8(%r15), %rcx
xorq (%r12), %rsi
xorq 0x8(%r12), %rcx
movabsq $0x400000011, %r12 # imm = 0x400000011
movq %rsi, %rax
mulq %r12
movq %rsi, %r13
subq %rdx, %r13
shrq %r13
addq %rdx, %r13
shrq $0x1d, %r13
movq %r13, %rax
shlq $0x1e, %rax
subq %rax, %r13
addq %rsi, %r13
movq %rcx, %rax
mulq %r12
movq %rcx, %rsi
subq %rdx, %rsi
shrq %rsi
addq %rdx, %rsi
shrq $0x1d, %rsi
movq %rsi, %rax
shlq $0x1e, %rax
subq %rax, %rsi
addq %rcx, %rsi
xorl %r15d, %r15d
leaq (,%r13,2), %rcx
addq %r13, %rcx
addq %rsi, %rcx
movq %rcx, %rax
mulq %r12
movq %rcx, %r13
subq %rdx, %r13
shrq %r13
addq %rdx, %r13
shrq $0x1d, %r13
movq %r13, %rax
shlq $0x1e, %rax
subq %rax, %r13
addq %rcx, %r13
leaq (%rsi,%r13), %r14
addq $0x21, %r14
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
divsd 0x6cdd(%rip), %xmm0 # 0x40340
mulsd 0x6cdd(%rip), %xmm0 # 0x40348
callq 0x137c0
addsd 0x6cd8(%rip), %xmm0 # 0x40350
cvttsd2si %xmm0, %eax
movb %al, (%rbx,%r15)
movq %r14, %rax
mulq %r12
incq %r15
movq %r14, %rsi
subq %rdx, %rsi
shrq %rsi
addq %rdx, %rsi
shrq $0x1d, %rsi
movq %rsi, %rax
shlq $0x1e, %rax
subq %rax, %rsi
addq %r14, %rsi
cmpq $0x8, %r15
jne 0x3961a
leal (%r13,%r13,2), %eax
addl %eax, %esi
leaq (%rsi,%rsi,4), %rax
shrq $0x20, %rax
movl %esi, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x1d, %ecx
movl %ecx, %eax
shll $0x1e, %eax
subl %eax, %ecx
addl %esi, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd 0x6c5e(%rip), %xmm0 # 0x40340
mulsd 0x6c5e(%rip), %xmm0 # 0x40348
callq 0x137c0
cvttsd2si %xmm0, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
movq (%rbx), %xmm1
pxor %xmm0, %xmm1
movq %xmm1, (%rbx)
addq %r15, %rbx
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_scramble_323:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
test rdx, rdx
jz loc_3970F
mov r15, rdx
cmp byte ptr [rdx], 0
jz loc_3970F
mov r14, rsi
mov rdi, r15
call _strlen
mov edx, eax
lea r12, [rbp+var_50]
mov rdi, r12
mov rsi, r15
call ma_hash_password
lea r15, [rbp+var_40]
mov edx, 8
mov rdi, r15
mov rsi, r14
call ma_hash_password
mov rsi, [r15]
mov rcx, [r15+8]
xor rsi, [r12]
xor rcx, [r12+8]
mov r12, 400000011h
mov rax, rsi
mul r12
mov r13, rsi
sub r13, rdx
shr r13, 1
add r13, rdx
shr r13, 1Dh
mov rax, r13
shl rax, 1Eh
sub r13, rax
add r13, rsi
mov rax, rcx
mul r12
mov rsi, rcx
sub rsi, rdx
shr rsi, 1
add rsi, rdx
shr rsi, 1Dh
mov rax, rsi
shl rax, 1Eh
sub rsi, rax
add rsi, rcx
xor r15d, r15d
loc_3961A:
lea rcx, ds:0[r13*2]
add rcx, r13
add rcx, rsi
mov rax, rcx
mul r12
mov r13, rcx
sub r13, rdx
shr r13, 1
add r13, rdx
shr r13, 1Dh
mov rax, r13
shl rax, 1Eh
sub r13, rax
add r13, rcx
lea r14, [rsi+r13]
add r14, 21h ; '!'
xorps xmm0, xmm0
cvtsi2sd xmm0, r13d
divsd xmm0, cs:qword_40340
mulsd xmm0, cs:qword_40348
call _floor
addsd xmm0, cs:qword_40350
cvttsd2si eax, xmm0
mov [rbx+r15], al
mov rax, r14
mul r12
inc r15
mov rsi, r14
sub rsi, rdx
shr rsi, 1
add rsi, rdx
shr rsi, 1Dh
mov rax, rsi
shl rax, 1Eh
sub rsi, rax
add rsi, r14
cmp r15, 8
jnz loc_3961A
lea eax, [r13+r13*2+0]
add esi, eax
lea rax, [rsi+rsi*4]
shr rax, 20h
mov ecx, esi
sub ecx, eax
shr ecx, 1
add ecx, eax
shr ecx, 1Dh
mov eax, ecx
shl eax, 1Eh
sub ecx, eax
add ecx, esi
xorps xmm0, xmm0
cvtsi2sd xmm0, ecx
divsd xmm0, cs:qword_40340
mulsd xmm0, cs:qword_40348
call _floor
cvttsd2si eax, xmm0
movd xmm0, eax
punpcklbw xmm0, xmm0
pshuflw xmm0, xmm0, 0
movq xmm1, qword ptr [rbx]
pxor xmm1, xmm0
movq qword ptr [rbx], xmm1
add rbx, r15
loc_3970F:
mov byte ptr [rbx], 0
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __m128i * ma_scramble_323(__m128i *a1, unsigned __int8 *a2, unsigned __int8 *a3)
{
__m128i *v3; // rbx
unsigned int v5; // eax
unsigned long long v6; // r13
unsigned long long v7; // rsi
long long i; // r15
__m128i v9; // xmm0
long long v11[2]; // [rsp+0h] [rbp-50h] BYREF
long long v12[8]; // [rsp+10h] [rbp-40h] BYREF
v3 = a1;
if ( a3 && *a3 )
{
v5 = strlen(a3);
ma_hash_password(v11, a3, v5);
ma_hash_password(v12, a2, 8LL);
v6 = (v11[0] ^ v12[0]) % 0x3FFFFFFFuLL;
v7 = (v11[1] ^ v12[1]) % 0x3FFFFFFFuLL;
for ( i = 0LL; i != 8; ++i )
{
v6 = (v7 + 3 * v6) % 0x3FFFFFFF;
a1->m128i_i8[i] = (int)(floor((double)(int)v6 / 1073741823.0 * 31.0) + 64.0);
v7 = (v7 + v6 + 33) % 0x3FFFFFFF;
}
v9 = _mm_cvtsi32_si128((int)floor((double)((3 * (int)v6 + (int)v7) % 0x3FFFFFFFu) / 1073741823.0 * 31.0));
a1->m128i_i64[0] = _mm_xor_si128(_mm_loadl_epi64(a1), _mm_shufflelo_epi16(_mm_unpacklo_epi8(v9, v9), 0)).m128i_u64[0];
v3 = (__m128i *)&a1->m128i_u64[1];
}
v3->m128i_i8[0] = 0;
return v3;
}
| ma_scramble_323:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
TEST RDX,RDX
JZ 0x0013970f
MOV R15,RDX
CMP byte ptr [RDX],0x0
JZ 0x0013970f
MOV R14,RSI
MOV RDI,R15
CALL 0x001131c0
MOV EDX,EAX
LEA R12,[RBP + -0x50]
MOV RDI,R12
MOV RSI,R15
CALL 0x00139360
LEA R15,[RBP + -0x40]
MOV EDX,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x00139360
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
XOR RSI,qword ptr [R12]
XOR RCX,qword ptr [R12 + 0x8]
MOV R12,0x400000011
MOV RAX,RSI
MUL R12
MOV R13,RSI
SUB R13,RDX
SHR R13,0x1
ADD R13,RDX
SHR R13,0x1d
MOV RAX,R13
SHL RAX,0x1e
SUB R13,RAX
ADD R13,RSI
MOV RAX,RCX
MUL R12
MOV RSI,RCX
SUB RSI,RDX
SHR RSI,0x1
ADD RSI,RDX
SHR RSI,0x1d
MOV RAX,RSI
SHL RAX,0x1e
SUB RSI,RAX
ADD RSI,RCX
XOR R15D,R15D
LAB_0013961a:
LEA RCX,[R13*0x2]
ADD RCX,R13
ADD RCX,RSI
MOV RAX,RCX
MUL R12
MOV R13,RCX
SUB R13,RDX
SHR R13,0x1
ADD R13,RDX
SHR R13,0x1d
MOV RAX,R13
SHL RAX,0x1e
SUB R13,RAX
ADD R13,RCX
LEA R14,[RSI + R13*0x1]
ADD R14,0x21
XORPS XMM0,XMM0
CVTSI2SD XMM0,R13D
DIVSD XMM0,qword ptr [0x00140340]
MULSD XMM0,qword ptr [0x00140348]
CALL 0x001137c0
ADDSD XMM0,qword ptr [0x00140350]
CVTTSD2SI EAX,XMM0
MOV byte ptr [RBX + R15*0x1],AL
MOV RAX,R14
MUL R12
INC R15
MOV RSI,R14
SUB RSI,RDX
SHR RSI,0x1
ADD RSI,RDX
SHR RSI,0x1d
MOV RAX,RSI
SHL RAX,0x1e
SUB RSI,RAX
ADD RSI,R14
CMP R15,0x8
JNZ 0x0013961a
LEA EAX,[R13 + R13*0x2]
ADD ESI,EAX
LEA RAX,[RSI + RSI*0x4]
SHR RAX,0x20
MOV ECX,ESI
SUB ECX,EAX
SHR ECX,0x1
ADD ECX,EAX
SHR ECX,0x1d
MOV EAX,ECX
SHL EAX,0x1e
SUB ECX,EAX
ADD ECX,ESI
XORPS XMM0,XMM0
CVTSI2SD XMM0,ECX
DIVSD XMM0,qword ptr [0x00140340]
MULSD XMM0,qword ptr [0x00140348]
CALL 0x001137c0
CVTTSD2SI EAX,XMM0
MOVD XMM0,EAX
PUNPCKLBW XMM0,XMM0
PSHUFLW XMM0,XMM0,0x0
MOVQ XMM1,qword ptr [RBX]
PXOR XMM1,XMM0
MOVQ qword ptr [RBX],XMM1
ADD RBX,R15
LAB_0013970f:
MOV byte ptr [RBX],0x0
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong * ma_scramble_323(ulong *param_1,int8 param_2,char *param_3)
{
int iVar1;
size_t sVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
int1 uVar8;
int1 uVar9;
int1 uVar10;
double dVar6;
int1 auVar7 [16];
ulong local_58;
ulong local_50;
ulong local_48;
ulong local_40;
if ((param_3 != (char *)0x0) && (*param_3 != '\0')) {
sVar2 = strlen(param_3);
ma_hash_password(&local_58,param_3,sVar2 & 0xffffffff);
ma_hash_password(&local_48,param_2,8);
uVar4 = (local_48 ^ local_58) % 0x3fffffff;
uVar3 = (local_40 ^ local_50) % 0x3fffffff;
lVar5 = 0;
do {
uVar4 = (uVar4 * 3 + uVar3) % 0x3fffffff;
dVar6 = floor(((double)(int)uVar4 / _DAT_00140340) * _DAT_00140348);
*(char *)((long)param_1 + lVar5) = (char)(int)(dVar6 + _DAT_00140350);
lVar5 = lVar5 + 1;
uVar3 = (uVar3 + uVar4 + 0x21) % 0x3fffffff;
} while (lVar5 != 8);
dVar6 = floor(((double)((uint)((int)uVar3 + (int)uVar4 * 3) % 0x3fffffff) / _DAT_00140340) *
_DAT_00140348);
iVar1 = (int)dVar6;
uVar10 = (int1)((uint)iVar1 >> 0x18);
uVar9 = (int1)((uint)iVar1 >> 0x10);
uVar8 = (int1)((uint)iVar1 >> 8);
auVar7._4_4_ = (int)(CONCAT35(CONCAT21(CONCAT11(uVar10,uVar10),uVar9),CONCAT14(uVar9,iVar1)) >>
0x20);
auVar7[3] = uVar8;
auVar7[2] = uVar8;
auVar7[0] = (int1)iVar1;
auVar7[1] = auVar7[0];
auVar7._8_8_ = 0;
auVar7 = pshuflw(auVar7,auVar7,0);
*param_1 = *param_1 ^ auVar7._0_8_;
param_1 = param_1 + 1;
}
*(int1 *)param_1 = 0;
return param_1;
}
| |
30,054 | fs_get_cache_directory[abi:cxx11]() | monkey531[P]llama/common/common.cpp | std::string fs_get_cache_directory() {
std::string cache_directory = "";
auto ensure_trailing_slash = [](std::string p) {
// Make sure to add trailing slash
if (p.back() != DIRECTORY_SEPARATOR) {
p += DIRECTORY_SEPARATOR;
}
return p;
};
if (getenv("LLAMA_CACHE")) {
cache_directory = std::getenv("LLAMA_CACHE");
} else {
#ifdef __linux__
if (std::getenv("XDG_CACHE_HOME")) {
cache_directory = std::getenv("XDG_CACHE_HOME");
} else {
cache_directory = std::getenv("HOME") + std::string("/.cache/");
}
#elif defined(__APPLE__)
cache_directory = std::getenv("HOME") + std::string("/Library/Caches/");
#elif defined(_WIN32)
cache_directory = std::getenv("LOCALAPPDATA");
#endif // __linux__
cache_directory = ensure_trailing_slash(cache_directory);
cache_directory += "llama.cpp";
}
return ensure_trailing_slash(cache_directory);
} | O2 | cpp | fs_get_cache_directory[abi:cxx11]():
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x55122(%rip), %rsi # 0xab5d3
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x28b3c
leaq 0x5ded1(%rip), %rdi # 0xb4398
callq 0x23ad0
testq %rax, %rax
je 0x564e3
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x241d0
jmp 0x565bb
leaq 0x5deba(%rip), %rdi # 0xb43a4
callq 0x23ad0
testq %rax, %rax
je 0x56503
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x241d0
jmp 0x56567
leaq 0x5dea4(%rip), %rdi # 0xb43ae
callq 0x23ad0
movq %rax, %r14
leaq 0x5de9a(%rip), %rsi # 0xb43b3
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x28b3c
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movq %r14, %rsi
callq 0x59ebe
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x23af0
movq %r14, %rdi
callq 0x242a8
leaq 0x90(%rsp), %rdi
callq 0x242a8
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x23c60
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5663a
leaq 0x10(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x23af0
movq %r15, %rdi
callq 0x242a8
leaq 0x70(%rsp), %rdi
callq 0x242a8
leaq 0x5de09(%rip), %rsi # 0xb43bc
movq %r14, %rdi
callq 0x241c0
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x23c60
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x5663a
leaq 0x50(%rsp), %rdi
callq 0x242a8
leaq 0x10(%rsp), %rdi
callq 0x242a8
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x5661e
jmp 0x56625
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x5661e
jmp 0x56625
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x242a8
jmp 0x56628
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x242a8
movq %rbx, %rdi
callq 0x24030
| _Z22fs_get_cache_directoryB5cxx11v:
push r15
push r14
push rbx
sub rsp, 0B0h
mov rbx, rdi
lea rsi, aInfillMode+1Ch; ""
lea rdi, [rsp+0C8h+var_B8]
lea rdx, [rsp+0C8h+var_98]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, aLlamaCache; "LLAMA_CACHE"
call _getenv
test rax, rax
jz short loc_564E3
lea rdi, [rsp+0C8h+var_B8]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
jmp loc_565BB
loc_564E3:
lea rdi, aXdgCacheHome; "XDG_CACHE_HOME"
call _getenv
test rax, rax
jz short loc_56503
lea rdi, [rsp+0C8h+var_B8]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
jmp short loc_56567
loc_56503:
lea rdi, aXdgCacheHome+0Ah; "HOME"
call _getenv
mov r14, rax
lea rsi, aCache; "/.cache/"
lea rdi, [rsp+0C8h+var_38]
lea rdx, [rsp+0C8h+var_B9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+0C8h+var_98]
lea rdx, [rsp+0C8h+var_38]
mov rsi, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdi, [rsp+0C8h+var_B8]
lea r14, [rsp+0C8h+var_98]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_56567:
lea rdi, [rsp+0C8h+var_58]
lea rsi, [rsp+0C8h+var_B8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+0C8h+var_98]
lea rsi, [rsp+0C8h+var_58]
call _ZZ22fs_get_cache_directoryB5cxx11vENK3$_0clENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_get_cache_directory(void)::$_0::operator()(std::string)
lea r14, [rsp+0C8h+var_B8]
lea r15, [rsp+0C8h+var_98]
mov rdi, r14
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rsi, aLlamaCpp; "llama.cpp"
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_565BB:
lea rdi, [rsp+0C8h+var_78]
lea rsi, [rsp+0C8h+var_B8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rsi, [rsp+0C8h+var_78]
mov rdi, rbx
call _ZZ22fs_get_cache_directoryB5cxx11vENK3$_0clENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_get_cache_directory(void)::$_0::operator()(std::string)
lea rdi, [rsp+0C8h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 0B0h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_88]
jmp short loc_5661E
jmp short loc_56625
mov rbx, rax
lea rdi, [rsp+arg_68]
jmp short loc_5661E
jmp short loc_56625
mov rbx, rax
lea rdi, [rsp+arg_48]; void *
loc_5661E:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_56628
loc_56625:
mov rbx, rax
loc_56628:
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long fs_get_cache_directory[abi:cxx11](long long a1)
{
long long v1; // rax
long long v2; // rax
long long v3; // r14
_QWORD v5[4]; // [rsp+10h] [rbp-B8h] BYREF
_BYTE v6[32]; // [rsp+30h] [rbp-98h] BYREF
_BYTE v7[32]; // [rsp+50h] [rbp-78h] BYREF
_BYTE v8[32]; // [rsp+70h] [rbp-58h] BYREF
_QWORD v9[7]; // [rsp+90h] [rbp-38h] BYREF
std::string::basic_string<std::allocator<char>>(v5, (long long)"");
v1 = getenv("LLAMA_CACHE");
if ( v1 )
{
std::string::assign(v5, v1);
}
else
{
v2 = getenv("XDG_CACHE_HOME");
if ( v2 )
{
std::string::assign(v5, v2);
}
else
{
v3 = getenv("HOME");
std::string::basic_string<std::allocator<char>>(v9, (long long)"/.cache/");
std::operator+<char>(v6, v3, v9);
std::string::operator=(v5, v6);
std::string::~string(v6);
std::string::~string(v9);
}
std::string::basic_string(v8, v5);
fs_get_cache_directory[abi:cxx11](void)::$_0::operator()(v6, v8);
std::string::operator=(v5, v6);
std::string::~string(v6);
std::string::~string(v8);
std::string::append(v5, "llama.cpp");
}
std::string::basic_string(v7, v5);
fs_get_cache_directory[abi:cxx11](void)::$_0::operator()(a1, v7);
std::string::~string(v7);
std::string::~string(v5);
return a1;
}
| fs_get_cache_directory[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xb0
MOV RBX,RDI
LEA RSI,[0x1ab5d3]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x30]
CALL 0x00128b3c
LEA RDI,[0x1b4398]
CALL 0x00123ad0
TEST RAX,RAX
JZ 0x001564e3
LAB_001564d1:
LEA RDI,[RSP + 0x10]
MOV RSI,RAX
CALL 0x001241d0
JMP 0x001565bb
LAB_001564e3:
LEA RDI,[0x1b43a4]
CALL 0x00123ad0
TEST RAX,RAX
JZ 0x00156503
LEA RDI,[RSP + 0x10]
MOV RSI,RAX
CALL 0x001241d0
JMP 0x00156567
LAB_00156503:
LEA RDI,[0x1b43ae]
CALL 0x00123ad0
MOV R14,RAX
LAB_00156512:
LEA RSI,[0x1b43b3]
LEA RDI,[RSP + 0x90]
LEA RDX,[RSP + 0xf]
CALL 0x00128b3c
LAB_0015652b:
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x90]
MOV RSI,R14
CALL 0x00159ebe
LEA RDI,[RSP + 0x10]
LEA R14,[RSP + 0x30]
MOV RSI,R14
CALL 0x00123af0
MOV RDI,R14
CALL 0x001242a8
LEA RDI,[RSP + 0x90]
CALL 0x001242a8
LAB_00156567:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x10]
CALL 0x00123c60
LAB_00156576:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x70]
CALL 0x0015663a
LEA R14,[RSP + 0x10]
LEA R15,[RSP + 0x30]
MOV RDI,R14
MOV RSI,R15
CALL 0x00123af0
MOV RDI,R15
CALL 0x001242a8
LEA RDI,[RSP + 0x70]
CALL 0x001242a8
LAB_001565ac:
LEA RSI,[0x1b43bc]
MOV RDI,R14
CALL 0x001241c0
LAB_001565bb:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x10]
CALL 0x00123c60
LAB_001565ca:
LEA RSI,[RSP + 0x50]
MOV RDI,RBX
CALL 0x0015663a
LAB_001565d7:
LEA RDI,[RSP + 0x50]
CALL 0x001242a8
LEA RDI,[RSP + 0x10]
CALL 0x001242a8
MOV RAX,RBX
ADD RSP,0xb0
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* fs_get_cache_directory[abi:cxx11]() */
void fs_get_cache_directory_abi_cxx11_(void)
{
char *pcVar1;
string *psVar2;
allocator local_b9;
string local_b8 [32];
allocator local_98 [32];
string local_78 [32];
string local_58 [32];
string local_38 [32];
std::__cxx11::string::string<std::allocator<char>>(local_b8,"",local_98);
pcVar1 = getenv("LLAMA_CACHE");
if (pcVar1 == (char *)0x0) {
pcVar1 = getenv("XDG_CACHE_HOME");
if (pcVar1 == (char *)0x0) {
psVar2 = (string *)getenv("HOME");
/* try { // try from 00156512 to 0015652a has its CatchHandler @ 00156608 */
std::__cxx11::string::string<std::allocator<char>>(local_38,"/.cache/",&local_b9);
/* try { // try from 0015652b to 0015653f has its CatchHandler @ 001565fb */
std::operator+((char *)local_98,psVar2);
std::__cxx11::string::operator=(local_b8,(string *)local_98);
std::__cxx11::string::~string((string *)local_98);
std::__cxx11::string::~string(local_38);
}
else {
std::__cxx11::string::assign((char *)local_b8);
}
/* try { // try from 00156567 to 00156575 has its CatchHandler @ 00156614 */
std::__cxx11::string::string(local_58,local_b8);
/* try { // try from 00156576 to 00156584 has its CatchHandler @ 0015660a */
fs_get_cache_directory[abi:cxx11]()::$_0::operator()((__0 *)local_98,local_58);
std::__cxx11::string::operator=(local_b8,(string *)local_98);
std::__cxx11::string::~string((string *)local_98);
std::__cxx11::string::~string(local_58);
/* try { // try from 001565ac to 001565c9 has its CatchHandler @ 00156625 */
std::__cxx11::string::append((char *)local_b8);
}
else {
/* try { // try from 001564d1 to 00156500 has its CatchHandler @ 00156625 */
std::__cxx11::string::assign((char *)local_b8);
}
std::__cxx11::string::string(local_78,local_b8);
/* try { // try from 001565ca to 001565d6 has its CatchHandler @ 00156616 */
fs_get_cache_directory[abi:cxx11]()::$_0::operator()();
std::__cxx11::string::~string(local_78);
std::__cxx11::string::~string(local_b8);
return;
}
| |
30,055 | fs_get_cache_directory[abi:cxx11]() | monkey531[P]llama/common/common.cpp | std::string fs_get_cache_directory() {
std::string cache_directory = "";
auto ensure_trailing_slash = [](std::string p) {
// Make sure to add trailing slash
if (p.back() != DIRECTORY_SEPARATOR) {
p += DIRECTORY_SEPARATOR;
}
return p;
};
if (getenv("LLAMA_CACHE")) {
cache_directory = std::getenv("LLAMA_CACHE");
} else {
#ifdef __linux__
if (std::getenv("XDG_CACHE_HOME")) {
cache_directory = std::getenv("XDG_CACHE_HOME");
} else {
cache_directory = std::getenv("HOME") + std::string("/.cache/");
}
#elif defined(__APPLE__)
cache_directory = std::getenv("HOME") + std::string("/Library/Caches/");
#elif defined(_WIN32)
cache_directory = std::getenv("LOCALAPPDATA");
#endif // __linux__
cache_directory = ensure_trailing_slash(cache_directory);
cache_directory += "llama.cpp";
}
return ensure_trailing_slash(cache_directory);
} | O3 | cpp | fs_get_cache_directory[abi:cxx11]():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x721ac(%rip), %rdx # 0xe85d3
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x24458
leaq 0x7af6d(%rip), %rdi # 0xf13a8
callq 0x1baa0
testq %rax, %rax
je 0x76471
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x1b3f0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1bdf0
jmp 0x7665f
leaq 0x7af3c(%rip), %rdi # 0xf13b4
callq 0x1baa0
testq %rax, %rax
je 0x764ae
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x1b3f0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1bdf0
jmp 0x7658e
leaq 0x7af09(%rip), %rdi # 0xf13be
callq 0x1baa0
movq %rax, %r14
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7aef3(%rip), %rsi # 0xf13c3
leaq 0x7aef4(%rip), %rdx # 0xf13cb
leaq 0x80(%rsp), %rdi
callq 0x24458
movq %r14, %rdi
callq 0x1b3f0
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x1b9f0
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7652b
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
jmp 0x76533
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x60(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1bac0
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x76571
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x7658e
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x24328
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x765cd
movq %rsp, %rdi
movl $0x2f, %esi
callq 0x1b750
movq (%rsp), %rax
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
cmpq %r15, %rax
je 0x765ed
movq %rax, 0x60(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x765f6
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rax
leaq 0x60(%rsp), %r14
movq %rax, 0x8(%r14)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1bac0
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x76638
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7664e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x7ad77(%rip), %rsi # 0xf13cc
leaq 0x20(%rsp), %rdi
callq 0x1c1b0
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x24328
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x766a4
leaq 0x40(%rsp), %rdi
movl $0x2f, %esi
callq 0x1b750
movq 0x40(%rsp), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
cmpq %r14, %rax
je 0x766be
movq %rax, (%rbx)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x766c5
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movb $0x0, 0x50(%rsp)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x766f8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x7675c
movq 0x90(%rsp), %rsi
jmp 0x7674f
jmp 0x76759
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7675c
movq 0x10(%rsp), %rsi
jmp 0x7674f
jmp 0x76759
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x7675c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x7675c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x76773
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq %rbx, %rdi
callq 0x1c030
| _Z22fs_get_cache_directoryB5cxx11v:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A0h
mov rbx, rdi
lea r13, [rsp+0C8h+var_98]
mov [r13-10h], r13
lea rdx, aInfillMode+1Ch; ""
lea rdi, [rsp+0C8h+var_A8]
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, aLlamaCache; "LLAMA_CACHE"
call _getenv
test rax, rax
jz short loc_76471
mov r14, rax
lea r15, [rsp+0C8h+var_A8]
mov r12, [r15+8]
mov rdi, rax
call _strlen
mov rdi, r15
xor esi, esi
mov rdx, r12
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_7665F
loc_76471:
lea rdi, aXdgCacheHome; "XDG_CACHE_HOME"
call _getenv
test rax, rax
jz short loc_764AE
mov r14, rax
lea r15, [rsp+0C8h+var_A8]
mov r12, [r15+8]
mov rdi, rax
call _strlen
mov rdi, r15
xor esi, esi
mov rdx, r12
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_7658E
loc_764AE:
lea rdi, aXdgCacheHome+0Ah; "HOME"
call _getenv
mov r14, rax
lea r15, [rsp+0C8h+var_38]
mov [r15-10h], r15
lea rsi, aCache; "/.cache/"
lea rdx, aCache+8; ""
lea rdi, [rsp+0C8h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, r14
call _strlen
lea rdi, [rsp+0C8h+var_48]
xor esi, esi
xor edx, edx
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r12, [rsp+0C8h+var_58]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_7652B
mov [rsp+0C8h+var_68], rdx
mov rdx, [rcx]
mov [rsp+0C8h+var_58], rdx
jmp short loc_76533
loc_7652B:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_76533:
mov rdx, [rax+8]
lea r14, [rsp+0C8h+var_68]
mov [r14+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0C8h+var_A8]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_76571
mov rsi, [rsp+0C8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76571:
mov rdi, [rsp+0C8h+var_48]; void *
cmp rdi, r15
jz short loc_7658E
mov rsi, [rsp+0C8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7658E:
lea r15, [rsp+0C8h+var_B8]
mov [r15-10h], r15
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
add rdx, rsi
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [rsp+0C8h+var_C8]
mov rcx, [rsp+0C8h+var_C0]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_765CD
mov rdi, rsp
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0C8h+var_C8]
loc_765CD:
lea r12, [rsp+0C8h+var_58]
mov [r12-10h], r12
cmp rax, r15
jz short loc_765ED
mov [rsp+0C8h+var_68], rax
mov rax, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_58], rax
jmp short loc_765F6
loc_765ED:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [r12], xmm0
loc_765F6:
mov rax, [rsp+0C8h+var_C0]
lea r14, [rsp+0C8h+var_68]
mov [r14+8], rax
mov [rsp+0C8h+var_C8], r15
mov [rsp+0C8h+var_C0], 0
mov byte ptr [rsp+0C8h+var_B8], 0
lea rdi, [rsp+0C8h+var_A8]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_76638
mov rsi, [rsp+0C8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76638:
mov rdi, [rsp+0C8h+var_C8]; void *
cmp rdi, r15
jz short loc_7664E
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7664E:
lea rsi, aLlamaCpp; "llama.cpp"
lea rdi, [rsp+0C8h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_7665F:
lea r14, [rsp+0C8h+var_78]
mov [r14-10h], r14
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
add rdx, rsi
lea rdi, [rsp+0C8h+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [rsp+0C8h+var_88]
mov rcx, [rsp+0C8h+var_80]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_766A4
lea rdi, [rsp+0C8h+var_88]
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0C8h+var_88]
loc_766A4:
lea rcx, [rbx+10h]
mov [rbx], rcx
cmp rax, r14
jz short loc_766BE
mov [rbx], rax
mov rax, [rsp+0C8h+var_78]
mov [rbx+10h], rax
jmp short loc_766C5
loc_766BE:
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [rcx], xmm0
loc_766C5:
mov rax, [rsp+0C8h+var_80]
mov [rbx+8], rax
mov [rsp+0C8h+var_88], r14
mov [rsp+0C8h+var_80], 0
mov byte ptr [rsp+0C8h+var_78], 0
mov rdi, [rsp+0C8h+var_A8]; void *
cmp rdi, r13
jz short loc_766F8
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_766F8:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_78]
cmp rdi, r15
jz short loc_7675C
mov rsi, [rsp+arg_88]
jmp short loc_7674F
jmp short loc_76759
mov rbx, rax
mov rdi, [rsp+0]
cmp rdi, r15
jz short loc_7675C
mov rsi, [rsp+arg_8]
jmp short loc_7674F
jmp short loc_76759
mov rbx, rax
mov rdi, [rsp+arg_38]; void *
cmp rdi, r14
jz short loc_7675C
mov rsi, [rsp+arg_48]
loc_7674F:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7675C
loc_76759:
mov rbx, rax
loc_7675C:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r13
jz short loc_76773
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76773:
mov rdi, rbx
call __Unwind_Resume
| long long fs_get_cache_directory[abi:cxx11](long long a1)
{
long long v1; // rax
long long v2; // r14
long long v3; // r12
long long v4; // rax
long long v5; // rax
long long v6; // r14
long long v7; // r12
long long v8; // rax
long long v9; // r14
long long v10; // rax
long long v11; // rax
__int128 *v12; // rcx
__int128 *v13; // rax
__int128 *v14; // rax
void *v16; // [rsp+0h] [rbp-C8h] BYREF
long long v17; // [rsp+8h] [rbp-C0h]
__int128 v18; // [rsp+10h] [rbp-B8h] BYREF
void *v19; // [rsp+20h] [rbp-A8h] BYREF
long long v20; // [rsp+28h] [rbp-A0h]
_QWORD v21[2]; // [rsp+30h] [rbp-98h] BYREF
__int128 *v22; // [rsp+40h] [rbp-88h] BYREF
long long v23; // [rsp+48h] [rbp-80h]
__int128 v24; // [rsp+50h] [rbp-78h] BYREF
__int128 *v25; // [rsp+60h] [rbp-68h] BYREF
long long v26; // [rsp+68h] [rbp-60h]
__int128 v27; // [rsp+70h] [rbp-58h] BYREF
void *v28[2]; // [rsp+80h] [rbp-48h] BYREF
_QWORD v29[7]; // [rsp+90h] [rbp-38h] BYREF
v19 = v21;
std::string::_M_construct<char const*>((long long)&v19, "", (long long)"");
v1 = getenv("LLAMA_CACHE");
if ( v1 )
{
v2 = v1;
v3 = v20;
v4 = strlen(v1);
std::string::_M_replace(&v19, 0LL, v3, v2, v4);
}
else
{
v5 = getenv("XDG_CACHE_HOME");
if ( v5 )
{
v6 = v5;
v7 = v20;
v8 = strlen(v5);
std::string::_M_replace(&v19, 0LL, v7, v6, v8);
}
else
{
v9 = getenv("HOME");
v28[0] = v29;
std::string::_M_construct<char const*>((long long)v28, "/.cache/", (long long)"");
v10 = strlen(v9);
v11 = std::string::replace(v28, 0LL, 0LL, v9, v10);
v25 = &v27;
v12 = (__int128 *)(v11 + 16);
if ( *(_QWORD *)v11 == v11 + 16 )
{
v27 = *v12;
}
else
{
v25 = *(__int128 **)v11;
*(_QWORD *)&v27 = *(_QWORD *)v12;
}
v26 = *(_QWORD *)(v11 + 8);
*(_QWORD *)v11 = v12;
*(_QWORD *)(v11 + 8) = 0LL;
*(_BYTE *)(v11 + 16) = 0;
std::string::operator=(&v19, &v25);
if ( v25 != &v27 )
operator delete(v25, v27 + 1);
if ( v28[0] != v29 )
operator delete(v28[0], v29[0] + 1LL);
}
v16 = &v18;
std::string::_M_construct<char *>((long long)&v16, v19, (long long)v19 + v20);
v13 = (__int128 *)v16;
if ( *((char *)v16 + v17 - 1) != 47 )
{
std::string::push_back(&v16, 47LL);
v13 = (__int128 *)v16;
}
v25 = &v27;
if ( v13 == &v18 )
{
v27 = v18;
}
else
{
v25 = v13;
*(_QWORD *)&v27 = v18;
}
v26 = v17;
v16 = &v18;
v17 = 0LL;
LOBYTE(v18) = 0;
std::string::operator=(&v19, &v25);
if ( v25 != &v27 )
operator delete(v25, v27 + 1);
if ( v16 != &v18 )
operator delete(v16, v18 + 1);
std::string::append(&v19, "llama.cpp");
}
v22 = &v24;
std::string::_M_construct<char *>((long long)&v22, v19, (long long)v19 + v20);
v14 = v22;
if ( *((_BYTE *)v22 + v23 - 1) != 47 )
{
std::string::push_back(&v22, 47LL);
v14 = v22;
}
*(_QWORD *)a1 = a1 + 16;
if ( v14 == &v24 )
{
*(_OWORD *)(a1 + 16) = v24;
}
else
{
*(_QWORD *)a1 = v14;
*(_QWORD *)(a1 + 16) = v24;
}
*(_QWORD *)(a1 + 8) = v23;
v22 = &v24;
v23 = 0LL;
LOBYTE(v24) = 0;
if ( v19 != v21 )
operator delete(v19, v21[0] + 1LL);
return a1;
}
| fs_get_cache_directory[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV RBX,RDI
LEA R13,[RSP + 0x30]
MOV qword ptr [R13 + -0x10],R13
LEA RDX,[0x1e85d3]
LEA RDI,[RSP + 0x20]
MOV RSI,RDX
CALL 0x00124458
LEA RDI,[0x1f13a8]
CALL 0x0011baa0
TEST RAX,RAX
JZ 0x00176471
MOV R14,RAX
LEA R15,[RSP + 0x20]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x0011b3f0
LAB_00176459:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x0011bdf0
JMP 0x0017665f
LAB_00176471:
LEA RDI,[0x1f13b4]
CALL 0x0011baa0
TEST RAX,RAX
JZ 0x001764ae
MOV R14,RAX
LEA R15,[RSP + 0x20]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x0011b3f0
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x0011bdf0
JMP 0x0017658e
LAB_001764ae:
LEA RDI,[0x1f13be]
CALL 0x0011baa0
MOV R14,RAX
LEA R15,[RSP + 0x90]
MOV qword ptr [R15 + -0x10],R15
LAB_001764c9:
LEA RSI,[0x1f13c3]
LEA RDX,[0x1f13cb]
LEA RDI,[RSP + 0x80]
CALL 0x00124458
MOV RDI,R14
CALL 0x0011b3f0
LAB_001764ec:
LEA RDI,[RSP + 0x80]
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R14
MOV R8,RAX
CALL 0x0011b9f0
LEA R12,[RSP + 0x70]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0017652b
MOV qword ptr [RSP + 0x60],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x70],RDX
JMP 0x00176533
LAB_0017652b:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00176533:
MOV RDX,qword ptr [RAX + 0x8]
LEA R14,[RSP + 0x60]
MOV qword ptr [R14 + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RDI,[RSP + 0x20]
MOV RSI,R14
CALL 0x0011bac0
MOV RDI,qword ptr [R14]
CMP RDI,R12
JZ 0x00176571
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011b8e0
LAB_00176571:
MOV RDI,qword ptr [RSP + 0x80]
CMP RDI,R15
JZ 0x0017658e
MOV RSI,qword ptr [RSP + 0x90]
INC RSI
CALL 0x0011b8e0
LAB_0017658e:
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LAB_001765a4:
MOV RDI,RSP
CALL 0x00124328
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x001765cd
LAB_001765bc:
MOV RDI,RSP
MOV ESI,0x2f
CALL 0x0011b750
MOV RAX,qword ptr [RSP]
LAB_001765cd:
LEA R12,[RSP + 0x70]
MOV qword ptr [R12 + -0x10],R12
CMP RAX,R15
JZ 0x001765ed
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
JMP 0x001765f6
LAB_001765ed:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [R12],XMM0
LAB_001765f6:
MOV RAX,qword ptr [RSP + 0x8]
LEA R14,[RSP + 0x60]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA RDI,[RSP + 0x20]
MOV RSI,R14
CALL 0x0011bac0
MOV RDI,qword ptr [R14]
CMP RDI,R12
JZ 0x00176638
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011b8e0
LAB_00176638:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x0017664e
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b8e0
LAB_0017664e:
LEA RSI,[0x1f13cc]
LEA RDI,[RSP + 0x20]
CALL 0x0011c1b0
LAB_0017665f:
LEA R14,[RSP + 0x50]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LEA RDI,[RSP + 0x40]
CALL 0x00124328
MOV RAX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x48]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x001766a4
LAB_00176690:
LEA RDI,[RSP + 0x40]
MOV ESI,0x2f
CALL 0x0011b750
LAB_0017669f:
MOV RAX,qword ptr [RSP + 0x40]
LAB_001766a4:
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
CMP RAX,R14
JZ 0x001766be
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RBX + 0x10],RAX
JMP 0x001766c5
LAB_001766be:
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RCX],XMM0
LAB_001766c5:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RBX + 0x8],RAX
MOV qword ptr [RSP + 0x40],R14
MOV qword ptr [RSP + 0x48],0x0
MOV byte ptr [RSP + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R13
JZ 0x001766f8
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011b8e0
LAB_001766f8:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* fs_get_cache_directory[abi:cxx11]() */
void fs_get_cache_directory_abi_cxx11_(void)
{
char *pcVar1;
char *pcVar2;
long *plVar3;
long *plVar4;
long *in_RDI;
long *local_c8;
long local_c0;
int1 local_b8;
int7 uStack_b7;
long lStack_b0;
long *local_a8;
char *local_a0;
long local_98 [2];
int1 *local_88;
long local_80;
int1 local_78;
int7 uStack_77;
long lStack_70;
long *local_68;
long local_60;
long local_58;
long lStack_50;
long *local_48 [2];
long local_38 [2];
local_a8 = local_98;
std::__cxx11::string::_M_construct<char_const*>(&local_a8);
pcVar1 = getenv("LLAMA_CACHE");
pcVar2 = local_a0;
if (pcVar1 == (char *)0x0) {
pcVar1 = getenv("XDG_CACHE_HOME");
pcVar2 = local_a0;
if (pcVar1 == (char *)0x0) {
pcVar2 = getenv("HOME");
/* try { // try from 001764c9 to 001764e3 has its CatchHandler @ 00176726 */
local_48[0] = local_38;
std::__cxx11::string::_M_construct<char_const*>(local_48,"/.cache/","");
strlen(pcVar2);
/* try { // try from 001764ec to 00176502 has its CatchHandler @ 0017670c */
plVar3 = (long *)std::__cxx11::string::replace((ulong)local_48,0,(char *)0x0,(ulong)pcVar2);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_58 = *plVar4;
lStack_50 = plVar3[3];
local_68 = &local_58;
}
else {
local_58 = *plVar4;
local_68 = (long *)*plVar3;
}
local_60 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
std::__cxx11::string::operator=((string *)&local_a8,(string *)&local_68);
if (local_68 != &local_58) {
operator_delete(local_68,local_58 + 1);
}
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
}
else {
strlen(pcVar1);
std::__cxx11::string::_M_replace((ulong)&local_a8,0,pcVar2,(ulong)pcVar1);
}
local_c8 = (long *)&local_b8;
/* try { // try from 001765a4 to 001765ab has its CatchHandler @ 0017673b */
std::__cxx11::string::_M_construct<char*>(&local_c8,local_a8,local_a0 + (long)local_a8);
if (*(char *)((long)local_c8 + local_c0 + -1) != '/') {
/* try { // try from 001765bc to 001765c8 has its CatchHandler @ 00176728 */
std::__cxx11::string::push_back((char)&local_c8);
}
local_68 = local_c8;
if (local_c8 == (long *)&local_b8) {
lStack_50 = lStack_b0;
local_68 = &local_58;
}
local_58 = CONCAT71(uStack_b7,local_b8);
local_60 = local_c0;
local_c0 = 0;
local_b8 = 0;
local_c8 = (long *)&local_b8;
std::__cxx11::string::operator=((string *)&local_a8,(string *)&local_68);
if (local_68 != &local_58) {
operator_delete(local_68,local_58 + 1);
}
if (local_c8 != (long *)&local_b8) {
operator_delete(local_c8,CONCAT71(uStack_b7,local_b8) + 1);
}
/* try { // try from 0017664e to 0017667e has its CatchHandler @ 00176759 */
std::__cxx11::string::append((char *)&local_a8);
}
else {
strlen(pcVar1);
/* try { // try from 00176459 to 001764a8 has its CatchHandler @ 00176759 */
std::__cxx11::string::_M_replace((ulong)&local_a8,0,pcVar2,(ulong)pcVar1);
}
local_88 = &local_78;
std::__cxx11::string::_M_construct<char*>(&local_88,local_a8,local_a0 + (long)local_a8);
if (local_88[local_80 + -1] != '/') {
/* try { // try from 00176690 to 0017669e has its CatchHandler @ 0017673d */
std::__cxx11::string::push_back((char)&local_88);
}
*in_RDI = (long)(in_RDI + 2);
if (local_88 == &local_78) {
in_RDI[2] = CONCAT71(uStack_77,local_78);
in_RDI[3] = lStack_70;
}
else {
*in_RDI = (long)local_88;
in_RDI[2] = CONCAT71(uStack_77,local_78);
}
in_RDI[1] = local_80;
local_80 = 0;
local_78 = 0;
if (local_a8 != local_98) {
local_88 = &local_78;
operator_delete(local_a8,local_98[0] + 1);
}
return;
}
| |
30,056 | httplib::detail::parse_query_text(char const*, unsigned long, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&) | hkr04[P]cpp-mcp/common/httplib.h | inline void parse_query_text(const char *data, std::size_t size,
Params ¶ms) {
std::set<std::string> cache;
split(data, data + size, '&', [&](const char *b, const char *e) {
std::string kv(b, e);
if (cache.find(kv) != cache.end()) { return; }
cache.insert(std::move(kv));
std::string key;
std::string val;
divide(b, static_cast<std::size_t>(e - b), '=',
[&](const char *lhs_data, std::size_t lhs_size, const char *rhs_data,
std::size_t rhs_size) {
key.assign(lhs_data, lhs_size);
val.assign(rhs_data, rhs_size);
});
if (!key.empty()) {
params.emplace(decode_url(key, true), decode_url(val, true));
}
});
} | O0 | c | httplib::detail::parse_query_text(char const*, unsigned long, std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x33150
movq (%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x98(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x33160
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl $0x26, %edx
callq 0x306d0
jmp 0x330ff
leaq 0x40(%rsp), %rdi
callq 0x30820
leaq 0x60(%rsp), %rdi
callq 0x30930
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30820
leaq 0x60(%rsp), %rdi
callq 0x30930
movq 0x28(%rsp), %rdi
callq 0xce40
nopw (%rax,%rax)
| _ZN7httplib6detail16parse_query_textEPKcmRSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEE:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
lea rdi, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_A8], rdi
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EEC2Ev; std::set<std::string>::set(void)
mov rax, [rsp+0A8h+var_A8]
mov rcx, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_A0], rcx
mov rdx, [rsp+0A8h+var_10]
add rcx, rdx
mov [rsp+0A8h+var_98], rcx
mov [rsp+0A8h+var_78], rax
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_70], rax
lea rdi, [rsp+0A8h+var_68]
mov [rsp+0A8h+var_90], rdi
lea rsi, [rsp+0A8h+var_78]
call _ZNSt8functionIFvPKcS1_EEC2IZN7httplib6detail16parse_query_textES1_mRSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESD_St4lessISD_ESaISt4pairIKSD_SD_EEEEUlS1_S1_E_vEEOT_; std::function<void ()(char const*,char const*)>::function<httplib::detail::parse_query_text(char const*,ulong,std::multimap<std::string,std::string> &)::{lambda(char const*,char const*)#1},void>(httplib::detail::parse_query_text(char const*,ulong,std::multimap<std::string,std::string> &)::{lambda(char const*,char const*)#1} &&)
mov rdi, [rsp+0A8h+var_A0]
mov rsi, [rsp+0A8h+var_98]
mov rcx, [rsp+0A8h+var_90]
mov edx, 26h ; '&'
call _ZN7httplib6detail5splitEPKcS2_cSt8functionIFvS2_S2_EE; httplib::detail::split(char const*,char const*,char,std::function<void ()(char const*,char const*)>)
jmp short $+2
loc_330FF:
lea rdi, [rsp+0A8h+var_68]
call _ZNSt8functionIFvPKcS1_EED2Ev; std::function<void ()(char const*,char const*)>::~function()
lea rdi, [rsp+0A8h+var_48]; void *
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EED2Ev; std::set<std::string>::~set()
add rsp, 0A8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_38]
call _ZNSt8functionIFvPKcS1_EED2Ev; std::function<void ()(char const*,char const*)>::~function()
lea rdi, [rsp+arg_58]; void *
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EED2Ev; std::set<std::string>::~set()
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| void httplib::detail::parse_query_text(long long a1, long long a2, long long a3)
{
long long v3; // [rsp+8h] [rbp-A0h]
long long v4; // [rsp+10h] [rbp-98h]
_QWORD v5[2]; // [rsp+30h] [rbp-78h] BYREF
_BYTE v6[32]; // [rsp+40h] [rbp-68h] BYREF
_BYTE v7[48]; // [rsp+60h] [rbp-48h] BYREF
long long v8; // [rsp+90h] [rbp-18h]
long long v9; // [rsp+98h] [rbp-10h]
long long v10; // [rsp+A0h] [rbp-8h]
v10 = a1;
v9 = a2;
v8 = a3;
std::set<std::string>::set();
v3 = v10;
v4 = v9 + v10;
v5[0] = v7;
v5[1] = v8;
std::function<void ()(char const*,char const*)>::function<httplib::detail::parse_query_text(char const*,unsigned long,std::multimap<std::string,std::string> &)::{lambda(char const*,char const*)#1},void>(
v6,
v5);
httplib::detail::split(v3, v4, 38, (long long)v6);
std::function<void ()(char const*,char const*)>::~function((std::_Function_base *)v6);
std::set<std::string>::~set(v7);
}
| parse_query_text:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
LEA RDI,[RSP + 0x60]
MOV qword ptr [RSP],RDI
CALL 0x00133150
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x8],RCX
MOV RDX,qword ptr [RSP + 0x98]
ADD RCX,RDX
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x38],RAX
LEA RDI,[RSP + 0x40]
MOV qword ptr [RSP + 0x18],RDI
LEA RSI,[RSP + 0x30]
CALL 0x00133160
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_001330f3:
MOV EDX,0x26
CALL 0x001306d0
LAB_001330fd:
JMP 0x001330ff
LAB_001330ff:
LEA RDI,[RSP + 0x40]
CALL 0x00130820
LEA RDI,[RSP + 0x60]
CALL 0x00130930
ADD RSP,0xa8
RET
|
/* httplib::detail::parse_query_text(char const*, unsigned long, std::multimap<std::__cxx11::string,
std::__cxx11::string, std::less<std::__cxx11::string >,
std::allocator<std::pair<std::__cxx11::string const, std::__cxx11::string > > >&) */
void httplib::detail::parse_query_text(char *param_1,ulong param_2,multimap *param_3)
{
char *pcVar1;
char *pcVar2;
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*local_78;
multimap *local_70;
function<void(char_const*,char_const*)> local_68 [32];
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
local_48 [48];
multimap *local_18;
ulong local_10;
char *local_8;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>::
set(local_48);
pcVar1 = local_8;
pcVar2 = local_8 + local_10;
local_70 = local_18;
local_78 = local_48;
std::function<void(char_const*,char_const*)>::
function<httplib::detail::parse_query_text(char_const*,unsigned_long,std::multimap<std::__cxx11::string,std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>&)::_lambda(char_const*,char_const*)_1_,void>
(local_68,(_lambda_char_const__char_const___1_ *)&local_78);
/* try { // try from 001330f3 to 001330fc has its CatchHandler @ 0013311b */
split(pcVar1,pcVar2,0x26,local_68);
std::function<void(char_const*,char_const*)>::~function(local_68);
std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>::
~set(local_48);
return;
}
| |
30,057 | protocol::encode(protocol::ChatMessage const&, unsigned int) | untodesu[P]voxelius/game/shared/protocol.cc | ENetPacket *protocol::encode(const protocol::ChatMessage &packet, enet_uint32 flags)
{
write_buffer.reset();
write_buffer.write_UI16(protocol::ChatMessage::ID);
write_buffer.write_UI16(packet.type);
write_buffer.write_string(packet.sender.substr(0, protocol::MAX_USERNAME));
write_buffer.write_string(packet.message.substr(0, protocol::MAX_CHAT));
return write_buffer.to_packet(flags);
} | O2 | cpp | protocol::encode(protocol::ChatMessage const&, unsigned int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xce303(%rip), %r15 # 0x10e118
movq %r15, %rdi
callq 0x4ca72
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x4ca9a
movzwl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x4ca9a
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r12
pushq $0x40
popq %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x17770
movq %r15, %rdi
movq %r12, %rsi
callq 0x4cbe8
leaq 0x8(%rsp), %rdi
callq 0x17ec8
addq $0x38, %r14
leaq 0x8(%rsp), %r15
movl $0x4000, %ecx # imm = 0x4000
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17770
leaq 0xce296(%rip), %rdi # 0x10e118
movq %r15, %rsi
callq 0x4cbe8
leaq 0x8(%rsp), %rdi
callq 0x17ec8
leaq 0xce27d(%rip), %rdi # 0x10e118
movl %ebx, %esi
callq 0x4cc8e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3feb0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17ec8
movq %rbx, %rdi
callq 0x17cd0
| _ZN8protocol6encodeERKNS_11ChatMessageEj:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov ebx, esi
mov r14, rdi
lea r15, _ZL12write_buffer; write_buffer
mov rdi, r15; this
call _ZN11WriteBuffer5resetEv; WriteBuffer::reset(void)
push 0Ah
pop rsi; unsigned __int16
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI16Et; WriteBuffer::write_UI16(ushort)
movzx esi, word ptr [r14+10h]; unsigned __int16
mov rdi, r15; this
call _ZN11WriteBuffer10write_UI16Et; WriteBuffer::write_UI16(ushort)
lea rsi, [r14+18h]
lea r12, [rsp+48h+var_40]
push 40h ; '@'
pop rcx
mov rdi, r12
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, r15
mov rsi, r12
call _ZN11WriteBuffer12write_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; WriteBuffer::write_string(std::string const&)
lea rdi, [rsp+48h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add r14, 38h ; '8'
lea r15, [rsp+48h+var_40]
mov ecx, 4000h
mov rdi, r15
mov rsi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rdi, _ZL12write_buffer; write_buffer
mov rsi, r15
call _ZN11WriteBuffer12write_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; WriteBuffer::write_string(std::string const&)
lea rdi, [rsp+48h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, _ZL12write_buffer; this
mov esi, ebx; unsigned int
call _ZNK11WriteBuffer9to_packetEj; WriteBuffer::to_packet(uint)
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_3FEB0:
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long protocol::encode(protocol *this, const protocol::ChatMessage *a2)
{
_BYTE v3[64]; // [rsp+8h] [rbp-40h] BYREF
WriteBuffer::reset((WriteBuffer *)&write_buffer);
WriteBuffer::write_UI16((WriteBuffer *)&write_buffer, 0xAu);
WriteBuffer::write_UI16((WriteBuffer *)&write_buffer, *((_WORD *)this + 8));
std::string::substr(v3, (char *)this + 24, 0LL, 64LL);
WriteBuffer::write_string(&write_buffer, v3);
std::string::~string(v3);
std::string::substr(v3, (char *)this + 56, 0LL, 0x4000LL);
WriteBuffer::write_string(&write_buffer, v3);
std::string::~string(v3);
return WriteBuffer::to_packet((WriteBuffer *)&write_buffer, (unsigned int)a2);
}
| encode:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,ESI
MOV R14,RDI
LEA R15,[0x20e118]
MOV RDI,R15
CALL 0x0014ca72
PUSH 0xa
POP RSI
MOV RDI,R15
CALL 0x0014ca9a
MOVZX ESI,word ptr [R14 + 0x10]
MOV RDI,R15
CALL 0x0014ca9a
LEA RSI,[R14 + 0x18]
LEA R12,[RSP + 0x8]
PUSH 0x40
POP RCX
MOV RDI,R12
XOR EDX,EDX
CALL 0x00117770
LAB_0013fe4b:
MOV RDI,R15
MOV RSI,R12
CALL 0x0014cbe8
LAB_0013fe56:
LEA RDI,[RSP + 0x8]
CALL 0x00117ec8
ADD R14,0x38
LEA R15,[RSP + 0x8]
MOV ECX,0x4000
MOV RDI,R15
MOV RSI,R14
XOR EDX,EDX
CALL 0x00117770
LAB_0013fe7b:
LEA RDI,[0x20e118]
MOV RSI,R15
CALL 0x0014cbe8
LAB_0013fe8a:
LEA RDI,[RSP + 0x8]
CALL 0x00117ec8
LEA RDI,[0x20e118]
MOV ESI,EBX
CALL 0x0014cc8e
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
/* protocol::encode(protocol::ChatMessage const&, unsigned int) */
void protocol::encode(ChatMessage *param_1,uint param_2)
{
string local_40 [32];
WriteBuffer::reset((WriteBuffer *)write_buffer);
WriteBuffer::write_UI16(0xe118);
WriteBuffer::write_UI16(0xe118);
std::__cxx11::string::substr((ulong)local_40,(ulong)(param_1 + 0x18));
/* try { // try from 0013fe4b to 0013fe55 has its CatchHandler @ 0013feb0 */
WriteBuffer::write_string((WriteBuffer *)write_buffer,local_40);
std::__cxx11::string::~string(local_40);
std::__cxx11::string::substr((ulong)local_40,(ulong)(param_1 + 0x38));
/* try { // try from 0013fe7b to 0013fe89 has its CatchHandler @ 0013feae */
WriteBuffer::write_string((WriteBuffer *)write_buffer,local_40);
std::__cxx11::string::~string(local_40);
WriteBuffer::to_packet((WriteBuffer *)write_buffer,param_2);
return;
}
| |
30,058 | js_number_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
if (argc == 0) {
val = js_int32(0);
} else {
val = JS_ToNumeric(ctx, argv[0]);
if (JS_IsException(val))
return val;
switch(JS_VALUE_GET_TAG(val)) {
case JS_TAG_BIG_INT:
{
JSBigInt *p = JS_VALUE_GET_PTR(val);
double d;
bf_get_float64(&p->num, &d, BF_RNDN);
JS_FreeValue(ctx, val);
val = js_float64(d);
}
break;
default:
break;
}
}
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O0 | c | js_number_constructor:
subq $0xa8, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
cmpl $0x0, 0x7c(%rsp)
jne 0x5d379
xorl %edi, %edi
callq 0x39fb0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x5d453
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xd8480
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x5d3e3
movq 0x60(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x5d51a
movl 0x68(%rsp), %eax
subl $-0x9, %eax
jne 0x5d44f
jmp 0x5d3ee
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0xf1090
movq 0x80(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x29f80
movsd 0x20(%rsp), %xmm0
callq 0x53950
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x5d451
jmp 0x5d451
jmp 0x5d453
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0x5d500
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movl $0x4, %ecx
callq 0x5b0f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
jne 0x5d4e4
movq 0x80(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0x5b300
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x5d51a
movq 0x60(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_number_constructor:
sub rsp, 0A8h
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_28], rdi
mov [rsp+0A8h+var_2C], ecx
mov [rsp+0A8h+var_38], r8
cmp [rsp+0A8h+var_2C], 0
jnz short loc_5D379
xor edi, edi
call js_int32
mov [rsp+0A8h+var_68], rax
mov [rsp+0A8h+var_60], rdx
mov rax, [rsp+0A8h+var_68]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_40], rax
jmp loc_5D453
loc_5D379:
mov rdi, [rsp+0A8h+var_28]
mov rax, [rsp+0A8h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToNumeric
mov [rsp+0A8h+var_78], rax
mov [rsp+0A8h+var_70], rdx
mov rax, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_70]
mov [rsp+0A8h+var_40], rax
mov rdi, [rsp+0A8h+var_48]
mov rsi, [rsp+0A8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_5D3E3
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_8], rax
jmp loc_5D51A
loc_5D3E3:
mov eax, dword ptr [rsp+0A8h+var_40]
sub eax, 0FFFFFFF7h
jnz short loc_5D44F
jmp short $+2
loc_5D3EE:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_80], rax
mov rdi, [rsp+0A8h+var_80]
add rdi, 8
lea rsi, [rsp+0A8h+var_88]
xor edx, edx
call bf_get_float64
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_48]
mov rdx, [rsp+0A8h+var_40]
call JS_FreeValue
movsd xmm0, [rsp+0A8h+var_88]
call js_float64
mov [rsp+0A8h+var_98], rax
mov [rsp+0A8h+var_90], rdx
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_40], rax
jmp short loc_5D451
loc_5D44F:
jmp short $+2
loc_5D451:
jmp short $+2
loc_5D453:
mov rdi, [rsp+0A8h+var_20]
mov rsi, [rsp+0A8h+var_18]
call JS_IsUndefined_1
cmp eax, 0
jnz loc_5D500
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
mov ecx, 4
call js_create_from_ctor
mov [rsp+0A8h+var_A8], rax
mov [rsp+0A8h+var_A0], rdx
mov rax, [rsp+0A8h+var_A8]
mov [rsp+0A8h+var_58], rax
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_50], rax
mov rdi, [rsp+0A8h+var_58]
mov rsi, [rsp+0A8h+var_50]
call JS_IsException_1
cmp eax, 0
jnz short loc_5D4E4
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_58]
mov rdx, [rsp+0A8h+var_50]
mov rcx, [rsp+0A8h+var_48]
mov r8, [rsp+0A8h+var_40]
call JS_SetObjectData
loc_5D4E4:
mov rax, [rsp+0A8h+var_58]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_8], rax
jmp short loc_5D51A
loc_5D500:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_8], rax
loc_5D51A:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
| long long js_number_constructor(
long long a1,
long long a2,
long long a3,
int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
double v17; // xmm4_8
double v18; // xmm5_8
double v20[2]; // [rsp+20h] [rbp-88h] BYREF
long long v21; // [rsp+30h] [rbp-78h]
long long v22; // [rsp+38h] [rbp-70h]
long long v23; // [rsp+40h] [rbp-68h]
long long v24; // [rsp+48h] [rbp-60h]
long long v25; // [rsp+50h] [rbp-58h]
long long v26; // [rsp+58h] [rbp-50h]
long long v27; // [rsp+60h] [rbp-48h]
long long v28; // [rsp+68h] [rbp-40h]
_QWORD *v29; // [rsp+70h] [rbp-38h]
int v30; // [rsp+7Ch] [rbp-2Ch]
long long v31; // [rsp+80h] [rbp-28h]
long long v32; // [rsp+88h] [rbp-20h]
long long v33; // [rsp+90h] [rbp-18h]
long long v34; // [rsp+98h] [rbp-10h]
long long v35; // [rsp+A0h] [rbp-8h]
v32 = a2;
v33 = a3;
v31 = a1;
v30 = a4;
v29 = a5;
if ( a4 )
{
v21 = JS_ToNumeric(v31, *v29, v29[1]);
v22 = v14;
v27 = v21;
v28 = v14;
if ( JS_IsException_1(v21, v14) )
{
v34 = v27;
v35 = v28;
return v34;
}
if ( (_DWORD)v28 == -9 )
{
*(_QWORD *)&v20[1] = v27;
bf_get_float64(v27 + 8, v20, 0LL);
JS_FreeValue(v31, v27, v28);
a6 = (__m128)*(unsigned long long *)&v20[0];
v27 = js_float64(v20[0]);
v28 = v15;
}
}
else
{
v23 = js_int32(0);
v24 = v13;
v27 = v23;
v28 = v13;
}
if ( JS_IsUndefined_1(v32, v33) )
{
v34 = v27;
v35 = v28;
}
else
{
v25 = js_create_from_ctor(v31, v32, v33, 4);
v26 = v16;
if ( !JS_IsException_1(v25, v16) )
JS_SetObjectData(v31, v25, v26, v27, v28, a6, a7, a8, a9, v17, v18, a12, a13);
v34 = v25;
v35 = v26;
}
return v34;
}
| js_number_constructor:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x80],RDI
MOV dword ptr [RSP + 0x7c],ECX
MOV qword ptr [RSP + 0x70],R8
CMP dword ptr [RSP + 0x7c],0x0
JNZ 0x0015d379
XOR EDI,EDI
CALL 0x00139fb0
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0015d453
LAB_0015d379:
MOV RDI,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001d8480
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0015d3e3
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x0015d51a
LAB_0015d3e3:
MOV EAX,dword ptr [RSP + 0x68]
SUB EAX,-0x9
JNZ 0x0015d44f
JMP 0x0015d3ee
LAB_0015d3ee:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x8
LEA RSI,[RSP + 0x20]
XOR EDX,EDX
CALL 0x001f1090
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00129f80
MOVSD XMM0,qword ptr [RSP + 0x20]
CALL 0x00153950
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x68],RAX
JMP 0x0015d451
LAB_0015d44f:
JMP 0x0015d451
LAB_0015d451:
JMP 0x0015d453
LAB_0015d453:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x90]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x0015d500
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
MOV ECX,0x4
CALL 0x0015b0f0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00129fb0
CMP EAX,0x0
JNZ 0x0015d4e4
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
MOV R8,qword ptr [RSP + 0x68]
CALL 0x0015b300
LAB_0015d4e4:
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x0015d51a
LAB_0015d500:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
LAB_0015d51a:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16]
js_number_constructor
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
int8 local_88;
long local_80;
int1 local_78 [16];
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if (param_4 == 0) {
local_68 = js_int32(0);
local_48 = local_68;
}
else {
local_78 = JS_ToNumeric(param_1,*param_5,param_5[1]);
local_48 = local_78;
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
if (iVar1 != 0) {
return local_48;
}
if (local_48._8_4_ == -9) {
local_80 = local_48._0_8_;
bf_get_float64(local_48._0_8_ + 8,&local_88,0);
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
auVar2 = js_float64(local_88);
local_48 = auVar2;
}
}
iVar1 = JS_IsUndefined(local_20,local_18);
auVar2 = local_48;
if (iVar1 == 0) {
local_58 = js_create_from_ctor(local_28,local_20,local_18,4);
iVar1 = JS_IsException(local_58._0_8_,local_58._8_8_);
auVar2 = local_58;
if (iVar1 == 0) {
JS_SetObjectData(local_28,local_58._0_8_,local_58._8_8_,local_48._0_8_,local_48._8_8_);
auVar2 = local_58;
}
}
return auVar2;
}
| |
30,059 | js_number_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
if (argc == 0) {
val = js_int32(0);
} else {
val = JS_ToNumeric(ctx, argv[0]);
if (JS_IsException(val))
return val;
switch(JS_VALUE_GET_TAG(val)) {
case JS_TAG_BIG_INT:
{
JSBigInt *p = JS_VALUE_GET_PTR(val);
double d;
bf_get_float64(&p->num, &d, BF_RNDN);
JS_FreeValue(ctx, val);
val = js_float64(d);
}
break;
default:
break;
}
}
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_NUMBER);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O1 | c | js_number_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x3c92b
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x3c8d1
movq 0x8(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x46b7c
movq %rdx, %r12
movq %rax, 0x8(%rsp)
cmpl $0x6, %r12d
je 0x3c938
cmpl $-0x9, %r12d
jne 0x3c93d
movq 0x8(%rsp), %r13
leaq 0x8(%r13), %rdi
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
xorl %edx, %edx
callq 0x8c54a
movq 0x18(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21922
movsd (%rbp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x7, %ebp
jmp 0x3c940
movq $0x0, 0x8(%rsp)
xorl %ebp, %ebp
jmp 0x3c940
movq %rax, %r13
jmp 0x3c985
movq %r12, %rbp
cmpl $0x3, %r14d
jne 0x3c950
movq 0x8(%rsp), %r13
movq %rbp, %r12
jmp 0x3c985
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x3adb2
movq %rax, %r13
movq %rdx, %r12
cmpl $0x6, %r12d
je 0x3c985
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r8
callq 0x3aebe
movq %r13, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_number_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
test ecx, ecx
jz short loc_3C92B
mov rsi, [r8]
mov rdx, [r8+8]
mov [rsp+48h+var_40], rsi
cmp edx, 0FFFFFFF7h
jb short loc_3C8D1
mov rax, [rsp+48h+var_40]
inc dword ptr [rax]
loc_3C8D1:
mov rdi, rbx
mov ecx, 1
call JS_ToNumberHintFree
mov r12, rdx
mov [rsp+48h+var_40], rax
cmp r12d, 6
jz short loc_3C938
cmp r12d, 0FFFFFFF7h
jnz short loc_3C93D
mov r13, [rsp+48h+var_40]
lea rdi, [r13+8]
lea rbp, [rsp+48h+var_38]
mov rsi, rbp
xor edx, edx
call bf_get_float64
mov rdi, [rbx+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
movsd xmm0, qword ptr [rbp+0]
movsd [rsp+48h+var_40], xmm0
mov ebp, 7
jmp short loc_3C940
loc_3C92B:
mov [rsp+48h+var_40], 0
xor ebp, ebp
jmp short loc_3C940
loc_3C938:
mov r13, rax
jmp short loc_3C985
loc_3C93D:
mov rbp, r12
loc_3C940:
cmp r14d, 3
jnz short loc_3C950
mov r13, [rsp+48h+var_40]
mov r12, rbp
jmp short loc_3C985
loc_3C950:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, 4
call js_create_from_ctor
mov r13, rax
mov r12, rdx
cmp r12d, 6
jz short loc_3C985
mov rcx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r13
mov rdx, r12
mov r8, rbp
call JS_SetObjectData
loc_3C985:
mov rax, r13
mov rdx, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _DWORD * js_number_constructor(
long long a1,
long long a2,
long long a3,
int a4,
_QWORD *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
_DWORD *v15; // rsi
long long v16; // rdx
long long v17; // rax
long long v18; // rdx
long long v19; // r12
long long v20; // rbp
unsigned long long v21; // r13
unsigned long long v22; // rax
int v23; // edx
long long v24; // r9
double v25; // xmm4_8
double v26; // xmm5_8
char v28; // [rsp+0h] [rbp-48h]
_DWORD *v29; // [rsp+8h] [rbp-40h]
_DWORD *v30; // [rsp+10h] [rbp-38h] BYREF
if ( a4 )
{
v15 = (_DWORD *)*a5;
v16 = a5[1];
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++*(_DWORD *)*a5;
v17 = JS_ToNumberHintFree(a1, v15, v16, 1LL);
v19 = v18;
v29 = (_DWORD *)v17;
if ( (_DWORD)v18 == 6 )
return (_DWORD *)v17;
if ( (_DWORD)v18 == -9 )
{
bf_get_float64(v17 + 8, &v30, 0LL);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v29, v19);
a6 = (__m128)(unsigned long long)v30;
v29 = v30;
v20 = 7LL;
}
else
{
v20 = v18;
}
}
else
{
v29 = 0LL;
v20 = 0LL;
}
if ( (_DWORD)a3 == 3 )
return v29;
v22 = js_create_from_ctor(a1, a2, a3, 4);
v21 = v22;
if ( v23 != 6 )
JS_SetObjectData(a1, v22, v23, v29, v20, a6, a7, a8, a9, v25, v26, a12, a13, v24, v28);
return (_DWORD *)v21;
}
| js_number_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
TEST ECX,ECX
JZ 0x0013c92b
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x0013c8d1
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0013c8d1:
MOV RDI,RBX
MOV ECX,0x1
CALL 0x00146b7c
MOV R12,RDX
MOV qword ptr [RSP + 0x8],RAX
CMP R12D,0x6
JZ 0x0013c938
CMP R12D,-0x9
JNZ 0x0013c93d
MOV R13,qword ptr [RSP + 0x8]
LEA RDI,[R13 + 0x8]
LEA RBP,[RSP + 0x10]
MOV RSI,RBP
XOR EDX,EDX
CALL 0x0018c54a
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x00121922
MOVSD XMM0,qword ptr [RBP]
MOVSD qword ptr [RSP + 0x8],XMM0
MOV EBP,0x7
JMP 0x0013c940
LAB_0013c92b:
MOV qword ptr [RSP + 0x8],0x0
XOR EBP,EBP
JMP 0x0013c940
LAB_0013c938:
MOV R13,RAX
JMP 0x0013c985
LAB_0013c93d:
MOV RBP,R12
LAB_0013c940:
CMP R14D,0x3
JNZ 0x0013c950
MOV R13,qword ptr [RSP + 0x8]
MOV R12,RBP
JMP 0x0013c985
LAB_0013c950:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,0x4
CALL 0x0013adb2
MOV R13,RAX
MOV R12,RDX
CMP R12D,0x6
JZ 0x0013c985
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
MOV R8,RBP
CALL 0x0013aebe
LAB_0013c985:
MOV RAX,R13
MOV RDX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_number_constructor
(long param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int *piVar1;
int8 uVar2;
int1 auVar3 [16];
int8 local_40;
long local_38;
if (param_4 == 0) {
auVar3 = ZEXT816(0);
}
else {
piVar1 = (int *)*param_5;
uVar2 = param_5[1];
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
auVar3 = JS_ToNumberHintFree(param_1,piVar1,uVar2,1);
if (auVar3._8_4_ == 6) {
return auVar3;
}
if (auVar3._8_4_ == -9) {
bf_get_float64(auVar3._0_8_ + 8,&local_38,0);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
auVar3._8_8_ = 7;
auVar3._0_8_ = local_38;
}
}
uVar2 = auVar3._8_8_;
local_40 = auVar3._0_8_;
if ((int)param_3 != 3) {
auVar3 = js_create_from_ctor(param_1,param_2,param_3,4);
if (auVar3._8_4_ != 6) {
JS_SetObjectData(param_1,auVar3._0_8_,auVar3._8_8_,local_40,uVar2);
}
}
return auVar3;
}
| |
30,060 | js_math_f16round | bluesky950520[P]quickjs/quickjs.c | static double js_math_f16round(double a)
{
return fromfp16(tofp16(a));
} | O1 | c | js_math_f16round:
pushq %r14
pushq %rbx
pushq %rax
movq %xmm0, %rax
movq %rax, %r14
shrq $0x30, %r14
andl $0x8000, %r14d # imm = 0x8000
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x7d434
orl $0x7c00, %r14d # imm = 0x7C00
jmp 0x7d513
ucomisd %xmm0, %xmm0
jp 0x7d585
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7d44e
jnp 0x7d513
andpd 0x1fc0a(%rip), %xmm0 # 0x9d060
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0xe4a0
movl (%rbx), %edi
leal -0x1(%rdi), %eax
movl %eax, (%rbx)
cmpl $0x11, %edi
jge 0x7d428
cmpl $-0x19, %edi
jg 0x7d482
movl $0x0, 0x4(%rsp)
xorpd %xmm0, %xmm0
jmp 0x7d4ac
addsd %xmm0, %xmm0
cmpl $-0xe, %edi
jg 0x7d49d
addl $0xd, %edi
callq 0xe660
movl $0x0, 0x4(%rsp)
jmp 0x7d4ac
addsd 0x1fcd3(%rip), %xmm0 # 0x9d178
addl $0xe, %edi
movl %edi, 0x4(%rsp)
mulsd 0x1fccc(%rip), %xmm0 # 0x9d180
cvttsd2si %xmm0, %eax
movzwl %ax, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subsd %xmm1, %xmm0
movsd 0x1fcba(%rip), %xmm1 # 0x9d188
ucomisd %xmm0, %xmm1
ja 0x7d506
testb $0x1, %al
jne 0x7d4e4
ucomisd 0x1fca8(%rip), %xmm0 # 0x9d188
jne 0x7d4e4
jnp 0x7d506
incl %eax
movzwl %ax, %ecx
cmpl $0x400, %ecx # imm = 0x400
jne 0x7d506
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x1f, %eax
je 0x7d428
xorl %eax, %eax
movl 0x4(%rsp), %ecx
shll $0xa, %ecx
orl %ecx, %r14d
orl %eax, %r14d
movzwl %r14w, %ecx
movl $0x7c00, %edx # imm = 0x7C00
movl %ecx, %eax
andl %edx, %eax
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0x7d53f
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x1fb08(%rip), %rcx # 0x9d040
movsd (%rcx,%rax,8), %xmm0
jmp 0x7d56f
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x1fc22(%rip), %xmm0 # 0x9d170
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0x7d562
addsd 0x1fbf6(%rip), %xmm0 # 0x9d158
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
cmovel %eax, %edi
callq 0xe660
testw %r14w, %r14w
jns 0x7d57d
xorpd 0x1fad3(%rip), %xmm0 # 0x9d050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
orl $0x7c01, %r14d # imm = 0x7C01
jmp 0x7d513
| js_math_f16round:
push r14
push rbx
push rax
movq rax, xmm0
mov r14, rax
shr r14, 30h
and r14d, 8000h
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jnz short loc_7D434
loc_7D428:
or r14d, 7C00h
jmp loc_7D513
loc_7D434:
ucomisd xmm0, xmm0
jp loc_7D585
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_7D44E
jnp loc_7D513
loc_7D44E:
andpd xmm0, cs:xmmword_9D060
lea rbx, [rsp+18h+var_14]
mov rdi, rbx
call _frexp
mov edi, [rbx]
lea eax, [rdi-1]
mov [rbx], eax
cmp edi, 11h
jge short loc_7D428
cmp edi, 0FFFFFFE7h
jg short loc_7D482
mov [rsp+18h+var_14], 0
xorpd xmm0, xmm0
jmp short loc_7D4AC
loc_7D482:
addsd xmm0, xmm0
cmp edi, 0FFFFFFF2h
jg short loc_7D49D
add edi, 0Dh
call _scalbn
mov [rsp+18h+var_14], 0
jmp short loc_7D4AC
loc_7D49D:
addsd xmm0, cs:qword_9D178
add edi, 0Eh
mov [rsp+18h+var_14], edi
loc_7D4AC:
mulsd xmm0, cs:qword_9D180
cvttsd2si eax, xmm0
movzx ecx, ax
xorps xmm1, xmm1
cvtsi2sd xmm1, ecx
subsd xmm0, xmm1
movsd xmm1, cs:qword_9D188
ucomisd xmm1, xmm0
ja short loc_7D506
test al, 1
jnz short loc_7D4E4
ucomisd xmm0, cs:qword_9D188
jnz short loc_7D4E4
jnp short loc_7D506
loc_7D4E4:
inc eax
movzx ecx, ax
cmp ecx, 400h
jnz short loc_7D506
mov eax, [rsp+18h+var_14]
inc eax
mov [rsp+18h+var_14], eax
cmp eax, 1Fh
jz loc_7D428
xor eax, eax
loc_7D506:
mov ecx, [rsp+18h+var_14]
shl ecx, 0Ah
or r14d, ecx
or r14d, eax
loc_7D513:
movzx ecx, r14w
mov edx, 7C00h
mov eax, ecx
and eax, edx
and ecx, 3FFh
cmp eax, edx
jnz short loc_7D53F
xor eax, eax
test ecx, ecx
setz al
lea rcx, dbl_9D040
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_7D56F
loc_7D53F:
xorps xmm0, xmm0
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_9D170
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_7D562
addsd xmm0, cs:qword_9D158
loc_7D562:
mov eax, 0FFFFFFF2h
cmovz edi, eax
call _scalbn
loc_7D56F:
test r14w, r14w
jns short loc_7D57D
xorpd xmm0, cs:xmmword_9D050
loc_7D57D:
add rsp, 8
pop rbx
pop r14
retn
loc_7D585:
or r14d, 7C01h
jmp short loc_7D513
| long long js_math_f16round(double a1)
{
long long v1; // rax
long long v2; // r14
double v3; // xmm0_8
int v4; // edi
double v5; // xmm0_8
double v6; // xmm0_8
int v7; // eax
double v8; // xmm0_8
unsigned int v9; // eax
int v10; // ecx
double v12; // xmm0_8
long long v13; // rdi
int v14[5]; // [rsp+0h] [rbp-14h] BYREF
v14[0] = HIDWORD(v1);
v2 = HIWORD(*(_QWORD *)&a1) & 0x8000LL;
if ( (*(_QWORD *)&a1 & 0x7FFFFFFFFFFFFFFFLL) == 0x7FF0000000000000LL )
goto LABEL_2;
if ( a1 != 0.0 )
{
v3 = frexp(fabs(a1), v14);
v4 = v14[0]--;
if ( v4 < 17 )
{
if ( v4 > -25 )
{
v5 = v3 + v3;
if ( v4 > -14 )
{
v5 = v5 + -1.0;
v14[0] = v4 + 14;
}
else
{
scalbn((unsigned int)(v4 + 13), v5);
v14[0] = 0;
}
}
else
{
v14[0] = 0;
v5 = 0.0;
}
v6 = v5 * 1024.0;
v7 = (int)v6;
v8 = v6 - (double)(unsigned __int16)(int)v6;
if ( v8 < 0.5 || (v7 & 1) == 0 && v8 == 0.5 )
goto LABEL_16;
LOWORD(v7) = v7 + 1;
if ( (unsigned __int16)v7 != 1024 )
goto LABEL_16;
if ( ++v14[0] != 31 )
{
LOWORD(v7) = 0;
LABEL_16:
LOWORD(v2) = v7 | (LOWORD(v14[0]) << 10) | v2;
goto LABEL_17;
}
}
LABEL_2:
LOWORD(v2) = v2 | 0x7C00;
}
LABEL_17:
v9 = v2 & 0x7C00;
v10 = v2 & 0x3FF;
if ( v9 == 31744 )
return v10 == 0;
v12 = (double)v10 * 0.0009765625;
v13 = (v9 >> 10) - 15;
if ( (v2 & 0x7C00) != 0 )
v12 = v12 + 1.0;
else
v13 = 4294967282LL;
return scalbn(v13, v12);
}
| js_math_f16round:
PUSH R14
PUSH RBX
PUSH RAX
MOVQ RAX,XMM0
MOV R14,RAX
SHR R14,0x30
AND R14D,0x8000
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JNZ 0x0017d434
LAB_0017d428:
OR R14D,0x7c00
JMP 0x0017d513
LAB_0017d434:
UCOMISD XMM0,XMM0
JP 0x0017d585
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0017d44e
JNP 0x0017d513
LAB_0017d44e:
ANDPD XMM0,xmmword ptr [0x0019d060]
LEA RBX,[RSP + 0x4]
MOV RDI,RBX
CALL 0x0010e4a0
MOV EDI,dword ptr [RBX]
LEA EAX,[RDI + -0x1]
MOV dword ptr [RBX],EAX
CMP EDI,0x11
JGE 0x0017d428
CMP EDI,-0x19
JG 0x0017d482
MOV dword ptr [RSP + 0x4],0x0
XORPD XMM0,XMM0
JMP 0x0017d4ac
LAB_0017d482:
ADDSD XMM0,XMM0
CMP EDI,-0xe
JG 0x0017d49d
ADD EDI,0xd
CALL 0x0010e660
MOV dword ptr [RSP + 0x4],0x0
JMP 0x0017d4ac
LAB_0017d49d:
ADDSD XMM0,qword ptr [0x0019d178]
ADD EDI,0xe
MOV dword ptr [RSP + 0x4],EDI
LAB_0017d4ac:
MULSD XMM0,qword ptr [0x0019d180]
CVTTSD2SI EAX,XMM0
MOVZX ECX,AX
XORPS XMM1,XMM1
CVTSI2SD XMM1,ECX
SUBSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x0019d188]
UCOMISD XMM1,XMM0
JA 0x0017d506
TEST AL,0x1
JNZ 0x0017d4e4
UCOMISD XMM0,qword ptr [0x0019d188]
JNZ 0x0017d4e4
JNP 0x0017d506
LAB_0017d4e4:
INC EAX
MOVZX ECX,AX
CMP ECX,0x400
JNZ 0x0017d506
MOV EAX,dword ptr [RSP + 0x4]
INC EAX
MOV dword ptr [RSP + 0x4],EAX
CMP EAX,0x1f
JZ 0x0017d428
XOR EAX,EAX
LAB_0017d506:
MOV ECX,dword ptr [RSP + 0x4]
SHL ECX,0xa
OR R14D,ECX
OR R14D,EAX
LAB_0017d513:
MOVZX ECX,R14W
MOV EDX,0x7c00
MOV EAX,ECX
AND EAX,EDX
AND ECX,0x3ff
CMP EAX,EDX
JNZ 0x0017d53f
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LEA RCX,[0x19d040]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
JMP 0x0017d56f
LAB_0017d53f:
XORPS XMM0,XMM0
CVTSI2SD XMM0,ECX
MULSD XMM0,qword ptr [0x0019d170]
MOV EDI,EAX
SHR EDI,0xa
ADD EDI,-0xf
TEST EAX,EAX
JZ 0x0017d562
ADDSD XMM0,qword ptr [0x0019d158]
LAB_0017d562:
MOV EAX,0xfffffff2
CMOVZ EDI,EAX
CALL 0x0010e660
LAB_0017d56f:
TEST R14W,R14W
JNS 0x0017d57d
XORPD XMM0,xmmword ptr [0x0019d050]
LAB_0017d57d:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0017d585:
OR R14D,0x7c01
JMP 0x0017d513
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 js_math_f16round(double param_1)
{
double dVar1;
ulong uVar2;
uint uVar3;
ulong in_RAX;
int iVar4;
uint uVar5;
int4 uVar6;
int4 uVar7;
int8 uStack_18;
uVar5 = (uint)((ulong)param_1 >> 0x30) & 0x8000;
uStack_18 = in_RAX;
if (ABS(param_1) == INFINITY) {
LAB_0017d428:
uVar5 = uVar5 | 0x7c00;
}
else {
if (NAN(param_1)) {
uVar5 = uVar5 | 0x7c01;
goto LAB_0017d513;
}
if ((param_1 == 0.0) && (!NAN(param_1))) goto LAB_0017d513;
dVar1 = frexp((double)((ulong)param_1 & _DAT_0019d060),(int *)((long)&uStack_18 + 4));
uVar2 = uStack_18;
iVar4 = uStack_18._4_4_;
uStack_18 = CONCAT44(uStack_18._4_4_ + -1,(int4)uStack_18);
if (0x10 < iVar4) goto LAB_0017d428;
if (iVar4 < -0x18) {
uStack_18 = uVar2 & 0xffffffff;
dVar1 = 0.0;
}
else if (iVar4 < -0xd) {
dVar1 = scalbn(dVar1 + dVar1,iVar4 + 0xd);
uStack_18 = uStack_18 & 0xffffffff;
}
else {
dVar1 = dVar1 + dVar1 + _DAT_0019d178;
uStack_18 = CONCAT44(iVar4 + 0xe,(int4)uStack_18);
}
uVar3 = (uint)(dVar1 * _DAT_0019d180);
dVar1 = dVar1 * _DAT_0019d180 - (double)(uVar3 & 0xffff);
if (DAT_0019d188 <= dVar1) {
if ((uVar3 & 1) == 0) {
if ((dVar1 == DAT_0019d188) && (!NAN(dVar1) && !NAN(DAT_0019d188))) goto LAB_0017d506;
}
uVar3 = uVar3 + 1;
if ((uVar3 & 0xffff) == 0x400) {
iVar4 = uStack_18._4_4_ + 1;
uStack_18 = CONCAT44(iVar4,(int4)uStack_18);
if (iVar4 == 0x1f) goto LAB_0017d428;
uVar3 = 0;
}
}
LAB_0017d506:
uVar5 = uVar5 | uStack_18._4_4_ << 10 | uVar3;
}
LAB_0017d513:
uVar3 = uVar5 & 0x7c00;
if (uVar3 == 0x7c00) {
uVar6 = (int4)*(int8 *)(&DAT_0019d040 + (ulong)((uVar5 & 0x3ff) == 0) * 8);
uVar7 = (int4)
((ulong)*(int8 *)(&DAT_0019d040 + (ulong)((uVar5 & 0x3ff) == 0) * 8) >> 0x20);
}
else {
dVar1 = (double)(uVar5 & 0x3ff) * _DAT_0019d170;
iVar4 = (uVar3 >> 10) - 0xf;
if (uVar3 == 0) {
iVar4 = -0xe;
}
else {
dVar1 = dVar1 + DAT_0019d158;
}
dVar1 = scalbn(dVar1,iVar4);
uVar6 = SUB84(dVar1,0);
uVar7 = (int4)((ulong)dVar1 >> 0x20);
}
if ((short)uVar5 < 0) {
uVar2 = CONCAT44(uVar7,uVar6) ^ _DAT_0019d050;
uVar6 = (int4)uVar2;
uVar7 = (int4)(uVar2 >> 0x20);
}
return CONCAT44(uVar7,uVar6);
}
| |
30,061 | js_math_f16round | bluesky950520[P]quickjs/quickjs.c | static double js_math_f16round(double a)
{
return fromfp16(tofp16(a));
} | O3 | c | js_math_f16round:
pushq %r14
pushq %rbx
pushq %rax
movq %xmm0, %rax
movq %rax, %r14
shrq $0x30, %r14
andl $0x8000, %r14d # imm = 0x8000
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x7ff43
orl $0x7c00, %r14d # imm = 0x7C00
jmp 0x8000b
ucomisd %xmm0, %xmm0
jp 0x8007d
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7ff5d
jnp 0x8000b
andpd 0x2009b(%rip), %xmm0 # 0xa0000
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
callq 0xe4a0
movl (%rbx), %edi
cmpl $0x11, %edi
jge 0x7ff37
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
cmpl $-0x18, %edi
jl 0x7ffb0
addsd %xmm1, %xmm1
cmpl $-0xe, %edi
jg 0x7ff9f
addl $0xd, %edi
movapd %xmm1, %xmm0
callq 0xe660
jmp 0x7ffb0
addsd 0x201a1(%rip), %xmm1 # 0xa0148
addl $0xe, %edi
movl %edi, %ebx
movapd %xmm1, %xmm0
mulsd 0x20198(%rip), %xmm0 # 0xa0150
cvttsd2si %xmm0, %eax
movzwl %ax, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
subsd %xmm1, %xmm0
movsd 0x20186(%rip), %xmm1 # 0xa0158
ucomisd %xmm0, %xmm1
ja 0x80002
testb $0x1, %al
jne 0x7ffe8
ucomisd 0x20174(%rip), %xmm0 # 0xa0158
jne 0x7ffe8
jnp 0x80002
incl %eax
movzwl %ax, %ecx
cmpl $0x400, %ecx # imm = 0x400
jne 0x80002
incl %ebx
cmpl $0x1f, %ebx
je 0x7ff37
xorl %eax, %eax
shll $0xa, %ebx
orl %ebx, %r14d
orl %eax, %r14d
movzwl %r14w, %ecx
movl $0x7c00, %edx # imm = 0x7C00
movl %ecx, %eax
andl %edx, %eax
andl $0x3ff, %ecx # imm = 0x3FF
cmpl %edx, %eax
jne 0x80037
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leaq 0x1ffb0(%rip), %rcx # 0x9ffe0
movsd (%rcx,%rax,8), %xmm0
jmp 0x80067
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x200fa(%rip), %xmm0 # 0xa0140
movl %eax, %edi
shrl $0xa, %edi
addl $-0xf, %edi
testl %eax, %eax
je 0x8005a
addsd 0x200ce(%rip), %xmm0 # 0xa0128
movl $0xfffffff2, %eax # imm = 0xFFFFFFF2
cmovel %eax, %edi
callq 0xe660
testw %r14w, %r14w
jns 0x80075
xorpd 0x1ff7b(%rip), %xmm0 # 0x9fff0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
orl $0x7c01, %r14d # imm = 0x7C01
jmp 0x8000b
| js_math_f16round:
push r14
push rbx
push rax
movq rax, xmm0
mov r14, rax
shr r14, 30h
and r14d, 8000h
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jnz short loc_7FF43
loc_7FF37:
or r14d, 7C00h
jmp loc_8000B
loc_7FF43:
ucomisd xmm0, xmm0
jp loc_8007D
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_7FF5D
jnp loc_8000B
loc_7FF5D:
andpd xmm0, cs:xmmword_A0000
lea rbx, [rsp+18h+var_14]
mov rdi, rbx
call _frexp
mov edi, [rbx]
cmp edi, 11h
jge short loc_7FF37
movapd xmm1, xmm0
xorpd xmm0, xmm0
xor ebx, ebx
cmp edi, 0FFFFFFE8h
jl short loc_7FFB0
addsd xmm1, xmm1
cmp edi, 0FFFFFFF2h
jg short loc_7FF9F
add edi, 0Dh
movapd xmm0, xmm1
call _scalbn
jmp short loc_7FFB0
loc_7FF9F:
addsd xmm1, cs:qword_A0148
add edi, 0Eh
mov ebx, edi
movapd xmm0, xmm1
loc_7FFB0:
mulsd xmm0, cs:qword_A0150
cvttsd2si eax, xmm0
movzx ecx, ax
xorps xmm1, xmm1
cvtsi2sd xmm1, ecx
subsd xmm0, xmm1
movsd xmm1, cs:qword_A0158
ucomisd xmm1, xmm0
ja short loc_80002
test al, 1
jnz short loc_7FFE8
ucomisd xmm0, cs:qword_A0158
jnz short loc_7FFE8
jnp short loc_80002
loc_7FFE8:
inc eax
movzx ecx, ax
cmp ecx, 400h
jnz short loc_80002
inc ebx
cmp ebx, 1Fh
jz loc_7FF37
loc_80000:
xor eax, eax
loc_80002:
shl ebx, 0Ah
or r14d, ebx
or r14d, eax
loc_8000B:
movzx ecx, r14w
mov edx, 7C00h
mov eax, ecx
and eax, edx
and ecx, 3FFh
cmp eax, edx
jnz short loc_80037
xor eax, eax
test ecx, ecx
setz al
lea rcx, dbl_9FFE0
movsd xmm0, qword ptr [rcx+rax*8]
jmp short loc_80067
loc_80037:
xorps xmm0, xmm0
cvtsi2sd xmm0, ecx
mulsd xmm0, cs:qword_A0140
mov edi, eax
shr edi, 0Ah
add edi, 0FFFFFFF1h
test eax, eax
jz short loc_8005A
addsd xmm0, cs:qword_A0128
loc_8005A:
mov eax, 0FFFFFFF2h
cmovz edi, eax
call _scalbn
loc_80067:
test r14w, r14w
jns short loc_80075
xorpd xmm0, cs:xmmword_9FFF0
loc_80075:
add rsp, 8
pop rbx
pop r14
retn
loc_8007D:
or r14d, 7C01h
jmp short loc_8000B
| long long js_math_f16round(double a1)
{
long long v1; // rax
long long v2; // r14
double v3; // xmm0_8
double v4; // xmm1_8
double v5; // xmm0_8
int v6; // ebx
double v7; // xmm1_8
double v8; // xmm0_8
int v9; // eax
double v10; // xmm0_8
unsigned int v11; // eax
int v12; // ecx
double v14; // xmm0_8
long long v15; // rdi
int v16[5]; // [rsp+0h] [rbp-14h] BYREF
v16[0] = HIDWORD(v1);
v2 = HIWORD(*(_QWORD *)&a1) & 0x8000LL;
if ( (*(_QWORD *)&a1 & 0x7FFFFFFFFFFFFFFFLL) == 0x7FF0000000000000LL )
goto LABEL_2;
if ( a1 != 0.0 )
{
v3 = frexp(fabs(a1), v16);
if ( v16[0] < 17 )
{
v4 = v3;
v5 = 0.0;
v6 = 0;
if ( v16[0] >= -24 )
{
v7 = v4 + v4;
if ( v16[0] > -14 )
{
v6 = v16[0] + 14;
v5 = v7 + -1.0;
}
else
{
v5 = v7;
scalbn((unsigned int)(v16[0] + 13), v7);
}
}
v8 = v5 * 1024.0;
v9 = (int)v8;
v10 = v8 - (double)(unsigned __int16)(int)v8;
if ( v10 < 0.5 || (v9 & 1) == 0 && v10 == 0.5 )
goto LABEL_15;
LOWORD(v9) = v9 + 1;
if ( (unsigned __int16)v9 != 1024 )
goto LABEL_15;
if ( ++v6 != 31 )
{
LOWORD(v9) = 0;
LABEL_15:
LOWORD(v2) = v9 | ((_WORD)v6 << 10) | v2;
goto LABEL_16;
}
}
LABEL_2:
LOWORD(v2) = v2 | 0x7C00;
}
LABEL_16:
v11 = v2 & 0x7C00;
v12 = v2 & 0x3FF;
if ( v11 == 31744 )
return v12 == 0;
v14 = (double)v12 * 0.0009765625;
v15 = (v11 >> 10) - 15;
if ( (v2 & 0x7C00) != 0 )
v14 = v14 + 1.0;
else
v15 = 4294967282LL;
return scalbn(v15, v14);
}
| js_math_f16round:
PUSH R14
PUSH RBX
PUSH RAX
MOVQ RAX,XMM0
MOV R14,RAX
SHR R14,0x30
AND R14D,0x8000
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JNZ 0x0017ff43
LAB_0017ff37:
OR R14D,0x7c00
JMP 0x0018000b
LAB_0017ff43:
UCOMISD XMM0,XMM0
JP 0x0018007d
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x0017ff5d
JNP 0x0018000b
LAB_0017ff5d:
ANDPD XMM0,xmmword ptr [0x001a0000]
LEA RBX,[RSP + 0x4]
MOV RDI,RBX
CALL 0x0010e4a0
MOV EDI,dword ptr [RBX]
CMP EDI,0x11
JGE 0x0017ff37
MOVAPD XMM1,XMM0
XORPD XMM0,XMM0
XOR EBX,EBX
CMP EDI,-0x18
JL 0x0017ffb0
ADDSD XMM1,XMM1
CMP EDI,-0xe
JG 0x0017ff9f
ADD EDI,0xd
MOVAPD XMM0,XMM1
CALL 0x0010e660
JMP 0x0017ffb0
LAB_0017ff9f:
ADDSD XMM1,qword ptr [0x001a0148]
ADD EDI,0xe
MOV EBX,EDI
MOVAPD XMM0,XMM1
LAB_0017ffb0:
MULSD XMM0,qword ptr [0x001a0150]
CVTTSD2SI EAX,XMM0
MOVZX ECX,AX
XORPS XMM1,XMM1
CVTSI2SD XMM1,ECX
SUBSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x001a0158]
UCOMISD XMM1,XMM0
JA 0x00180002
TEST AL,0x1
JNZ 0x0017ffe8
UCOMISD XMM0,qword ptr [0x001a0158]
JNZ 0x0017ffe8
JNP 0x00180002
LAB_0017ffe8:
INC EAX
MOVZX ECX,AX
CMP ECX,0x400
JNZ 0x00180002
INC EBX
CMP EBX,0x1f
JZ 0x0017ff37
XOR EAX,EAX
LAB_00180002:
SHL EBX,0xa
OR R14D,EBX
OR R14D,EAX
LAB_0018000b:
MOVZX ECX,R14W
MOV EDX,0x7c00
MOV EAX,ECX
AND EAX,EDX
AND ECX,0x3ff
CMP EAX,EDX
JNZ 0x00180037
XOR EAX,EAX
TEST ECX,ECX
SETZ AL
LEA RCX,[0x19ffe0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
JMP 0x00180067
LAB_00180037:
XORPS XMM0,XMM0
CVTSI2SD XMM0,ECX
MULSD XMM0,qword ptr [0x001a0140]
MOV EDI,EAX
SHR EDI,0xa
ADD EDI,-0xf
TEST EAX,EAX
JZ 0x0018005a
ADDSD XMM0,qword ptr [0x001a0128]
LAB_0018005a:
MOV EAX,0xfffffff2
CMOVZ EDI,EAX
CALL 0x0010e660
LAB_00180067:
TEST R14W,R14W
JNS 0x00180075
XORPD XMM0,xmmword ptr [0x0019fff0]
LAB_00180075:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0018007d:
OR R14D,0x7c01
JMP 0x0018000b
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 js_math_f16round(double param_1)
{
double dVar1;
ulong uVar2;
uint uVar3;
int8 in_RAX;
int iVar4;
uint uVar5;
int4 uVar6;
int4 uVar7;
double dVar8;
int local_14;
local_14 = (int)((ulong)in_RAX >> 0x20);
uVar5 = (uint)((ulong)param_1 >> 0x30) & 0x8000;
if (ABS(param_1) == INFINITY) {
LAB_0017ff37:
uVar5 = uVar5 | 0x7c00;
}
else {
if (NAN(param_1)) {
uVar5 = uVar5 | 0x7c01;
goto LAB_0018000b;
}
if ((param_1 == 0.0) && (!NAN(param_1))) goto LAB_0018000b;
dVar1 = frexp((double)((ulong)param_1 & _DAT_001a0000),&local_14);
if (0x10 < local_14) goto LAB_0017ff37;
dVar8 = 0.0;
iVar4 = 0;
if (-0x19 < local_14) {
if (local_14 < -0xd) {
dVar8 = scalbn(dVar1 + dVar1,local_14 + 0xd);
iVar4 = 0;
}
else {
dVar8 = dVar1 + dVar1 + _DAT_001a0148;
iVar4 = local_14 + 0xe;
}
}
uVar3 = (uint)(dVar8 * _DAT_001a0150);
dVar1 = dVar8 * _DAT_001a0150 - (double)(uVar3 & 0xffff);
if (DAT_001a0158 <= dVar1) {
if ((uVar3 & 1) == 0) {
if ((dVar1 == DAT_001a0158) && (!NAN(dVar1) && !NAN(DAT_001a0158))) goto LAB_00180002;
}
uVar3 = uVar3 + 1;
if ((uVar3 & 0xffff) == 0x400) {
iVar4 = iVar4 + 1;
if (iVar4 == 0x1f) goto LAB_0017ff37;
uVar3 = 0;
}
}
LAB_00180002:
uVar5 = uVar5 | iVar4 << 10 | uVar3;
}
LAB_0018000b:
uVar3 = uVar5 & 0x7c00;
if (uVar3 == 0x7c00) {
uVar6 = (int4)*(int8 *)(&DAT_0019ffe0 + (ulong)((uVar5 & 0x3ff) == 0) * 8);
uVar7 = (int4)
((ulong)*(int8 *)(&DAT_0019ffe0 + (ulong)((uVar5 & 0x3ff) == 0) * 8) >> 0x20);
}
else {
dVar1 = (double)(uVar5 & 0x3ff) * _DAT_001a0140;
iVar4 = (uVar3 >> 10) - 0xf;
if (uVar3 == 0) {
iVar4 = -0xe;
}
else {
dVar1 = dVar1 + DAT_001a0128;
}
dVar1 = scalbn(dVar1,iVar4);
uVar6 = SUB84(dVar1,0);
uVar7 = (int4)((ulong)dVar1 >> 0x20);
}
if ((short)uVar5 < 0) {
uVar2 = CONCAT44(uVar7,uVar6) ^ _DAT_0019fff0;
uVar6 = (int4)uVar2;
uVar7 = (int4)(uVar2 >> 0x20);
}
return CONCAT44(uVar7,uVar6);
}
| |
30,062 | ma_open_datafile | eloqsql/storage/maria/ma_open.c | int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share)
{
myf flags= (share->mode & O_NOFOLLOW) ? MY_NOSYMLINKS | MY_WME : MY_WME;
if (share->temporary)
flags|= MY_THREAD_SPECIFIC;
DEBUG_SYNC_C("mi_open_datafile");
info->dfile.file= share->bitmap.file.file=
mysql_file_open(key_file_dfile, share->data_file_name.str,
share->mode | O_SHARE | O_CLOEXEC, flags);
return info->dfile.file >= 0 ? 0 : 1;
} | O0 | c | ma_open_datafile:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x7a4(%rax), %edx
andl $0x20000, %edx # imm = 0x20000
movl $0x10, %eax
movl $0x210, %ecx # imm = 0x210
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7d9(%rax)
je 0x65511
movq -0x18(%rbp), %rax
orq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
jmp 0x65513
jmp 0x65515
leaq 0x41d750(%rip), %rax # 0x482c6c
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x5c0(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x7a4(%rax), %r8d
orl $0x0, %r8d
orl $0x80000, %r8d # imm = 0x80000
movq -0x18(%rbp), %r9
leaq 0xf5ca0(%rip), %rsi # 0x15b1ea
movl $0x806, %edx # imm = 0x806
callq 0x63a20
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa60(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x480(%rax)
movq -0x8(%rbp), %rax
movl 0x480(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovgel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_open_datafile:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov edx, [rax+7A4h]
and edx, 20000h
mov eax, 10h
mov ecx, 210h
cmp edx, 0
cmovnz eax, ecx
mov eax, eax
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
cmp byte ptr [rax+7D9h], 0
jz short loc_65511
mov rax, [rbp+var_18]
or rax, 10000h
mov [rbp+var_18], rax
loc_65511:
jmp short $+2
loc_65513:
jmp short $+2
loc_65515:
lea rax, key_file_dfile
mov edi, [rax]
mov rax, [rbp+var_10]
mov rcx, [rax+5C0h]
mov rax, [rbp+var_10]
mov r8d, [rax+7A4h]
or r8d, 0
or r8d, 80000h
mov r9, [rbp+var_18]
lea rsi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 806h
call inline_mysql_file_open_1
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0A60h], ecx
mov rax, [rbp+var_8]
mov [rax+480h], ecx
mov rax, [rbp+var_8]
mov edx, [rax+480h]
mov eax, 1
xor ecx, ecx
cmp edx, 0
cmovge eax, ecx
add rsp, 20h
pop rbp
retn
| _BOOL8 ma_open_datafile(long long a1, long long a2)
{
unsigned int v2; // eax
int v3; // eax
long long v5; // [rsp+8h] [rbp-18h]
v2 = 16;
if ( (*(_DWORD *)(a2 + 1956) & 0x20000) != 0 )
v2 = 528;
v5 = v2;
if ( *(_BYTE *)(a2 + 2009) )
v5 = v2 | 0x10000LL;
v3 = inline_mysql_file_open_1(
key_file_dfile,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
0x806u,
*(_QWORD *)(a2 + 1472),
*(_DWORD *)(a2 + 1956) | 0x80000u,
v5);
*(_DWORD *)(a2 + 2656) = v3;
*(_DWORD *)(a1 + 1152) = v3;
return *(int *)(a1 + 1152) < 0;
}
| _ma_open_datafile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x7a4]
AND EDX,0x20000
MOV EAX,0x10
MOV ECX,0x210
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x7d9],0x0
JZ 0x00165511
MOV RAX,qword ptr [RBP + -0x18]
OR RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
LAB_00165511:
JMP 0x00165513
LAB_00165513:
JMP 0x00165515
LAB_00165515:
LEA RAX,[0x582c6c]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x5c0]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0x7a4]
OR R8D,0x0
OR R8D,0x80000
MOV R9,qword ptr [RBP + -0x18]
LEA RSI,[0x25b1ea]
MOV EDX,0x806
CALL 0x00163a20
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xa60],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x480],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0x480]
MOV EAX,0x1
XOR ECX,ECX
CMP EDX,0x0
CMOVGE EAX,ECX
ADD RSP,0x20
POP RBP
RET
|
bool _ma_open_datafile(long param_1,long param_2)
{
uint uVar1;
int4 uVar2;
uVar1 = 0x10;
if ((*(uint *)(param_2 + 0x7a4) & 0x20000) != 0) {
uVar1 = 0x210;
}
if (*(char *)(param_2 + 0x7d9) != '\0') {
uVar1 = uVar1 | 0x10000;
}
uVar2 = inline_mysql_file_open
(key_file_dfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x806,
*(int8 *)(param_2 + 0x5c0),*(uint *)(param_2 + 0x7a4) | 0x80000,uVar1);
*(int4 *)(param_2 + 0xa60) = uVar2;
*(int4 *)(param_1 + 0x480) = uVar2;
return *(int *)(param_1 + 0x480) < 0;
}
| |
30,063 | ma_write_abort_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_write_abort_block_record(MARIA_HA *info)
{
my_bool res= 0;
MARIA_BITMAP_BLOCKS *blocks= &info->cur_row.insert_blocks;
MARIA_BITMAP_BLOCK *block, *end;
LSN lsn= LSN_IMPOSSIBLE;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_write_abort_block_record");
_ma_bitmap_lock(share); /* Lock bitmap from other insert threads */
if (delete_head_or_tail(info,
ma_recordpos_to_page(info->cur_row.lastpos),
ma_recordpos_to_dir_entry(info->cur_row.lastpos), 1,
0))
res= 1;
for (block= blocks->block + 1, end= block + blocks->count - 1; block < end;
block++)
{
if (block->used & BLOCKUSED_USED)
{
if (block->used & BLOCKUSED_TAIL)
{
/*
block->page_count is set to the tail directory entry number in
write_block_record()
*/
if (delete_head_or_tail(info, block->page,
block->page_count & ~TAIL_BIT,
0, 0))
res= 1;
}
else
{
if (free_full_page_range(info, block->page, block->page_count))
res= 1;
}
}
}
_ma_bitmap_unlock(share);
if (share->now_transactional)
{
/*
Write clr to mark end of aborted row insert.
The above delete_head_or_tail() calls will only log redo, not undo.
The undo just before the row insert is stored in row->orig_undo_lsn.
When applying undo's, we can skip all undo records between current
lsn and row->orig_undo_lsn as logically things are as before the
attempted insert.
*/
if (_ma_write_clr(info, info->cur_row.orig_undo_lsn,
LOGREC_UNDO_ROW_INSERT,
share->calc_checksum != 0,
(ha_checksum) 0 - info->cur_row.checksum,
&lsn, (void*) 0))
res= 1;
}
_ma_unpin_all_pages_and_finalize_row(info, lsn);
DBUG_RETURN(res);
} | O0 | c | ma_write_abort_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62b10
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x56510
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x56530
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x56170
cmpb $0x0, %al
je 0x56025
movb $0x1, -0x9(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $-0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x560df
movq -0x20(%rbp), %rax
movzbl 0x14(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x560cc
movq -0x20(%rbp), %rax
movzbl 0x14(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x560a9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
andl $0xffff7fff, %edx # imm = 0xFFFF7FFF
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x56170
cmpb $0x0, %al
je 0x560a7
movb $0x1, -0x9(%rbp)
jmp 0x560ca
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x56550
cmpb $0x0, %al
je 0x560c8
movb $0x1, -0x9(%rbp)
jmp 0x560ca
jmp 0x560cc
jmp 0x560ce
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x5604e
movq -0x38(%rbp), %rdi
callq 0x62be0
movq -0x38(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x5614b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rsi
movq -0x38(%rbp), %rax
cmpq $0x0, 0x6a8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x8(%rbp), %rcx
xorl %r8d, %r8d
subl 0xb0(%rcx), %r8d
movl $0x12, %edx
leaq -0x30(%rbp), %r9
xorl %ecx, %ecx
movsbl %al, %ecx
movq $0x0, (%rsp)
callq 0x43fa0
cmpb $0x0, %al
je 0x56149
movb $0x1, -0x9(%rbp)
jmp 0x5614b
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x56780
movb -0x9(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_write_abort_block_record:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rax, [rbp+var_8]
add rax, 80h
mov [rbp+var_18], rax
mov [rbp+var_30], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
call _ma_bitmap_lock
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rdi, [rax+98h]
call ma_recordpos_to_page
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rdi, [rax+98h]
call ma_recordpos_to_dir_entry
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov edx, eax
mov ecx, 1
xor r8d, r8d
call delete_head_or_tail
cmp al, 0
jz short loc_56025
mov [rbp+var_9], 1
loc_56025:
mov rax, [rbp+var_18]
mov rax, [rax]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov ecx, [rcx+8]
imul rcx, 18h
add rax, rcx
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_28], rax
loc_5604E:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb loc_560DF
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+14h]
and eax, 1
cmp eax, 0
jz short loc_560CC
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+14h]
and eax, 4
cmp eax, 0
jz short loc_560A9
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
and edx, 0FFFF7FFFh
xor r8d, r8d
mov ecx, r8d
call delete_head_or_tail
cmp al, 0
jz short loc_560A7
mov [rbp+var_9], 1
loc_560A7:
jmp short loc_560CA
loc_560A9:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
call free_full_page_range
cmp al, 0
jz short loc_560C8
mov [rbp+var_9], 1
loc_560C8:
jmp short $+2
loc_560CA:
jmp short $+2
loc_560CC:
jmp short $+2
loc_560CE:
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp loc_5604E
loc_560DF:
mov rdi, [rbp+var_38]
call _ma_bitmap_unlock
mov rax, [rbp+var_38]
cmp byte ptr [rax+7E7h], 0
jz short loc_5614B
mov rdi, [rbp+var_8]
mov rax, [rbp+var_8]
mov rsi, [rax+0B8h]
mov rax, [rbp+var_38]
cmp qword ptr [rax+6A8h], 0
setnz al
and al, 1
movzx eax, al
mov rcx, [rbp+var_8]
xor r8d, r8d
sub r8d, [rcx+0B0h]
mov edx, 12h
lea r9, [rbp+var_30]
xor ecx, ecx
movsx ecx, al
mov [rsp+60h+var_60], 0
call _ma_write_clr
cmp al, 0
jz short loc_56149
mov [rbp+var_9], 1
loc_56149:
jmp short $+2
loc_5614B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
call _ma_unpin_all_pages_and_finalize_row_0
mov al, [rbp+var_9]
mov [rbp+var_49], al
mov al, [rbp+var_49]
add rsp, 60h
pop rbp
retn
| bool ma_write_abort_block_record(long long *a1)
{
unsigned int v1; // eax
long long v3; // [rsp+20h] [rbp-40h]
long long v4; // [rsp+28h] [rbp-38h]
long long v5; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v6; // [rsp+38h] [rbp-28h]
unsigned long long v7; // [rsp+40h] [rbp-20h]
_QWORD *v8; // [rsp+48h] [rbp-18h]
bool v9; // [rsp+57h] [rbp-9h]
long long *v10; // [rsp+58h] [rbp-8h]
v10 = a1;
v8 = a1 + 16;
v5 = 0LL;
v4 = *a1;
ma_bitmap_lock(*a1);
v3 = ma_recordpos_to_page(a1[19]);
v1 = ma_recordpos_to_dir_entry(a1[19]);
v9 = (unsigned __int8)delete_head_or_tail(a1, v3, v1, 1LL, 0LL) != 0;
v7 = a1[16] + 24;
v6 = 24LL * *((unsigned int *)a1 + 34) + v7 - 24;
while ( v7 < v6 )
{
if ( (*(_BYTE *)(v7 + 20) & 1) != 0 )
{
if ( (*(_BYTE *)(v7 + 20) & 4) != 0 )
{
if ( (unsigned __int8)delete_head_or_tail(v10, *(_QWORD *)v7, *(_DWORD *)(v7 + 8) & 0xFFFF7FFF, 0LL, 0LL) )
v9 = 1;
}
else if ( (unsigned __int8)free_full_page_range(v10, *(_QWORD *)v7, *(unsigned int *)(v7 + 8)) )
{
v9 = 1;
}
}
v7 += 24LL;
}
ma_bitmap_unlock(v4);
if ( *(_BYTE *)(v4 + 2023)
&& ma_write_clr(v10, v10[23], 18, *(_QWORD *)(v4 + 1704) != 0LL, -*((_DWORD *)v10 + 44), (long long)&v5, 0LL) )
{
v9 = 1;
}
ma_unpin_all_pages_and_finalize_row_0(v10, v5);
return v9;
}
| _ma_write_abort_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x80
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00162b10
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x00156510
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x00156530
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,EAX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x00156170
CMP AL,0x0
JZ 0x00156025
MOV byte ptr [RBP + -0x9],0x1
LAB_00156025:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x8]
IMUL RCX,RCX,0x18
ADD RAX,RCX
ADD RAX,-0x18
MOV qword ptr [RBP + -0x28],RAX
LAB_0015604e:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x001560df
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001560cc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x14]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001560a9
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
AND EDX,0xffff7fff
XOR R8D,R8D
MOV ECX,R8D
CALL 0x00156170
CMP AL,0x0
JZ 0x001560a7
MOV byte ptr [RBP + -0x9],0x1
LAB_001560a7:
JMP 0x001560ca
LAB_001560a9:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
CALL 0x00156550
CMP AL,0x0
JZ 0x001560c8
MOV byte ptr [RBP + -0x9],0x1
LAB_001560c8:
JMP 0x001560ca
LAB_001560ca:
JMP 0x001560cc
LAB_001560cc:
JMP 0x001560ce
LAB_001560ce:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015604e
LAB_001560df:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00162be0
MOV RAX,qword ptr [RBP + -0x38]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0015614b
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x6a8],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x8]
XOR R8D,R8D
SUB R8D,dword ptr [RCX + 0xb0]
MOV EDX,0x12
LEA R9,[RBP + -0x30]
XOR ECX,ECX
MOVSX ECX,AL
MOV qword ptr [RSP],0x0
CALL 0x00143fa0
CMP AL,0x0
JZ 0x00156149
MOV byte ptr [RBP + -0x9],0x1
LAB_00156149:
JMP 0x0015614b
LAB_0015614b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00156780
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x49],AL
MOV AL,byte ptr [RBP + -0x49]
ADD RSP,0x60
POP RBP
RET
|
int1 _ma_write_abort_block_record(long *param_1)
{
long lVar1;
long *plVar2;
char cVar3;
int4 uVar4;
int8 uVar5;
int8 local_38;
int8 *local_30;
int8 *local_28;
long *local_20;
int1 local_11;
long *local_10;
local_11 = 0;
local_20 = param_1 + 0x10;
local_38 = 0;
lVar1 = *param_1;
local_10 = param_1;
_ma_bitmap_lock(lVar1);
plVar2 = local_10;
uVar5 = ma_recordpos_to_page(local_10[0x13]);
uVar4 = ma_recordpos_to_dir_entry(local_10[0x13]);
cVar3 = delete_head_or_tail(plVar2,uVar5,uVar4,1,0);
if (cVar3 != '\0') {
local_11 = 1;
}
local_28 = (int8 *)(*local_20 + 0x18);
local_30 = local_28 + (ulong)*(uint *)(local_20 + 1) * 3 + -3;
for (; local_28 < local_30; local_28 = local_28 + 3) {
if ((*(byte *)((long)local_28 + 0x14) & 1) != 0) {
if ((*(byte *)((long)local_28 + 0x14) & 4) == 0) {
cVar3 = free_full_page_range(local_10,*local_28,*(int4 *)(local_28 + 1));
if (cVar3 != '\0') {
local_11 = 1;
}
}
else {
cVar3 = delete_head_or_tail(local_10,*local_28,*(uint *)(local_28 + 1) & 0xffff7fff,0);
if (cVar3 != '\0') {
local_11 = 1;
}
}
}
}
_ma_bitmap_unlock(lVar1);
if ((*(char *)(lVar1 + 0x7e7) != '\0') &&
(cVar3 = _ma_write_clr(local_10,local_10[0x17],0x12,*(long *)(lVar1 + 0x6a8) != 0,
-(int)local_10[0x16],&local_38,0), cVar3 != '\0')) {
local_11 = 1;
}
_ma_unpin_all_pages_and_finalize_row(local_10,local_38);
return local_11;
}
| |
30,064 | rlFramebufferComplete | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | bool rlFramebufferComplete(unsigned int id)
{
bool result = false;
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
glBindFramebuffer(GL_FRAMEBUFFER, id);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
switch (status)
{
case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break;
#if defined(GRAPHICS_API_OPENGL_ES2)
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break;
#endif
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break;
default: break;
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
result = (status == GL_FRAMEBUFFER_COMPLETE);
#endif
return result;
} | O0 | c | rlFramebufferComplete:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movq 0x161a2a(%rip), %rax # 0x218310
movl -0x4(%rbp), %esi
movl $0x8d40, %edi # imm = 0x8D40
callq *%rax
movl $0x8d40, %edi # imm = 0x8D40
callq *0x161b55(%rip) # 0x218450
movl %eax, -0xc(%rbp)
cmpl $0x8cd5, -0xc(%rbp) # imm = 0x8CD5
je 0xb697a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x8cd6, %eax # imm = 0x8CD6
je 0xb6946
jmp 0xb6916
movl -0x10(%rbp), %eax
subl $0x8cd7, %eax # imm = 0x8CD7
je 0xb695e
jmp 0xb6922
movl -0x10(%rbp), %eax
subl $0x8cdd, %eax # imm = 0x8CDD
jne 0xb6976
jmp 0xb692e
movl -0x4(%rbp), %edx
movl $0x4, %edi
leaq 0xfe44c(%rip), %rsi # 0x1b4d89
movb $0x0, %al
callq 0x182c40
jmp 0xb6978
movl -0x4(%rbp), %edx
movl $0x4, %edi
leaq 0xfe45c(%rip), %rsi # 0x1b4db1
movb $0x0, %al
callq 0x182c40
jmp 0xb6978
movl -0x4(%rbp), %edx
movl $0x4, %edi
leaq 0xfe477(%rip), %rsi # 0x1b4de4
movb $0x0, %al
callq 0x182c40
jmp 0xb6978
jmp 0xb6978
jmp 0xb697a
movl $0x8d40, %edi # imm = 0x8D40
xorl %esi, %esi
callq *0x161989(%rip) # 0x218310
cmpl $0x8cd5, -0xc(%rbp) # imm = 0x8CD5
sete %al
andb $0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rlFramebufferComplete:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_5], 0
mov rax, cs:glad_glBindFramebuffer
mov esi, [rbp+var_4]
mov edi, 8D40h
call rax ; glad_glBindFramebuffer
mov edi, 8D40h
call cs:glad_glCheckFramebufferStatus
mov [rbp+var_C], eax
cmp [rbp+var_C], 8CD5h
jz short loc_B697A
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
sub eax, 8CD6h
jz short loc_B6946
jmp short $+2
loc_B6916:
mov eax, [rbp+var_10]
sub eax, 8CD7h
jz short loc_B695E
jmp short $+2
loc_B6922:
mov eax, [rbp+var_10]
sub eax, 8CDDh
jnz short loc_B6976
jmp short $+2
loc_B692E:
mov edx, [rbp+var_4]
mov edi, 4
lea rsi, aFboIdIFramebuf; "FBO: [ID %i] Framebuffer is unsupported"
mov al, 0
call TraceLog
jmp short loc_B6978
loc_B6946:
mov edx, [rbp+var_4]
mov edi, 4
lea rsi, aFboIdIFramebuf_0; "FBO: [ID %i] Framebuffer has incomplete"...
mov al, 0
call TraceLog
jmp short loc_B6978
loc_B695E:
mov edx, [rbp+var_4]
mov edi, 4
lea rsi, aFboIdIFramebuf_1; "FBO: [ID %i] Framebuffer has a missing "...
mov al, 0
call TraceLog
jmp short loc_B6978
loc_B6976:
jmp short $+2
loc_B6978:
jmp short $+2
loc_B697A:
mov edi, 8D40h
xor esi, esi
call cs:glad_glBindFramebuffer
cmp [rbp+var_C], 8CD5h
setz al
and al, 1
mov [rbp+var_5], al
mov al, [rbp+var_5]
and al, 1
add rsp, 10h
pop rbp
retn
| bool rlFramebufferComplete(unsigned int a1)
{
int v1; // ecx
int v2; // r8d
int v3; // r9d
int v5; // [rsp+4h] [rbp-Ch]
glad_glBindFramebuffer(36160LL, a1);
v5 = glad_glCheckFramebufferStatus(36160LL);
if ( v5 != 36053 )
{
switch ( v5 )
{
case 36054:
TraceLog(4, (unsigned int)"FBO: [ID %i] Framebuffer has incomplete attachment", a1, v1, v2, v3);
break;
case 36055:
TraceLog(4, (unsigned int)"FBO: [ID %i] Framebuffer has a missing attachment", a1, v1, v2, v3);
break;
case 36061:
TraceLog(4, (unsigned int)"FBO: [ID %i] Framebuffer is unsupported", a1, v1, v2, v3);
break;
}
}
glad_glBindFramebuffer(36160LL, 0LL);
return v5 == 36053;
}
| rlFramebufferComplete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV byte ptr [RBP + -0x5],0x0
MOV RAX,qword ptr [0x00318310]
MOV ESI,dword ptr [RBP + -0x4]
MOV EDI,0x8d40
CALL RAX
MOV EDI,0x8d40
CALL qword ptr [0x00318450]
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x8cd5
JZ 0x001b697a
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
SUB EAX,0x8cd6
JZ 0x001b6946
JMP 0x001b6916
LAB_001b6916:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x8cd7
JZ 0x001b695e
JMP 0x001b6922
LAB_001b6922:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x8cdd
JNZ 0x001b6976
JMP 0x001b692e
LAB_001b692e:
MOV EDX,dword ptr [RBP + -0x4]
MOV EDI,0x4
LEA RSI,[0x2b4d89]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b6978
LAB_001b6946:
MOV EDX,dword ptr [RBP + -0x4]
MOV EDI,0x4
LEA RSI,[0x2b4db1]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b6978
LAB_001b695e:
MOV EDX,dword ptr [RBP + -0x4]
MOV EDI,0x4
LEA RSI,[0x2b4de4]
MOV AL,0x0
CALL 0x00282c40
JMP 0x001b6978
LAB_001b6976:
JMP 0x001b6978
LAB_001b6978:
JMP 0x001b697a
LAB_001b697a:
MOV EDI,0x8d40
XOR ESI,ESI
CALL qword ptr [0x00318310]
CMP dword ptr [RBP + -0xc],0x8cd5
SETZ AL
AND AL,0x1
MOV byte ptr [RBP + -0x5],AL
MOV AL,byte ptr [RBP + -0x5]
AND AL,0x1
ADD RSP,0x10
POP RBP
RET
|
bool rlFramebufferComplete(int4 param_1)
{
int iVar1;
(*glad_glBindFramebuffer)(0x8d40,param_1);
iVar1 = (*glad_glCheckFramebufferStatus)(0x8d40);
if (iVar1 != 0x8cd5) {
if (iVar1 == 0x8cd6) {
TraceLog(4,"FBO: [ID %i] Framebuffer has incomplete attachment",param_1);
}
else if (iVar1 == 0x8cd7) {
TraceLog(4,"FBO: [ID %i] Framebuffer has a missing attachment",param_1);
}
else if (iVar1 == 0x8cdd) {
TraceLog(4,"FBO: [ID %i] Framebuffer is unsupported",param_1);
}
}
(*glad_glBindFramebuffer)(0x8d40,0);
return iVar1 == 0x8cd5;
}
| |
30,065 | rlFramebufferComplete | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | bool rlFramebufferComplete(unsigned int id)
{
bool result = false;
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
glBindFramebuffer(GL_FRAMEBUFFER, id);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
switch (status)
{
case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break;
#if defined(GRAPHICS_API_OPENGL_ES2)
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break;
#endif
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break;
default: break;
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
result = (status == GL_FRAMEBUFFER_COMPLETE);
#endif
return result;
} | O3 | c | rlFramebufferComplete:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x8d40, %edi # imm = 0x8D40
movl %ebx, %esi
callq *0xd4343(%rip) # 0x139250
movl $0x8d40, %edi # imm = 0x8D40
callq *0xd4478(%rip) # 0x139390
movl %eax, %ebp
cmpl $0x8cdd, %eax # imm = 0x8CDD
je 0x64f43
cmpl $0x8cd7, %ebp # imm = 0x8CD7
je 0x64f3a
cmpl $0x8cd6, %ebp # imm = 0x8CD6
jne 0x64f58
leaq 0x7a419(%rip), %rsi # 0xdf351
jmp 0x64f4a
leaq 0x7a443(%rip), %rsi # 0xdf384
jmp 0x64f4a
leaq 0x7a3df(%rip), %rsi # 0xdf329
movl $0x4, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0xb9db7
movl $0x8d40, %edi # imm = 0x8D40
xorl %esi, %esi
callq *0xd42eb(%rip) # 0x139250
cmpl $0x8cd5, %ebp # imm = 0x8CD5
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| rlFramebufferComplete:
push rbp
push rbx
push rax
mov ebx, edi
mov edi, 8D40h
mov esi, ebx
call cs:glad_glBindFramebuffer
mov edi, 8D40h
call cs:glad_glCheckFramebufferStatus
mov ebp, eax
cmp eax, 8CDDh
jz short loc_64F43
cmp ebp, 8CD7h
jz short loc_64F3A
cmp ebp, 8CD6h
jnz short loc_64F58
lea rsi, aFboIdIFramebuf; "FBO: [ID %i] Framebuffer has incomplete"...
jmp short loc_64F4A
loc_64F3A:
lea rsi, aFboIdIFramebuf_0; "FBO: [ID %i] Framebuffer has a missing "...
jmp short loc_64F4A
loc_64F43:
lea rsi, aFboIdIFramebuf_1; "FBO: [ID %i] Framebuffer is unsupported"
loc_64F4A:
mov edi, 4
mov edx, ebx
xor eax, eax
call TraceLog
loc_64F58:
mov edi, 8D40h
xor esi, esi
call cs:glad_glBindFramebuffer
cmp ebp, 8CD5h
setz al
add rsp, 8
pop rbx
pop rbp
retn
| bool rlFramebufferComplete(unsigned int a1)
{
int v1; // ecx
int v2; // ebp
int v3; // r8d
int v4; // r9d
const char *v5; // rsi
glad_glBindFramebuffer(36160LL, a1);
v2 = glad_glCheckFramebufferStatus(36160LL);
switch ( v2 )
{
case 36061:
v5 = "FBO: [ID %i] Framebuffer is unsupported";
goto LABEL_7;
case 36055:
v5 = "FBO: [ID %i] Framebuffer has a missing attachment";
goto LABEL_7;
case 36054:
v5 = "FBO: [ID %i] Framebuffer has incomplete attachment";
LABEL_7:
TraceLog(4, (_DWORD)v5, a1, v1, v3, v4);
break;
}
glad_glBindFramebuffer(36160LL, 0LL);
return v2 == 36053;
}
| rlFramebufferComplete:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBX,EDI
MOV EDI,0x8d40
MOV ESI,EBX
CALL qword ptr [0x00239250]
MOV EDI,0x8d40
CALL qword ptr [0x00239390]
MOV EBP,EAX
CMP EAX,0x8cdd
JZ 0x00164f43
CMP EBP,0x8cd7
JZ 0x00164f3a
CMP EBP,0x8cd6
JNZ 0x00164f58
LEA RSI,[0x1df351]
JMP 0x00164f4a
LAB_00164f3a:
LEA RSI,[0x1df384]
JMP 0x00164f4a
LAB_00164f43:
LEA RSI,[0x1df329]
LAB_00164f4a:
MOV EDI,0x4
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001b9db7
LAB_00164f58:
MOV EDI,0x8d40
XOR ESI,ESI
CALL qword ptr [0x00239250]
CMP EBP,0x8cd5
SETZ AL
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool rlFramebufferComplete(int4 param_1)
{
int iVar1;
char *pcVar2;
(*glad_glBindFramebuffer)(0x8d40,param_1);
iVar1 = (*glad_glCheckFramebufferStatus)(0x8d40);
if (iVar1 == 0x8cdd) {
pcVar2 = "FBO: [ID %i] Framebuffer is unsupported";
}
else if (iVar1 == 0x8cd7) {
pcVar2 = "FBO: [ID %i] Framebuffer has a missing attachment";
}
else {
if (iVar1 != 0x8cd6) goto LAB_00164f58;
pcVar2 = "FBO: [ID %i] Framebuffer has incomplete attachment";
}
TraceLog(4,pcVar2,param_1);
LAB_00164f58:
(*glad_glBindFramebuffer)(0x8d40,0);
return iVar1 == 0x8cd5;
}
| |
30,066 | my_xml_scan | eloqsql/strings/xml.c | static int my_xml_scan(MY_XML_PARSER *p,MY_XML_ATTR *a)
{
int lex;
for (; ( p->cur < p->end) && my_xml_is_space(p->cur[0]) ; p->cur++);
if (p->cur >= p->end)
{
a->beg=p->end;
a->end=p->end;
lex=MY_XML_EOF;
goto ret;
}
a->beg=p->cur;
a->end=p->cur;
if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("<!--")))
{
for (; p->cur < p->end; p->cur++)
{
if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("-->")))
{
p->cur+= 3;
break;
}
}
a->end=p->cur;
lex=MY_XML_COMMENT;
}
else if (!my_xml_parser_prefix_cmp(p, C_STRING_WITH_LEN("<![CDATA[")))
{
p->cur+= 9;
for (; p->cur < p->end - 2 ; p->cur++)
{
if (p->cur[0] == ']' && p->cur[1] == ']' && p->cur[2] == '>')
{
p->cur+= 3;
a->end= p->cur;
break;
}
}
lex= MY_XML_CDATA;
}
else if (strchr("?=/<>!",p->cur[0]))
{
p->cur++;
a->end=p->cur;
lex=a->beg[0];
}
else if ( (p->cur[0] == '"') || (p->cur[0] == '\'') )
{
/*
"string" or 'string' found.
Scan until the closing quote/doublequote, or until the END-OF-INPUT.
*/
p->cur++;
for (; ( p->cur < p->end ) && (p->cur[0] != a->beg[0]); p->cur++)
{}
a->end=p->cur;
if (p->cur < p->end) /* Closing quote or doublequote has been found */
p->cur++;
a->beg++;
if (!(p->flags & MY_XML_FLAG_SKIP_TEXT_NORMALIZATION))
my_xml_norm_text(a);
lex=MY_XML_STRING;
}
else if (my_xml_is_id0(p->cur[0]))
{
p->cur++;
while (p->cur < p->end && my_xml_is_id1(p->cur[0]))
p->cur++;
a->end=p->cur;
my_xml_norm_text(a);
lex=MY_XML_IDENT;
}
else
lex= MY_XML_UNKNOWN;
#if 0
printf("LEX=%s[%d]\n",lex2str(lex),a->end-a->beg);
#endif
ret:
return lex;
} | O3 | c | my_xml_scan:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x130(%rdi), %rax
movq 0x138(%rdi), %rcx
cmpq %rcx, %rax
jae 0x5aaa6
leaq 0x27e882(%rip), %rbx # 0x2d9310
movzbl (%rax), %edx
testb $0x8, (%rdx,%rbx)
je 0x5aacc
incq %rax
movq %rax, 0x130(%r14)
cmpq %rcx, %rax
jne 0x5aa8e
movq %rcx, (%rsi)
movq 0x138(%r14), %rax
movq %rax, 0x8(%rsi)
movl $0x45, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsi)
movq 0x130(%r14), %r13
movq %r13, 0x8(%rsi)
movq 0x138(%r14), %r12
leaq 0x4(%r13), %rax
cmpq %r12, %rax
ja 0x5aaf4
cmpl $0x2d2d213c, (%r13) # imm = 0x2D2D213C
je 0x5ab5d
leaq 0x9(%r13), %rax
cmpq %r12, %rax
ja 0x5ab1d
movabsq $0x41544144435b213c, %rcx # imm = 0x41544144435B213C
xorq (%r13), %rcx
movzbl 0x8(%r13), %edx
xorq $0x5b, %rdx
orq %rcx, %rdx
je 0x5ac0a
movq %rsi, -0x30(%rbp)
movsbl (%r13), %r15d
leaq 0x5f71(%rip), %rdi # 0x60a9e
movl $0x7, %edx
movl %r15d, %esi
callq 0x24310
testq %rax, %rax
je 0x5ab99
incq %r13
movq %r13, 0x130(%r14)
movq -0x30(%rbp), %rax
movq %r13, 0x8(%rax)
movq (%rax), %rax
movsbl (%rax), %r15d
jmp 0x5aaba
leaq 0x3(%r13), %rax
cmpq %r12, %rax
ja 0x5ab82
movzwl (%r13), %ecx
xorl $0x2d2d, %ecx # imm = 0x2D2D
movzbl 0x2(%r13), %edx
xorl $0x3e, %edx
orw %cx, %dx
je 0x5aca0
incq %r13
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jne 0x5ab5d
movq %r12, %rax
jmp 0x5aca7
movzbl %r15b, %eax
cmpq $0x27, %rax
movq -0x30(%rbp), %rdi
je 0x5abb0
cmpl $0x22, %eax
jne 0x5ac5d
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5abcf
movb (%rax), %cl
movq (%rdi), %rdx
leaq 0x1(%rax), %r13
cmpb (%rdx), %cl
jne 0x5abb3
movq %rax, 0x8(%rdi)
movq 0x130(%r14), %rax
cmpq 0x138(%r14), %rax
jae 0x5abed
incq %rax
movq %rax, 0x130(%r14)
incq (%rdi)
movl $0x53, %r15d
testb $0x2, (%r14)
jne 0x5aaba
callq 0x5b09b
jmp 0x5aaba
leaq -0x2(%r12), %rcx
movq %rax, 0x130(%r14)
movl $0x44, %r15d
cmpq %rcx, %rax
jae 0x5aaba
subq %r13, %r12
addq $0xc, %r13
addq $-0xb, %r12
cmpb $0x5d, -0x3(%r13)
jne 0x5ac45
cmpb $0x5d, -0x2(%r13)
jne 0x5ac45
cmpb $0x3e, -0x1(%r13)
je 0x5acb6
leaq -0x2(%r13), %rax
movq %rax, 0x130(%r14)
incq %r13
decq %r12
jne 0x5ac30
jmp 0x5aaba
movl $0x55, %r15d
testb $0x1, (%rax,%rbx)
je 0x5aaba
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5ac8c
movzbl (%rax), %ecx
leaq 0x1(%rax), %r13
testb $0x2, (%rcx,%rbx)
jne 0x5ac70
movq %rax, 0x8(%rdi)
callq 0x5b09b
movl $0x49, %r15d
jmp 0x5aaba
movq %rax, 0x130(%r14)
movq %rax, 0x8(%rsi)
movl $0x43, %r15d
jmp 0x5aaba
movq %r13, 0x130(%r14)
movq %r13, 0x8(%rsi)
jmp 0x5aaba
| my_xml_scan:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov rax, [rdi+130h]
mov rcx, [rdi+138h]
cmp rax, rcx
jnb short loc_5AAA6
lea rbx, my_xml_ctype
loc_5AA8E:
movzx edx, byte ptr [rax]
test byte ptr [rdx+rbx], 8
jz short loc_5AACC
inc rax
mov [r14+130h], rax
cmp rax, rcx
jnz short loc_5AA8E
loc_5AAA6:
mov [rsi], rcx
mov rax, [r14+138h]
mov [rsi+8], rax
mov r15d, 45h ; 'E'
loc_5AABA:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5AACC:
mov [rsi], rax
mov r13, [r14+130h]
mov [rsi+8], r13
mov r12, [r14+138h]
lea rax, [r13+4]
cmp rax, r12
ja short loc_5AAF4
cmp dword ptr [r13+0], 2D2D213Ch
jz short loc_5AB5D
loc_5AAF4:
lea rax, [r13+9]
cmp rax, r12
ja short loc_5AB1D
mov rcx, 41544144435B213Ch
xor rcx, [r13+0]
movzx edx, byte ptr [r13+8]
xor rdx, 5Bh
or rdx, rcx
jz loc_5AC0A
loc_5AB1D:
mov [rbp+var_30], rsi
movsx r15d, byte ptr [r13+0]
lea rdi, asc_60A9E; "?=/<>!"
mov edx, 7
mov esi, r15d
call _memchr
test rax, rax
jz short loc_5AB99
inc r13
mov [r14+130h], r13
mov rax, [rbp+var_30]
mov [rax+8], r13
mov rax, [rax]
movsx r15d, byte ptr [rax]
jmp loc_5AABA
loc_5AB5D:
lea rax, [r13+3]
cmp rax, r12
ja short loc_5AB82
movzx ecx, word ptr [r13+0]
xor ecx, 2D2Dh
movzx edx, byte ptr [r13+2]
xor edx, 3Eh
or dx, cx
jz loc_5ACA0
loc_5AB82:
inc r13
mov [r14+130h], r13
cmp r13, r12
jnz short loc_5AB5D
mov rax, r12
jmp loc_5ACA7
loc_5AB99:
movzx eax, r15b
cmp rax, 27h ; '''
mov rdi, [rbp+var_30]
jz short loc_5ABB0
cmp eax, 22h ; '"'
jnz loc_5AC5D
loc_5ABB0:
inc r13
loc_5ABB3:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5ABCF
mov cl, [rax]
mov rdx, [rdi]
lea r13, [rax+1]
cmp cl, [rdx]
jnz short loc_5ABB3
loc_5ABCF:
mov [rdi+8], rax
mov rax, [r14+130h]
cmp rax, [r14+138h]
jnb short loc_5ABED
inc rax
mov [r14+130h], rax
loc_5ABED:
inc qword ptr [rdi]
mov r15d, 53h ; 'S'
test byte ptr [r14], 2
jnz loc_5AABA
call my_xml_norm_text
jmp loc_5AABA
loc_5AC0A:
lea rcx, [r12-2]
mov [r14+130h], rax
mov r15d, 44h ; 'D'
cmp rax, rcx
jnb loc_5AABA
sub r12, r13
add r13, 0Ch
add r12, 0FFFFFFFFFFFFFFF5h
loc_5AC30:
cmp byte ptr [r13-3], 5Dh ; ']'
jnz short loc_5AC45
cmp byte ptr [r13-2], 5Dh ; ']'
jnz short loc_5AC45
cmp byte ptr [r13-1], 3Eh ; '>'
jz short loc_5ACB6
loc_5AC45:
lea rax, [r13-2]
mov [r14+130h], rax
inc r13
dec r12
jnz short loc_5AC30
jmp loc_5AABA
loc_5AC5D:
mov r15d, 55h ; 'U'
test byte ptr [rax+rbx], 1
jz loc_5AABA
inc r13
loc_5AC70:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5AC8C
movzx ecx, byte ptr [rax]
lea r13, [rax+1]
test byte ptr [rcx+rbx], 2
jnz short loc_5AC70
loc_5AC8C:
mov [rdi+8], rax
call my_xml_norm_text
mov r15d, 49h ; 'I'
jmp loc_5AABA
loc_5ACA0:
mov [r14+130h], rax
loc_5ACA7:
mov [rsi+8], rax
mov r15d, 43h ; 'C'
jmp loc_5AABA
loc_5ACB6:
mov [r14+130h], r13
mov [rsi+8], r13
jmp loc_5AABA
| long long my_xml_scan(long long a1, unsigned __int8 **a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 *v3; // rcx
unsigned int v4; // r15d
char *v6; // r13
unsigned long long v7; // r12
unsigned long long v8; // rax
unsigned __int8 v9; // r15
char *v10; // r13
char *v11; // rax
long long v12; // rax
char *v13; // r13
char *v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // r12
char *v17; // r13
unsigned long long v18; // r12
char *v19; // r13
char *v20; // rax
long long v21; // rcx
v2 = *(unsigned __int8 **)(a1 + 304);
v3 = *(unsigned __int8 **)(a1 + 312);
if ( v2 >= v3 )
{
LABEL_4:
*a2 = v3;
a2[1] = *(unsigned __int8 **)(a1 + 312);
return 69;
}
else
{
while ( (my_xml_ctype[*v2] & 8) != 0 )
{
*(_QWORD *)(a1 + 304) = ++v2;
if ( v2 == v3 )
goto LABEL_4;
}
*a2 = v2;
v6 = *(char **)(a1 + 304);
a2[1] = (unsigned __int8 *)v6;
v7 = *(_QWORD *)(a1 + 312);
if ( (unsigned long long)(v6 + 4) <= v7 && *(_DWORD *)v6 == 757932348 )
{
while ( 1 )
{
v11 = v6 + 3;
if ( (unsigned long long)(v6 + 3) <= v7 && !(*(_WORD *)v6 ^ 0x2D2D | (unsigned __int8)v6[2] ^ 0x3E) )
break;
*(_QWORD *)(a1 + 304) = ++v6;
if ( v6 == (char *)v7 )
{
v11 = (char *)v7;
goto LABEL_38;
}
}
*(_QWORD *)(a1 + 304) = v11;
LABEL_38:
a2[1] = (unsigned __int8 *)v11;
return 67;
}
else
{
v8 = (unsigned long long)(v6 + 9);
if ( (unsigned long long)(v6 + 9) > v7 || *(_QWORD *)v6 ^ 0x41544144435B213CLL | (unsigned __int8)v6[8] ^ 0x5BLL )
{
v9 = *v6;
if ( memchr("?=/<>!", (unsigned int)*v6, 7LL) )
{
v10 = v6 + 1;
*(_QWORD *)(a1 + 304) = v10;
a2[1] = (unsigned __int8 *)v10;
return (unsigned int)(char)**a2;
}
else
{
v12 = v9;
if ( v9 == 39LL || v9 == 34 )
{
v13 = v6 + 1;
do
{
v14 = v13;
*(_QWORD *)(a1 + 304) = v13;
if ( (unsigned long long)v13 >= v7 )
break;
++v13;
}
while ( *v14 != **a2 );
a2[1] = (unsigned __int8 *)v14;
v15 = *(_QWORD *)(a1 + 304);
if ( v15 < *(_QWORD *)(a1 + 312) )
*(_QWORD *)(a1 + 304) = v15 + 1;
++*a2;
v4 = 83;
if ( (*(_BYTE *)a1 & 2) == 0 )
my_xml_norm_text(a2);
}
else
{
v4 = 85;
if ( (my_xml_ctype[v12] & 1) != 0 )
{
v19 = v6 + 1;
do
{
v20 = v19;
*(_QWORD *)(a1 + 304) = v19;
if ( (unsigned long long)v19 >= v7 )
break;
v21 = (unsigned __int8)*v19++;
}
while ( (my_xml_ctype[v21] & 2) != 0 );
a2[1] = (unsigned __int8 *)v20;
my_xml_norm_text(a2);
return 73;
}
}
}
}
else
{
*(_QWORD *)(a1 + 304) = v8;
v4 = 68;
if ( v8 < v7 - 2 )
{
v16 = v7 - (_QWORD)v6;
v17 = v6 + 12;
v18 = v16 - 11;
while ( *(v17 - 3) != 93 || *(v17 - 2) != 93 || *(v17 - 1) != 62 )
{
*(_QWORD *)(a1 + 304) = v17 - 2;
++v17;
if ( !--v18 )
return v4;
}
*(_QWORD *)(a1 + 304) = v17;
a2[1] = (unsigned __int8 *)v17;
}
}
}
}
return v4;
}
| my_xml_scan:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x130]
MOV RCX,qword ptr [RDI + 0x138]
CMP RAX,RCX
JNC 0x0015aaa6
LEA RBX,[0x3d9310]
LAB_0015aa8e:
MOVZX EDX,byte ptr [RAX]
TEST byte ptr [RDX + RBX*0x1],0x8
JZ 0x0015aacc
INC RAX
MOV qword ptr [R14 + 0x130],RAX
CMP RAX,RCX
JNZ 0x0015aa8e
LAB_0015aaa6:
MOV qword ptr [RSI],RCX
MOV RAX,qword ptr [R14 + 0x138]
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x45
LAB_0015aaba:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015aacc:
MOV qword ptr [RSI],RAX
MOV R13,qword ptr [R14 + 0x130]
MOV qword ptr [RSI + 0x8],R13
MOV R12,qword ptr [R14 + 0x138]
LEA RAX,[R13 + 0x4]
CMP RAX,R12
JA 0x0015aaf4
CMP dword ptr [R13],0x2d2d213c
JZ 0x0015ab5d
LAB_0015aaf4:
LEA RAX,[R13 + 0x9]
CMP RAX,R12
JA 0x0015ab1d
MOV RCX,0x41544144435b213c
XOR RCX,qword ptr [R13]
MOVZX EDX,byte ptr [R13 + 0x8]
XOR RDX,0x5b
OR RDX,RCX
JZ 0x0015ac0a
LAB_0015ab1d:
MOV qword ptr [RBP + -0x30],RSI
MOVSX R15D,byte ptr [R13]
LEA RDI,[0x160a9e]
MOV EDX,0x7
MOV ESI,R15D
CALL 0x00124310
TEST RAX,RAX
JZ 0x0015ab99
INC R13
MOV qword ptr [R14 + 0x130],R13
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],R13
MOV RAX,qword ptr [RAX]
MOVSX R15D,byte ptr [RAX]
JMP 0x0015aaba
LAB_0015ab5d:
LEA RAX,[R13 + 0x3]
CMP RAX,R12
JA 0x0015ab82
MOVZX ECX,word ptr [R13]
XOR ECX,0x2d2d
MOVZX EDX,byte ptr [R13 + 0x2]
XOR EDX,0x3e
OR DX,CX
JZ 0x0015aca0
LAB_0015ab82:
INC R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNZ 0x0015ab5d
MOV RAX,R12
JMP 0x0015aca7
LAB_0015ab99:
MOVZX EAX,R15B
CMP RAX,0x27
MOV RDI,qword ptr [RBP + -0x30]
JZ 0x0015abb0
CMP EAX,0x22
JNZ 0x0015ac5d
LAB_0015abb0:
INC R13
LAB_0015abb3:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015abcf
MOV CL,byte ptr [RAX]
MOV RDX,qword ptr [RDI]
LEA R13,[RAX + 0x1]
CMP CL,byte ptr [RDX]
JNZ 0x0015abb3
LAB_0015abcf:
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [R14 + 0x130]
CMP RAX,qword ptr [R14 + 0x138]
JNC 0x0015abed
INC RAX
MOV qword ptr [R14 + 0x130],RAX
LAB_0015abed:
INC qword ptr [RDI]
MOV R15D,0x53
TEST byte ptr [R14],0x2
JNZ 0x0015aaba
CALL 0x0015b09b
JMP 0x0015aaba
LAB_0015ac0a:
LEA RCX,[R12 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
MOV R15D,0x44
CMP RAX,RCX
JNC 0x0015aaba
SUB R12,R13
ADD R13,0xc
ADD R12,-0xb
LAB_0015ac30:
CMP byte ptr [R13 + -0x3],0x5d
JNZ 0x0015ac45
CMP byte ptr [R13 + -0x2],0x5d
JNZ 0x0015ac45
CMP byte ptr [R13 + -0x1],0x3e
JZ 0x0015acb6
LAB_0015ac45:
LEA RAX,[R13 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
INC R13
DEC R12
JNZ 0x0015ac30
JMP 0x0015aaba
LAB_0015ac5d:
MOV R15D,0x55
TEST byte ptr [RAX + RBX*0x1],0x1
JZ 0x0015aaba
INC R13
LAB_0015ac70:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015ac8c
MOVZX ECX,byte ptr [RAX]
LEA R13,[RAX + 0x1]
TEST byte ptr [RCX + RBX*0x1],0x2
JNZ 0x0015ac70
LAB_0015ac8c:
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015b09b
MOV R15D,0x49
JMP 0x0015aaba
LAB_0015aca0:
MOV qword ptr [R14 + 0x130],RAX
LAB_0015aca7:
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x43
JMP 0x0015aaba
LAB_0015acb6:
MOV qword ptr [R14 + 0x130],R13
MOV qword ptr [RSI + 0x8],R13
JMP 0x0015aaba
|
int my_xml_scan(byte *param_1,long *param_2)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
void *pvVar4;
byte *pbVar5;
byte *pbVar6;
pbVar3 = *(byte **)(param_1 + 0x130);
pbVar5 = *(byte **)(param_1 + 0x138);
if (pbVar3 < pbVar5) {
do {
if ((my_xml_ctype[*pbVar3] & 8) == 0) {
*param_2 = (long)pbVar3;
pbVar3 = *(byte **)(param_1 + 0x130);
param_2[1] = (long)pbVar3;
pbVar5 = *(byte **)(param_1 + 0x138);
if ((pbVar3 + 4 <= pbVar5) && (*(int *)pbVar3 == 0x2d2d213c)) goto LAB_0015ab5d;
pbVar6 = pbVar3 + 9;
if ((pbVar6 <= pbVar5) && (pbVar3[8] == 0x5b && *(long *)pbVar3 == 0x41544144435b213c)) {
*(byte **)(param_1 + 0x130) = pbVar6;
if (pbVar5 + -2 <= pbVar6) {
return 0x44;
}
pbVar6 = pbVar3 + 0xc;
pbVar5 = pbVar5 + (-0xb - (long)pbVar3);
while (((pbVar6[-3] != 0x5d || (pbVar6[-2] != 0x5d)) || (pbVar6[-1] != 0x3e))) {
*(byte **)(param_1 + 0x130) = pbVar6 + -2;
pbVar6 = pbVar6 + 1;
pbVar5 = pbVar5 + -1;
if (pbVar5 == (byte *)0x0) {
return 0x44;
}
}
*(byte **)(param_1 + 0x130) = pbVar6;
param_2[1] = (long)pbVar6;
return 0x44;
}
bVar1 = *pbVar3;
pvVar4 = memchr("?=/<>!",(int)(char)bVar1,7);
if (pvVar4 != (void *)0x0) {
*(byte **)(param_1 + 0x130) = pbVar3 + 1;
param_2[1] = (long)(pbVar3 + 1);
return (int)*(char *)*param_2;
}
uVar2 = (uint)bVar1;
if (((ulong)uVar2 == 0x27) || (uVar2 == 0x22)) goto LAB_0015abb3;
if ((my_xml_ctype[uVar2] & 1) == 0) {
return 0x55;
}
goto LAB_0015ac70;
}
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
} while (pbVar3 != pbVar5);
}
*param_2 = (long)pbVar5;
param_2[1] = *(long *)(param_1 + 0x138);
return 0x45;
LAB_0015ab5d:
pbVar6 = pbVar3 + 3;
if ((pbVar6 <= pbVar5) && (pbVar3[2] == 0x3e && *(short *)pbVar3 == 0x2d2d)) {
*(byte **)(param_1 + 0x130) = pbVar6;
pbVar5 = pbVar6;
goto LAB_0015aca7;
}
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar3 == pbVar5) {
LAB_0015aca7:
param_2[1] = (long)pbVar5;
return 0x43;
}
goto LAB_0015ab5d;
while (*pbVar3 != *(byte *)*param_2) {
LAB_0015abb3:
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar5 <= pbVar3) break;
}
param_2[1] = (long)pbVar3;
if (*(ulong *)(param_1 + 0x130) < *(ulong *)(param_1 + 0x138)) {
*(ulong *)(param_1 + 0x130) = *(ulong *)(param_1 + 0x130) + 1;
}
*param_2 = *param_2 + 1;
if ((*param_1 & 2) != 0) {
return 0x53;
}
my_xml_norm_text();
return 0x53;
while ((my_xml_ctype[*pbVar3] & 2) != 0) {
LAB_0015ac70:
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar5 <= pbVar3) break;
}
param_2[1] = (long)pbVar3;
my_xml_norm_text();
return 0x49;
}
| |
30,067 | testing::internal::FilePath::DirectoryExists() const | seiftnesse[P]memoryallocator/build_O2/_deps/googletest-src/googletest/src/gtest-filepath.cc | bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this
: RemoveTrailingPathSeparator());
#else
const FilePath& path(*this);
#endif
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
if ((attributes != kInvalidFileAttributes) &&
(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
result = true;
}
#else
posix::StatStruct file_stat{};
result =
posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat);
#endif // GTEST_OS_WINDOWS_MOBILE
return result;
} | O2 | cpp | testing::internal::FilePath::DirectoryExists() const:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x92c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x9460
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4000
orl %eax, %ecx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| _ZNK7testing8internal8FilePath15DirectoryExistsEv:
push r14
push rbx
sub rsp, 98h
mov rbx, rdi
lea r14, [rsp+0A8h+var_A0]
mov edx, 90h
mov rdi, r14
xor esi, esi
call _memset
mov rdi, [rbx]
mov rsi, r14
call _stat
mov ecx, [r14+18h]
and ecx, 0F000h
xor ecx, 4000h
or ecx, eax
setz al
add rsp, 98h
pop rbx
pop r14
retn
| bool testing::internal::FilePath::DirectoryExists(testing::internal::FilePath *this)
{
int v1; // eax
_BYTE v3[24]; // [rsp+8h] [rbp-A0h] BYREF
__int16 v4; // [rsp+20h] [rbp-88h]
memset(v3, 0LL, 144LL);
v1 = stat(*(_QWORD *)this, v3);
return (v1 | v4 & 0xF000 ^ 0x4000) == 0;
}
| DirectoryExists:
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV EDX,0x90
MOV RDI,R14
XOR ESI,ESI
CALL 0x001092c0
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x00109460
MOV ECX,dword ptr [R14 + 0x18]
AND ECX,0xf000
XOR ECX,0x4000
OR ECX,EAX
SETZ AL
ADD RSP,0x98
POP RBX
POP R14
RET
|
/* testing::internal::FilePath::DirectoryExists() const */
int8 __thiscall testing::internal::FilePath::DirectoryExists(FilePath *this)
{
int iVar1;
int4 extraout_var;
stat local_a0;
memset(&local_a0,0,0x90);
iVar1 = stat(*(char **)this,&local_a0);
return CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),
(local_a0.st_mode & 0xf000) == 0x4000 && iVar1 == 0);
}
| |
30,068 | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&) | monkey531[P]llama/common/minja.hpp | static std::shared_ptr<TemplateNode> parse(const std::string& template_str, const Options & options) {
Parser parser(std::make_shared<std::string>(normalize_newlines(template_str)), options);
auto tokens = parser.tokenize();
TemplateTokenIterator begin = tokens.begin();
auto it = begin;
TemplateTokenIterator end = tokens.end();
return parser.parseTemplate(begin, it, end, /* full= */ true);
} | O1 | cpp | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x23264
movq $0x0, 0x20(%rsp)
movl $0x30, %edi
callq 0x196c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x8cad7(%rip), %rcx # 0xec3d0
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movq %rax, %rdx
addq $0x20, %rdx
movq %rdx, 0x10(%rax)
movq (%rsp), %rsi
cmpq %r15, %rsi
je 0x5f925
movq %rsi, (%rcx)
movq 0x10(%rsp), %rsi
movq %rsi, (%rdx)
jmp 0x5f92c
movups (%r15), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rsp), %rdx
movq %rdx, 0x18(%rax)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x60716
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5f96f
callq 0x31024
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5f985
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x196d0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x607e0
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %r8
movq %rsi, (%r8)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x62f80
movq %rsp, %rdi
callq 0x6437a
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x5f9dd
callq 0x31024
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6437a
jmp 0x5f9fa
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x5fa38
callq 0x31024
jmp 0x5fa38
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5fa22
callq 0x31024
jmp 0x5fa22
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5fa38
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x196d0
movq %rbx, %rdi
callq 0x19c00
| _ZN5minja6Parser5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7OptionsE:
push r15
push r14
push rbx
sub rsp, 70h
mov r14, rdx
mov rbx, rdi
lea r15, [rsp+88h+var_78]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
mov rdi, rsp
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov [rsp+88h+var_68], 0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<std::string>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
lea rcx, [rax+10h]
mov rdx, rax
add rdx, 20h ; ' '
mov [rax+10h], rdx
mov rsi, [rsp+88h+var_88]
cmp rsi, r15
jz short loc_5F925
mov [rcx], rsi
mov rsi, [rsp+88h+var_78]
mov [rdx], rsi
jmp short loc_5F92C
loc_5F925:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rdx], xmm0
loc_5F92C:
mov rdx, [rsp+88h+var_80]
mov [rax+18h], rdx
mov [rsp+88h+var_88], r15
mov [rsp+88h+var_80], 0
mov byte ptr [rsp+88h+var_78], 0
lea rsi, [rsp+88h+var_68]
mov [rsi+8], rax
mov [rsi], rcx
lea rdi, [rsp+88h+var_48]
mov rdx, r14
call _ZN5minja6ParserC2ERKSt10shared_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERKNS_7OptionsE; minja::Parser::Parser(std::shared_ptr<std::string> const&,minja::Options const&)
mov rdi, [rsp+88h+var_60]
test rdi, rdi
jz short loc_5F96F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5F96F:
mov rdi, [rsp+88h+var_88]; void *
cmp rdi, r15
jz short loc_5F985
mov rsi, [rsp+88h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5F985:
mov rdi, rsp; this
lea rsi, [rsp+88h+var_48]
call _ZN5minja6Parser8tokenizeEv; minja::Parser::tokenize(void)
mov rax, [rsp+88h+var_88]
mov rsi, [rsp+88h+var_80]
lea rdx, [rsp+88h+var_68]
mov [rdx], rax
lea rcx, [rsp+88h+var_50]
mov [rcx], rax
lea r8, [rsp+88h+var_58]
mov [r8], rsi
lea rsi, [rsp+88h+var_48]
mov rdi, rbx
mov r9d, 1
call _ZNK5minja6Parser13parseTemplateERKN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrINS_13TemplateTokenESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEERSD_SF_b; minja::Parser::parseTemplate(__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>>&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,bool)
mov rdi, rsp
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
mov rdi, [rsp+88h+var_40]
test rdi, rdi
jz short loc_5F9DD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5F9DD:
mov rax, rbx
add rsp, 70h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
jmp short loc_5F9FA
mov rbx, rax
loc_5F9FA:
mov rdi, [rsp+arg_40]
test rdi, rdi
jz short loc_5FA38
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_5FA38
mov rbx, rax
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_5FA22
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_5FA22
mov rbx, rax
loc_5FA22:
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_5FA38
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5FA38:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::parse(long long a1, long long a2, long long a3)
{
long long v4; // rax
_OWORD *v5; // rdx
void *v7; // [rsp+0h] [rbp-88h] BYREF
long long v8; // [rsp+8h] [rbp-80h]
__int128 v9; // [rsp+10h] [rbp-78h] BYREF
void *v10; // [rsp+20h] [rbp-68h] BYREF
volatile signed __int32 *v11; // [rsp+28h] [rbp-60h]
long long v12; // [rsp+30h] [rbp-58h] BYREF
void *v13; // [rsp+38h] [rbp-50h] BYREF
_BYTE v14[8]; // [rsp+40h] [rbp-48h] BYREF
volatile signed __int32 *v15; // [rsp+48h] [rbp-40h]
v7 = &v9;
std::string::_M_construct<char *>(&v7, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
v10 = 0LL;
v4 = operator new(0x30uLL);
*(_QWORD *)(v4 + 8) = 0x100000001LL;
*(_QWORD *)v4 = &`vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<std::string>,(__gnu_cxx::_Lock_policy)2>
+ 2;
v5 = (_OWORD *)(v4 + 32);
*(_QWORD *)(v4 + 16) = v4 + 32;
if ( v7 == &v9 )
{
*v5 = v9;
}
else
{
*(_QWORD *)(v4 + 16) = v7;
*(_QWORD *)v5 = v9;
}
*(_QWORD *)(v4 + 24) = v8;
v7 = &v9;
v8 = 0LL;
LOBYTE(v9) = 0;
v11 = (volatile signed __int32 *)v4;
v10 = (void *)(v4 + 16);
minja::Parser::Parser(v14, &v10, a3);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v7 != &v9 )
operator delete(v7, v9 + 1);
minja::Parser::tokenize((minja::Parser *)&v7);
v10 = v7;
v13 = v7;
v12 = v8;
minja::Parser::parseTemplate(a1, v14, &v10, &v13, &v12, 1LL);
std::vector<std::unique_ptr<minja::TemplateToken>>::~vector(&v7);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
return a1;
}
| parse:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV R14,RDX
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00123264
MOV qword ptr [RSP + 0x20],0x0
LAB_0015f8da:
MOV EDI,0x30
CALL 0x001196c0
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1ec3d0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
MOV RDX,RAX
ADD RDX,0x20
MOV qword ptr [RAX + 0x10],RDX
MOV RSI,qword ptr [RSP]
CMP RSI,R15
JZ 0x0015f925
MOV qword ptr [RCX],RSI
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RDX],RSI
JMP 0x0015f92c
LAB_0015f925:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0015f92c:
MOV RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x18],RDX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI],RCX
LAB_0015f953:
LEA RDI,[RSP + 0x40]
MOV RDX,R14
CALL 0x00160716
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0015f96f
CALL 0x00131024
LAB_0015f96f:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x0015f985
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001196d0
LAB_0015f985:
MOV RDI,RSP
LEA RSI,[RSP + 0x40]
CALL 0x001607e0
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LEA RCX,[RSP + 0x38]
MOV qword ptr [RCX],RAX
LEA R8,[RSP + 0x30]
MOV qword ptr [R8],RSI
LAB_0015f9b3:
LEA RSI,[RSP + 0x40]
MOV RDI,RBX
MOV R9D,0x1
CALL 0x00162f80
LAB_0015f9c6:
MOV RDI,RSP
CALL 0x0016437a
MOV RDI,qword ptr [RSP + 0x48]
TEST RDI,RDI
JZ 0x0015f9dd
CALL 0x00131024
LAB_0015f9dd:
MOV RAX,RBX
ADD RSP,0x70
POP RBX
POP R14
POP R15
RET
|
/* minja::Parser::parse(std::__cxx11::string const&, minja::Options const&) */
Parser * __thiscall minja::Parser::parse(Parser *this,string *param_1,Options *param_2)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_88;
int8 local_80;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> local_78;
int7 uStack_77;
int8 uStack_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
int8 local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
Parser local_48 [8];
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
local_88 = &local_78;
std::__cxx11::string::_M_construct<char*>
(&local_88,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
local_68 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
/* try { // try from 0015f8da to 0015f8e3 has its CatchHandler @ 0015fa1f */
local_60 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x30);
*(int8 *)(local_60 + 8) = 0x100000001;
*(int ***)local_60 = &PTR___Sp_counted_ptr_inplace_001ec3e0;
local_68 = local_60 + 0x10;
p_Var1 = local_60 + 0x20;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(local_60 + 0x10) = p_Var1;
if (local_88 == &local_78) {
*(ulong *)p_Var1 = CONCAT71(uStack_77,local_78);
*(int8 *)(local_60 + 0x28) = uStack_70;
}
else {
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)local_68 = local_88;
*(ulong *)p_Var1 = CONCAT71(uStack_77,local_78);
}
*(int8 *)(local_60 + 0x18) = local_80;
local_80 = 0;
local_78 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>)0x0;
/* try { // try from 0015f953 to 0015f95f has its CatchHandler @ 0015fa0b */
local_88 = &local_78;
Parser(local_48,(shared_ptr *)&local_68,param_2);
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_88 != &local_78) {
operator_delete(local_88,CONCAT71(uStack_77,local_78) + 1);
}
/* try { // try from 0015f985 to 0015f991 has its CatchHandler @ 0015f9f7 */
tokenize();
local_68 = local_88;
local_50 = local_88;
local_58 = local_80;
/* try { // try from 0015f9b3 to 0015f9c5 has its CatchHandler @ 0015f9ea */
parseTemplate(this,local_48,(__normal_iterator *)&local_68,SUB81(&local_50,0));
std::
vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
::~vector((vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
*)&local_88);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
return this;
}
| |
30,069 | parser_parse_expressions | tsotchke[P]eshkol/src/frontend/parser/parser_core.c | AstNode** parser_parse_expressions(Parser* parser, size_t* count) {
// Allocate initial array
size_t capacity = 8;
AstNode** exprs = arena_alloc(parser->arena, sizeof(AstNode*) * capacity);
if (!exprs) {
*count = 0;
return NULL;
}
size_t expr_count = 0;
// Parse expressions until end of file
while (!parser_is_at_end(parser)) {
// Skip comments
while (parser_match(parser, TOKEN_COMMENT)) {
// Do nothing, just advance
}
// Check if we're at the end
if (parser_is_at_end(parser)) {
break;
}
// Parse an expression
AstNode* expr = parser_parse_expression(parser);
if (!expr) {
// Error occurred, but we'll try to continue
parser_synchronize(parser);
continue;
}
// Add the expression to the array
if (expr_count >= capacity) {
// Resize the array
size_t new_capacity = capacity * 2;
AstNode** new_exprs = arena_alloc(parser->arena, sizeof(AstNode*) * new_capacity);
if (!new_exprs) {
*count = expr_count;
return exprs;
}
// Copy the old array
for (size_t i = 0; i < expr_count; i++) {
new_exprs[i] = exprs[i];
}
exprs = new_exprs;
capacity = new_capacity;
}
exprs[expr_count++] = expr;
}
*count = expr_count;
return exprs;
} | O0 | c | parser_parse_expressions:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3a90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x824f
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x837e
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8440
xorb $-0x1, %al
testb $0x1, %al
jne 0x826b
jmp 0x836b
jmp 0x826d
movq -0x10(%rbp), %rdi
movl $0x11, %esi
callq 0x8460
testb $0x1, %al
jne 0x8281
jmp 0x8283
jmp 0x826d
movq -0x10(%rbp), %rdi
callq 0x8440
testb $0x1, %al
jne 0x8292
jmp 0x8297
jmp 0x836b
movq -0x10(%rbp), %rdi
callq 0x8830
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x82b6
movq -0x10(%rbp), %rdi
callq 0x87d0
jmp 0x8257
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x834b
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3a90
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x8303
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x837e
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x833b
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x830b
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x8257
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| parser_parse_expressions:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], 8
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_20]
shl rsi, 3
call arena_alloc
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_824F
mov rax, [rbp+var_18]
mov qword ptr [rax], 0
mov [rbp+var_8], 0
jmp loc_837E
loc_824F:
mov [rbp+var_30], 0
loc_8257:
mov rdi, [rbp+var_10]
call parser_is_at_end
xor al, 0FFh
test al, 1
jnz short loc_826B
jmp loc_836B
loc_826B:
jmp short $+2
loc_826D:
mov rdi, [rbp+var_10]
mov esi, 11h
call parser_match
test al, 1
jnz short loc_8281
jmp short loc_8283
loc_8281:
jmp short loc_826D
loc_8283:
mov rdi, [rbp+var_10]
call parser_is_at_end
test al, 1
jnz short loc_8292
jmp short loc_8297
loc_8292:
jmp loc_836B
loc_8297:
mov rdi, [rbp+var_10]
call parser_parse_expression
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_82B6
mov rdi, [rbp+var_10]
call parser_synchronize
jmp short loc_8257
loc_82B6:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jb loc_834B
mov rax, [rbp+var_20]
shl rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rsi, [rbp+var_40]
shl rsi, 3
call arena_alloc
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jnz short loc_8303
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_837E
loc_8303:
mov [rbp+var_50], 0
loc_830B:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_30]
jnb short loc_833B
mov rax, [rbp+var_28]
mov rcx, [rbp+var_50]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_48]
mov rcx, [rbp+var_50]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_830B
loc_833B:
mov rax, [rbp+var_48]
mov [rbp+var_28], rax
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
loc_834B:
mov rdx, [rbp+var_38]
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov rsi, rcx
add rsi, 1
mov [rbp+var_30], rsi
mov [rax+rcx*8], rdx
jmp loc_8257
loc_836B:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_837E:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long parser_parse_expressions(long long *a1, unsigned long long *a2)
{
unsigned long long v2; // rcx
unsigned long long i; // [rsp+0h] [rbp-50h]
long long v5; // [rsp+8h] [rbp-48h]
long long v6; // [rsp+18h] [rbp-38h]
unsigned long long v7; // [rsp+20h] [rbp-30h]
long long v8; // [rsp+28h] [rbp-28h]
unsigned long long v9; // [rsp+30h] [rbp-20h]
v9 = 8LL;
v8 = arena_alloc(*a1, 64LL);
if ( v8 )
{
v7 = 0LL;
while ( (parser_is_at_end(a1) & 1) == 0 )
{
while ( (parser_match(a1, 17LL) & 1) != 0 )
;
if ( (parser_is_at_end(a1) & 1) != 0 )
break;
v6 = parser_parse_expression(a1);
if ( v6 )
{
if ( v7 >= v9 )
{
v5 = arena_alloc(*a1, 16 * v9);
if ( !v5 )
{
*a2 = v7;
return v8;
}
for ( i = 0LL; i < v7; ++i )
*(_QWORD *)(v5 + 8 * i) = *(_QWORD *)(v8 + 8 * i);
v8 = v5;
v9 *= 2LL;
}
v2 = v7++;
*(_QWORD *)(v8 + 8 * v2) = v6;
}
else
{
parser_synchronize(a1);
}
}
*a2 = v7;
return v8;
}
else
{
*a2 = 0LL;
return 0LL;
}
}
| parser_parse_expressions:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
SHL RSI,0x3
CALL 0x00103a90
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0010824f
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0010837e
LAB_0010824f:
MOV qword ptr [RBP + -0x30],0x0
LAB_00108257:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00108440
XOR AL,0xff
TEST AL,0x1
JNZ 0x0010826b
JMP 0x0010836b
LAB_0010826b:
JMP 0x0010826d
LAB_0010826d:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x11
CALL 0x00108460
TEST AL,0x1
JNZ 0x00108281
JMP 0x00108283
LAB_00108281:
JMP 0x0010826d
LAB_00108283:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00108440
TEST AL,0x1
JNZ 0x00108292
JMP 0x00108297
LAB_00108292:
JMP 0x0010836b
LAB_00108297:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00108830
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001082b6
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001087d0
JMP 0x00108257
LAB_001082b6:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x0010834b
MOV RAX,qword ptr [RBP + -0x20]
SHL RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x40]
SHL RSI,0x3
CALL 0x00103a90
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x00108303
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0010837e
LAB_00108303:
MOV qword ptr [RBP + -0x50],0x0
LAB_0010830b:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0010833b
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0010830b
LAB_0010833b:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
LAB_0010834b:
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RAX + RCX*0x8],RDX
JMP 0x00108257
LAB_0010836b:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0010837e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long parser_parse_expressions(int8 *param_1,ulong *param_2)
{
byte bVar1;
ulong uVar2;
long lVar3;
long lVar4;
ulong local_58;
ulong local_38;
long local_30;
ulong local_28;
long local_10;
local_28 = 8;
local_30 = arena_alloc(*param_1,0x40);
if (local_30 == 0) {
*param_2 = 0;
local_10 = 0;
}
else {
local_38 = 0;
while (bVar1 = parser_is_at_end(param_1), ((bVar1 ^ 0xff) & 1) != 0) {
do {
uVar2 = parser_match(param_1,0x11);
} while ((uVar2 & 1) != 0);
uVar2 = parser_is_at_end(param_1);
if ((uVar2 & 1) != 0) break;
lVar3 = parser_parse_expression(param_1);
if (lVar3 == 0) {
parser_synchronize(param_1);
}
else {
lVar4 = local_30;
if (local_28 <= local_38) {
uVar2 = local_28 << 1;
lVar4 = arena_alloc(*param_1,local_28 << 4);
if (lVar4 == 0) {
*param_2 = local_38;
return local_30;
}
for (local_58 = 0; local_28 = uVar2, local_58 < local_38; local_58 = local_58 + 1) {
*(int8 *)(lVar4 + local_58 * 8) = *(int8 *)(local_30 + local_58 * 8);
}
}
local_30 = lVar4;
*(long *)(local_30 + local_38 * 8) = lVar3;
local_38 = local_38 + 1;
}
}
*param_2 = local_38;
local_10 = local_30;
}
return local_10;
}
| |
30,070 | bitmap_exists_intersection | eloqsql/mysys/my_bitmap.c | my_bool bitmap_exists_intersection(const MY_BITMAP **bitmap_array,
uint bitmap_count,
uint start_bit, uint end_bit)
{
uint i, j, start_idx, end_idx;
my_bitmap_map cur_res;
DBUG_ASSERT(bitmap_count);
DBUG_ASSERT(end_bit >= start_bit);
for (j= 0; j < bitmap_count; j++)
DBUG_ASSERT(end_bit < bitmap_array[j]->n_bits);
start_idx= start_bit/8/sizeof(my_bitmap_map);
end_idx= end_bit/8/sizeof(my_bitmap_map);
for (i= start_idx; i < end_idx; i++)
{
cur_res= ~0;
for (j= 0; cur_res && j < bitmap_count; j++)
cur_res &= bitmap_array[j]->bitmap[i];
if (cur_res)
return TRUE;
}
cur_res= ~last_word_mask(end_bit);
for (j= 0; cur_res && j < bitmap_count; j++)
cur_res &= bitmap_array[j]->bitmap[end_idx];
return cur_res != 0;
} | O0 | c | bitmap_exists_intersection:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
jmp 0xee977
jmp 0xee979
jmp 0xee97b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xee99b
jmp 0xee98c
jmp 0xee98e
jmp 0xee990
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xee982
movl -0x18(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
shrq $0x2, %rax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
shrq $0x2, %rax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0xeea33
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
je 0xee9ec
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xee9f5
jmp 0xeea1a
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
andl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xee9d5
cmpl $0x0, -0x30(%rbp)
je 0xeea26
movb $0x1, -0x1(%rbp)
jmp 0xeea9c
jmp 0xeea28
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xee9bf
movl -0x1c(%rbp), %edi
callq 0xeeab0
xorl $-0x1, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x30(%rbp)
movb %al, -0x32(%rbp)
je 0xeea5f
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0xeea68
jmp 0xeea8d
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
andl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xeea48
cmpl $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bitmap_exists_intersection:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
jmp short $+2
loc_EE977:
jmp short $+2
loc_EE979:
jmp short $+2
loc_EE97B:
mov [rbp+var_24], 0
loc_EE982:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
jnb short loc_EE99B
jmp short $+2
loc_EE98C:
jmp short $+2
loc_EE98E:
jmp short $+2
loc_EE990:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_EE982
loc_EE99B:
mov eax, [rbp+var_18]
shr eax, 3
mov eax, eax
shr rax, 2
mov [rbp+var_28], eax
mov eax, [rbp+var_1C]
shr eax, 3
mov eax, eax
shr rax, 2
mov [rbp+var_2C], eax
mov eax, [rbp+var_28]
mov [rbp+var_20], eax
loc_EE9BF:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_2C]
jnb short loc_EEA33
mov [rbp+var_30], 0FFFFFFFFh
mov [rbp+var_24], 0
loc_EE9D5:
xor eax, eax
cmp [rbp+var_30], 0
mov [rbp+var_31], al
jz short loc_EE9EC
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
setb al
mov [rbp+var_31], al
loc_EE9EC:
mov al, [rbp+var_31]
test al, 1
jnz short loc_EE9F5
jmp short loc_EEA1A
loc_EE9F5:
mov rax, [rbp+var_10]
mov ecx, [rbp+var_24]
mov rax, [rax+rcx*8]
mov rax, [rax]
mov ecx, [rbp+var_20]
mov eax, [rax+rcx*4]
and eax, [rbp+var_30]
mov [rbp+var_30], eax
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_EE9D5
loc_EEA1A:
cmp [rbp+var_30], 0
jz short loc_EEA26
mov [rbp+var_1], 1
jmp short loc_EEA9C
loc_EEA26:
jmp short $+2
loc_EEA28:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_EE9BF
loc_EEA33:
mov edi, [rbp+var_1C]
call last_word_mask
xor eax, 0FFFFFFFFh
mov [rbp+var_30], eax
mov [rbp+var_24], 0
loc_EEA48:
xor eax, eax
cmp [rbp+var_30], 0
mov [rbp+var_32], al
jz short loc_EEA5F
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
setb al
mov [rbp+var_32], al
loc_EEA5F:
mov al, [rbp+var_32]
test al, 1
jnz short loc_EEA68
jmp short loc_EEA8D
loc_EEA68:
mov rax, [rbp+var_10]
mov ecx, [rbp+var_24]
mov rax, [rax+rcx*8]
mov rax, [rax]
mov ecx, [rbp+var_2C]
mov eax, [rax+rcx*4]
and eax, [rbp+var_30]
mov [rbp+var_30], eax
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_EEA48
loc_EEA8D:
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_EEA9C:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| bool bitmap_exists_intersection(long long a1, unsigned int a2, unsigned int a3, unsigned int a4)
{
bool v5; // [rsp+Eh] [rbp-32h]
bool v6; // [rsp+Fh] [rbp-31h]
int v7; // [rsp+10h] [rbp-30h]
unsigned int v8; // [rsp+10h] [rbp-30h]
unsigned int v9; // [rsp+14h] [rbp-2Ch]
unsigned int i; // [rsp+1Ch] [rbp-24h]
unsigned int k; // [rsp+1Ch] [rbp-24h]
unsigned int m; // [rsp+1Ch] [rbp-24h]
unsigned int j; // [rsp+20h] [rbp-20h]
for ( i = 0; i < a2; ++i )
;
v9 = a4 >> 5;
for ( j = a3 >> 5; j < v9; ++j )
{
v7 = -1;
for ( k = 0; ; ++k )
{
v6 = 0;
if ( v7 )
v6 = k < a2;
if ( !v6 )
break;
v7 &= *(_DWORD *)(**(_QWORD **)(a1 + 8LL * k) + 4LL * j);
}
if ( v7 )
return 1;
}
v8 = ~(unsigned int)last_word_mask(a4);
for ( m = 0; ; ++m )
{
v5 = 0;
if ( v8 )
v5 = m < a2;
if ( !v5 )
break;
v8 &= *(_DWORD *)(**(_QWORD **)(a1 + 8LL * m) + 4LL * v9);
}
return v8 != 0;
}
| bitmap_exists_intersection:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
JMP 0x001ee977
LAB_001ee977:
JMP 0x001ee979
LAB_001ee979:
JMP 0x001ee97b
LAB_001ee97b:
MOV dword ptr [RBP + -0x24],0x0
LAB_001ee982:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x001ee99b
JMP 0x001ee98c
LAB_001ee98c:
JMP 0x001ee98e
LAB_001ee98e:
JMP 0x001ee990
LAB_001ee990:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001ee982
LAB_001ee99b:
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x3
MOV EAX,EAX
SHR RAX,0x2
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHR EAX,0x3
MOV EAX,EAX
SHR RAX,0x2
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x20],EAX
LAB_001ee9bf:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x2c]
JNC 0x001eea33
MOV dword ptr [RBP + -0x30],0xffffffff
MOV dword ptr [RBP + -0x24],0x0
LAB_001ee9d5:
XOR EAX,EAX
CMP dword ptr [RBP + -0x30],0x0
MOV byte ptr [RBP + -0x31],AL
JZ 0x001ee9ec
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
SETC AL
MOV byte ptr [RBP + -0x31],AL
LAB_001ee9ec:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x001ee9f5
JMP 0x001eea1a
LAB_001ee9f5:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + RCX*0x4]
AND EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001ee9d5
LAB_001eea1a:
CMP dword ptr [RBP + -0x30],0x0
JZ 0x001eea26
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001eea9c
LAB_001eea26:
JMP 0x001eea28
LAB_001eea28:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001ee9bf
LAB_001eea33:
MOV EDI,dword ptr [RBP + -0x1c]
CALL 0x001eeab0
XOR EAX,0xffffffff
MOV dword ptr [RBP + -0x30],EAX
MOV dword ptr [RBP + -0x24],0x0
LAB_001eea48:
XOR EAX,EAX
CMP dword ptr [RBP + -0x30],0x0
MOV byte ptr [RBP + -0x32],AL
JZ 0x001eea5f
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
SETC AL
MOV byte ptr [RBP + -0x32],AL
LAB_001eea5f:
MOV AL,byte ptr [RBP + -0x32]
TEST AL,0x1
JNZ 0x001eea68
JMP 0x001eea8d
LAB_001eea68:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [RAX + RCX*0x4]
AND EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001eea48
LAB_001eea8d:
CMP dword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_001eea9c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int8 bitmap_exists_intersection(long param_1,uint param_2,uint param_3,uint param_4)
{
uint3 uVar1;
uint7 uVar2;
ulong uVar3;
uint local_38;
uint local_2c;
uint local_28;
bool local_9;
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
}
local_28 = param_3 >> 5;
do {
if (param_4 >> 5 <= local_28) {
local_38 = last_word_mask(param_4);
local_2c = 0;
for (local_38 = local_38 ^ 0xffffffff; local_38 != 0 && local_2c < param_2;
local_38 = *(uint *)(**(long **)(param_1 + uVar3 * 8) + (ulong)(param_4 >> 5) * 4) &
local_38) {
uVar3 = (ulong)local_2c;
local_2c = local_2c + 1;
}
local_9 = local_38 != 0;
uVar2 = 0;
LAB_001eea9c:
return CONCAT71(uVar2,local_9);
}
local_38 = 0xffffffff;
local_2c = 0;
while( true ) {
uVar1 = 0;
if (local_38 != 0) {
uVar1 = (uint3)(local_2c >> 8);
}
uVar2 = (uint7)uVar1;
if (local_38 == 0 || param_2 <= local_2c) break;
local_38 = *(uint *)(**(long **)(param_1 + (ulong)local_2c * 8) + (ulong)local_28 * 4) &
local_38;
local_2c = local_2c + 1;
}
if (local_38 != 0) {
local_9 = true;
goto LAB_001eea9c;
}
local_28 = local_28 + 1;
} while( true );
}
| |
30,071 | cli::group cli::group::operator+<cli::option>(cli::matchable_derived<cli::option> const&) | msxemulator/build_O3/_deps/picotool-src/cli.h | group operator+(const matchable_derived<T> &m) {
if (type == set) {
elements.push_back(m.to_ptr());
return *this;
}
return matchable_derived::operator+(m);
} | O3 | c | cli::group cli::group::operator+<cli::option>(cli::matchable_derived<cli::option> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, 0xd8(%rsi)
jne 0x37b89
leaq 0xe0(%r14), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x511f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5b580
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x37b1b
callq 0x4bd0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e7de
leaq 0xa87b3(%rip), %rax # 0xe02e0
movq %rax, (%rbx)
leaq 0xb8(%rbx), %r12
leaq 0xc8(%rbx), %r13
movq %r13, 0xb8(%rbx)
movq 0xb8(%r14), %rsi
movq 0xc0(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1d410
movl 0xd8(%r14), %eax
movl %eax, 0xd8(%rbx)
leaq 0xe0(%rbx), %rdi
movq %r15, %rsi
callq 0x4dd34
movb 0xf8(%r14), %al
movb %al, 0xf8(%rbx)
jmp 0x37b94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5df5e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x37bc2
movq (%r13), %rsi
incq %rsi
callq 0xf470
jmp 0x37bc2
movq %rax, %r14
movq %rbx, %rdi
callq 0x5872e
jmp 0x37bde
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x37bde
callq 0x4bd0a
movq %r14, %rdi
callq 0xf7d0
| _ZN3cli5groupplINS_6optionEEES0_RKNS_17matchable_derivedIT_EE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
cmp dword ptr [rsi+0D8h], 1
jnz loc_37B89
lea r15, [r14+0E0h]
mov r12, rsp
mov rdi, r12
mov rsi, rdx
call _ZNK3cli17matchable_derivedINS_6optionEE6to_ptrEv; cli::matchable_derived<cli::option>::to_ptr(void)
mov rdi, r15
mov rsi, r12
call _ZNSt6vectorISt10shared_ptrIN3cli9matchableEESaIS3_EE12emplace_backIJS3_EEEvDpOT_; std::vector<std::shared_ptr<cli::matchable>>::emplace_back<std::shared_ptr<cli::matchable>>(std::shared_ptr<cli::matchable> &&)
mov rdi, [rsp+38h+var_30]
test rdi, rdi
jz short loc_37B1B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_37B1B:
mov rdi, rbx; this
mov rsi, r14; cli::matchable *
call _ZN3cli9matchableC2ERKS0_; cli::matchable::matchable(cli::matchable const&)
lea rax, off_E02E0
mov [rbx], rax
lea r12, [rbx+0B8h]
lea r13, [rbx+0C8h]
mov [rbx+0B8h], r13
mov rsi, [r14+0B8h]
mov rdx, [r14+0C0h]
add rdx, rsi
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov eax, [r14+0D8h]
mov [rbx+0D8h], eax
lea rdi, [rbx+0E0h]
mov rsi, r15
call _ZNSt6vectorISt10shared_ptrIN3cli9matchableEESaIS3_EEC2ERKS5_; std::vector<std::shared_ptr<cli::matchable>>::vector(std::vector<std::shared_ptr<cli::matchable>> const&)
mov al, [r14+0F8h]
mov [rbx+0F8h], al
jmp short loc_37B94
loc_37B89:
mov rdi, rbx
mov rsi, r14
call _ZN3cli17matchable_derivedINS_5groupEEplINS_6optionEEES1_RKNS0_IT_EE; cli::matchable_derived<cli::group>::operator+<cli::option>(cli::matchable_derived<cli::option> const&)
loc_37B94:
mov rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [r12]; void *
cmp rdi, r13
jz short loc_37BC2
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_37BC2
mov r14, rax
loc_37BC2:
mov rdi, rbx; this
call _ZN3cli9matchableD2Ev; cli::matchable::~matchable()
jmp short loc_37BDE
mov r14, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_37BDE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_37BDE:
mov rdi, r14
call __Unwind_Resume
| cli::matchable * cli::group::operator+<cli::option>(
cli::matchable *this,
cli::matchable *a2,
int a3,
int a4,
int a5,
int a6)
{
int v7; // [rsp+0h] [rbp-38h] BYREF
long long v8; // [rsp+8h] [rbp-30h]
int v9; // [rsp+10h] [rbp-28h]
long long v10; // [rsp+18h] [rbp-20h]
if ( *((_DWORD *)a2 + 54) == 1 )
{
cli::matchable_derived<cli::option>::to_ptr(&v7);
std::vector<std::shared_ptr<cli::matchable>>::emplace_back<std::shared_ptr<cli::matchable>>((char *)a2 + 224, &v7);
if ( v8 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v8);
cli::matchable::matchable(this, a2);
*(_QWORD *)this = off_E02E0;
*((_QWORD *)this + 23) = (char *)this + 200;
std::string::_M_construct<char *>(
(long long)this + 184,
*((_BYTE **)a2 + 23),
*((_QWORD *)a2 + 23) + *((_QWORD *)a2 + 24));
*((_DWORD *)this + 54) = *((_DWORD *)a2 + 54);
std::vector<std::shared_ptr<cli::matchable>>::vector((char *)this + 224, (char *)a2 + 224);
*((_BYTE *)this + 248) = *((_BYTE *)a2 + 248);
}
else
{
cli::matchable_derived<cli::group>::operator+<cli::option>(
(_DWORD)this,
(_DWORD)a2,
a3,
a4,
a5,
a6,
v7,
v8,
v9,
v10);
}
return this;
}
| operator+:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
CMP dword ptr [RSI + 0xd8],0x1
JNZ 0x00137b89
LEA R15,[R14 + 0xe0]
MOV R12,RSP
MOV RDI,R12
MOV RSI,RDX
CALL 0x001511f0
LAB_00137b01:
MOV RDI,R15
MOV RSI,R12
CALL 0x0015b580
LAB_00137b0c:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00137b1b
CALL 0x0014bd0a
LAB_00137b1b:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014e7de
LEA RAX,[0x1e02e0]
MOV qword ptr [RBX],RAX
LEA R12,[RBX + 0xb8]
LEA R13,[RBX + 0xc8]
MOV qword ptr [RBX + 0xb8],R13
MOV RSI,qword ptr [R14 + 0xb8]
MOV RDX,qword ptr [R14 + 0xc0]
ADD RDX,RSI
LAB_00137b56:
MOV RDI,R12
CALL 0x0011d410
MOV EAX,dword ptr [R14 + 0xd8]
MOV dword ptr [RBX + 0xd8],EAX
LEA RDI,[RBX + 0xe0]
LAB_00137b72:
MOV RSI,R15
CALL 0x0014dd34
LAB_00137b7a:
MOV AL,byte ptr [R14 + 0xf8]
MOV byte ptr [RBX + 0xf8],AL
JMP 0x00137b94
LAB_00137b89:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0015df5e
LAB_00137b94:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* cli::group cli::group::TEMPNAMEPLACEHOLDERVALUE(cli::matchable_derived<cli::option> const&) */
group * __thiscall cli::group::operator+(group *this,matchable_derived *param_1)
{
shared_ptr asStack_38 [8];
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
if (*(int *)(param_1 + 0xd8) == 1) {
matchable_derived<cli::option>::to_ptr();
/* try { // try from 00137b01 to 00137b0b has its CatchHandler @ 00137bcc */
std::vector<std::shared_ptr<cli::matchable>,std::allocator<std::shared_ptr<cli::matchable>>>::
emplace_back<std::shared_ptr<cli::matchable>>
((vector<std::shared_ptr<cli::matchable>,std::allocator<std::shared_ptr<cli::matchable>>>
*)(param_1 + 0xe0),asStack_38);
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
matchable::matchable((matchable *)this,(matchable *)param_1);
*(int ***)this = &PTR__group_001e02e0;
*(group **)(this + 0xb8) = this + 200;
/* try { // try from 00137b56 to 00137b5d has its CatchHandler @ 00137bbf */
std::__cxx11::string::_M_construct<char*>
(this + 0xb8,*(long *)(param_1 + 0xb8),
*(long *)(param_1 + 0xc0) + *(long *)(param_1 + 0xb8));
*(int4 *)(this + 0xd8) = *(int4 *)(param_1 + 0xd8);
/* try { // try from 00137b72 to 00137b79 has its CatchHandler @ 00137ba5 */
std::vector<std::shared_ptr<cli::matchable>,std::allocator<std::shared_ptr<cli::matchable>>>::
vector((vector<std::shared_ptr<cli::matchable>,std::allocator<std::shared_ptr<cli::matchable>>>
*)(this + 0xe0),
(vector<std::shared_ptr<cli::matchable>,std::allocator<std::shared_ptr<cli::matchable>>>
*)(param_1 + 0xe0));
*(matchable_derived *)(this + 0xf8) = param_1[0xf8];
}
else {
matchable_derived<cli::group>::operator+((matchable_derived<cli::group> *)this,param_1);
}
return this;
}
| |
30,072 | SDL::OpenGL1Texture::OpenGL1Texture(SDL_Renderer*, SDL::Vec2i const&, int) | SDL3Lite/source/Renders/OpenGL1/OpenGL1Texture.cpp | OpenGL1Texture::OpenGL1Texture(SDL_Renderer* render, const Vec2i& size, int bpp) :
_render(render),
_texture(0),
_size(size)
{
GLint format = BppToFormat(bpp);
int sz = SelectTextureSize(_size);
_quad = Vec2i(sz, sz);
_texture = CreateTexture(_quad.x, _quad.y, format);
} | O3 | cpp | SDL::OpenGL1Texture::OpenGL1Texture(SDL_Renderer*, SDL::Vec2i const&, int):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x212c0
movq 0x10(%rsp), %rdi
movq 0x17e7e(%rip), %rax # 0x43aa0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x14(%rdi)
addq $0x1c, %rdi
callq 0x21a70
jmp 0x2bc50
movl 0x3c(%rsp), %edi
callq 0x217f0
movl %eax, 0xc(%rsp)
jmp 0x2bc5f
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rsp)
addq $0x14, %rdi
callq 0x21280
movl %eax, 0x8(%rsp)
jmp 0x2bc7b
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %edx
leaq 0x1c(%rsp), %rdi
movl %edx, %esi
callq 0x21920
jmp 0x2bc95
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x212f0
jmp 0x2bcaa
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %edi
movl 0x20(%rax), %esi
movl 0x28(%rsp), %edx
callq 0x220f0
movl %eax, 0x4(%rsp)
jmp 0x2bcc4
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x10(%rax)
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x216d0
movq 0x30(%rsp), %rdi
callq 0x22300
nopw (%rax,%rax)
| _ZN3SDL14OpenGL1TextureC2EP12SDL_RendererRKNS_5Vec2iEi:
sub rsp, 58h; Alternative name is 'SDL::OpenGL1Texture::OpenGL1Texture(SDL_Renderer *, SDL::Vec2i const&, int)'
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_1C+4], rdx
mov dword ptr [rsp+58h+var_1C], ecx
mov rdi, [rsp+58h+var_8]; this
mov [rsp+58h+var_48], rdi
call __ZN11SDL_TextureC2Ev; SDL_Texture::SDL_Texture(void)
mov rdi, [rsp+58h+var_48]
mov rax, cs:_ZTVN3SDL14OpenGL1TextureE_ptr
add rax, 10h
mov [rdi], rax
mov rax, [rsp+58h+var_10]
mov [rdi+8], rax
mov dword ptr [rdi+10h], 0
mov rax, [rsp+58h+var_1C+4]
mov rax, [rax]
mov [rdi+14h], rax
add rdi, 1Ch; this
call __ZN3SDL5Vec2iC2Ev; SDL::Vec2i::Vec2i(void)
jmp short $+2
loc_2BC50:
mov edi, dword ptr [rsp+58h+var_1C]; this
call __ZN3SDL11BppToFormatEi; SDL::BppToFormat(int)
mov [rsp+58h+var_4C], eax
jmp short $+2
loc_2BC5F:
mov rdi, [rsp+58h+var_48]
mov eax, [rsp+58h+var_4C]
mov [rsp+58h+var_30], eax
add rdi, 14h; this
call __ZN3SDL17SelectTextureSizeERKNS_5Vec2iE; SDL::SelectTextureSize(SDL::Vec2i const&)
mov [rsp+58h+var_50], eax
jmp short $+2
loc_2BC7B:
mov eax, [rsp+58h+var_50]
mov [rsp+58h+var_34], eax
mov edx, [rsp+58h+var_34]; int
lea rdi, [rsp+58h+var_3C]; this
mov esi, edx; int
call __ZN3SDL5Vec2iC2Eii; SDL::Vec2i::Vec2i(int,int)
jmp short $+2
loc_2BC95:
mov rdi, [rsp+58h+var_48]
add rdi, 1Ch
lea rsi, [rsp+58h+var_3C]
call __ZN3SDL5Vec2iaSERKS0_; SDL::Vec2i::operator=(SDL::Vec2i const&)
jmp short $+2
loc_2BCAA:
mov rax, [rsp+58h+var_48]
mov edi, [rax+1Ch]; this
mov esi, [rax+20h]; int
mov edx, [rsp+58h+var_30]; int
call __ZN3SDL13CreateTextureEiii; SDL::CreateTexture(int,int,int)
mov [rsp+58h+var_54], eax
jmp short $+2
loc_2BCC4:
mov rax, [rsp+58h+var_48]
mov ecx, [rsp+58h+var_54]
mov [rax+10h], ecx
add rsp, 58h
retn
mov rdi, [rsp+arg_8]; this
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call __ZN11SDL_TextureD2Ev; SDL_Texture::~SDL_Texture()
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| SDL::OpenGL1Texture * SDL::OpenGL1Texture::OpenGL1Texture(
SDL::OpenGL1Texture *this,
SDL_Renderer *a2,
const SDL::Vec2i *a3,
int a4)
{
int v4; // ecx
SDL::OpenGL1Texture *result; // rax
int Texture; // [rsp+4h] [rbp-54h]
_BYTE v7[8]; // [rsp+1Ch] [rbp-3Ch] BYREF
int v8; // [rsp+24h] [rbp-34h]
int v9; // [rsp+28h] [rbp-30h]
_DWORD v10[3]; // [rsp+3Ch] [rbp-1Ch]
SDL_Renderer *v11; // [rsp+48h] [rbp-10h]
SDL_Texture *v12; // [rsp+50h] [rbp-8h]
v12 = this;
v11 = a2;
*(_QWORD *)&v10[1] = a3;
v10[0] = a4;
SDL_Texture::SDL_Texture(this);
*(_QWORD *)this = &`vtable for'SDL::OpenGL1Texture + 2;
*((_QWORD *)this + 1) = v11;
*((_DWORD *)this + 4) = 0;
*(_QWORD *)((char *)this + 20) = **(_QWORD **)&v10[1];
SDL::Vec2i::Vec2i((SDL::OpenGL1Texture *)((char *)this + 28));
v9 = SDL::BppToFormat((SDL *)v10[0], (int)a2);
v8 = SDL::SelectTextureSize((SDL::OpenGL1Texture *)((char *)this + 20), a2);
SDL::Vec2i::Vec2i((SDL::Vec2i *)v7, v8, v8);
SDL::Vec2i::operator=((char *)this + 28, v7);
Texture = SDL::CreateTexture((SDL *)*((unsigned int *)this + 7), *((_DWORD *)this + 8), v9, v4);
result = this;
*((_DWORD *)this + 4) = Texture;
return result;
}
| OpenGL1Texture:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV dword ptr [RSP + 0x3c],ECX
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001212c0
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [0x00143aa0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RDI + 0x8],RAX
MOV dword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0x14],RAX
ADD RDI,0x1c
LAB_0012bc49:
CALL 0x00121a70
JMP 0x0012bc50
LAB_0012bc50:
MOV EDI,dword ptr [RSP + 0x3c]
CALL 0x001217f0
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0012bc5f
LAB_0012bc5f:
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x28],EAX
ADD RDI,0x14
CALL 0x00121280
MOV dword ptr [RSP + 0x8],EAX
JMP 0x0012bc7b
LAB_0012bc7b:
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x24],EAX
MOV EDX,dword ptr [RSP + 0x24]
LEA RDI,[RSP + 0x1c]
MOV ESI,EDX
CALL 0x00121920
JMP 0x0012bc95
LAB_0012bc95:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x1c
LEA RSI,[RSP + 0x1c]
CALL 0x001212f0
JMP 0x0012bcaa
LAB_0012bcaa:
MOV RAX,qword ptr [RSP + 0x10]
MOV EDI,dword ptr [RAX + 0x1c]
MOV ESI,dword ptr [RAX + 0x20]
MOV EDX,dword ptr [RSP + 0x28]
CALL 0x001220f0
LAB_0012bcbe:
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0012bcc4
LAB_0012bcc4:
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x4]
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x58
RET
|
/* SDL::OpenGL1Texture::OpenGL1Texture(SDL_Renderer*, SDL::Vec2i const&, int) */
void __thiscall
SDL::OpenGL1Texture::OpenGL1Texture
(OpenGL1Texture *this,SDL_Renderer *param_1,Vec2i *param_2,int param_3)
{
int4 uVar1;
Vec2i local_3c [8];
int local_34;
int local_30;
int local_1c;
Vec2i *local_18;
SDL_Renderer *local_10;
OpenGL1Texture *local_8;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
SDL_Texture::SDL_Texture((SDL_Texture *)this);
*(int **)this = PTR_vtable_00143aa0 + 0x10;
*(SDL_Renderer **)(this + 8) = local_10;
*(int4 *)(this + 0x10) = 0;
*(int8 *)(this + 0x14) = *(int8 *)local_18;
/* try { // try from 0012bc49 to 0012bcbd has its CatchHandler @ 0012bcd5 */
Vec2i::Vec2i((Vec2i *)(this + 0x1c));
local_30 = BppToFormat(local_1c);
local_34 = SelectTextureSize((Vec2i *)(this + 0x14));
Vec2i::Vec2i(local_3c,local_34,local_34);
Vec2i::operator=((Vec2i *)(this + 0x1c),local_3c);
uVar1 = CreateTexture(*(int *)(this + 0x1c),*(int *)(this + 0x20),local_30);
*(int4 *)(this + 0x10) = uVar1;
return;
}
| |
30,073 | bc_reader_free | bluesky950520[P]quickjs/quickjs.c | static void bc_reader_free(BCReaderState *s)
{
int i;
if (s->idx_to_atom) {
for(i = 0; i < s->idx_to_atom_count; i++) {
JS_FreeAtom(s->ctx, s->idx_to_atom[i]);
}
js_free(s->ctx, s->idx_to_atom);
}
js_free(s->ctx, s->objects);
} | O0 | c | bc_reader_free:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4ca8c
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jae 0x4ca76
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x29040
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4ca3d
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0x21db0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x21db0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| bc_reader_free:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
cmp qword ptr [rax+28h], 0
jz short loc_4CA8C
mov [rsp+18h+var_C], 0
loc_4CA3D:
mov eax, [rsp+18h+var_C]
mov rcx, [rsp+18h+var_8]
cmp eax, [rcx+24h]
jnb short loc_4CA76
mov rax, [rsp+18h+var_8]
mov rdi, [rax]
mov rax, [rsp+18h+var_8]
mov rax, [rax+28h]
movsxd rcx, [rsp+18h+var_C]
mov esi, [rax+rcx*4]
call JS_FreeAtom
mov eax, [rsp+18h+var_C]
add eax, 1
mov [rsp+18h+var_C], eax
jmp short loc_4CA3D
loc_4CA76:
mov rax, [rsp+18h+var_8]
mov rdi, [rax]
mov rax, [rsp+18h+var_8]
mov rsi, [rax+28h]
call js_free
loc_4CA8C:
mov rax, [rsp+18h+var_8]
mov rdi, [rax]
mov rax, [rsp+18h+var_8]
mov rsi, [rax+38h]
call js_free
add rsp, 18h
retn
| void bc_reader_free(long long a1)
{
unsigned int i; // [rsp+Ch] [rbp-Ch]
if ( *(_QWORD *)(a1 + 40) )
{
for ( i = 0; i < *(_DWORD *)(a1 + 36); ++i )
JS_FreeAtom(*(_QWORD *)a1, *(_DWORD *)(*(_QWORD *)(a1 + 40) + 4LL * (int)i));
js_free(*(_QWORD *)a1, *(_QWORD *)(a1 + 40));
}
js_free(*(_QWORD *)a1, *(_QWORD *)(a1 + 56));
}
| bc_reader_free:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x0014ca8c
MOV dword ptr [RSP + 0xc],0x0
LAB_0014ca3d:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x10]
CMP EAX,dword ptr [RCX + 0x24]
JNC 0x0014ca76
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x00129040
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0014ca3d
LAB_0014ca76:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX + 0x28]
CALL 0x00121db0
LAB_0014ca8c:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX + 0x38]
CALL 0x00121db0
ADD RSP,0x18
RET
|
void bc_reader_free(int8 *param_1)
{
uint local_c;
if (param_1[5] != 0) {
for (local_c = 0; local_c < *(uint *)((long)param_1 + 0x24); local_c = local_c + 1) {
JS_FreeAtom(*param_1,*(int4 *)(param_1[5] + (long)(int)local_c * 4));
}
js_free(*param_1,param_1[5]);
}
js_free(*param_1,param_1[7]);
return;
}
| |
30,074 | js_calloc_rt | bluesky950520[P]quickjs/quickjs.c | void *js_calloc_rt(JSRuntime *rt, size_t count, size_t size)
{
void *ptr;
JSMallocState *s;
/* Do not allocate zero bytes: behavior is platform dependent */
assert(count != 0 && size != 0);
if (size > 0)
if (unlikely(count != (count * size) / size))
return NULL;
s = &rt->malloc_state;
/* When malloc_limit is 0 (unlimited), malloc_limit - 1 will be SIZE_MAX. */
if (unlikely(s->malloc_size + (count * size) > s->malloc_limit - 1))
return NULL;
ptr = rt->mf.js_calloc(s->opaque, count, size);
if (!ptr)
return NULL;
s->malloc_count++;
s->malloc_size += rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
return ptr;
} | O0 | c | js_calloc_rt:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x217b6
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
imulq 0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x18(%rsp)
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x217b4
movq $0x0, 0x30(%rsp)
jmp 0x2187c
jmp 0x217b6
movq 0x28(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
imulq 0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2180a
movq $0x0, 0x30(%rsp)
jmp 0x2187c
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2183f
movq $0x0, 0x30(%rsp)
jmp 0x2187c
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq %rax, %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| js_calloc_rt:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
cmp [rsp+38h+var_20], 0
jbe short loc_217B6
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_38], rax
mov rax, [rsp+38h+var_18]
imul rax, [rsp+38h+var_20]
xor ecx, ecx
mov edx, ecx
div [rsp+38h+var_20]
mov rcx, rax
mov rax, [rsp+38h+var_38]
cmp rax, rcx
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_217B4
mov [rsp+38h+var_8], 0
jmp loc_2187C
loc_217B4:
jmp short $+2
loc_217B6:
mov rax, [rsp+38h+var_10]
add rax, 28h ; '('
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
mov rax, [rax+8]
mov rcx, [rsp+38h+var_18]
imul rcx, [rsp+38h+var_20]
add rax, rcx
mov rcx, [rsp+38h+var_30]
mov rcx, [rcx+10h]
sub rcx, 1
cmp rax, rcx
setnbe al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2180A
mov [rsp+38h+var_8], 0
jmp short loc_2187C
loc_2180A:
mov rax, [rsp+38h+var_10]
mov rax, [rax]
mov rcx, [rsp+38h+var_30]
mov rdi, [rcx+18h]
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_20]
call rax
mov [rsp+38h+var_28], rax
cmp [rsp+38h+var_28], 0
jnz short loc_2183F
mov [rsp+38h+var_8], 0
jmp short loc_2187C
loc_2183F:
mov rax, [rsp+38h+var_30]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rsp+38h+var_10]
mov rax, [rax+20h]
mov rdi, [rsp+38h+var_28]
call rax
mov rcx, rax
add rcx, 8
mov rax, [rsp+38h+var_30]
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_8], rax
loc_2187C:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long js_calloc_rt(long long a1, long long a2, unsigned long long a3)
{
long long v4; // [rsp+10h] [rbp-28h]
if ( a3 && a2 != a3 * a2 / a3 )
return 0LL;
if ( a3 * a2 + *(_QWORD *)(a1 + 48) > *(_QWORD *)(a1 + 56) - 1LL )
return 0LL;
v4 = (*(long long ( **)(_QWORD, long long, unsigned long long))a1)(*(_QWORD *)(a1 + 64), a2, a3);
if ( !v4 )
return 0LL;
++*(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 48) += (*(long long ( **)(long long))(a1 + 32))(v4) + 8;
return v4;
}
| js_calloc_rt:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
CMP qword ptr [RSP + 0x18],0x0
JBE 0x001217b6
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x20]
IMUL RAX,qword ptr [RSP + 0x18]
XOR ECX,ECX
MOV EDX,ECX
DIV qword ptr [RSP + 0x18]
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
CMP RAX,RCX
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001217b4
MOV qword ptr [RSP + 0x30],0x0
JMP 0x0012187c
LAB_001217b4:
JMP 0x001217b6
LAB_001217b6:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x28
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
IMUL RCX,qword ptr [RSP + 0x18]
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RCX + 0x10]
SUB RCX,0x1
CMP RAX,RCX
SETA AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012180a
MOV qword ptr [RSP + 0x30],0x0
JMP 0x0012187c
LAB_0012180a:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RCX + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
CALL RAX
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x0012183f
MOV qword ptr [RSP + 0x30],0x0
JMP 0x0012187c
LAB_0012183f:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RSP + 0x10]
CALL RAX
MOV RCX,RAX
ADD RCX,0x8
MOV RAX,qword ptr [RSP + 0x8]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
LAB_0012187c:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
long js_calloc_rt(int8 *param_1,ulong param_2,ulong param_3)
{
long lVar1;
long local_8;
if ((param_3 == 0) || (param_2 == (param_2 * param_3) / param_3)) {
if (param_1[7] - 1 < param_1[6] + param_2 * param_3) {
local_8 = 0;
}
else {
local_8 = (*(code *)*param_1)(param_1[8],param_2,param_3);
if (local_8 == 0) {
local_8 = 0;
}
else {
param_1[5] = param_1[5] + 1;
lVar1 = (*(code *)param_1[4])(local_8);
param_1[6] = lVar1 + 8 + param_1[6];
}
}
}
else {
local_8 = 0;
}
return local_8;
}
| |
30,075 | ma_bitmap_end | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_end(MARIA_SHARE *share)
{
my_bool res;
#ifndef DBUG_OFF
if (! share->internal_table)
mysql_mutex_assert_owner(&share->close_lock);
#endif
DBUG_ASSERT(share->bitmap.non_flushable == 0);
DBUG_ASSERT(share->bitmap.flush_all_requested == 0);
DBUG_ASSERT(share->bitmap.waiting_for_non_flushable == 0 &&
share->bitmap.waiting_for_flush_all_requested == 0);
DBUG_ASSERT(share->bitmap.pinned_pages.elements == 0);
res= _ma_bitmap_flush(share);
mysql_mutex_destroy(&share->bitmap.bitmap_lock);
mysql_cond_destroy(&share->bitmap.bitmap_cond);
delete_dynamic(&share->bitmap.pinned_pages);
my_free(share->bitmap.map);
share->bitmap.map= 0;
/*
This is to not get an assert in checkpoint. The bitmap will be flushed
at once by _ma_once_end_block_record() as part of the normal flush
of the kfile.
*/
share->bitmap.changed_not_flushed= 0;
return res;
} | O0 | c | ma_bitmap_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x6234e
jmp 0x62350
jmp 0x62352
jmp 0x62354
jmp 0x62356
jmp 0x62358
jmp 0x6235a
movq -0x8(%rbp), %rdi
callq 0x623e0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x62490
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0xd0, %rdi
callq 0x624e0
movq -0x8(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x140, %rdi # imm = 0x140
callq 0xdab40
movq -0x8(%rbp), %rax
movq 0xa18(%rax), %rdi
callq 0xf3ba0
movq -0x8(%rbp), %rax
movq $0x0, 0xa18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa31(%rax)
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
| _ma_bitmap_end:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_6234E:
jmp short $+2
loc_62350:
jmp short $+2
loc_62352:
jmp short $+2
loc_62354:
jmp short $+2
loc_62356:
jmp short $+2
loc_62358:
jmp short $+2
loc_6235A:
mov rdi, [rbp+var_8]
call _ma_bitmap_flush
mov [rbp+var_9], al
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_destroy_2
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 0D0h
call inline_mysql_cond_destroy_1
mov rdi, [rbp+var_8]
add rdi, 0A10h
add rdi, 140h
call delete_dynamic
mov rax, [rbp+var_8]
mov rdi, [rax+0A18h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0A18h], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+0A31h], 0
mov al, [rbp+var_9]
add rsp, 10h
pop rbp
retn
| char ma_bitmap_end(long long a1)
{
char v2; // [rsp+7h] [rbp-9h]
v2 = ma_bitmap_flush(a1);
inline_mysql_mutex_destroy_2(a1 + 2712);
inline_mysql_cond_destroy_1(a1 + 2784);
delete_dynamic(a1 + 2896);
my_free(*(_QWORD *)(a1 + 2584));
*(_QWORD *)(a1 + 2584) = 0LL;
*(_BYTE *)(a1 + 2609) = 0;
return v2;
}
| _ma_bitmap_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0016234e
LAB_0016234e:
JMP 0x00162350
LAB_00162350:
JMP 0x00162352
LAB_00162352:
JMP 0x00162354
LAB_00162354:
JMP 0x00162356
LAB_00162356:
JMP 0x00162358
LAB_00162358:
JMP 0x0016235a
LAB_0016235a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001623e0
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00162490
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0xd0
CALL 0x001624e0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xa10
ADD RDI,0x140
CALL 0x001dab40
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa18]
CALL 0x001f3ba0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0xa31],0x0
MOV AL,byte ptr [RBP + -0x9]
ADD RSP,0x10
POP RBP
RET
|
int1 _ma_bitmap_end(long param_1)
{
int1 uVar1;
uVar1 = _ma_bitmap_flush(param_1);
inline_mysql_mutex_destroy(param_1 + 0xa98);
inline_mysql_cond_destroy(param_1 + 0xae0);
delete_dynamic(param_1 + 0xb50);
my_free(*(int8 *)(param_1 + 0xa18));
*(int8 *)(param_1 + 0xa18) = 0;
*(int1 *)(param_1 + 0xa31) = 0;
return uVar1;
}
| |
30,076 | httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char const*, char const*)>) | monkey531[P]llama/examples/server/httplib.h | inline void split(const char *b, const char *e, char d, size_t m,
std::function<void(const char *, const char *)> fn) {
size_t i = 0;
size_t beg = 0;
size_t count = 1;
while (e ? (b + i < e) : (b[i] != '\0')) {
if (b[i] == d && count < m) {
auto r = trim(b, e, beg, i);
if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
beg = i + 1;
count++;
}
i++;
}
if (i) {
auto r = trim(b, e, beg, i);
if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
}
} | O1 | c | httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char const*, char const*)>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r12
movq %rcx, %rbp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rax
subq %rdi, %rax
movq %rax, 0x18(%rsp)
movl $0x1, %r9d
xorl %eax, %eax
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
testq %r15, %r15
je 0x6a9ef
cmpq %r15, %rsi
setb %sil
jmp 0x6a9f6
cmpb $0x0, (%rsi)
setne %sil
testb %sil, %sil
je 0x6aab5
cmpb %bl, (%r14,%r13)
sete %sil
cmpq %rbp, %r9
setb %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x6aaad
leaq (%r14,%rax), %rsi
cmpq %r15, %rsi
jae 0x6aa47
movzbl (%r14,%rax), %esi
cmpl $0x20, %esi
je 0x6aa33
cmpl $0x9, %esi
jne 0x6aa47
leaq (%r14,%rax), %rsi
incq %rsi
incq %rax
cmpq %r15, %rsi
jb 0x6aa24
movq 0x18(%rsp), %rax
movq %r13, %rsi
testq %r13, %r13
je 0x6aa69
movq %r13, %rsi
movzbl -0x1(%r14,%rsi), %edi
cmpl $0x20, %edi
je 0x6aa62
cmpl $0x9, %edi
jne 0x6aa69
decq %rsi
jne 0x6aa52
xorl %esi, %esi
cmpq %rsi, %rax
jae 0x6aaa6
movq %r9, 0x20(%rsp)
addq %r14, %rax
addq %r14, %rsi
movq %rax, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%r12)
je 0x6ab40
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq *0x18(%r12)
movq 0x20(%rsp), %r9
leaq 0x1(%r13), %rax
incq %r9
incq %r13
jmp 0x6a9dd
testq %r13, %r13
je 0x6ab31
leaq (%r14,%rax), %rcx
cmpq %r15, %rcx
jae 0x6aaea
movq %r15, %rcx
subq %r14, %rcx
movzbl (%r14,%rax), %edx
cmpl $0x20, %edx
je 0x6aad8
cmpl $0x9, %edx
jne 0x6aaea
leaq (%r14,%rax), %rdx
incq %rdx
incq %rax
cmpq %r15, %rdx
jb 0x6aac9
movq %rcx, %rax
movzbl -0x1(%r14,%r13), %ecx
cmpl $0x20, %ecx
je 0x6aafa
cmpl $0x9, %ecx
jne 0x6ab02
decq %r13
jne 0x6aaea
xorl %r13d, %r13d
cmpq %r13, %rax
jae 0x6ab31
addq %r14, %rax
addq %r14, %r13
movq %rax, 0x10(%rsp)
movq %r13, 0x8(%rsp)
cmpq $0x0, 0x10(%r12)
je 0x6ab40
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq *0x18(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f3e0
nop
| _ZN7httplib6detail5splitEPKcS2_cmSt8functionIFvS2_S2_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, r8
mov rbp, rcx
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov rax, rsi
sub rax, rdi
mov [rsp+58h+var_40], rax
mov r9d, 1
xor eax, eax
xor r13d, r13d
loc_6A9DD:
lea rsi, [r14+r13]
test r15, r15
jz short loc_6A9EF
cmp rsi, r15
setb sil
jmp short loc_6A9F6
loc_6A9EF:
cmp byte ptr [rsi], 0
setnz sil
loc_6A9F6:
test sil, sil
jz loc_6AAB5
cmp [r14+r13], bl
setz sil
cmp r9, rbp
setb dil
and dil, sil
cmp dil, 1
jnz loc_6AAAD
lea rsi, [r14+rax]
cmp rsi, r15
jnb short loc_6AA47
loc_6AA24:
movzx esi, byte ptr [r14+rax]
cmp esi, 20h ; ' '
jz short loc_6AA33
cmp esi, 9
jnz short loc_6AA47
loc_6AA33:
lea rsi, [r14+rax]
inc rsi
inc rax
cmp rsi, r15
jb short loc_6AA24
mov rax, [rsp+58h+var_40]
loc_6AA47:
mov rsi, r13
test r13, r13
jz short loc_6AA69
mov rsi, r13
loc_6AA52:
movzx edi, byte ptr [r14+rsi-1]
cmp edi, 20h ; ' '
jz short loc_6AA62
cmp edi, 9
jnz short loc_6AA69
loc_6AA62:
dec rsi
jnz short loc_6AA52
xor esi, esi
loc_6AA69:
cmp rax, rsi
jnb short loc_6AAA6
mov [rsp+58h+var_38], r9
add rax, r14
add rsi, r14
mov [rsp+58h+var_48], rax
mov [rsp+58h+var_50], rsi
cmp qword ptr [r12+10h], 0
jz loc_6AB40
mov rdi, r12
lea rsi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_50]
call qword ptr [r12+18h]
mov r9, [rsp+58h+var_38]
loc_6AAA6:
lea rax, [r13+1]
inc r9
loc_6AAAD:
inc r13
jmp loc_6A9DD
loc_6AAB5:
test r13, r13
jz short loc_6AB31
lea rcx, [r14+rax]
cmp rcx, r15
jnb short loc_6AAEA
mov rcx, r15
sub rcx, r14
loc_6AAC9:
movzx edx, byte ptr [r14+rax]
cmp edx, 20h ; ' '
jz short loc_6AAD8
cmp edx, 9
jnz short loc_6AAEA
loc_6AAD8:
lea rdx, [r14+rax]
inc rdx
inc rax
cmp rdx, r15
jb short loc_6AAC9
mov rax, rcx
loc_6AAEA:
movzx ecx, byte ptr [r14+r13-1]
cmp ecx, 20h ; ' '
jz short loc_6AAFA
cmp ecx, 9
jnz short loc_6AB02
loc_6AAFA:
dec r13
jnz short loc_6AAEA
xor r13d, r13d
loc_6AB02:
cmp rax, r13
jnb short loc_6AB31
add rax, r14
add r13, r14
mov [rsp+58h+var_48], rax
mov [rsp+58h+var_50], r13
cmp qword ptr [r12+10h], 0
jz short loc_6AB40
lea rsi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_50]
mov rdi, r12
call qword ptr [r12+18h]
loc_6AB31:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6AB40:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
| unsigned long long httplib::detail::split(
long long a1,
unsigned long long a2,
unsigned __int8 a3,
unsigned long long a4,
long long a5)
{
unsigned long long v10; // r9
unsigned long long result; // rax
unsigned long long i; // r13
_BYTE *v13; // rsi
int v15; // esi
unsigned long long v16; // rsi
unsigned long long v17; // rsi
int v18; // edi
int v19; // edx
unsigned long long v20; // rdx
long long v21; // rcx
long long v22; // [rsp+8h] [rbp-50h] BYREF
long long v23; // [rsp+10h] [rbp-48h] BYREF
unsigned long long v24; // [rsp+18h] [rbp-40h]
unsigned long long v25; // [rsp+20h] [rbp-38h]
v24 = a2 - a1;
v10 = 1LL;
result = 0LL;
for ( i = 0LL; ; ++i )
{
v13 = (_BYTE *)(a1 + i);
if ( !(a2 ? (unsigned long long)v13 < a2 : *v13 != 0) )
break;
if ( *(_BYTE *)(a1 + i) == a3 && v10 < a4 )
{
if ( a1 + result < a2 )
{
while ( 1 )
{
v15 = *(unsigned __int8 *)(a1 + result);
if ( v15 != 32 && v15 != 9 )
break;
v16 = a1 + result++ + 1;
if ( v16 >= a2 )
{
result = v24;
break;
}
}
}
v17 = i;
if ( i )
{
v17 = i;
while ( 1 )
{
v18 = *(unsigned __int8 *)(a1 + v17 - 1);
if ( v18 != 32 && v18 != 9 )
break;
if ( !--v17 )
{
v17 = 0LL;
break;
}
}
}
if ( result < v17 )
{
v25 = v10;
v23 = a1 + result;
v22 = a1 + v17;
if ( !*(_QWORD *)(a5 + 16) )
goto LABEL_37;
(*(void ( **)(long long, long long *, long long *))(a5 + 24))(a5, &v23, &v22);
v10 = v25;
}
result = i + 1;
++v10;
}
}
if ( i )
{
if ( a1 + result < a2 )
{
while ( 1 )
{
v19 = *(unsigned __int8 *)(a1 + result);
if ( v19 != 32 && v19 != 9 )
break;
v20 = a1 + result++ + 1;
if ( v20 >= a2 )
{
result = a2 - a1;
break;
}
}
}
while ( 1 )
{
v21 = *(unsigned __int8 *)(a1 + i - 1);
if ( (_DWORD)v21 != 32 && (_DWORD)v21 != 9 )
break;
if ( !--i )
{
i = 0LL;
break;
}
}
if ( result < i )
{
v23 = a1 + result;
v22 = a1 + i;
if ( !*(_QWORD *)(a5 + 16) )
LABEL_37:
std::__throw_bad_function_call();
return (*(long long ( **)(long long, long long *, long long *, long long, long long, unsigned long long))(a5 + 24))(
a5,
&v23,
&v22,
v21,
a5,
v10);
}
}
return result;
}
| split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,R8
MOV RBP,RCX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,RSI
SUB RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV R9D,0x1
XOR EAX,EAX
XOR R13D,R13D
LAB_0016a9dd:
LEA RSI,[R14 + R13*0x1]
TEST R15,R15
JZ 0x0016a9ef
CMP RSI,R15
SETC SIL
JMP 0x0016a9f6
LAB_0016a9ef:
CMP byte ptr [RSI],0x0
SETNZ SIL
LAB_0016a9f6:
TEST SIL,SIL
JZ 0x0016aab5
CMP byte ptr [R14 + R13*0x1],BL
SETZ SIL
CMP R9,RBP
SETC DIL
AND DIL,SIL
CMP DIL,0x1
JNZ 0x0016aaad
LEA RSI,[R14 + RAX*0x1]
CMP RSI,R15
JNC 0x0016aa47
LAB_0016aa24:
MOVZX ESI,byte ptr [R14 + RAX*0x1]
CMP ESI,0x20
JZ 0x0016aa33
CMP ESI,0x9
JNZ 0x0016aa47
LAB_0016aa33:
LEA RSI,[R14 + RAX*0x1]
INC RSI
INC RAX
CMP RSI,R15
JC 0x0016aa24
MOV RAX,qword ptr [RSP + 0x18]
LAB_0016aa47:
MOV RSI,R13
TEST R13,R13
JZ 0x0016aa69
MOV RSI,R13
LAB_0016aa52:
MOVZX EDI,byte ptr [R14 + RSI*0x1 + -0x1]
CMP EDI,0x20
JZ 0x0016aa62
CMP EDI,0x9
JNZ 0x0016aa69
LAB_0016aa62:
DEC RSI
JNZ 0x0016aa52
XOR ESI,ESI
LAB_0016aa69:
CMP RAX,RSI
JNC 0x0016aaa6
MOV qword ptr [RSP + 0x20],R9
ADD RAX,R14
ADD RSI,R14
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x8],RSI
CMP qword ptr [R12 + 0x10],0x0
JZ 0x0016ab40
MOV RDI,R12
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
CALL qword ptr [R12 + 0x18]
MOV R9,qword ptr [RSP + 0x20]
LAB_0016aaa6:
LEA RAX,[R13 + 0x1]
INC R9
LAB_0016aaad:
INC R13
JMP 0x0016a9dd
LAB_0016aab5:
TEST R13,R13
JZ 0x0016ab31
LEA RCX,[R14 + RAX*0x1]
CMP RCX,R15
JNC 0x0016aaea
MOV RCX,R15
SUB RCX,R14
LAB_0016aac9:
MOVZX EDX,byte ptr [R14 + RAX*0x1]
CMP EDX,0x20
JZ 0x0016aad8
CMP EDX,0x9
JNZ 0x0016aaea
LAB_0016aad8:
LEA RDX,[R14 + RAX*0x1]
INC RDX
INC RAX
CMP RDX,R15
JC 0x0016aac9
MOV RAX,RCX
LAB_0016aaea:
MOVZX ECX,byte ptr [R14 + R13*0x1 + -0x1]
CMP ECX,0x20
JZ 0x0016aafa
CMP ECX,0x9
JNZ 0x0016ab02
LAB_0016aafa:
DEC R13
JNZ 0x0016aaea
XOR R13D,R13D
LAB_0016ab02:
CMP RAX,R13
JNC 0x0016ab31
ADD RAX,R14
ADD R13,R14
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x8],R13
CMP qword ptr [R12 + 0x10],0x0
JZ 0x0016ab40
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
MOV RDI,R12
CALL qword ptr [R12 + 0x18]
LAB_0016ab31:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016ab40:
CALL 0x0011f3e0
|
/* httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char
const*, char const*)>) */
void httplib::detail::split(long param_1,char *param_2,char param_3,ulong param_4,long param_5)
{
long lVar1;
char cVar2;
ulong uVar3;
ulong uVar4;
char *pcVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
long local_50;
long local_48;
ulong local_40;
ulong local_38;
local_40 = (long)param_2 - param_1;
uVar6 = 1;
uVar3 = 0;
uVar7 = 0;
while( true ) {
if (param_2 == (char *)0x0) {
bVar8 = *(char *)(param_1 + uVar7) != '\0';
}
else {
bVar8 = (char *)(param_1 + uVar7) < param_2;
}
if (!bVar8) break;
if (uVar6 < param_4 && *(char *)(param_1 + uVar7) == param_3) {
pcVar5 = (char *)(param_1 + uVar3);
uVar4 = uVar3;
for (; (pcVar5 < param_2 &&
((*(char *)(param_1 + uVar3) == ' ' ||
(uVar4 = uVar3, *(char *)(param_1 + uVar3) == '\t')))); uVar3 = uVar3 + 1) {
pcVar5 = (char *)(param_1 + uVar3 + 1);
uVar4 = local_40;
}
uVar3 = uVar7;
if (uVar7 != 0) {
do {
cVar2 = *(char *)(param_1 + -1 + uVar3);
if ((cVar2 != ' ') && (cVar2 != '\t')) goto LAB_0016aa69;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
uVar3 = 0;
}
LAB_0016aa69:
if (uVar4 < uVar3) {
local_48 = uVar4 + param_1;
local_50 = uVar3 + param_1;
local_38 = uVar6;
if (*(long *)(param_5 + 0x10) == 0) goto LAB_0016ab40;
(**(code **)(param_5 + 0x18))(param_5,&local_48,&local_50);
uVar6 = local_38;
}
uVar3 = uVar7 + 1;
uVar6 = uVar6 + 1;
}
uVar7 = uVar7 + 1;
}
if (uVar7 != 0) {
uVar6 = uVar3;
if ((char *)(param_1 + uVar3) < param_2) {
do {
if ((*(char *)(param_1 + uVar3) != ' ') &&
(uVar6 = uVar3, *(char *)(param_1 + uVar3) != '\t')) break;
lVar1 = param_1 + uVar3;
uVar3 = uVar3 + 1;
uVar6 = (long)param_2 - param_1;
} while ((char *)(lVar1 + 1) < param_2);
}
do {
cVar2 = *(char *)(param_1 + -1 + uVar7);
if ((cVar2 != ' ') && (cVar2 != '\t')) goto LAB_0016ab02;
uVar7 = uVar7 - 1;
} while (uVar7 != 0);
uVar7 = 0;
LAB_0016ab02:
if (uVar6 < uVar7) {
local_48 = uVar6 + param_1;
local_50 = uVar7 + param_1;
if (*(long *)(param_5 + 0x10) == 0) {
LAB_0016ab40:
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
(**(code **)(param_5 + 0x18))(param_5,&local_48,&local_50);
}
}
return;
}
| |
30,077 | httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char const*, char const*)>) | monkey531[P]llama/examples/server/httplib.h | inline void split(const char *b, const char *e, char d, size_t m,
std::function<void(const char *, const char *)> fn) {
size_t i = 0;
size_t beg = 0;
size_t count = 1;
while (e ? (b + i < e) : (b[i] != '\0')) {
if (b[i] == d && count < m) {
auto r = trim(b, e, beg, i);
if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
beg = i + 1;
count++;
}
i++;
}
if (i) {
auto r = trim(b, e, beg, i);
if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
}
} | O3 | c | httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char const*, char const*)>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
subq %r14, %rdi
movl $0x1, %ebx
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rax, %r13
leaq (%r14,%r13), %rcx
testq %r15, %r15
je 0x690d8
cmpq %r15, %rcx
jae 0x6919b
movb (%rcx), %cl
jmp 0x690e2
movb (%rcx), %cl
testb %cl, %cl
je 0x6919b
cmpq %r12, %rbx
setb %r9b
cmpb %bpl, %cl
sete %cl
testb %r9b, %cl
jne 0x690f9
incq %r13
jmp 0x690c2
leaq (%r14,%rax), %rcx
cmpq %r15, %rcx
jae 0x69123
movzbl (%r14,%rax), %ecx
cmpl $0x20, %ecx
je 0x69111
cmpl $0x9, %ecx
jne 0x69123
leaq (%r14,%rax), %rcx
incq %rcx
incq %rax
cmpq %r15, %rcx
jb 0x69102
movq %rdi, %rax
testq %r13, %r13
je 0x69142
movq %r13, %rcx
movzbl -0x1(%r14,%rcx), %r9d
cmpl $0x20, %r9d
je 0x6913d
cmpl $0x9, %r9d
jne 0x69144
decq %rcx
jne 0x6912b
xorl %ecx, %ecx
cmpq %rcx, %rax
jae 0x6918d
movq %rdi, 0x20(%rsp)
addq %r14, %rax
addq %r14, %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x10(%r8)
je 0x6921e
movq %r8, %rdi
movq %r8, 0x18(%rsp)
movq 0x18(%rsp), %rax
callq *0x18(%rax)
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rsi
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %rdi
incq %r13
incq %rbx
movq %r13, %rax
jmp 0x690c2
testq %r13, %r13
je 0x6920f
leaq (%r14,%rax), %rcx
cmpq %r15, %rcx
jae 0x691ca
movzbl (%r14,%rax), %ecx
cmpl $0x20, %ecx
je 0x691b8
cmpl $0x9, %ecx
jne 0x691ca
leaq (%r14,%rax), %rcx
incq %rcx
incq %rax
cmpq %r15, %rcx
jb 0x691a9
movq %rdi, %rax
movzbl -0x1(%r14,%r13), %ecx
cmpl $0x20, %ecx
je 0x691da
cmpl $0x9, %ecx
jne 0x691e2
decq %r13
jne 0x691ca
xorl %r13d, %r13d
cmpq %r13, %rax
jae 0x6920f
addq %r14, %rax
addq %r14, %r13
movq %rax, 0x10(%rsp)
movq %r13, 0x8(%rsp)
cmpq $0x0, 0x10(%r8)
je 0x6921e
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r8, %rdi
callq *0x18(%r8)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f3e0
nop
| _ZN7httplib6detail5splitEPKcS2_cmSt8functionIFvS2_S2_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, rcx
mov ebp, edx
mov r15, rsi
mov r14, rdi
mov rdi, rsi
sub rdi, r14
mov ebx, 1
xor eax, eax
lea rsi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_50]
mov r13, rax
loc_690C2:
lea rcx, [r14+r13]
test r15, r15
jz short loc_690D8
cmp rcx, r15
jnb loc_6919B
mov cl, [rcx]
jmp short loc_690E2
loc_690D8:
mov cl, [rcx]
test cl, cl
jz loc_6919B
loc_690E2:
cmp rbx, r12
setb r9b
cmp cl, bpl
setz cl
test cl, r9b
jnz short loc_690F9
inc r13
jmp short loc_690C2
loc_690F9:
lea rcx, [r14+rax]
cmp rcx, r15
jnb short loc_69123
loc_69102:
movzx ecx, byte ptr [r14+rax]
cmp ecx, 20h ; ' '
jz short loc_69111
cmp ecx, 9
jnz short loc_69123
loc_69111:
lea rcx, [r14+rax]
inc rcx
inc rax
cmp rcx, r15
jb short loc_69102
mov rax, rdi
loc_69123:
test r13, r13
jz short loc_69142
mov rcx, r13
loc_6912B:
movzx r9d, byte ptr [r14+rcx-1]
cmp r9d, 20h ; ' '
jz short loc_6913D
cmp r9d, 9
jnz short loc_69144
loc_6913D:
dec rcx
jnz short loc_6912B
loc_69142:
xor ecx, ecx
loc_69144:
cmp rax, rcx
jnb short loc_6918D
mov [rsp+58h+var_38], rdi
add rax, r14
add rcx, r14
mov [rsp+58h+var_48], rax
mov [rsp+58h+var_50], rcx
cmp qword ptr [r8+10h], 0
jz loc_6921E
mov rdi, r8
mov [rsp+58h+var_40], r8
mov rax, [rsp+58h+var_40]
call qword ptr [rax+18h]
lea rdx, [rsp+58h+var_50]
lea rsi, [rsp+58h+var_48]
mov r8, [rsp+58h+var_40]
mov rdi, [rsp+58h+var_38]
loc_6918D:
inc r13
inc rbx
mov rax, r13
jmp loc_690C2
loc_6919B:
test r13, r13
jz short loc_6920F
lea rcx, [r14+rax]
cmp rcx, r15
jnb short loc_691CA
loc_691A9:
movzx ecx, byte ptr [r14+rax]
cmp ecx, 20h ; ' '
jz short loc_691B8
cmp ecx, 9
jnz short loc_691CA
loc_691B8:
lea rcx, [r14+rax]
inc rcx
inc rax
cmp rcx, r15
jb short loc_691A9
mov rax, rdi
loc_691CA:
movzx ecx, byte ptr [r14+r13-1]
cmp ecx, 20h ; ' '
jz short loc_691DA
cmp ecx, 9
jnz short loc_691E2
loc_691DA:
dec r13
jnz short loc_691CA
xor r13d, r13d
loc_691E2:
cmp rax, r13
jnb short loc_6920F
add rax, r14
add r13, r14
mov [rsp+58h+var_48], rax
mov [rsp+58h+var_50], r13
cmp qword ptr [r8+10h], 0
jz short loc_6921E
lea rsi, [rsp+58h+var_48]
lea rdx, [rsp+58h+var_50]
mov rdi, r8
call qword ptr [r8+18h]
loc_6920F:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6921E:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
| unsigned long long httplib::detail::split(
long long a1,
unsigned long long a2,
char a3,
unsigned long long a4,
long long a5)
{
unsigned long long v8; // rdi
unsigned long long v9; // rbx
unsigned long long result; // rax
unsigned long long v11; // r13
char *v12; // rcx
char v13; // cl
int v14; // ecx
unsigned long long v15; // rcx
unsigned long long v16; // rcx
int v17; // r9d
int v18; // ecx
unsigned long long v19; // rcx
int v20; // ecx
long long v21; // [rsp+8h] [rbp-50h] BYREF
long long v22; // [rsp+10h] [rbp-48h] BYREF
long long v23; // [rsp+18h] [rbp-40h]
unsigned long long v24; // [rsp+20h] [rbp-38h]
v8 = a2 - a1;
v9 = 1LL;
result = 0LL;
v11 = 0LL;
while ( 1 )
{
v12 = (char *)(a1 + v11);
if ( a2 )
{
if ( (unsigned long long)v12 >= a2 )
break;
v13 = *v12;
goto LABEL_6;
}
v13 = *v12;
if ( !v13 )
break;
LABEL_6:
if ( v9 < a4 && v13 == a3 )
{
if ( a1 + result < a2 )
{
while ( 1 )
{
v14 = *(unsigned __int8 *)(a1 + result);
if ( v14 != 32 && v14 != 9 )
break;
v15 = a1 + result++ + 1;
if ( v15 >= a2 )
{
result = v8;
break;
}
}
}
if ( v11 )
{
v16 = v11;
while ( 1 )
{
v17 = *(unsigned __int8 *)(a1 + v16 - 1);
if ( v17 != 32 && v17 != 9 )
break;
if ( !--v16 )
goto LABEL_18;
}
}
else
{
LABEL_18:
v16 = 0LL;
}
if ( result < v16 )
{
v24 = v8;
v22 = a1 + result;
v21 = a1 + v16;
if ( !*(_QWORD *)(a5 + 16) )
goto LABEL_37;
v23 = a5;
(*(void ( **)(long long, long long *, long long *))(a5 + 24))(a5, &v22, &v21);
a5 = v23;
v8 = v24;
}
++v11;
++v9;
result = v11;
}
else
{
++v11;
}
}
if ( v11 )
{
if ( a1 + result < a2 )
{
while ( 1 )
{
v18 = *(unsigned __int8 *)(a1 + result);
if ( v18 != 32 && v18 != 9 )
break;
v19 = a1 + result++ + 1;
if ( v19 >= a2 )
{
result = v8;
break;
}
}
}
while ( 1 )
{
v20 = *(unsigned __int8 *)(a1 + v11 - 1);
if ( v20 != 32 && v20 != 9 )
break;
if ( !--v11 )
{
v11 = 0LL;
break;
}
}
if ( result < v11 )
{
v22 = a1 + result;
v21 = a1 + v11;
if ( !*(_QWORD *)(a5 + 16) )
LABEL_37:
std::__throw_bad_function_call();
return (*(long long ( **)(long long, long long *, long long *))(a5 + 24))(a5, &v22, &v21);
}
}
return result;
}
| split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,RCX
MOV EBP,EDX
MOV R15,RSI
MOV R14,RDI
MOV RDI,RSI
SUB RDI,R14
MOV EBX,0x1
XOR EAX,EAX
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
MOV R13,RAX
LAB_001690c2:
LEA RCX,[R14 + R13*0x1]
TEST R15,R15
JZ 0x001690d8
CMP RCX,R15
JNC 0x0016919b
MOV CL,byte ptr [RCX]
JMP 0x001690e2
LAB_001690d8:
MOV CL,byte ptr [RCX]
TEST CL,CL
JZ 0x0016919b
LAB_001690e2:
CMP RBX,R12
SETC R9B
CMP CL,BPL
SETZ CL
TEST CL,R9B
JNZ 0x001690f9
INC R13
JMP 0x001690c2
LAB_001690f9:
LEA RCX,[R14 + RAX*0x1]
CMP RCX,R15
JNC 0x00169123
LAB_00169102:
MOVZX ECX,byte ptr [R14 + RAX*0x1]
CMP ECX,0x20
JZ 0x00169111
CMP ECX,0x9
JNZ 0x00169123
LAB_00169111:
LEA RCX,[R14 + RAX*0x1]
INC RCX
INC RAX
CMP RCX,R15
JC 0x00169102
MOV RAX,RDI
LAB_00169123:
TEST R13,R13
JZ 0x00169142
MOV RCX,R13
LAB_0016912b:
MOVZX R9D,byte ptr [R14 + RCX*0x1 + -0x1]
CMP R9D,0x20
JZ 0x0016913d
CMP R9D,0x9
JNZ 0x00169144
LAB_0016913d:
DEC RCX
JNZ 0x0016912b
LAB_00169142:
XOR ECX,ECX
LAB_00169144:
CMP RAX,RCX
JNC 0x0016918d
MOV qword ptr [RSP + 0x20],RDI
ADD RAX,R14
ADD RCX,R14
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x8],RCX
CMP qword ptr [R8 + 0x10],0x0
JZ 0x0016921e
MOV RDI,R8
MOV qword ptr [RSP + 0x18],R8
MOV RAX,qword ptr [RSP + 0x18]
CALL qword ptr [RAX + 0x18]
LEA RDX,[RSP + 0x8]
LEA RSI,[RSP + 0x10]
MOV R8,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x20]
LAB_0016918d:
INC R13
INC RBX
MOV RAX,R13
JMP 0x001690c2
LAB_0016919b:
TEST R13,R13
JZ 0x0016920f
LEA RCX,[R14 + RAX*0x1]
CMP RCX,R15
JNC 0x001691ca
LAB_001691a9:
MOVZX ECX,byte ptr [R14 + RAX*0x1]
CMP ECX,0x20
JZ 0x001691b8
CMP ECX,0x9
JNZ 0x001691ca
LAB_001691b8:
LEA RCX,[R14 + RAX*0x1]
INC RCX
INC RAX
CMP RCX,R15
JC 0x001691a9
MOV RAX,RDI
LAB_001691ca:
MOVZX ECX,byte ptr [R14 + R13*0x1 + -0x1]
CMP ECX,0x20
JZ 0x001691da
CMP ECX,0x9
JNZ 0x001691e2
LAB_001691da:
DEC R13
JNZ 0x001691ca
XOR R13D,R13D
LAB_001691e2:
CMP RAX,R13
JNC 0x0016920f
ADD RAX,R14
ADD R13,R14
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x8],R13
CMP qword ptr [R8 + 0x10],0x0
JZ 0x0016921e
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
MOV RDI,R8
CALL qword ptr [R8 + 0x18]
LAB_0016920f:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016921e:
CALL 0x0011f3e0
|
/* httplib::detail::split(char const*, char const*, char, unsigned long, std::function<void (char
const*, char const*)>) */
void httplib::detail::split(long param_1,char *param_2,char param_3,ulong param_4,long param_5)
{
ulong uVar1;
ulong uVar2;
char cVar3;
char *pcVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
long local_50;
long local_48;
long local_40;
ulong local_38;
uVar7 = (long)param_2 - param_1;
uVar6 = 1;
uVar1 = 0;
uVar8 = uVar1;
LAB_001690c2:
pcVar4 = (char *)(param_1 + uVar8);
if (param_2 == (char *)0x0) {
cVar3 = *pcVar4;
if (cVar3 == '\0') goto LAB_0016919b;
}
else {
if (param_2 <= pcVar4) goto LAB_0016919b;
cVar3 = *pcVar4;
}
if (cVar3 == param_3 && uVar6 < param_4) {
pcVar4 = (char *)(param_1 + uVar1);
uVar2 = uVar1;
for (; (uVar5 = uVar8, pcVar4 < param_2 &&
((*(char *)(param_1 + uVar1) == ' ' ||
(uVar2 = uVar1, *(char *)(param_1 + uVar1) == '\t')))); uVar1 = uVar1 + 1) {
pcVar4 = (char *)(param_1 + uVar1 + 1);
uVar2 = uVar7;
}
for (; uVar5 != 0; uVar5 = uVar5 - 1) {
cVar3 = *(char *)(param_1 + -1 + uVar5);
if ((cVar3 != ' ') && (cVar3 != '\t')) goto LAB_00169144;
}
uVar5 = 0;
LAB_00169144:
if (uVar2 < uVar5) {
local_48 = uVar2 + param_1;
local_50 = uVar5 + param_1;
local_38 = uVar7;
if (*(long *)(param_5 + 0x10) == 0) goto LAB_0016921e;
local_40 = param_5;
(**(code **)(param_5 + 0x18))(param_5,&local_48,&local_50);
uVar7 = local_38;
param_5 = local_40;
}
uVar1 = uVar8 + 1;
uVar6 = uVar6 + 1;
uVar8 = uVar1;
}
else {
uVar8 = uVar8 + 1;
}
goto LAB_001690c2;
LAB_0016919b:
if (uVar8 != 0) {
pcVar4 = (char *)(param_1 + uVar1);
uVar6 = uVar1;
for (; (pcVar4 < param_2 &&
((*(char *)(param_1 + uVar1) == ' ' ||
(uVar6 = uVar1, *(char *)(param_1 + uVar1) == '\t')))); uVar1 = uVar1 + 1) {
pcVar4 = (char *)(param_1 + uVar1 + 1);
uVar6 = uVar7;
}
do {
cVar3 = *(char *)(param_1 + -1 + uVar8);
if ((cVar3 != ' ') && (cVar3 != '\t')) goto LAB_001691e2;
uVar8 = uVar8 - 1;
} while (uVar8 != 0);
uVar8 = 0;
LAB_001691e2:
if (uVar6 < uVar8) {
local_48 = uVar6 + param_1;
local_50 = uVar8 + param_1;
if (*(long *)(param_5 + 0x10) == 0) {
LAB_0016921e:
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
(**(code **)(param_5 + 0x18))(param_5,&local_48,&local_50);
}
}
return;
}
| |
30,078 | client_chat::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | untodesu[P]voxelius/game/client/chat.cc | void client_chat::print(const std::string &text)
{
GuiChatMessage message = {};
message.spawn = globals::curtime;
message.text = text;
message.color = ImGui::GetStyleColorVec4(ImGuiCol_Text);
history.push_back(message);
if(sfx_chat_message && session::is_ingame()) {
sound::play_ui(sfx_chat_message, false, 1.0f);
}
} | O0 | cpp | client_chat::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2c6d0
leaq -0x18(%rbp), %rdi
callq 0x59ce0
jmp 0x588bf
leaq 0x4b81da(%rip), %rax # 0x510aa0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2d4d0
jmp 0x588dc
xorl %edi, %edi
callq 0x2251c0
movq %rax, -0x70(%rbp)
jmp 0x588e9
movq -0x70(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, -0x18(%rbp)
leaq 0x4b5135(%rip), %rdi # 0x50da30
leaq -0x40(%rbp), %rsi
callq 0x59d10
jmp 0x58906
leaq 0x4b5193(%rip), %rdi # 0x50daa0
callq 0x59d70
testb $0x1, %al
jne 0x5891b
jmp 0x5899e
callq 0x11c270
movb %al, -0x71(%rbp)
jmp 0x58925
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x5892e
jmp 0x5899e
leaq 0x4b516b(%rip), %rsi # 0x50daa0
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x59d90
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movss 0x3116f4(%rip), %xmm0 # 0x36a044
callq 0x133c50
jmp 0x58957
leaq -0x60(%rbp), %rdi
callq 0x597d0
jmp 0x5899e
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x2d648
jmp 0x589b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x589b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x597d0
jmp 0x589b0
leaq -0x40(%rbp), %rdi
callq 0x59dc0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x59dc0
movq -0x48(%rbp), %rdi
callq 0x2cbe0
nopw %cs:(%rax,%rax)
| _ZN11client_chat5printERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 80h
mov qword ptr [rbp+var_8], rdi
mov [rbp+var_40], 0
lea rdi, [rbp+var_38]
mov [rbp+var_68], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
lea rdi, [rbp+var_18]; this
call _ZN6ImVec4C2Ev; ImVec4::ImVec4(void)
jmp short $+2
loc_588BF:
lea rax, _ZN7globals7curtimeE; globals::curtime
mov rax, [rax]
mov [rbp+var_40], rax
mov rsi, qword ptr [rbp+var_8]; int
lea rdi, [rbp+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_588DC:
xor edi, edi; this
call _ZN5ImGui17GetStyleColorVec4Ei; ImGui::GetStyleColorVec4(int)
mov [rbp+var_70], rax
jmp short $+2
loc_588E9:
mov rax, [rbp+var_70]
movups xmm0, xmmword ptr [rax]
movups [rbp+var_18], xmm0
lea rdi, _ZL7history; history
lea rsi, [rbp+var_40]
call _ZNSt5dequeI14GuiChatMessageSaIS0_EE9push_backERKS0_; std::deque<GuiChatMessage>::push_back(GuiChatMessage const&)
jmp short $+2
loc_58906:
lea rdi, _ZL16sfx_chat_message; this
call _ZNKSt12__shared_ptrIK11SoundEffectLN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<SoundEffect const,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_5891B
jmp loc_5899E
loc_5891B:
call _ZN7session9is_ingameEv; session::is_ingame(void)
mov [rbp+var_71], al
jmp short $+2
loc_58925:
mov al, [rbp+var_71]
test al, 1
jnz short loc_5892E
jmp short loc_5899E
loc_5892E:
lea rsi, _ZL16sfx_chat_message; sfx_chat_message
lea rdi, [rbp+var_60]
mov [rbp+var_80], rdi
call _ZNSt10shared_ptrIK11SoundEffectEC2ERKS2_; std::shared_ptr<SoundEffect const>::shared_ptr(std::shared_ptr<SoundEffect const> const&)
mov rdi, [rbp+var_80]
xor esi, esi
movss xmm0, cs:flt_36A044
call _ZN5sound7play_uiESt10shared_ptrIK11SoundEffectEbf; sound::play_ui(std::shared_ptr<SoundEffect const>,bool,float)
jmp short $+2
loc_58957:
lea rdi, [rbp+var_60]; void *
call _ZNSt10shared_ptrIK11SoundEffectED2Ev; std::shared_ptr<SoundEffect const>::~shared_ptr()
jmp short loc_5899E
mov rdi, [rbp+var_68]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_589B9
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
jmp short loc_589B0
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
lea rdi, [rbp+var_60]; void *
call _ZNSt10shared_ptrIK11SoundEffectED2Ev; std::shared_ptr<SoundEffect const>::~shared_ptr()
jmp short loc_589B0
loc_5899E:
lea rdi, [rbp+var_40]; this
call _ZN14GuiChatMessageD2Ev; GuiChatMessage::~GuiChatMessage()
add rsp, 80h
pop rbp
retn
loc_589B0:
lea rdi, [rbp+var_40]; this
call _ZN14GuiChatMessageD2Ev; GuiChatMessage::~GuiChatMessage()
loc_589B9:
mov rdi, [rbp+var_48]
call __Unwind_Resume
| void client_chat::print(long long a1)
{
int v1; // esi
_BYTE v2[20]; // [rsp+20h] [rbp-60h] BYREF
long long v3; // [rsp+40h] [rbp-40h] BYREF
_BYTE v4[32]; // [rsp+48h] [rbp-38h] BYREF
__int128 v5; // [rsp+68h] [rbp-18h] BYREF
int v6[2]; // [rsp+78h] [rbp-8h]
*(_QWORD *)v6 = a1;
std::string::basic_string(v4);
ImVec4::ImVec4((ImVec4 *)&v5);
v3 = globals::curtime;
v1 = v6[0];
std::string::operator=(v4, *(_QWORD *)v6);
v5 = *(_OWORD *)ImGui::GetStyleColorVec4(0LL, v1);
std::deque<GuiChatMessage>::push_back(&history, &v3);
if ( (std::__shared_ptr<SoundEffect const,(__gnu_cxx::_Lock_policy)2>::operator bool(&sfx_chat_message) & 1) != 0
&& (session::is_ingame((session *)&sfx_chat_message) & 1) != 0 )
{
std::shared_ptr<SoundEffect const>::shared_ptr(v2, &sfx_chat_message);
sound::play_ui(v2, 0LL, 1.0);
std::shared_ptr<SoundEffect const>::~shared_ptr(v2);
}
GuiChatMessage::~GuiChatMessage((GuiChatMessage *)&v3);
}
| print:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x40],0x0
LEA RDI,[RBP + -0x38]
MOV qword ptr [RBP + -0x68],RDI
CALL 0x0012c6d0
LEA RDI,[RBP + -0x18]
LAB_001588b8:
CALL 0x00159ce0
JMP 0x001588bf
LAB_001588bf:
LEA RAX,[0x610aa0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[RBP + -0x38]
LAB_001588d5:
CALL 0x0012d4d0
JMP 0x001588dc
LAB_001588dc:
XOR EDI,EDI
CALL 0x003251c0
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001588e9
LAB_001588e9:
MOV RAX,qword ptr [RBP + -0x70]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RBP + -0x18],XMM0
LEA RDI,[0x60da30]
LEA RSI,[RBP + -0x40]
CALL 0x00159d10
JMP 0x00158906
LAB_00158906:
LEA RDI,[0x60daa0]
CALL 0x00159d70
TEST AL,0x1
JNZ 0x0015891b
JMP 0x0015899e
LAB_0015891b:
CALL 0x0021c270
MOV byte ptr [RBP + -0x71],AL
JMP 0x00158925
LAB_00158925:
MOV AL,byte ptr [RBP + -0x71]
TEST AL,0x1
JNZ 0x0015892e
JMP 0x0015899e
LAB_0015892e:
LEA RSI,[0x60daa0]
LEA RDI,[RBP + -0x60]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x00159d90
MOV RDI,qword ptr [RBP + -0x80]
LAB_00158946:
XOR ESI,ESI
MOVSS XMM0,dword ptr [0x0046a044]
CALL 0x00233c50
LAB_00158955:
JMP 0x00158957
LAB_00158957:
LEA RDI,[RBP + -0x60]
CALL 0x001597d0
JMP 0x0015899e
LAB_0015899e:
LEA RDI,[RBP + -0x40]
CALL 0x00159dc0
ADD RSP,0x80
POP RBP
RET
|
/* client_chat::print(std::__cxx11::string const&) */
void client_chat::print(string *param_1)
{
bool bVar1;
byte bVar2;
int8 *puVar3;
shared_ptr<SoundEffect_const> local_68 [32];
int8 local_48;
string local_40 [32];
int8 local_20;
int8 uStack_18;
string *local_10;
local_48 = 0;
local_10 = param_1;
std::__cxx11::string::string(local_40);
/* try { // try from 001588b8 to 001588bc has its CatchHandler @ 00158962 */
ImVec4::ImVec4((ImVec4 *)&local_20);
local_48 = globals::curtime;
/* try { // try from 001588d5 to 0015891f has its CatchHandler @ 00158979 */
std::__cxx11::string::operator=(local_40,local_10);
puVar3 = (int8 *)ImGui::GetStyleColorVec4(0);
local_20 = *puVar3;
uStack_18 = puVar3[1];
std::deque<GuiChatMessage,std::allocator<GuiChatMessage>>::push_back
((deque<GuiChatMessage,std::allocator<GuiChatMessage>> *)history,
(GuiChatMessage *)&local_48);
bVar1 = std::__shared_ptr::operator_cast_to_bool((__shared_ptr *)sfx_chat_message);
if ((bVar1) && (bVar2 = session::is_ingame(), (bVar2 & 1) != 0)) {
std::shared_ptr<SoundEffect_const>::shared_ptr(local_68,(shared_ptr *)sfx_chat_message);
/* try { // try from 00158946 to 00158954 has its CatchHandler @ 00158987 */
sound::play_ui(DAT_0046a044,local_68,0);
std::shared_ptr<SoundEffect_const>::~shared_ptr(local_68);
}
GuiChatMessage::~GuiChatMessage((GuiChatMessage *)&local_48);
return;
}
| |
30,079 | js_realloc_array | bluesky950520[P]quickjs/quickjs.c | static no_inline int js_realloc_array(JSContext *ctx, void **parray,
int elem_size, int *psize, int req_size)
{
int new_size;
size_t slack;
void *new_array;
/* XXX: potential arithmetic overflow */
new_size = max_int(req_size, *psize * 3 / 2);
new_array = js_realloc2(ctx, *parray, new_size * elem_size, &slack);
if (!new_array)
return -1;
new_size += slack / elem_size;
*psize = new_size;
*parray = new_array;
return 0;
} | O0 | c | js_realloc_array:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %rax
imull $0x3, (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x5d310
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movl 0x18(%rsp), %eax
imull 0x2c(%rsp), %eax
movslq %eax, %rdx
leaq 0x10(%rsp), %rcx
callq 0x21e80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x73225
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x73263
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movslq 0x18(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
| js_realloc_array:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_1C], edx
mov [rsp+48h+var_28], rcx
mov [rsp+48h+var_2C], r8d
mov edi, [rsp+48h+var_2C]
mov rax, [rsp+48h+var_28]
imul eax, [rax], 3
mov ecx, 2
cdq
idiv ecx
mov esi, eax
call max_int_0
mov [rsp+48h+var_30], eax
mov rdi, [rsp+48h+var_10]
mov rax, [rsp+48h+var_18]
mov rsi, [rax]
mov eax, [rsp+48h+var_30]
imul eax, [rsp+48h+var_1C]
movsxd rdx, eax
lea rcx, [rsp+48h+var_38]
call js_realloc2
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jnz short loc_73225
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_73263
loc_73225:
mov rax, [rsp+48h+var_38]
movsxd rcx, [rsp+48h+var_1C]
xor edx, edx
div rcx
mov rcx, rax
movsxd rax, [rsp+48h+var_30]
add rax, rcx
mov [rsp+48h+var_30], eax
mov ecx, [rsp+48h+var_30]
mov rax, [rsp+48h+var_28]
mov [rax], ecx
mov rcx, [rsp+48h+var_40]
mov rax, [rsp+48h+var_18]
mov [rax], rcx
mov [rsp+48h+var_4], 0
loc_73263:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long js_realloc_array(long long a1, long long *a2, int a3, _DWORD *a4, unsigned int a5)
{
long long v6; // [rsp+8h] [rbp-40h]
unsigned long long v7; // [rsp+10h] [rbp-38h] BYREF
int v8; // [rsp+18h] [rbp-30h]
unsigned int v9; // [rsp+1Ch] [rbp-2Ch]
_DWORD *v10; // [rsp+20h] [rbp-28h]
int v11; // [rsp+2Ch] [rbp-1Ch]
long long *v12; // [rsp+30h] [rbp-18h]
long long v13; // [rsp+38h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v8 = max_int_0(a5, 3 * *a4 / 2);
v6 = js_realloc2(a1, *a2, v11 * v8, &v7);
if ( v6 )
{
v8 += v7 / v11;
*v10 = v8;
*v12 = v6;
return 0;
}
else
{
return (unsigned int)-1;
}
}
| js_realloc_array:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV dword ptr [RSP + 0x2c],EDX
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x1c],R8D
MOV EDI,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x20]
IMUL EAX,dword ptr [RAX],0x3
MOV ECX,0x2
CDQ
IDIV ECX
MOV ESI,EAX
CALL 0x0015d310
MOV dword ptr [RSP + 0x18],EAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RSP + 0x18]
IMUL EAX,dword ptr [RSP + 0x2c]
MOVSXD RDX,EAX
LEA RCX,[RSP + 0x10]
CALL 0x00121e80
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00173225
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x00173263
LAB_00173225:
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x2c]
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOVSXD RAX,dword ptr [RSP + 0x18]
ADD RAX,RCX
MOV dword ptr [RSP + 0x18],EAX
MOV ECX,dword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV dword ptr [RSP + 0x44],0x0
LAB_00173263:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4
js_realloc_array(int8 param_1,long *param_2,int param_3,int *param_4,int4 param_5)
{
long lVar1;
ulong local_38;
int local_30;
int4 local_2c;
int *local_28;
int local_1c;
long *local_18;
int8 local_10;
int4 local_4;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_30 = max_int(param_5,(long)(*param_4 * 3) / 2 & 0xffffffff,
(long)(*param_4 * 3) % 2 & 0xffffffff);
lVar1 = js_realloc2(local_10,*local_18,(long)(local_30 * local_1c),&local_38);
if (lVar1 == 0) {
local_4 = 0xffffffff;
}
else {
*local_28 = local_30 + (int)(local_38 / (ulong)(long)local_1c);
*local_18 = lVar1;
local_4 = 0;
}
return local_4;
}
| |
30,080 | js_realloc_array | bluesky950520[P]quickjs/quickjs.c | static no_inline int js_realloc_array(JSContext *ctx, void **parray,
int elem_size, int *psize, int req_size)
{
int new_size;
size_t slack;
void *new_array;
/* XXX: potential arithmetic overflow */
new_size = max_int(req_size, *psize * 3 / 2);
new_array = js_realloc2(ctx, *parray, new_size * elem_size, &slack);
if (!new_array)
return -1;
new_size += slack / elem_size;
*psize = new_size;
*parray = new_array;
return 0;
} | O1 | c | js_realloc_array:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl (%rcx), %eax
leal (%rax,%rax,2), %eax
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
cmpl %r15d, %r8d
cmovgl %r8d, %r15d
movq (%rsi), %rsi
movl %r15d, %eax
imull %edx, %eax
movslq %eax, %rdx
movq %rsp, %rcx
callq 0x1cc0f
testq %rax, %rax
je 0x4354b
movq %rax, %rcx
movq (%rsp), %rax
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
divq %rdi
addl %eax, %r15d
movl %r15d, (%rbx)
movq %rcx, (%r14)
jmp 0x43550
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_realloc_array:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov eax, [rcx]
lea eax, [rax+rax*2]
mov r15d, eax
shr r15d, 1Fh
add r15d, eax
sar r15d, 1
cmp r8d, r15d
cmovg r15d, r8d
mov rsi, [rsi]
mov eax, r15d
imul eax, edx
movsxd rdx, eax
mov rcx, rsp
call js_realloc2
test rax, rax
jz short loc_4354B
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov edi, ebp
xor esi, esi
xor edx, edx
div rdi
add r15d, eax
mov [rbx], r15d
mov [r14], rcx
jmp short loc_43550
loc_4354B:
mov esi, 0FFFFFFFFh
loc_43550:
mov eax, esi
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long js_realloc_array(long long a1, long long *a2, unsigned int a3, _DWORD *a4, int a5)
{
unsigned long long v5; // rax
int v9; // r15d
long long v10; // rax
unsigned int v11; // esi
unsigned long long v13[5]; // [rsp+0h] [rbp-28h] BYREF
v13[0] = v5;
v9 = 3 * *a4 / 2;
if ( a5 > v9 )
v9 = a5;
v10 = js_realloc2(a1, *a2, (int)(a3 * v9), v13);
if ( v10 )
{
v11 = 0;
*a4 = v13[0] / a3 + v9;
*a2 = v10;
}
else
{
return (unsigned int)-1;
}
return v11;
}
| |||
30,081 | js_realloc_array | bluesky950520[P]quickjs/quickjs.c | static no_inline int js_realloc_array(JSContext *ctx, void **parray,
int elem_size, int *psize, int req_size)
{
int new_size;
size_t slack;
void *new_array;
/* XXX: potential arithmetic overflow */
new_size = max_int(req_size, *psize * 3 / 2);
new_array = js_realloc2(ctx, *parray, new_size * elem_size, &slack);
if (!new_array)
return -1;
new_size += slack / elem_size;
*psize = new_size;
*parray = new_array;
return 0;
} | O2 | c | js_realloc_array:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r14
imull $0x3, (%rcx), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
cmpl %eax, %r8d
cmovgl %r8d, %ebp
movq (%rsi), %rsi
movl %ebp, %eax
imull %r15d, %eax
movslq %eax, %rdx
movq %rsp, %rcx
callq 0x172b1
testq %rax, %rax
je 0x3b14c
movq %rax, %rcx
movq (%rsp), %rax
movl %r15d, %edi
xorl %esi, %esi
xorl %edx, %edx
divq %rdi
addl %eax, %ebp
movl %ebp, (%rbx)
movq %rcx, (%r14)
jmp 0x3b14f
pushq $-0x1
popq %rsi
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_realloc_array:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r15d, edx
mov r14, rsi
imul eax, [rcx], 3
push 2
pop rcx
cdq
idiv ecx
mov ebp, eax
cmp r8d, eax
cmovg ebp, r8d
mov rsi, [rsi]
mov eax, ebp
imul eax, r15d
movsxd rdx, eax
mov rcx, rsp
call js_realloc2
test rax, rax
jz short loc_3B14C
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov edi, r15d
xor esi, esi
xor edx, edx
div rdi
add ebp, eax
mov [rbx], ebp
mov [r14], rcx
jmp short loc_3B14F
loc_3B14C:
push 0FFFFFFFFFFFFFFFFh
pop rsi
loc_3B14F:
mov eax, esi
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long js_realloc_array(long long a1, long long *a2, unsigned int a3, _DWORD *a4, int a5)
{
unsigned long long v5; // rax
int v9; // ebp
long long v10; // rax
unsigned int v11; // esi
unsigned long long v13[5]; // [rsp+0h] [rbp-28h] BYREF
v13[0] = v5;
v9 = 3 * *a4 / 2;
if ( a5 > v9 )
v9 = a5;
v10 = js_realloc2(a1, *a2, (int)(a3 * v9), v13);
if ( v10 )
{
v11 = 0;
*a4 = v13[0] / a3 + v9;
*a2 = v10;
}
else
{
return (unsigned int)-1;
}
return v11;
}
| js_realloc_array:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15D,EDX
MOV R14,RSI
IMUL EAX,dword ptr [RCX],0x3
PUSH 0x2
POP RCX
CDQ
IDIV ECX
MOV EBP,EAX
CMP R8D,EAX
CMOVG EBP,R8D
MOV RSI,qword ptr [RSI]
MOV EAX,EBP
IMUL EAX,R15D
MOVSXD RDX,EAX
MOV RCX,RSP
CALL 0x001172b1
TEST RAX,RAX
JZ 0x0013b14c
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV EDI,R15D
XOR ESI,ESI
XOR EDX,EDX
DIV RDI
ADD EBP,EAX
MOV dword ptr [RBX],EBP
MOV qword ptr [R14],RCX
JMP 0x0013b14f
LAB_0013b14c:
PUSH -0x1
POP RSI
LAB_0013b14f:
MOV EAX,ESI
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 js_realloc_array(int8 param_1,long *param_2,uint param_3,int *param_4,int param_5)
{
int iVar1;
ulong in_RAX;
long lVar2;
int4 uVar3;
ulong local_28;
iVar1 = (*param_4 * 3) / 2;
if (iVar1 < param_5) {
iVar1 = param_5;
}
local_28 = in_RAX;
lVar2 = js_realloc2(param_1,*param_2,(long)(int)(iVar1 * param_3),&local_28);
if (lVar2 == 0) {
uVar3 = 0xffffffff;
}
else {
uVar3 = 0;
*param_4 = iVar1 + (int)(local_28 / param_3);
*param_2 = lVar2;
}
return uVar3;
}
| |
30,082 | my_dirend | eloqsql/mysys/my_lib.c | void my_dirend(MY_DIR *dir)
{
MY_DIR_HANDLE *dirh= (MY_DIR_HANDLE*) dir;
DBUG_ENTER("my_dirend");
if (dirh)
{
delete_dynamic(&dirh->array);
free_root(&dirh->root, MYF(0));
my_free(dirh);
}
DBUG_VOID_RETURN;
} | O0 | c | my_dirend:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x673b2
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5a450
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6ac10
movq -0x10(%rbp), %rdi
callq 0x5b4b0
jmp 0x673b4
jmp 0x673b6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| my_dirend:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_673B2
mov rdi, [rbp+var_10]
add rdi, 10h
call delete_dynamic
mov rdi, [rbp+var_10]
add rdi, 38h ; '8'
xor eax, eax
mov esi, eax
call free_root
mov rdi, [rbp+var_10]
call my_free
loc_673B2:
jmp short $+2
loc_673B4:
jmp short $+2
loc_673B6:
add rsp, 10h
pop rbp
retn
| long long my_dirend(long long a1)
{
long long result; // rax
result = a1;
if ( a1 )
{
delete_dynamic(a1 + 16);
free_root(a1 + 56, 0LL);
return my_free(a1);
}
return result;
}
| my_dirend:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001673b2
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10
CALL 0x0015a450
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x38
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0016ac10
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015b4b0
LAB_001673b2:
JMP 0x001673b4
LAB_001673b4:
JMP 0x001673b6
LAB_001673b6:
ADD RSP,0x10
POP RBP
RET
|
void my_dirend(long param_1)
{
if (param_1 != 0) {
delete_dynamic(param_1 + 0x10);
free_root(param_1 + 0x38,0);
my_free(param_1);
}
return;
}
| |
30,083 | my_dirend | eloqsql/mysys/my_lib.c | void my_dirend(MY_DIR *dir)
{
MY_DIR_HANDLE *dirh= (MY_DIR_HANDLE*) dir;
DBUG_ENTER("my_dirend");
if (dirh)
{
delete_dynamic(&dirh->array);
free_root(&dirh->root, MYF(0));
my_free(dirh);
}
DBUG_VOID_RETURN;
} | O3 | c | my_dirend:
testq %rdi, %rdi
je 0x4d7cc
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x469b8
leaq 0x38(%rbx), %rdi
xorl %esi, %esi
callq 0x4f623
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x472ea
retq
| my_dirend:
test rdi, rdi
jz short locret_4D7CC
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rdi, 10h
call delete_dynamic
lea rdi, [rbx+38h]
xor esi, esi
call free_root
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_free
locret_4D7CC:
retn
| long long my_dirend(long long a1)
{
long long result; // rax
if ( a1 )
{
delete_dynamic((long long *)(a1 + 16));
free_root(a1 + 56, 0LL);
return my_free(a1);
}
return result;
}
| my_dirend:
TEST RDI,RDI
JZ 0x0014d7cc
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RDI,0x10
CALL 0x001469b8
LEA RDI,[RBX + 0x38]
XOR ESI,ESI
CALL 0x0014f623
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001472ea
LAB_0014d7cc:
RET
|
void my_dirend(long param_1)
{
if (param_1 != 0) {
delete_dynamic(param_1 + 0x10);
free_root(param_1 + 0x38,0);
my_free(param_1);
return;
}
return;
}
| |
30,084 | my_8bit_charset_flags_from_data | eloqsql/strings/ctype-simple.c | uint my_8bit_charset_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (my_charset_is_8bit_pure_ascii(cs))
flags|= MY_CS_PUREASCII;
if (!my_charset_is_ascii_compatible(cs))
flags|= MY_CS_NONASCII;
return flags;
} | O3 | c | my_8bit_charset_flags_from_data:
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xc0e78
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorl %edx, %edx
cmpw $0x80, (%rcx,%rdx,2)
jae 0xc0e5f
incq %rdx
cmpq $0x100, %rdx # imm = 0x100
jne 0xc0e46
movl $0x1000, %eax # imm = 0x1000
xorl %edx, %edx
movzwl (%rcx,%rdx,2), %esi
cmpq %rsi, %rdx
jne 0xc0e7b
incq %rdx
cmpq $0x80, %rdx
jne 0xc0e61
jmp 0xc0e80
xorl %eax, %eax
retq
orl $0x2000, %eax # imm = 0x2000
popq %rbp
retq
| my_8bit_charset_flags_from_data:
mov rcx, [rdi+68h]
test rcx, rcx
jz short loc_C0E78
push rbp
mov rbp, rsp
xor eax, eax
xor edx, edx
loc_C0E46:
cmp word ptr [rcx+rdx*2], 80h
jnb short loc_C0E5F
inc rdx
cmp rdx, 100h
jnz short loc_C0E46
mov eax, 1000h
loc_C0E5F:
xor edx, edx
loc_C0E61:
movzx esi, word ptr [rcx+rdx*2]
cmp rdx, rsi
jnz short loc_C0E7B
inc rdx
cmp rdx, 80h
jnz short loc_C0E61
jmp short loc_C0E80
loc_C0E78:
xor eax, eax
retn
loc_C0E7B:
or eax, 2000h
loc_C0E80:
pop rbp
retn
| long long my_8bit_charset_flags_from_data(long long a1)
{
long long v1; // rcx
long long result; // rax
long long v3; // rdx
long long v4; // rdx
v1 = *(_QWORD *)(a1 + 104);
if ( !v1 )
return 0LL;
result = 0LL;
v3 = 0LL;
while ( *(_WORD *)(v1 + 2 * v3) < 0x80u )
{
if ( ++v3 == 256 )
{
result = 4096LL;
break;
}
}
v4 = 0LL;
while ( v4 == *(unsigned __int16 *)(v1 + 2 * v4) )
{
if ( ++v4 == 128 )
return result;
}
return (unsigned int)result | 0x2000;
}
| my_8bit_charset_flags_from_data:
MOV RCX,qword ptr [RDI + 0x68]
TEST RCX,RCX
JZ 0x001c0e78
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
XOR EDX,EDX
LAB_001c0e46:
CMP word ptr [RCX + RDX*0x2],0x80
JNC 0x001c0e5f
INC RDX
CMP RDX,0x100
JNZ 0x001c0e46
MOV EAX,0x1000
LAB_001c0e5f:
XOR EDX,EDX
LAB_001c0e61:
MOVZX ESI,word ptr [RCX + RDX*0x2]
CMP RDX,RSI
JNZ 0x001c0e7b
INC RDX
CMP RDX,0x80
JNZ 0x001c0e61
JMP 0x001c0e80
LAB_001c0e78:
XOR EAX,EAX
RET
LAB_001c0e7b:
OR EAX,0x2000
LAB_001c0e80:
POP RBP
RET
|
uint my_8bit_charset_flags_from_data(long param_1)
{
long lVar1;
uint uVar2;
long lVar3;
ulong uVar4;
lVar1 = *(long *)(param_1 + 0x68);
if (lVar1 == 0) {
return 0;
}
uVar2 = 0;
lVar3 = 0;
do {
if (0x7f < *(ushort *)(lVar1 + lVar3 * 2)) goto LAB_001c0e5f;
lVar3 = lVar3 + 1;
} while (lVar3 != 0x100);
uVar2 = 0x1000;
LAB_001c0e5f:
uVar4 = 0;
do {
if (uVar4 != *(ushort *)(lVar1 + uVar4 * 2)) {
return uVar2 | 0x2000;
}
uVar4 = uVar4 + 1;
} while (uVar4 != 0x80);
return uVar2;
}
| |
30,085 | JS_NewClass1 | bluesky950520[P]quickjs/quickjs.c | static int JS_NewClass1(JSRuntime *rt, JSClassID class_id,
const JSClassDef *class_def, JSAtom name)
{
int new_size, i;
JSClass *cl, *new_class_array;
struct list_head *el;
if (class_id >= (1 << 16))
return -1;
if (class_id < rt->class_count &&
rt->class_array[class_id].class_id != 0)
return -1;
if (class_id >= rt->class_count) {
new_size = max_int(JS_CLASS_INIT_COUNT,
max_int(class_id + 1, rt->class_count * 3 / 2));
/* reallocate the context class prototype array, if any */
list_for_each(el, &rt->context_list) {
JSContext *ctx = list_entry(el, JSContext, link);
JSValue *new_tab;
new_tab = js_realloc_rt(rt, ctx->class_proto,
sizeof(ctx->class_proto[0]) * new_size);
if (!new_tab)
return -1;
for(i = rt->class_count; i < new_size; i++)
new_tab[i] = JS_NULL;
ctx->class_proto = new_tab;
}
/* reallocate the class array */
new_class_array = js_realloc_rt(rt, rt->class_array,
sizeof(JSClass) * new_size);
if (!new_class_array)
return -1;
memset(new_class_array + rt->class_count, 0,
(new_size - rt->class_count) * sizeof(JSClass));
rt->class_array = new_class_array;
rt->class_count = new_size;
}
cl = &rt->class_array[class_id];
cl->class_id = class_id;
cl->class_name = JS_DupAtomRT(rt, name);
cl->finalizer = class_def->finalizer;
cl->gc_mark = class_def->gc_mark;
cl->call = class_def->call;
cl->exotic = class_def->exotic;
return 0;
} | O2 | c | JS_NewClass1:
pushq $-0x1
popq %rax
cmpl $0xffff, %esi # imm = 0xFFFF
ja 0x1e862
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movl %esi, %r15d
movq %rdi, %r14
movl 0x78(%rdi), %esi
cmpl %r15d, %esi
jbe 0x1e736
movq 0x80(%r14), %rbx
movl %r15d, %esi
imulq $0x28, %rsi, %rdx
cmpl $0x0, (%rbx,%rdx)
jne 0x1e854
jmp 0x1e81a
movl %ecx, 0xc(%rsp)
movq %rbp, 0x10(%rsp)
leal 0x1(%r15), %ecx
movl %esi, %edx
shrl %edx
addl %esi, %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
cmpl $0x3e, %edx
pushq $0x3d
popq %r13
cmovael %edx, %r13d
leaq 0x88(%r14), %rbp
leaq 0x90(%r14), %r12
movq %r13, %rbx
shlq $0x4, %rbx
movq (%r12), %r12
cmpq %rbp, %r12
je 0x1e7c6
movq 0x20(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1acb9
testq %rax, %rax
je 0x1e851
movslq 0x78(%r14), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %r13, %rcx
jge 0x1e7bb
andl $0x0, -0x8(%rdx)
movq $0x2, (%rdx)
incq %rcx
addq $0x10, %rdx
jmp 0x1e7a2
movq %rax, 0x20(%r12)
addq $0x8, %r12
jmp 0x1e76e
movq 0x80(%r14), %rsi
imulq $0x28, %r13, %rdx
movq %r14, %rdi
callq 0x1acb9
movq %rax, %rbx
testq %rax, %rax
movq 0x10(%rsp), %rbp
pushq $-0x1
popq %rax
je 0x1e854
movslq 0x78(%r14), %rax
imulq $0x28, %rax, %rdi
addq %rbx, %rdi
movslq %r13d, %r12
movq %r12, %rcx
subq %rax, %rcx
imulq $0x28, %rcx, %rdx
xorl %esi, %esi
callq 0xe390
movq %rbx, 0x80(%r14)
movl %r12d, 0x78(%r14)
movl 0xc(%rsp), %ecx
movl %r15d, %esi
imulq $0x28, %rsi, %rdx
leaq (%rbx,%rdx), %rax
movl %r15d, (%rbx,%rdx)
cmpl $0xe0, %ecx
jl 0x1e83a
movq 0x68(%r14), %rsi
movl %ecx, %edx
movq (%rsi,%rdx,8), %rdx
incl (%rdx)
movl %ecx, 0x4(%rax)
movups 0x8(%rbp), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x18(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
xorl %eax, %eax
jmp 0x1e854
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_NewClass1:
push 0FFFFFFFFFFFFFFFFh
pop rax
cmp esi, 0FFFFh
ja locret_1E862
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbp, rdx
mov r15d, esi
mov r14, rdi
mov esi, [rdi+78h]
cmp esi, r15d
jbe short loc_1E736
mov rbx, [r14+80h]
mov esi, r15d
imul rdx, rsi, 28h ; '('
cmp dword ptr [rbx+rdx], 0
jnz loc_1E854
jmp loc_1E81A
loc_1E736:
mov [rsp+48h+var_3C], ecx
mov [rsp+48h+var_38], rbp
lea ecx, [r15+1]
mov edx, esi
shr edx, 1
add edx, esi
cmp ecx, edx
cmova edx, ecx
cmp edx, 3Eh ; '>'
push 3Dh ; '='
pop r13
cmovnb r13d, edx
lea rbp, [r14+88h]
lea r12, [r14+90h]
mov rbx, r13
shl rbx, 4
loc_1E76E:
mov r12, [r12]
cmp r12, rbp
jz short loc_1E7C6
mov rsi, [r12+20h]
mov rdi, r14
mov rdx, rbx
call js_realloc_rt
test rax, rax
jz loc_1E851
movsxd rcx, dword ptr [r14+78h]
mov rdx, rcx
shl rdx, 4
add rdx, rax
add rdx, 8
loc_1E7A2:
cmp rcx, r13
jge short loc_1E7BB
and dword ptr [rdx-8], 0
mov qword ptr [rdx], 2
inc rcx
add rdx, 10h
jmp short loc_1E7A2
loc_1E7BB:
mov [r12+20h], rax
add r12, 8
jmp short loc_1E76E
loc_1E7C6:
mov rsi, [r14+80h]
imul rdx, r13, 28h ; '('
mov rdi, r14
call js_realloc_rt
mov rbx, rax
test rax, rax
mov rbp, [rsp+48h+var_38]
push 0FFFFFFFFFFFFFFFFh
pop rax
jz short loc_1E854
movsxd rax, dword ptr [r14+78h]
imul rdi, rax, 28h ; '('
add rdi, rbx
movsxd r12, r13d
mov rcx, r12
sub rcx, rax
imul rdx, rcx, 28h ; '('
xor esi, esi
call _memset
mov [r14+80h], rbx
mov [r14+78h], r12d
mov ecx, [rsp+48h+var_3C]
mov esi, r15d
loc_1E81A:
imul rdx, rsi, 28h ; '('
lea rax, [rbx+rdx]
mov [rbx+rdx], r15d
cmp ecx, 0E0h
jl short loc_1E83A
mov rsi, [r14+68h]
mov edx, ecx
mov rdx, [rsi+rdx*8]
inc dword ptr [rdx]
loc_1E83A:
mov [rax+4], ecx
movups xmm0, xmmword ptr [rbp+8]
movups xmmword ptr [rax+8], xmm0
movups xmm0, xmmword ptr [rbp+18h]
movups xmmword ptr [rax+18h], xmm0
xor eax, eax
jmp short loc_1E854
loc_1E851:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_1E854:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_1E862:
retn
| long long JS_NewClass1(long long a1, unsigned int a2, long long a3, int a4)
{
long long result; // rax
long long v5; // rbp
unsigned int v7; // esi
long long v8; // rbx
long long v9; // rsi
unsigned int v10; // edx
long long v11; // r13
long long *i; // r12
long long v13; // r12
long long v14; // rax
long long v15; // rcx
_QWORD *v16; // rdx
long long v17; // rax
_DWORD *v18; // rdx
int v19; // [rsp+0h] [rbp-3Ch]
result = -1LL;
if ( a2 <= 0xFFFF )
{
v5 = a3;
v7 = *(_DWORD *)(a1 + 120);
if ( v7 <= a2 )
{
v19 = a4;
v10 = v7 + (v7 >> 1);
if ( a2 + 1 > v10 )
v10 = a2 + 1;
v11 = 61LL;
if ( v10 >= 0x3E )
v11 = v10;
for ( i = (long long *)(a1 + 144); ; i = (long long *)(v13 + 8) )
{
v13 = *i;
if ( v13 == a1 + 136 )
break;
v14 = js_realloc_rt(a1, *(_QWORD *)(v13 + 32), 16 * v11);
if ( !v14 )
return -1LL;
v15 = *(int *)(a1 + 120);
v16 = (_QWORD *)(v14 + 16 * v15 + 8);
while ( v15 < v11 )
{
*((_DWORD *)v16 - 2) = 0;
*v16 = 2LL;
++v15;
v16 += 2;
}
*(_QWORD *)(v13 + 32) = v14;
}
v8 = js_realloc_rt(a1, *(_QWORD *)(a1 + 128), 40 * v11);
v5 = a3;
result = -1LL;
if ( !v8 )
return result;
memset(v8 + 40LL * *(int *)(a1 + 120), 0LL, 40 * ((int)v11 - (long long)*(int *)(a1 + 120)));
*(_QWORD *)(a1 + 128) = v8;
*(_DWORD *)(a1 + 120) = v11;
a4 = v19;
v9 = a2;
}
else
{
v8 = *(_QWORD *)(a1 + 128);
v9 = a2;
if ( *(_DWORD *)(v8 + 40LL * a2) )
return result;
}
v17 = v8 + 40 * v9;
*(_DWORD *)v17 = a2;
if ( a4 >= 224 )
{
v18 = *(_DWORD **)(*(_QWORD *)(a1 + 104) + 8LL * (unsigned int)a4);
++*v18;
}
*(_DWORD *)(v17 + 4) = a4;
*(_OWORD *)(v17 + 8) = *(_OWORD *)(v5 + 8);
*(_OWORD *)(v17 + 24) = *(_OWORD *)(v5 + 24);
return 0LL;
}
return result;
}
| JS_NewClass1:
PUSH -0x1
POP RAX
CMP ESI,0xffff
JA 0x0011e862
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBP,RDX
MOV R15D,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x78]
CMP ESI,R15D
JBE 0x0011e736
MOV RBX,qword ptr [R14 + 0x80]
MOV ESI,R15D
IMUL RDX,RSI,0x28
CMP dword ptr [RBX + RDX*0x1],0x0
JNZ 0x0011e854
JMP 0x0011e81a
LAB_0011e736:
MOV dword ptr [RSP + 0xc],ECX
MOV qword ptr [RSP + 0x10],RBP
LEA ECX,[R15 + 0x1]
MOV EDX,ESI
SHR EDX,0x1
ADD EDX,ESI
CMP ECX,EDX
CMOVA EDX,ECX
CMP EDX,0x3e
PUSH 0x3d
POP R13
CMOVNC R13D,EDX
LEA RBP,[R14 + 0x88]
LEA R12,[R14 + 0x90]
MOV RBX,R13
SHL RBX,0x4
LAB_0011e76e:
MOV R12,qword ptr [R12]
CMP R12,RBP
JZ 0x0011e7c6
MOV RSI,qword ptr [R12 + 0x20]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0011acb9
TEST RAX,RAX
JZ 0x0011e851
MOVSXD RCX,dword ptr [R14 + 0x78]
MOV RDX,RCX
SHL RDX,0x4
ADD RDX,RAX
ADD RDX,0x8
LAB_0011e7a2:
CMP RCX,R13
JGE 0x0011e7bb
AND dword ptr [RDX + -0x8],0x0
MOV qword ptr [RDX],0x2
INC RCX
ADD RDX,0x10
JMP 0x0011e7a2
LAB_0011e7bb:
MOV qword ptr [R12 + 0x20],RAX
ADD R12,0x8
JMP 0x0011e76e
LAB_0011e7c6:
MOV RSI,qword ptr [R14 + 0x80]
IMUL RDX,R13,0x28
MOV RDI,R14
CALL 0x0011acb9
MOV RBX,RAX
TEST RAX,RAX
MOV RBP,qword ptr [RSP + 0x10]
PUSH -0x1
POP RAX
JZ 0x0011e854
MOVSXD RAX,dword ptr [R14 + 0x78]
IMUL RDI,RAX,0x28
ADD RDI,RBX
MOVSXD R12,R13D
MOV RCX,R12
SUB RCX,RAX
IMUL RDX,RCX,0x28
XOR ESI,ESI
CALL 0x0010e390
MOV qword ptr [R14 + 0x80],RBX
MOV dword ptr [R14 + 0x78],R12D
MOV ECX,dword ptr [RSP + 0xc]
MOV ESI,R15D
LAB_0011e81a:
IMUL RDX,RSI,0x28
LEA RAX,[RBX + RDX*0x1]
MOV dword ptr [RBX + RDX*0x1],R15D
CMP ECX,0xe0
JL 0x0011e83a
MOV RSI,qword ptr [R14 + 0x68]
MOV EDX,ECX
MOV RDX,qword ptr [RSI + RDX*0x8]
INC dword ptr [RDX]
LAB_0011e83a:
MOV dword ptr [RAX + 0x4],ECX
MOVUPS XMM0,xmmword ptr [RBP + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOVUPS XMM0,xmmword ptr [RBP + 0x18]
MOVUPS xmmword ptr [RAX + 0x18],XMM0
XOR EAX,EAX
JMP 0x0011e854
LAB_0011e851:
PUSH -0x1
POP RAX
LAB_0011e854:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0011e862:
RET
|
int8 JS_NewClass1(long param_1,uint param_2,long param_3,uint param_4)
{
int *piVar1;
long lVar2;
long lVar3;
int8 uVar4;
long lVar5;
uint uVar6;
int8 *puVar7;
long *plVar8;
ulong uVar9;
uVar4 = 0xffffffffffffffff;
if (param_2 < 0x10000) {
uVar6 = *(uint *)(param_1 + 0x78);
if (param_2 < uVar6) {
lVar3 = *(long *)(param_1 + 0x80);
if (*(int *)(lVar3 + (ulong)param_2 * 0x28) != 0) {
return 0xffffffffffffffff;
}
}
else {
uVar6 = (uVar6 >> 1) + uVar6;
if (uVar6 < param_2 + 1) {
uVar6 = param_2 + 1;
}
uVar9 = 0x3d;
if (0x3d < uVar6) {
uVar9 = (ulong)uVar6;
}
plVar8 = (long *)(param_1 + 0x90);
while (lVar3 = *plVar8, lVar3 != param_1 + 0x88) {
lVar2 = js_realloc_rt(param_1,*(int8 *)(lVar3 + 0x20),uVar9 << 4);
if (lVar2 == 0) {
return 0xffffffffffffffff;
}
lVar5 = (long)*(int *)(param_1 + 0x78);
puVar7 = (int8 *)(lVar5 * 0x10 + lVar2 + 8);
for (; lVar5 < (long)uVar9; lVar5 = lVar5 + 1) {
*(int4 *)(puVar7 + -1) = 0;
*puVar7 = 2;
puVar7 = puVar7 + 2;
}
*(long *)(lVar3 + 0x20) = lVar2;
plVar8 = (long *)(lVar3 + 8);
}
lVar3 = js_realloc_rt(param_1,*(int8 *)(param_1 + 0x80),uVar9 * 0x28);
if (lVar3 == 0) {
return 0xffffffffffffffff;
}
memset((void *)((long)*(int *)(param_1 + 0x78) * 0x28 + lVar3),0,
((long)(int)uVar9 - (long)*(int *)(param_1 + 0x78)) * 0x28);
*(long *)(param_1 + 0x80) = lVar3;
*(int *)(param_1 + 0x78) = (int)uVar9;
}
lVar2 = lVar3 + (ulong)param_2 * 0x28;
*(uint *)(lVar3 + (ulong)param_2 * 0x28) = param_2;
if (0xdf < (int)param_4) {
piVar1 = *(int **)(*(long *)(param_1 + 0x68) + (ulong)param_4 * 8);
*piVar1 = *piVar1 + 1;
}
*(uint *)(lVar2 + 4) = param_4;
uVar4 = *(int8 *)(param_3 + 0x10);
*(int8 *)(lVar2 + 8) = *(int8 *)(param_3 + 8);
*(int8 *)(lVar2 + 0x10) = uVar4;
uVar4 = *(int8 *)(param_3 + 0x20);
*(int8 *)(lVar2 + 0x18) = *(int8 *)(param_3 + 0x18);
*(int8 *)(lVar2 + 0x20) = uVar4;
uVar4 = 0;
}
return uVar4;
}
| |
30,086 | test_bug8330 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_bug8330(MYSQL *mysql)
{
const char *stmt_text;
MYSQL_STMT *stmt[2];
int i, rc;
const char *query= "select a,b from t1 where a=?";
MYSQL_BIND my_bind[2];
long lval[2]= {1,2};
stmt_text= "drop table if exists t1";
/* in case some previous test failed */
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "create table t1 (a int, b int)";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
memset(my_bind, '\0', sizeof(my_bind));
for (i=0; i < 2; i++)
{
stmt[i]= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt[i], SL(query));
check_stmt_rc(rc, stmt[i]);
my_bind[i].buffer_type= MYSQL_TYPE_LONG;
my_bind[i].buffer= (void*) &lval[i];
my_bind[i].is_null= 0;
mysql_stmt_bind_param(stmt[i], &my_bind[i]);
}
rc= mysql_stmt_execute(stmt[0]);
check_stmt_rc(rc, stmt[0]);
rc= mysql_stmt_execute(stmt[1]);
FAIL_UNLESS(rc && mysql_stmt_errno(stmt[1]) == CR_COMMANDS_OUT_OF_SYNC, "Error expected");
rc= mysql_stmt_execute(stmt[0]);
check_stmt_rc(rc, stmt[0]);
mysql_stmt_close(stmt[0]);
mysql_stmt_close(stmt[1]);
stmt_text= "drop table t1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
return OK;
} | O0 | c | test_bug8330:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
leaq 0x40402(%rip), %rax # 0x69d98
movq %rax, -0x40(%rbp)
movq 0x3bbdf(%rip), %rax # 0x65580
movq %rax, -0x130(%rbp)
movq 0x3bbd9(%rip), %rax # 0x65588
movq %rax, -0x128(%rbp)
leaq 0x3cb15(%rip), %rax # 0x664d2
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x18(%rbp), %rdi
callq 0x141a0
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29a57
movl -0x38(%rbp), %eax
movl %eax, -0x14c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x14c(%rbp), %esi
movq -0x148(%rbp), %rdx
movl %eax, %ecx
leaq 0x3bc9e(%rip), %rdi # 0x656d5
leaq 0x3c62f(%rip), %r8 # 0x6606d
movl $0xc08, %r9d # imm = 0xC08
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29a59
leaq 0x40355(%rip), %rax # 0x69db5
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x18(%rbp), %rdi
callq 0x141a0
movq -0x160(%rbp), %rdi
movq -0x158(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29afa
movl -0x38(%rbp), %eax
movl %eax, -0x16c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x16c(%rbp), %esi
movq -0x168(%rbp), %rdx
movl %eax, %ecx
leaq 0x3bbfb(%rip), %rdi # 0x656d5
leaq 0x3c58c(%rip), %r8 # 0x6606d
movl $0xc0b, %r9d # imm = 0xC0B
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29afc
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xe0, %edx
callq 0x14260
movl $0x0, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jge 0x29c3a
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, %rcx
movslq -0x34(%rbp), %rax
movq %rcx, -0x30(%rbp,%rax,8)
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rax
movq %rax, -0x180(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x40(%rbp), %rdi
callq 0x141a0
movq -0x180(%rbp), %rdi
movq -0x178(%rbp), %rsi
movq %rax, %rdx
callq 0x45070
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29baf
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3ba00(%rip), %rdi # 0x65590
leaq 0x3c4d6(%rip), %rdx # 0x6606d
movl $0xc12, %ecx # imm = 0xC12
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29bb1
movslq -0x34(%rbp), %rcx
leaq -0x120(%rbp), %rax
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl $0x3, 0x60(%rax)
movslq -0x34(%rbp), %rax
leaq -0x130(%rbp), %rcx
shlq $0x3, %rax
addq %rax, %rcx
movslq -0x34(%rbp), %rdx
leaq -0x120(%rbp), %rax
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movslq -0x34(%rbp), %rcx
leaq -0x120(%rbp), %rax
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
movslq -0x34(%rbp), %rax
leaq -0x120(%rbp), %rsi
imulq $0x70, %rax, %rax
addq %rax, %rsi
callq 0x432c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29b16
movq -0x30(%rbp), %rdi
callq 0x46580
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29c7e
movq -0x30(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3b931(%rip), %rdi # 0x65590
leaq 0x3c407(%rip), %rdx # 0x6606d
movl $0xc1a, %ecx # imm = 0xC1A
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29c80
movq -0x28(%rbp), %rdi
callq 0x46580
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29ca2
movq -0x28(%rbp), %rdi
callq 0x43fb0
cmpl $0x7de, %eax # imm = 0x7DE
je 0x29ccf
leaq 0x3b8e7(%rip), %rdi # 0x65590
leaq 0x3dad9(%rip), %rsi # 0x67789
leaq 0x3c3b6(%rip), %rdx # 0x6606d
movl $0xc1c, %ecx # imm = 0xC1C
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29cd1
movq -0x30(%rbp), %rdi
callq 0x46580
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29d15
movq -0x30(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3b89a(%rip), %rdi # 0x65590
leaq 0x3c370(%rip), %rdx # 0x6606d
movl $0xc1e, %ecx # imm = 0xC1E
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29d17
movq -0x30(%rbp), %rdi
callq 0x43eb0
movq -0x28(%rbp), %rdi
callq 0x43eb0
leaq 0x3d4d9(%rip), %rax # 0x67209
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x18(%rbp), %rdi
callq 0x141a0
movq -0x190(%rbp), %rdi
movq -0x188(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x29dc7
movl -0x38(%rbp), %eax
movl %eax, -0x19c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x19c(%rbp), %esi
movq -0x198(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b92b(%rip), %rdi # 0x656d5
leaq 0x3c2bc(%rip), %r8 # 0x6606d
movl $0xc24, %r9d # imm = 0xC24
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x29dd0
jmp 0x29dc9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbp
retq
nopl (%rax)
| test_bug8330:
push rbp
mov rbp, rsp
sub rsp, 1A0h
mov [rbp+var_10], rdi
lea rax, aSelectABFromT1_1; "select a,b from t1 where a=?"
mov [rbp+var_40], rax
mov rax, cs:qword_65580
mov [rbp+var_130], rax
mov rax, cs:qword_65588
mov [rbp+var_128], rax
lea rax, aDropTableIfExi; "drop table if exists t1"
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_140], rax
mov rax, [rbp+var_18]
mov [rbp+var_138], rax
mov rdi, [rbp+var_18]
call _strlen
mov rdi, [rbp+var_140]
mov rsi, [rbp+var_138]
mov rdx, rax
call mysql_real_query
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29A57
mov eax, [rbp+var_38]
mov [rbp+var_14C], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_148], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_14C]
mov rdx, [rbp+var_148]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0C08h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29A57:
jmp short $+2
loc_29A59:
lea rax, aCreateTableT1A_9; "create table t1 (a int, b int)"
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_160], rax
mov rax, [rbp+var_18]
mov [rbp+var_158], rax
mov rdi, [rbp+var_18]
call _strlen
mov rdi, [rbp+var_160]
mov rsi, [rbp+var_158]
mov rdx, rax
call mysql_real_query
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29AFA
mov eax, [rbp+var_38]
mov [rbp+var_16C], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_168], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_16C]
mov rdx, [rbp+var_168]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0C0Bh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29AFA:
jmp short $+2
loc_29AFC:
lea rdi, [rbp+var_120]
xor esi, esi
mov edx, 0E0h
call _memset
mov [rbp+var_34], 0
loc_29B16:
cmp [rbp+var_34], 2
jge loc_29C3A
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov rcx, rax
movsxd rax, [rbp+var_34]
mov [rbp+rax*8+var_30], rcx
movsxd rax, [rbp+var_34]
mov rax, [rbp+rax*8+var_30]
mov [rbp+var_180], rax
mov rax, [rbp+var_40]
mov [rbp+var_178], rax
mov rdi, [rbp+var_40]
call _strlen
mov rdi, [rbp+var_180]
mov rsi, [rbp+var_178]
mov rdx, rax
call mysql_stmt_prepare
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29BAF
movsxd rax, [rbp+var_34]
mov rdi, [rbp+rax*8+var_30]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0C12h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29BAF:
jmp short $+2
loc_29BB1:
movsxd rcx, [rbp+var_34]
lea rax, [rbp+var_120]
imul rcx, 70h ; 'p'
add rax, rcx
mov dword ptr [rax+60h], 3
movsxd rax, [rbp+var_34]
lea rcx, [rbp+var_130]
shl rax, 3
add rcx, rax
movsxd rdx, [rbp+var_34]
lea rax, [rbp+var_120]
imul rdx, 70h ; 'p'
add rax, rdx
mov [rax+10h], rcx
movsxd rcx, [rbp+var_34]
lea rax, [rbp+var_120]
imul rcx, 70h ; 'p'
add rax, rcx
mov qword ptr [rax+8], 0
movsxd rax, [rbp+var_34]
mov rdi, [rbp+rax*8+var_30]
movsxd rax, [rbp+var_34]
lea rsi, [rbp+var_120]
imul rax, 70h ; 'p'
add rsi, rax
call mysql_stmt_bind_param
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
jmp loc_29B16
loc_29C3A:
mov rdi, [rbp+var_30]
call mysql_stmt_execute
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29C7E
mov rdi, [rbp+var_30]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0C1Ah
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29C7E:
jmp short $+2
loc_29C80:
mov rdi, [rbp+var_28]
call mysql_stmt_execute
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29CA2
mov rdi, [rbp+var_28]
call mysql_stmt_errno
cmp eax, 7DEh
jz short loc_29CCF
loc_29CA2:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aNoErrorExpecte+3; "Error expected"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0C1Ch
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29CCF:
jmp short $+2
loc_29CD1:
mov rdi, [rbp+var_30]
call mysql_stmt_execute
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29D15
mov rdi, [rbp+var_30]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0C1Eh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_29DD0
loc_29D15:
jmp short $+2
loc_29D17:
mov rdi, [rbp+var_30]
call mysql_stmt_close
mov rdi, [rbp+var_28]
call mysql_stmt_close
lea rax, aDropTableT1_0; "drop table t1"
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_190], rax
mov rax, [rbp+var_18]
mov [rbp+var_188], rax
mov rdi, [rbp+var_18]
call _strlen
mov rdi, [rbp+var_190]
mov rsi, [rbp+var_188]
mov rdx, rax
call mysql_real_query
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jz short loc_29DC7
mov eax, [rbp+var_38]
mov [rbp+var_19C], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_198], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_19C]
mov rdx, [rbp+var_198]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0C24h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_29DD0
loc_29DC7:
jmp short $+2
loc_29DC9:
mov [rbp+var_4], 0
loc_29DD0:
mov eax, [rbp+var_4]
add rsp, 1A0h
pop rbp
retn
| long long test_bug8330(long long a1)
{
long long v1; // rax
int v2; // eax
long long v3; // rax
int v4; // eax
long long v5; // rax
long long v6; // rax
int v7; // eax
int v8; // r8d
int v9; // r9d
int v10; // eax
int v11; // r8d
int v12; // r9d
int v13; // r8d
int v14; // r9d
int v15; // eax
int v16; // r8d
int v17; // r9d
long long v18; // rax
int v19; // eax
int v21; // [rsp+4h] [rbp-19Ch]
int v22; // [rsp+8h] [rbp-198h]
long long v23; // [rsp+10h] [rbp-190h]
long long v24; // [rsp+20h] [rbp-180h]
const char *v25; // [rsp+28h] [rbp-178h]
int v26; // [rsp+38h] [rbp-168h]
int v27; // [rsp+58h] [rbp-148h]
_QWORD v28[2]; // [rsp+70h] [rbp-130h] BYREF
_OWORD v29[14]; // [rsp+80h] [rbp-120h] BYREF
const char *v30; // [rsp+160h] [rbp-40h]
int v31; // [rsp+168h] [rbp-38h]
int i; // [rsp+16Ch] [rbp-34h]
long long v33; // [rsp+170h] [rbp-30h]
long long v34; // [rsp+178h] [rbp-28h]
const char *v35; // [rsp+188h] [rbp-18h]
long long v36; // [rsp+190h] [rbp-10h]
v36 = a1;
v30 = "select a,b from t1 where a=?";
v28[0] = 1LL;
v28[1] = 2LL;
v35 = "drop table if exists t1";
v1 = strlen("drop table if exists t1");
v31 = mysql_real_query(a1, "drop table if exists t1", v1);
if ( v31 )
{
v27 = mysql_error(v36);
v2 = mysql_errno(v36);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v31,
v27,
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3080);
return 1;
}
else
{
v35 = "create table t1 (a int, b int)";
v3 = strlen("create table t1 (a int, b int)");
v31 = mysql_real_query(v36, "create table t1 (a int, b int)", v3);
if ( v31 )
{
v26 = mysql_error(v36);
v4 = mysql_errno(v36);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v31,
v26,
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3083);
return 1;
}
else
{
memset(v29, 0LL, sizeof(v29));
for ( i = 0; i < 2; ++i )
{
v5 = mysql_stmt_init(v36);
*(&v33 + i) = v5;
v24 = *(&v33 + i);
v25 = v30;
v6 = strlen(v30);
v31 = mysql_stmt_prepare(v24, v25, v6);
if ( v31 )
{
v7 = mysql_stmt_error(*(&v33 + i));
diag(
(unsigned int)"Error: %s (%s: %d)",
v7,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3090,
v8,
v9);
return 1;
}
LODWORD(v29[7 * i + 6]) = 3;
*(_QWORD *)&v29[7 * i + 1] = &v28[i];
*((_QWORD *)&v29[7 * i] + 1) = 0LL;
mysql_stmt_bind_param(*(&v33 + i), &v29[7 * i]);
}
v31 = mysql_stmt_execute(v33);
if ( v31 )
{
v10 = mysql_stmt_error(v33);
diag(
(unsigned int)"Error: %s (%s: %d)",
v10,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3098,
v11,
v12);
return 1;
}
else
{
v31 = mysql_stmt_execute(v34);
if ( v31 && (unsigned int)mysql_stmt_errno(v34) == 2014 )
{
v31 = mysql_stmt_execute(v33);
if ( v31 )
{
v15 = mysql_stmt_error(v33);
diag(
(unsigned int)"Error: %s (%s: %d)",
v15,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3102,
v16,
v17);
return 1;
}
else
{
mysql_stmt_close(v33);
mysql_stmt_close(v34);
v35 = "drop table t1";
v23 = v36;
v18 = strlen("drop table t1");
v31 = mysql_real_query(v23, "drop table t1", v18);
if ( v31 )
{
v21 = v31;
v22 = mysql_error(v36);
v19 = mysql_errno(v36);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v21,
v22,
v19,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3108);
return 1;
}
else
{
return 0;
}
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Error expected",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3100,
v13,
v14);
return 1;
}
}
}
}
}
| test_bug8330:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1a0
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x169d98]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [0x00165580]
MOV qword ptr [RBP + -0x130],RAX
MOV RAX,qword ptr [0x00165588]
MOV qword ptr [RBP + -0x128],RAX
LEA RAX,[0x1664d2]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x140],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x138],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x140]
MOV RSI,qword ptr [RBP + -0x138]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129a57
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x14c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x148],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x14c]
MOV RDX,qword ptr [RBP + -0x148]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xc08
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129a57:
JMP 0x00129a59
LAB_00129a59:
LEA RAX,[0x169db5]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x160],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x158],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x160]
MOV RSI,qword ptr [RBP + -0x158]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129afa
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x16c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x168],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x16c]
MOV RDX,qword ptr [RBP + -0x168]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xc0b
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129afa:
JMP 0x00129afc
LAB_00129afc:
LEA RDI,[RBP + -0x120]
XOR ESI,ESI
MOV EDX,0xe0
CALL 0x00114260
MOV dword ptr [RBP + -0x34],0x0
LAB_00129b16:
CMP dword ptr [RBP + -0x34],0x2
JGE 0x00129c3a
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV RCX,RAX
MOVSXD RAX,dword ptr [RBP + -0x34]
MOV qword ptr [RBP + RAX*0x8 + -0x30],RCX
MOVSXD RAX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x30]
MOV qword ptr [RBP + -0x180],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x178],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x180]
MOV RSI,qword ptr [RBP + -0x178]
MOV RDX,RAX
CALL 0x00145070
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129baf
MOVSXD RAX,dword ptr [RBP + -0x34]
MOV RDI,qword ptr [RBP + RAX*0x8 + -0x30]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0xc12
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129baf:
JMP 0x00129bb1
LAB_00129bb1:
MOVSXD RCX,dword ptr [RBP + -0x34]
LEA RAX,[RBP + -0x120]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV dword ptr [RAX + 0x60],0x3
MOVSXD RAX,dword ptr [RBP + -0x34]
LEA RCX,[RBP + -0x130]
SHL RAX,0x3
ADD RCX,RAX
MOVSXD RDX,dword ptr [RBP + -0x34]
LEA RAX,[RBP + -0x120]
IMUL RDX,RDX,0x70
ADD RAX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOVSXD RCX,dword ptr [RBP + -0x34]
LEA RAX,[RBP + -0x120]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RAX + 0x8],0x0
MOVSXD RAX,dword ptr [RBP + -0x34]
MOV RDI,qword ptr [RBP + RAX*0x8 + -0x30]
MOVSXD RAX,dword ptr [RBP + -0x34]
LEA RSI,[RBP + -0x120]
IMUL RAX,RAX,0x70
ADD RSI,RAX
CALL 0x001432c0
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00129b16
LAB_00129c3a:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00146580
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129c7e
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0xc1a
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129c7e:
JMP 0x00129c80
LAB_00129c80:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00146580
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129ca2
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00143fb0
CMP EAX,0x7de
JZ 0x00129ccf
LAB_00129ca2:
LEA RDI,[0x165590]
LEA RSI,[0x167789]
LEA RDX,[0x16606d]
MOV ECX,0xc1c
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129ccf:
JMP 0x00129cd1
LAB_00129cd1:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00146580
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129d15
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0xc1e
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129d15:
JMP 0x00129d17
LAB_00129d17:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00143eb0
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00143eb0
LEA RAX,[0x167209]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x190],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x188],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x190]
MOV RSI,qword ptr [RBP + -0x188]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00129dc7
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x19c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x198],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x19c]
MOV RDX,qword ptr [RBP + -0x198]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xc24
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00129dd0
LAB_00129dc7:
JMP 0x00129dc9
LAB_00129dc9:
MOV dword ptr [RBP + -0x4],0x0
LAB_00129dd0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x1a0
POP RBP
RET
|
int4 test_bug8330(int8 param_1)
{
char *pcVar1;
int iVar2;
int4 uVar3;
size_t sVar4;
int8 uVar5;
char *pcVar6;
int8 local_138 [2];
int1 local_128 [8];
long alStack_120 [11];
int4 auStack_c8 [32];
char *local_48;
int local_40;
int local_3c;
char *local_38 [4];
int8 local_18;
local_48 = "select a,b from t1 where a=?";
local_138[0] = DAT_00165580;
local_138[1] = DAT_00165588;
local_38[3] = "drop table if exists t1";
local_18 = param_1;
sVar4 = strlen("drop table if exists t1");
iVar2 = mysql_real_query(param_1,"drop table if exists t1",sVar4);
uVar5 = local_18;
local_40 = iVar2;
if (iVar2 == 0) {
local_38[3] = "create table t1 (a int, b int)";
sVar4 = strlen("create table t1 (a int, b int)");
iVar2 = mysql_real_query(uVar5,"create table t1 (a int, b int)",sVar4);
local_40 = iVar2;
if (iVar2 == 0) {
memset(local_128,0,0xe0);
for (local_3c = 0; local_3c < 2; local_3c = local_3c + 1) {
pcVar6 = (char *)mysql_stmt_init(local_18);
pcVar1 = local_48;
local_38[local_3c] = pcVar6;
pcVar6 = local_38[local_3c];
sVar4 = strlen(local_48);
local_40 = mysql_stmt_prepare(pcVar6,pcVar1,sVar4);
if (local_40 != 0) {
uVar5 = mysql_stmt_error(local_38[local_3c]);
diag("Error: %s (%s: %d)",uVar5,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xc12);
return 1;
}
auStack_c8[(long)local_3c * 0x1c] = 3;
alStack_120[(long)local_3c * 0xe + 1] = (long)(local_138 + local_3c);
alStack_120[(long)local_3c * 0xe] = 0;
mysql_stmt_bind_param(local_38[local_3c],local_128 + (long)local_3c * 0x70);
}
local_40 = mysql_stmt_execute(local_38[0]);
if (local_40 == 0) {
local_40 = mysql_stmt_execute(local_38[1]);
if ((local_40 != 0) && (iVar2 = mysql_stmt_errno(local_38[1]), iVar2 == 0x7de)) {
local_40 = mysql_stmt_execute(local_38[0]);
if (local_40 != 0) {
uVar5 = mysql_stmt_error(local_38[0]);
diag("Error: %s (%s: %d)",uVar5,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xc1e);
return 1;
}
mysql_stmt_close(local_38[0]);
mysql_stmt_close(local_38[1]);
uVar5 = local_18;
local_38[3] = "drop table t1";
sVar4 = strlen("drop table t1");
iVar2 = mysql_real_query(uVar5,"drop table t1",sVar4);
if (iVar2 != 0) {
local_40 = iVar2;
uVar5 = mysql_error(local_18);
uVar3 = mysql_errno(local_18);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xc24);
return 1;
}
return 0;
}
diag("Error: %s (%s: %d)","Error expected",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xc1c);
}
else {
uVar5 = mysql_stmt_error(local_38[0]);
diag("Error: %s (%s: %d)",uVar5,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xc1a);
}
}
else {
uVar5 = mysql_error(local_18);
uVar3 = mysql_errno(local_18);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xc0b
);
}
}
else {
uVar5 = mysql_error(local_18);
uVar3 = mysql_errno(local_18);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xc08);
}
return 1;
}
| |
30,087 | release_whole_queue | eloqsql/mysys/mf_keycache.c | static void release_whole_queue(KEYCACHE_WQUEUE *wqueue)
{
struct st_my_thread_var *last;
struct st_my_thread_var *next;
struct st_my_thread_var *thread;
/* Queue may be empty. */
if (!(last= wqueue->last_thread))
return;
next= last->next; /* First (oldest) element */
do
{
thread=next;
DBUG_ASSERT(thread && thread->init == 1);
KEYCACHE_DBUG_PRINT("release_whole_queue: signal",
("thread %ld", (ulong) thread->id));
/* Take thread from queue. */
next= thread->next;
thread->next= NULL;
/* Signal the thread. */
keycache_pthread_cond_signal(&thread->suspend);
}
while (thread != last);
/* Now queue is definitely empty. */
wqueue->last_thread= NULL;
} | O0 | c | release_whole_queue:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8e56f
jmp 0x8e5cc
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8e588
jmp 0x8e58a
jmp 0x8e58c
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x8e710
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x8e57e
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| release_whole_queue:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_8E56F
jmp short loc_8E5CC
loc_8E56F:
mov rax, [rbp+var_10]
mov rax, [rax+88h]
mov [rbp+var_18], rax
loc_8E57E:
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short $+2
loc_8E588:
jmp short $+2
loc_8E58A:
jmp short $+2
loc_8E58C:
mov rax, [rbp+var_20]
mov rax, [rax+88h]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
mov qword ptr [rax+88h], 0
mov rdi, [rbp+var_20]
add rdi, 8
call inline_mysql_cond_signal_1
mov rax, [rbp+var_20]
cmp rax, [rbp+var_10]
jnz short loc_8E57E
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
loc_8E5CC:
add rsp, 20h
pop rbp
retn
| _QWORD * release_whole_queue(_QWORD *a1)
{
_QWORD *result; // rax
_QWORD *v2; // [rsp+0h] [rbp-20h]
_QWORD *v3; // [rsp+8h] [rbp-18h]
_QWORD *v4; // [rsp+10h] [rbp-10h]
result = (_QWORD *)*a1;
v4 = (_QWORD *)*a1;
if ( *a1 )
{
v3 = (_QWORD *)v4[17];
do
{
v2 = v3;
v3 = (_QWORD *)v3[17];
v2[17] = 0LL;
inline_mysql_cond_signal_1(v2 + 1);
}
while ( v2 != v4 );
result = a1;
*a1 = 0LL;
}
return result;
}
| release_whole_queue:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x0018e56f
JMP 0x0018e5cc
LAB_0018e56f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x18],RAX
LAB_0018e57e:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018e588
LAB_0018e588:
JMP 0x0018e58a
LAB_0018e58a:
JMP 0x0018e58c
LAB_0018e58c:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x88],0x0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x8
CALL 0x0018e710
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x0018e57e
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
LAB_0018e5cc:
ADD RSP,0x20
POP RBP
RET
|
void release_whole_queue(long *param_1)
{
long lVar1;
long lVar2;
bool bVar3;
int8 local_20;
lVar1 = *param_1;
if (lVar1 != 0) {
local_20 = *(long *)(lVar1 + 0x88);
do {
lVar2 = *(long *)(local_20 + 0x88);
*(int8 *)(local_20 + 0x88) = 0;
inline_mysql_cond_signal(local_20 + 8);
bVar3 = local_20 != lVar1;
local_20 = lVar2;
} while (bVar3);
*param_1 = 0;
}
return;
}
| |
30,088 | gc_scan | bluesky950520[P]quickjs/quickjs.c | static void gc_scan(JSRuntime *rt)
{
struct list_head *el;
JSGCObjectHeader *p;
/* keep the objects with a refcount > 0 and their children. */
list_for_each(el, &rt->gc_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
assert(p->ref_count > 0);
p->mark = 0; /* reset the mark for the next GC call */
mark_children(rt, p, gc_scan_incref_child);
}
/* restore the refcount of the objects to be deleted. */
list_for_each(el, &rt->tmp_obj_list) {
p = list_entry(el, JSGCObjectHeader, link);
mark_children(rt, p, gc_scan_incref_child2);
}
} | O0 | c | gc_scan:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x98, %rcx
cmpq %rcx, %rax
je 0x29ac2
movq 0x8(%rsp), %rax
addq $-0x8, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb 0x4(%rax), %cl
andb $0xf, %cl
orb $0x0, %cl
movb %cl, 0x4(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x34ec3(%rip), %rdx # 0x5e970
callq 0x5df50
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x29a6a
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0xb8, %rcx
cmpq %rcx, %rax
je 0x29b1b
movq 0x8(%rsp), %rax
addq $-0x8, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x34eda(%rip), %rdx # 0x5e9e0
callq 0x5df50
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x29ad3
addq $0x18, %rsp
retq
| gc_scan:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov rax, [rax+0A0h]
mov [rsp+18h+var_10], rax
loc_29A6A:
mov rax, [rsp+18h+var_10]
mov rcx, [rsp+18h+var_8]
add rcx, 98h
cmp rax, rcx
jz short loc_29AC2
mov rax, [rsp+18h+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov cl, [rax+4]
and cl, 0Fh
or cl, 0
mov [rax+4], cl
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_18]
lea rdx, gc_scan_incref_child
call mark_children
mov rax, [rsp+18h+var_10]
mov rax, [rax+8]
mov [rsp+18h+var_10], rax
jmp short loc_29A6A
loc_29AC2:
mov rax, [rsp+18h+var_8]
mov rax, [rax+0C0h]
mov [rsp+18h+var_10], rax
loc_29AD3:
mov rax, [rsp+18h+var_10]
mov rcx, [rsp+18h+var_8]
add rcx, 0B8h
cmp rax, rcx
jz short loc_29B1B
mov rax, [rsp+18h+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rsp+18h+var_18], rax
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_18]
lea rdx, gc_scan_incref_child2
call mark_children
mov rax, [rsp+18h+var_10]
mov rax, [rax+8]
mov [rsp+18h+var_10], rax
jmp short loc_29AD3
loc_29B1B:
add rsp, 18h
retn
| long long gc_scan(long long a1)
{
long long result; // rax
long long i; // [rsp+8h] [rbp-10h]
long long j; // [rsp+8h] [rbp-10h]
for ( i = *(_QWORD *)(a1 + 160); i != a1 + 152; i = *(_QWORD *)(i + 8) )
{
*(_BYTE *)(i - 8 + 4) &= 0xFu;
mark_children(a1, i - 8, gc_scan_incref_child);
}
for ( j = *(_QWORD *)(a1 + 192); ; j = *(_QWORD *)(j + 8) )
{
result = j;
if ( j == a1 + 184 )
break;
mark_children(a1, j - 8, gc_scan_incref_child2);
}
return result;
}
| gc_scan:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0xa0]
MOV qword ptr [RSP + 0x8],RAX
LAB_00129a6a:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
ADD RCX,0x98
CMP RAX,RCX
JZ 0x00129ac2
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,-0x8
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV CL,byte ptr [RAX + 0x4]
AND CL,0xf
OR CL,0x0
MOV byte ptr [RAX + 0x4],CL
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP]
LEA RDX,[0x15e970]
CALL 0x0015df50
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00129a6a
LAB_00129ac2:
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0xc0]
MOV qword ptr [RSP + 0x8],RAX
LAB_00129ad3:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
ADD RCX,0xb8
CMP RAX,RCX
JZ 0x00129b1b
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,-0x8
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP]
LEA RDX,[0x15e9e0]
CALL 0x0015df50
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00129ad3
LAB_00129b1b:
ADD RSP,0x18
RET
|
void gc_scan(long param_1)
{
long local_10;
for (local_10 = *(long *)(param_1 + 0xa0); local_10 != param_1 + 0x98;
local_10 = *(long *)(local_10 + 8)) {
*(byte *)(local_10 + -4) = *(byte *)(local_10 + -4) & 0xf;
mark_children(param_1,local_10 + -8,gc_scan_incref_child);
}
for (local_10 = *(long *)(param_1 + 0xc0); local_10 != param_1 + 0xb8;
local_10 = *(long *)(local_10 + 8)) {
mark_children(param_1,local_10 + -8,gc_scan_incref_child2);
}
return;
}
| |
30,089 | linenoiseNoTTY() | llama.cpp/examples/run/linenoise.cpp/linenoise.cpp | static char *linenoiseNoTTY(void) {
char *line = NULL;
size_t len = 0, maxlen = 0;
while(1) {
if (len == maxlen) {
if (maxlen == 0) maxlen = 16;
maxlen *= 2;
char *oldval = line;
line = (char*) realloc(line,maxlen);
if (line == NULL) {
if (oldval) free(oldval);
return NULL;
}
}
int c = fgetc(stdin);
if (c == EOF || c == '\n') {
if (c == EOF && len == 0) {
free(line);
return NULL;
} else {
line[len] = '\0';
return line;
}
} else {
line[len] = c;
len++;
}
}
} | O3 | cpp | linenoiseNoTTY():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r13d, %r13d
movq 0xd7c46(%rip), %rbp # 0x10afe8
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq %r14, %r13
jne 0x333d6
leaq (,%r13,2), %r14
testq %r13, %r13
movl $0x20, %eax
cmoveq %rax, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d130
movq %rax, %r15
testq %rax, %rax
jne 0x333d9
jmp 0x33421
movq %r12, %r15
movq (%rbp), %rdi
callq 0x1d840
cmpl $0xa, %eax
je 0x333ec
cmpl $-0x1, %eax
jne 0x33406
cmpl $-0x1, %eax
setne %cl
testq %r13, %r13
setne %dl
orb %cl, %dl
je 0x3341c
movb $0x0, (%r15,%r13)
movq %r15, %rbx
jmp 0x3340d
movb %al, (%r15,%r13)
incq %r13
cmpl $0xa, %eax
je 0x33430
movq %r15, %r12
cmpl $-0x1, %eax
jne 0x333a8
jmp 0x33430
movq %r15, %rdi
jmp 0x33429
testq %r12, %r12
je 0x3342e
movq %r12, %rdi
callq 0x1d240
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL14linenoiseNoTTYv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
xor r13d, r13d
mov rbp, cs:stdin_ptr
xor r14d, r14d
xor r12d, r12d
loc_333A8:
cmp r13, r14
jnz short loc_333D6
lea r14, ds:0[r13*2]
test r13, r13
mov eax, 20h ; ' '
cmovz r14, rax
mov rdi, r12
mov rsi, r14
call _realloc
mov r15, rax
test rax, rax
jnz short loc_333D9
jmp short loc_33421
loc_333D6:
mov r15, r12
loc_333D9:
mov rdi, [rbp+0]
call _fgetc
cmp eax, 0Ah
jz short loc_333EC
cmp eax, 0FFFFFFFFh
jnz short loc_33406
loc_333EC:
cmp eax, 0FFFFFFFFh
setnz cl
test r13, r13
setnz dl
or dl, cl
jz short loc_3341C
mov byte ptr [r15+r13], 0
mov rbx, r15
jmp short loc_3340D
loc_33406:
mov [r15+r13], al
inc r13
loc_3340D:
cmp eax, 0Ah
jz short loc_33430
mov r12, r15
cmp eax, 0FFFFFFFFh
jnz short loc_333A8
jmp short loc_33430
loc_3341C:
mov rdi, r15
jmp short loc_33429
loc_33421:
test r12, r12
jz short loc_3342E
mov rdi, r12
loc_33429:
call _free
loc_3342E:
xor ebx, ebx
loc_33430:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long linenoiseNoTTY()
{
long long v0; // rbx
long long v1; // r13
long long v2; // r14
long long v3; // r12
long long v4; // r15
int v5; // eax
long long v6; // rdi
v1 = 0LL;
v2 = 0LL;
v3 = 0LL;
while ( 1 )
{
if ( v1 != v2 )
{
v4 = v3;
goto LABEL_8;
}
v2 = 2 * v1;
if ( !v1 )
v2 = 32LL;
v4 = realloc(v3, v2);
if ( !v4 )
break;
LABEL_8:
v5 = fgetc(stdin);
if ( v5 == 10 || v5 == -1 )
{
if ( v5 == -1 && v1 == 0 )
{
v6 = v4;
goto LABEL_19;
}
*(_BYTE *)(v4 + v1) = 0;
v0 = v4;
}
else
{
*(_BYTE *)(v4 + v1++) = v5;
}
if ( v5 != 10 )
{
v3 = v4;
if ( v5 != -1 )
continue;
}
return v0;
}
if ( !v3 )
return 0LL;
v6 = v3;
LABEL_19:
free(v6);
return 0LL;
}
| linenoiseNoTTY:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
XOR R13D,R13D
MOV RBP,qword ptr [0x0020afe8]
XOR R14D,R14D
XOR R12D,R12D
LAB_001333a8:
CMP R13,R14
JNZ 0x001333d6
LEA R14,[R13*0x2]
TEST R13,R13
MOV EAX,0x20
CMOVZ R14,RAX
MOV RDI,R12
MOV RSI,R14
CALL 0x0011d130
MOV R15,RAX
TEST RAX,RAX
JNZ 0x001333d9
JMP 0x00133421
LAB_001333d6:
MOV R15,R12
LAB_001333d9:
MOV RDI,qword ptr [RBP]
CALL 0x0011d840
CMP EAX,0xa
JZ 0x001333ec
CMP EAX,-0x1
JNZ 0x00133406
LAB_001333ec:
CMP EAX,-0x1
SETNZ CL
TEST R13,R13
SETNZ DL
OR DL,CL
JZ 0x0013341c
MOV byte ptr [R15 + R13*0x1],0x0
MOV RBX,R15
JMP 0x0013340d
LAB_00133406:
MOV byte ptr [R15 + R13*0x1],AL
INC R13
LAB_0013340d:
CMP EAX,0xa
JZ 0x00133430
MOV R12,R15
CMP EAX,-0x1
JNZ 0x001333a8
JMP 0x00133430
LAB_0013341c:
MOV RDI,R15
JMP 0x00133429
LAB_00133421:
TEST R12,R12
JZ 0x0013342e
MOV RDI,R12
LAB_00133429:
CALL 0x0011d240
LAB_0013342e:
XOR EBX,EBX
LAB_00133430:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* linenoiseNoTTY() */
void * linenoiseNoTTY(void)
{
int *puVar1;
int iVar2;
void *pvVar3;
void *unaff_RBX;
void *__ptr;
size_t sVar4;
size_t __size;
puVar1 = PTR_stdin_0020afe8;
sVar4 = 0;
__size = 0;
__ptr = (void *)0x0;
do {
pvVar3 = __ptr;
if (sVar4 == __size) {
__size = sVar4 * 2;
if (sVar4 == 0) {
__size = 0x20;
}
pvVar3 = realloc(__ptr,__size);
if (pvVar3 == (void *)0x0) {
if (__ptr == (void *)0x0) {
return (void *)0x0;
}
goto LAB_00133429;
}
}
__ptr = pvVar3;
iVar2 = fgetc(*(FILE **)puVar1);
if ((iVar2 == 10) || (iVar2 == -1)) {
if (sVar4 == 0 && iVar2 == -1) {
LAB_00133429:
free(__ptr);
return (void *)0x0;
}
*(int1 *)((long)__ptr + sVar4) = 0;
unaff_RBX = __ptr;
}
else {
*(char *)((long)__ptr + sVar4) = (char)iVar2;
sVar4 = sVar4 + 1;
}
if (iVar2 == 10) {
return unaff_RBX;
}
if (iVar2 == -1) {
return unaff_RBX;
}
} while( true );
}
| |
30,090 | google::protobuf::DynamicMessage::~DynamicMessage() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/dynamic_message.cc | DynamicMessage::~DynamicMessage() {
const Descriptor* descriptor = type_info_->type;
_internal_metadata_.Delete<UnknownFieldSet>();
if (type_info_->extensions_offset != -1) {
reinterpret_cast<ExtensionSet*>(MutableExtensionsRaw())->~ExtensionSet();
}
// We need to manually run the destructors for repeated fields and strings,
// just as we ran their constructors in the DynamicMessage constructor.
// We also need to manually delete oneof fields if it is set and is string
// or message.
// Additionally, if any singular embedded messages have been allocated, we
// need to delete them, UNLESS we are the prototype message of this type,
// in which case any embedded messages are other prototypes and shouldn't
// be touched.
for (int i = 0; i < descriptor->field_count(); i++) {
const FieldDescriptor* field = descriptor->field(i);
if (InRealOneof(field)) {
void* field_ptr = MutableOneofCaseRaw(field->containing_oneof()->index());
if (*(reinterpret_cast<const int32_t*>(field_ptr)) == field->number()) {
field_ptr = MutableOneofFieldRaw(field);
if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
switch (field->options().ctype()) {
default:
case FieldOptions::STRING: {
reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy();
break;
}
}
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
delete *reinterpret_cast<Message**>(field_ptr);
}
}
continue;
}
void* field_ptr = MutableRaw(i);
if (field->is_repeated()) {
switch (field->cpp_type()) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
reinterpret_cast<RepeatedField<LOWERCASE>*>(field_ptr) \
->~RepeatedField<LOWERCASE>(); \
break
HANDLE_TYPE(INT32, int32_t);
HANDLE_TYPE(INT64, int64_t);
HANDLE_TYPE(UINT32, uint32_t);
HANDLE_TYPE(UINT64, uint64_t);
HANDLE_TYPE(DOUBLE, double);
HANDLE_TYPE(FLOAT, float);
HANDLE_TYPE(BOOL, bool);
HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
switch (field->options().ctype()) {
default: // TODO(kenton): Support other string reps.
case FieldOptions::STRING:
reinterpret_cast<RepeatedPtrField<std::string>*>(field_ptr)
->~RepeatedPtrField<std::string>();
break;
}
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
reinterpret_cast<DynamicMapField*>(field_ptr)->~DynamicMapField();
} else {
reinterpret_cast<RepeatedPtrField<Message>*>(field_ptr)
->~RepeatedPtrField<Message>();
}
break;
}
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
switch (field->options().ctype()) {
default: // TODO(kenton): Support other string reps.
case FieldOptions::STRING: {
reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy();
break;
}
}
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
if (!is_prototype()) {
Message* message = *reinterpret_cast<Message**>(field_ptr);
if (message != nullptr) {
delete message;
}
}
}
}
} | O0 | cpp | google::protobuf::DynamicMessage::~DynamicMessage():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xff820
movq 0x8(%rsp), %rdi
callq 0x100d20
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| _ZN6google8protobuf14DynamicMessageD0Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]; this
mov [rsp+18h+var_10], rdi
call _ZN6google8protobuf14DynamicMessageD2Ev; google::protobuf::DynamicMessage::~DynamicMessage()
mov rdi, [rsp+18h+var_10]; void *
call _ZN6google8protobuf14DynamicMessagedlEPv; google::protobuf::DynamicMessage::operator delete(void *)
add rsp, 18h
retn
| void google::protobuf::DynamicMessage::~DynamicMessage(google::protobuf::DynamicMessage *this)
{
google::protobuf::DynamicMessage::~DynamicMessage(this);
google::protobuf::DynamicMessage::operator delete(this);
}
| ~DynamicMessage:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001ff820
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00200d20
ADD RSP,0x18
RET
|
/* google::protobuf::DynamicMessage::~DynamicMessage() */
void __thiscall google::protobuf::DynamicMessage::~DynamicMessage(DynamicMessage *this)
{
void *in_RSI;
~DynamicMessage(this);
operator_delete(this,in_RSI);
return;
}
| |
30,091 | JS_AtomIsArrayIndex | bluesky950520[P]quickjs/quickjs.c | static BOOL JS_AtomIsArrayIndex(JSContext *ctx, uint32_t *pval, JSAtom atom)
{
if (__JS_AtomIsTaggedInt(atom)) {
*pval = __JS_AtomToUInt32(atom);
return TRUE;
} else {
JSRuntime *rt = ctx->rt;
JSAtomStruct *p;
uint32_t val;
assert(atom < rt->atom_size);
p = rt->atom_array[atom];
if (p->atom_type == JS_ATOM_TYPE_STRING &&
is_num_string(&val, p) && val != -1) {
*pval = val;
return TRUE;
} else {
*pval = 0;
return FALSE;
}
}
} | O0 | c | JS_AtomIsArrayIndex:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
callq 0x34e00
cmpl $0x0, %eax
je 0x5f64c
movl 0x1c(%rsp), %edi
callq 0x34e20
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0x5f6c8
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x3e, %rax
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5f6b5
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdi
callq 0x5b770
cmpl $0x0, %eax
je 0x5f6b5
cmpl $-0x1, 0x4(%rsp)
je 0x5f6b5
movl 0x4(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x34(%rsp)
jmp 0x5f6c8
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_AtomIsArrayIndex:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov edi, [rsp+38h+var_1C]
call __JS_AtomIsTaggedInt
cmp eax, 0
jz short loc_5F64C
mov edi, [rsp+38h+var_1C]
call __JS_AtomToUInt32
mov ecx, eax
mov rax, [rsp+38h+var_18]
mov [rax], ecx
mov [rsp+38h+var_4], 1
jmp short loc_5F6C8
loc_5F64C:
mov rax, [rsp+38h+var_10]
mov rax, [rax+18h]
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
mov rax, [rax+68h]
mov ecx, [rsp+38h+var_1C]
mov rax, [rax+rcx*8]
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
mov rax, [rax+4]
shr rax, 3Eh
movzx eax, al
cmp eax, 1
jnz short loc_5F6B5
mov rsi, [rsp+38h+var_30]
lea rdi, [rsp+38h+var_34]
call is_num_string
cmp eax, 0
jz short loc_5F6B5
cmp [rsp+38h+var_34], 0FFFFFFFFh
jz short loc_5F6B5
mov ecx, [rsp+38h+var_34]
mov rax, [rsp+38h+var_18]
mov [rax], ecx
mov [rsp+38h+var_4], 1
jmp short loc_5F6C8
loc_5F6B5:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax], 0
mov [rsp+38h+var_4], 0
loc_5F6C8:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long JS_AtomIsArrayIndex(long long a1, _DWORD *a2, int a3)
{
unsigned int v4; // [rsp+4h] [rbp-34h] BYREF
long long v5; // [rsp+8h] [rbp-30h]
long long v6; // [rsp+10h] [rbp-28h]
unsigned int v7; // [rsp+1Ch] [rbp-1Ch]
_DWORD *v8; // [rsp+20h] [rbp-18h]
long long v9; // [rsp+28h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( _JS_AtomIsTaggedInt(a3) )
{
*v8 = _JS_AtomToUInt32(v7);
return 1;
}
else
{
v6 = *(_QWORD *)(v9 + 24);
v5 = *(_QWORD *)(*(_QWORD *)(v6 + 104) + 8LL * v7);
if ( *(_QWORD *)(v5 + 4) >> 62 == 1 && (unsigned int)is_num_string(&v4, v5) && v4 != -1 )
{
*v8 = v4;
return 1;
}
else
{
*v8 = 0;
return 0;
}
}
}
| JS_AtomIsArrayIndex:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x00134e00
CMP EAX,0x0
JZ 0x0015f64c
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x00134e20
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x34],0x1
JMP 0x0015f6c8
LAB_0015f64c:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x3e
MOVZX EAX,AL
CMP EAX,0x1
JNZ 0x0015f6b5
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x4]
CALL 0x0015b770
CMP EAX,0x0
JZ 0x0015f6b5
CMP dword ptr [RSP + 0x4],-0x1
JZ 0x0015f6b5
MOV ECX,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x34],0x1
JMP 0x0015f6c8
LAB_0015f6b5:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],0x0
MOV dword ptr [RSP + 0x34],0x0
LAB_0015f6c8:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 JS_AtomIsArrayIndex(long param_1,int *param_2,uint param_3)
{
int iVar1;
int local_34;
long local_30;
long local_28;
uint local_1c;
int *local_18;
long local_10;
int4 local_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
iVar1 = __JS_AtomIsTaggedInt(param_3);
if (iVar1 == 0) {
local_28 = *(long *)(local_10 + 0x18);
local_30 = *(long *)(*(long *)(local_28 + 0x68) + (ulong)local_1c * 8);
if ((((uint)((ulong)*(int8 *)(local_30 + 4) >> 0x3e) == 1) &&
(iVar1 = is_num_string(&local_34,local_30), iVar1 != 0)) && (local_34 != -1)) {
*local_18 = local_34;
return 1;
}
*local_18 = 0;
local_4 = 0;
}
else {
iVar1 = __JS_AtomToUInt32(local_1c);
*local_18 = iVar1;
local_4 = 1;
}
return local_4;
}
| |
30,092 | JS_AtomIsArrayIndex | bluesky950520[P]quickjs/quickjs.c | static BOOL JS_AtomIsArrayIndex(JSContext *ctx, uint32_t *pval, JSAtom atom)
{
if (__JS_AtomIsTaggedInt(atom)) {
*pval = __JS_AtomToUInt32(atom);
return TRUE;
} else {
JSRuntime *rt = ctx->rt;
JSAtomStruct *p;
uint32_t val;
assert(atom < rt->atom_size);
p = rt->atom_array[atom];
if (p->atom_type == JS_ATOM_TYPE_STRING &&
is_num_string(&val, p) && val != -1) {
*pval = val;
return TRUE;
} else {
*pval = 0;
return FALSE;
}
}
} | O1 | c | JS_AtomIsArrayIndex:
testl %edx, %edx
js 0x3cc18
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
movq 0x4(%rax), %rcx
movq %rcx, %rdx
shrq $0x3e, %rdx
cmpl $0x1, %edx
jne 0x3cc42
movl %ecx, %r8d
andl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
leal -0xb(%r8), %edx
cmpl $-0xa, %edx
jb 0x3cc31
testl %ecx, %ecx
js 0x3cc25
movzbl 0x18(%rax), %edi
jmp 0x3cc29
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
movl $0x1, %eax
jmp 0x3cc46
movzwl 0x18(%rax), %edi
leal -0x30(%rdi), %edx
cmpl $0x9, %edx
jbe 0x3cc49
xorl %edi, %edi
testb %dil, %dil
je 0x3cc42
movl $0x1, %eax
cmpl $-0x1, %edx
jne 0x3cc46
xorl %edx, %edx
xorl %eax, %eax
movl %edx, (%rsi)
retq
cmpl $0x30, %edi
jne 0x3cc5a
cmpl $0x1, %r8d
sete %dil
xorl %edx, %edx
jmp 0x3cc33
movb $0x1, %dil
cmpl $0x2, %r8d
jb 0x3cc33
movl %ecx, %r8d
andl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
decq %r8
xorl %r9d, %r9d
testl %ecx, %ecx
js 0x3cc7f
movzbl 0x19(%rax,%r9), %r10d
jmp 0x3cc85
movzwl 0x1a(%rax,%r9,2), %r10d
addl $-0x30, %r10d
cmpl $0x9, %r10d
ja 0x3cc31
movl %edx, %edx
leaq (%rdx,%rdx,4), %rdx
movl %r10d, %r10d
leaq (%r10,%rdx,2), %rdx
movq %rdx, %r10
shrq $0x20, %r10
jne 0x3cc31
incq %r9
cmpq %r9, %r8
jne 0x3cc73
jmp 0x3cc33
| JS_AtomIsArrayIndex:
test edx, edx
js short loc_3CC18
mov rax, [rdi+18h]
mov rax, [rax+68h]
mov ecx, edx
mov rax, [rax+rcx*8]
mov rcx, [rax+4]
mov rdx, rcx
shr rdx, 3Eh
cmp edx, 1
jnz short loc_3CC42
mov r8d, ecx
and r8d, 7FFFFFFFh
lea edx, [r8-0Bh]
cmp edx, 0FFFFFFF6h
jb short loc_3CC31
test ecx, ecx
js short loc_3CC25
movzx edi, byte ptr [rax+18h]
jmp short loc_3CC29
loc_3CC18:
and edx, 7FFFFFFFh
mov eax, 1
jmp short loc_3CC46
loc_3CC25:
movzx edi, word ptr [rax+18h]
loc_3CC29:
lea edx, [rdi-30h]
cmp edx, 9
jbe short loc_3CC49
loc_3CC31:
xor edi, edi
loc_3CC33:
test dil, dil
jz short loc_3CC42
mov eax, 1
cmp edx, 0FFFFFFFFh
jnz short loc_3CC46
loc_3CC42:
xor edx, edx
xor eax, eax
loc_3CC46:
mov [rsi], edx
retn
loc_3CC49:
cmp edi, 30h ; '0'
jnz short loc_3CC5A
cmp r8d, 1
setz dil
xor edx, edx
jmp short loc_3CC33
loc_3CC5A:
mov dil, 1
cmp r8d, 2
jb short loc_3CC33
mov r8d, ecx
and r8d, 7FFFFFFFh
dec r8
xor r9d, r9d
loc_3CC73:
test ecx, ecx
js short loc_3CC7F
movzx r10d, byte ptr [rax+r9+19h]
jmp short loc_3CC85
loc_3CC7F:
movzx r10d, word ptr [rax+r9*2+1Ah]
loc_3CC85:
add r10d, 0FFFFFFD0h
cmp r10d, 9
ja short loc_3CC31
mov edx, edx
lea rdx, [rdx+rdx*4]
mov r10d, r10d
lea rdx, [r10+rdx*2]
mov r10, rdx
shr r10, 20h
jnz short loc_3CC31
inc r9
cmp r8, r9
jnz short loc_3CC73
jmp short loc_3CC33
| long long JS_AtomIsArrayIndex(long long a1, _DWORD *a2, int a3)
{
long long v3; // rax
unsigned long long v4; // rcx
unsigned int v5; // r8d
unsigned long long v6; // rdx
int v7; // edi
long long result; // rax
bool v9; // di
long long v10; // r9
int v11; // r10d
unsigned int v12; // r10d
if ( a3 < 0 )
{
LODWORD(v6) = a3 & 0x7FFFFFFF;
result = 1LL;
goto LABEL_13;
}
v3 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
v4 = *(_QWORD *)(v3 + 4);
if ( v4 >> 62 != 1 )
{
LABEL_12:
LODWORD(v6) = 0;
result = 0LL;
goto LABEL_13;
}
v5 = v4 & 0x7FFFFFFF;
LODWORD(v6) = (v4 & 0x7FFFFFFF) - 11;
if ( (unsigned int)v6 >= 0xFFFFFFF6 )
{
v7 = (v4 & 0x80000000) != 0LL ? *(unsigned __int16 *)(v3 + 24) : *(unsigned __int8 *)(v3 + 24);
LODWORD(v6) = v7 - 48;
if ( (unsigned int)(v7 - 48) <= 9 )
{
if ( v7 == 48 )
{
v9 = v5 == 1;
LODWORD(v6) = 0;
goto LABEL_10;
}
v9 = 1;
if ( v5 < 2 )
goto LABEL_10;
v10 = 0LL;
while ( 1 )
{
v11 = (v4 & 0x80000000) != 0LL ? *(unsigned __int16 *)(v3 + 2 * v10 + 26) : *(unsigned __int8 *)(v3 + v10 + 25);
v12 = v11 - 48;
if ( v12 > 9 )
break;
v6 = v12 + 10LL * (unsigned int)v6;
if ( HIDWORD(v6) )
break;
if ( (v4 & 0x7FFFFFFF) - 1 == ++v10 )
goto LABEL_10;
}
}
}
v9 = 0;
LABEL_10:
if ( !v9 )
goto LABEL_12;
result = 1LL;
if ( (_DWORD)v6 == -1 )
goto LABEL_12;
LABEL_13:
*a2 = v6;
return result;
}
| JS_AtomIsArrayIndex:
TEST EDX,EDX
JS 0x0013cc18
MOV RAX,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,EDX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RCX,qword ptr [RAX + 0x4]
MOV RDX,RCX
SHR RDX,0x3e
CMP EDX,0x1
JNZ 0x0013cc42
MOV R8D,ECX
AND R8D,0x7fffffff
LEA EDX,[R8 + -0xb]
CMP EDX,-0xa
JC 0x0013cc31
TEST ECX,ECX
JS 0x0013cc25
MOVZX EDI,byte ptr [RAX + 0x18]
JMP 0x0013cc29
LAB_0013cc18:
AND EDX,0x7fffffff
MOV EAX,0x1
JMP 0x0013cc46
LAB_0013cc25:
MOVZX EDI,word ptr [RAX + 0x18]
LAB_0013cc29:
LEA EDX,[RDI + -0x30]
CMP EDX,0x9
JBE 0x0013cc49
LAB_0013cc31:
XOR EDI,EDI
LAB_0013cc33:
TEST DIL,DIL
JZ 0x0013cc42
MOV EAX,0x1
CMP EDX,-0x1
JNZ 0x0013cc46
LAB_0013cc42:
XOR EDX,EDX
XOR EAX,EAX
LAB_0013cc46:
MOV dword ptr [RSI],EDX
RET
LAB_0013cc49:
CMP EDI,0x30
JNZ 0x0013cc5a
CMP R8D,0x1
SETZ DIL
XOR EDX,EDX
JMP 0x0013cc33
LAB_0013cc5a:
MOV DIL,0x1
CMP R8D,0x2
JC 0x0013cc33
MOV R8D,ECX
AND R8D,0x7fffffff
DEC R8
XOR R9D,R9D
LAB_0013cc73:
TEST ECX,ECX
JS 0x0013cc7f
MOVZX R10D,byte ptr [RAX + R9*0x1 + 0x19]
JMP 0x0013cc85
LAB_0013cc7f:
MOVZX R10D,word ptr [RAX + R9*0x2 + 0x1a]
LAB_0013cc85:
ADD R10D,-0x30
CMP R10D,0x9
JA 0x0013cc31
MOV EDX,EDX
LEA RDX,[RDX + RDX*0x4]
MOV R10D,R10D
LEA RDX,[R10 + RDX*0x2]
MOV R10,RDX
SHR R10,0x20
JNZ 0x0013cc31
INC R9
CMP R8,R9
JNZ 0x0013cc73
JMP 0x0013cc33
|
int8 JS_AtomIsArrayIndex(long param_1,uint *param_2,uint param_3)
{
long lVar1;
int8 uVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
uint uVar6;
long lVar7;
bool bVar8;
if ((int)param_3 < 0) {
param_3 = param_3 & 0x7fffffff;
uVar2 = 1;
goto LAB_0013cc46;
}
lVar1 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
if ((uint)((ulong)*(int8 *)(lVar1 + 4) >> 0x3e) == 1) {
uVar3 = (uint)*(int8 *)(lVar1 + 4);
uVar6 = uVar3 & 0x7fffffff;
uVar4 = (ulong)(uVar6 - 0xb);
if (uVar6 - 0xb < 0xfffffff6) {
LAB_0013cc31:
bVar8 = false;
}
else {
if ((int)uVar3 < 0) {
uVar5 = (uint)*(ushort *)(lVar1 + 0x18);
}
else {
uVar5 = (uint)*(byte *)(lVar1 + 0x18);
}
uVar4 = (ulong)(uVar5 - 0x30);
if (9 < uVar5 - 0x30) goto LAB_0013cc31;
if (uVar5 == 0x30) {
bVar8 = uVar6 == 1;
uVar4 = 0;
}
else {
bVar8 = true;
if (1 < uVar6) {
lVar7 = 0;
do {
if ((int)uVar3 < 0) {
uVar6 = (uint)*(ushort *)(lVar1 + 0x1a + lVar7 * 2);
}
else {
uVar6 = (uint)*(byte *)(lVar1 + 0x19 + lVar7);
}
if ((9 < uVar6 - 0x30) ||
(uVar4 = (ulong)(uVar6 - 0x30) + (uVar4 & 0xffffffff) * 10, uVar4 >> 0x20 != 0))
goto LAB_0013cc31;
lVar7 = lVar7 + 1;
} while ((ulong)(uVar3 & 0x7fffffff) - 1 != lVar7);
}
}
}
param_3 = (uint)uVar4;
if ((bVar8) && (uVar2 = 1, param_3 != 0xffffffff)) goto LAB_0013cc46;
}
param_3 = 0;
uVar2 = 0;
LAB_0013cc46:
*param_2 = param_3;
return uVar2;
}
| |
30,093 | google::protobuf::compiler::java::EnumGenerator::~EnumGenerator() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/enum.cc | EnumGenerator::~EnumGenerator() {} | O3 | cpp | google::protobuf::compiler::java::EnumGenerator::~EnumGenerator():
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xd0d48
callq 0x1f4a0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xd0d57
popq %rbx
jmp 0x1f4a0
popq %rbx
retq
nop
| _ZN6google8protobuf8compiler4java13EnumGeneratorD2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+20h]; void *
test rdi, rdi
jz short loc_D0D48
call __ZdlPv; operator delete(void *)
loc_D0D48:
mov rdi, [rbx+8]; void *
test rdi, rdi
jz short loc_D0D57
pop rbx
jmp __ZdlPv; operator delete(void *)
loc_D0D57:
pop rbx
retn
| void google::protobuf::compiler::java::EnumGenerator::~EnumGenerator(
google::protobuf::compiler::java::EnumGenerator *this)
{
void *v2; // rdi
void *v3; // rdi
v2 = (void *)*((_QWORD *)this + 4);
if ( v2 )
operator delete(v2);
v3 = (void *)*((_QWORD *)this + 1);
if ( v3 )
operator delete(v3);
}
| ~EnumGenerator:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x20]
TEST RDI,RDI
JZ 0x001d0d48
CALL 0x0011f4a0
LAB_001d0d48:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x001d0d57
POP RBX
JMP 0x0011f4a0
LAB_001d0d57:
POP RBX
RET
|
/* google::protobuf::compiler::java::EnumGenerator::~EnumGenerator() */
void __thiscall google::protobuf::compiler::java::EnumGenerator::~EnumGenerator(EnumGenerator *this)
{
if (*(void **)(this + 0x20) != (void *)0x0) {
operator_delete(*(void **)(this + 0x20));
}
if (*(void **)(this + 8) != (void *)0x0) {
operator_delete(*(void **)(this + 8));
return;
}
return;
}
| |
30,094 | my_load_path | eloqsql/mysys/mf_loadpath.c | char * my_load_path(char * to, const char *path,
const char *own_path_prefix)
{
char buff[FN_REFLEN+1];
const char *from= buff;
int is_cur;
DBUG_ENTER("my_load_path");
DBUG_PRINT("enter",("path: %s prefix: %s",path,
own_path_prefix ? own_path_prefix : ""));
if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
test_if_hard_path(path))
from= path;
else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
(is_prefix(path,FN_PARENTDIR)) ||
! own_path_prefix)
{
if (is_cur)
is_cur=2; /* Remove current dir */
if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
{
size_t length= strlen(buff);
(void) strmake(buff + length, path+is_cur, FN_REFLEN - length);
}
else
from= path; /* Return org file name */
}
else
(void) strxnmov(buff, FN_REFLEN, own_path_prefix, path, NullS);
strmake(to, from, FN_REFLEN-1);
DBUG_PRINT("exit",("to: %s",to));
DBUG_RETURN(to);
} | O3 | c | my_load_path:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpb $0x7e, (%rsi)
jne 0xa8cbe
cmpb $0x2f, 0x1(%r14)
je 0xa8cca
movq %r14, %rdi
callq 0x9e8a2
testl %eax, %eax
je 0xa8d05
movq %r14, %r12
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd7258
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa8dac
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x2e, (%r14)
jne 0xa8d18
movl $0x2, %r13d
cmpb $0x2f, 0x1(%r14)
je 0xa8d57
leaq 0x33413(%rip), %rsi # 0xdc132
movq %r14, %rdi
callq 0xd5938
xorl %r13d, %r13d
testq %r15, %r15
je 0xa8d57
testl %eax, %eax
jne 0xa8d57
leaq -0x240(%rbp), %r12
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd7378
jmp 0xa8ccd
movq %r14, %rdi
callq 0x29340
leal 0x200(%r13), %esi
subl %eax, %esi
leaq -0x240(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x9e70c
testl %eax, %eax
jne 0xa8cca
movq %r12, %rdi
callq 0x29340
leaq (%rax,%rbp), %rdi
addq $-0x240, %rdi # imm = 0xFDC0
addq %r13, %r14
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
movq %r14, %rsi
callq 0xd7258
jmp 0xa8ccd
callq 0x29250
nopl (%rax)
| my_load_path:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp byte ptr [rsi], 7Eh ; '~'
jnz short loc_A8CBE
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_A8CCA
loc_A8CBE:
mov rdi, r14
call test_if_hard_path
test eax, eax
jz short loc_A8D05
loc_A8CCA:
mov r12, r14
loc_A8CCD:
mov edx, 1FFh
mov rdi, rbx
mov rsi, r12
call strmake
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_A8DAC
mov rax, rbx
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A8D05:
cmp byte ptr [r14], 2Eh ; '.'
jnz short loc_A8D18
mov r13d, 2
cmp byte ptr [r14+1], 2Fh ; '/'
jz short loc_A8D57
loc_A8D18:
lea rsi, asc_DC132; ".."
mov rdi, r14
call is_prefix
xor r13d, r13d
test r15, r15
jz short loc_A8D57
test eax, eax
jnz short loc_A8D57
lea r12, [rbp+var_240]
mov esi, 200h
mov rdi, r12
mov rdx, r15
mov rcx, r14
xor r8d, r8d
xor eax, eax
call strxnmov
jmp loc_A8CCD
loc_A8D57:
mov rdi, r14
call _strlen
lea esi, [r13+200h]
sub esi, eax
lea r12, [rbp+var_240]
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jnz loc_A8CCA
mov rdi, r12
call _strlen
lea rdi, [rax+rbp]
add rdi, 0FFFFFFFFFFFFFDC0h
add r14, r13
mov edx, 200h
sub rdx, rax
mov rsi, r14
call strmake
jmp loc_A8CCD
loc_A8DAC:
call ___stack_chk_fail
| long long my_load_path(long long a1, char *a2, long long a3)
{
char *v4; // r12
long long v6; // r13
int v7; // eax
int v8; // r9d
int v9; // eax
long long v10; // rax
char v11[528]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+210h] [rbp-30h]
v12 = __readfsqword(0x28u);
if ( (*a2 != 126 || a2[1] != 47) && !test_if_hard_path(a2) )
{
if ( *a2 != 46 || (v6 = 2LL, a2[1] != 47) )
{
v7 = is_prefix(a2, "..");
v6 = 0LL;
if ( a3 )
{
if ( !v7 )
{
v4 = v11;
strxnmov((unsigned int)v11, 512, a3, (_DWORD)a2, 0, v8, v11[0]);
goto LABEL_5;
}
}
}
v9 = strlen(a2);
v4 = v11;
if ( !(unsigned int)my_getwd(v11, (unsigned int)(v6 + 512 - v9), 0) )
{
v10 = strlen(v11);
strmake(&v11[v10], &a2[v6], 512 - v10);
goto LABEL_5;
}
}
v4 = a2;
LABEL_5:
strmake(a1, v4, 511LL);
return a1;
}
| my_load_path:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP byte ptr [RSI],0x7e
JNZ 0x001a8cbe
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x001a8cca
LAB_001a8cbe:
MOV RDI,R14
CALL 0x0019e8a2
TEST EAX,EAX
JZ 0x001a8d05
LAB_001a8cca:
MOV R12,R14
LAB_001a8ccd:
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,R12
CALL 0x001d7258
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a8dac
MOV RAX,RBX
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a8d05:
CMP byte ptr [R14],0x2e
JNZ 0x001a8d18
MOV R13D,0x2
CMP byte ptr [R14 + 0x1],0x2f
JZ 0x001a8d57
LAB_001a8d18:
LEA RSI,[0x1dc132]
MOV RDI,R14
CALL 0x001d5938
XOR R13D,R13D
TEST R15,R15
JZ 0x001a8d57
TEST EAX,EAX
JNZ 0x001a8d57
LEA R12,[RBP + -0x240]
MOV ESI,0x200
MOV RDI,R12
MOV RDX,R15
MOV RCX,R14
XOR R8D,R8D
XOR EAX,EAX
CALL 0x001d7378
JMP 0x001a8ccd
LAB_001a8d57:
MOV RDI,R14
CALL 0x00129340
LEA ESI,[R13 + 0x200]
SUB ESI,EAX
LEA R12,[RBP + -0x240]
MOV RDI,R12
XOR EDX,EDX
CALL 0x0019e70c
TEST EAX,EAX
JNZ 0x001a8cca
MOV RDI,R12
CALL 0x00129340
LEA RDI,[RAX + RBP*0x1]
ADD RDI,-0x240
ADD R14,R13
MOV EDX,0x200
SUB RDX,RAX
MOV RSI,R14
CALL 0x001d7258
JMP 0x001a8ccd
LAB_001a8dac:
CALL 0x00129250
|
int8 my_load_path(int8 param_1,char *param_2,long param_3)
{
int iVar1;
size_t sVar2;
long lVar3;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (((*param_2 != '~') || (param_2[1] != '/')) && (iVar1 = test_if_hard_path(param_2), iVar1 == 0)
) {
if ((*param_2 != '.') || (lVar3 = 2, param_2[1] != '/')) {
iVar1 = is_prefix(param_2,&DAT_001dc132);
lVar3 = 0;
if ((param_3 != 0) && (iVar1 == 0)) {
strxnmov(local_248,0x200,param_3,param_2,0);
param_2 = local_248;
goto LAB_001a8ccd;
}
}
sVar2 = strlen(param_2);
iVar1 = my_getwd(local_248,((int)lVar3 + 0x200) - (int)sVar2,0);
if (iVar1 == 0) {
sVar2 = strlen(local_248);
strmake(local_248 + sVar2,param_2 + lVar3,0x200 - sVar2);
param_2 = local_248;
}
}
LAB_001a8ccd:
strmake(param_1,param_2,0x1ff);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
| |
30,095 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
} | O0 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int):
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x208cc0
andb $0x1, %al
movb %al, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
je 0x208830
movq 0x78(%rsp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x1e46e0
movl %eax, 0x70(%rsp)
movb 0x77(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movslq 0x70(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1e3ae0
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x1e3af0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2088eb
testb $0x1, 0x77(%rsp)
je 0x2088b9
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rsp)
movb $0x2d, (%rax)
movq 0x58(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %edx
callq 0x1e46f0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x20897e
testb $0x1, 0x77(%rsp)
je 0x20891f
movb $0x2d, 0x3f(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x1e3cf0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1e3d10
movq %rax, %rdi
leaq 0x3f(%rsp), %rsi
callq 0x1e3d20
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rsi
movl 0x70(%rsp), %edx
movq 0x18(%rsp), %rdi
callq 0x1e4860
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1e3de0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nop
| _ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov [rsp+98h+var_18], rsi
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_20], rax
mov rdi, [rsp+98h+var_18]
call _ZN3fmt3v106detail11is_negativeImTnNSt9enable_ifIXntsr9is_signedIT_EE5valueEiE4typeELi0EEEbS4_
and al, 1
mov [rsp+98h+var_21], al
test [rsp+98h+var_21], 1
jz short loc_208830
mov rax, [rsp+98h+var_20]
xor rax, 0FFFFFFFFFFFFFFFFh
add rax, 1
mov [rsp+98h+var_20], rax
loc_208830:
mov rdi, [rsp+98h+var_20]; this
call _ZN3fmt3v106detail12count_digitsEm; fmt::v10::detail::count_digits(ulong)
mov [rsp+98h+var_28], eax
mov dl, [rsp+98h+var_21]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
cdqe
movsxd rcx, [rsp+98h+var_28]
add rax, rcx
mov [rsp+98h+var_30], rax
mov rsi, [rsp+98h+var_30]
lea rdi, [rsp+98h+var_10]
call _ZN3fmt3v106detail7reserveINS0_8appenderEEERT_S5_m; fmt::v10::detail::reserve<fmt::v10::appender>(fmt::v10::appender &,ulong)
mov rax, [rax]
mov [rsp+98h+var_38], rax
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_48], rax
mov rsi, [rsp+98h+var_30]
mov rdi, [rsp+98h+var_48]
call _ZN3fmt3v106detail10to_pointerIcEEPT_NSt11conditionalIXsr3std7is_sameIS3_cEE5valueENS0_8appenderESt20back_insert_iteratorINS1_6bufferIS3_EEEE4typeEm
mov [rsp+98h+var_40], rax
cmp [rsp+98h+var_40], 0
jz short loc_2088EB
test [rsp+98h+var_21], 1
jz short loc_2088B9
mov rax, [rsp+98h+var_40]
mov rcx, rax
add rcx, 1
mov [rsp+98h+var_40], rcx
mov byte ptr [rax], 2Dh ; '-'
loc_2088B9:
mov rdi, [rsp+98h+var_40]
mov rsi, [rsp+98h+var_20]
mov edx, [rsp+98h+var_28]
call _ZN3fmt3v106detail14format_decimalIcmEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,ulong>(char *,ulong,int)
mov [rsp+98h+var_58], rax
mov [rsp+98h+var_50], rdx
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_8], rax
jmp loc_20897E
loc_2088EB:
test [rsp+98h+var_21], 1
jz short loc_20891F
mov [rsp+98h+var_59], 2Dh ; '-'
lea rdi, [rsp+98h+var_38]
xor esi, esi
call _ZN3fmt3v108appenderppEi; fmt::v10::appender::operator++(int)
mov [rsp+98h+var_68], rax
lea rdi, [rsp+98h+var_68]
call _ZNSt20back_insert_iteratorIN3fmt3v106detail6bufferIcEEEdeEv; std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator*(void)
mov rdi, rax
lea rsi, [rsp+98h+var_59]
call _ZNSt20back_insert_iteratorIN3fmt3v106detail6bufferIcEEEaSEOc; std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator=(char &&)
loc_20891F:
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_80], rax
mov rsi, [rsp+98h+var_20]
mov edx, [rsp+98h+var_28]
mov rdi, [rsp+98h+var_80]
call _ZN3fmt3v106detail14format_decimalIcmNS0_8appenderETnNSt9enable_ifIXntsr3std10is_pointerINSt9remove_cvINSt16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEENS1_21format_decimal_resultIS7_EES7_T0_i
mov [rsp+98h+var_78], rax
mov [rsp+98h+var_70], rdx
mov rax, [rsp+98h+var_70]
mov [rsp+98h+var_38], rax
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_88], rax
mov rax, [rsp+98h+var_38]
mov [rsp+98h+var_90], rax
mov rdi, [rsp+98h+var_88]
mov rsi, [rsp+98h+var_90]
call _ZN3fmt3v106detail13base_iteratorINS0_8appenderEEET_S4_S4_; fmt::v10::detail::base_iterator<fmt::v10::appender>(fmt::v10::appender,fmt::v10::appender)
mov [rsp+98h+var_8], rax
loc_20897E:
mov rax, [rsp+98h+var_8]
add rsp, 98h
retn
| long long ZN3fmt3v106detail5writeIcNS0_8appenderEmTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_(
long long a1,
fmt::v10::detail *a2)
{
_BYTE *v2; // rax
long long v3; // rdx
_QWORD *v4; // rax
long long v5; // rdx
long long v7; // [rsp+30h] [rbp-68h] BYREF
char v8; // [rsp+3Fh] [rbp-59h] BYREF
_WORD *v9; // [rsp+40h] [rbp-58h]
long long v10; // [rsp+48h] [rbp-50h]
long long v11; // [rsp+50h] [rbp-48h]
_BYTE *v12; // [rsp+58h] [rbp-40h]
long long v13; // [rsp+60h] [rbp-38h] BYREF
long long v14; // [rsp+68h] [rbp-30h]
int v15; // [rsp+70h] [rbp-28h]
char v16; // [rsp+77h] [rbp-21h]
fmt::v10::detail *v17; // [rsp+78h] [rbp-20h]
fmt::v10::detail *v18; // [rsp+80h] [rbp-18h]
long long v19; // [rsp+88h] [rbp-10h] BYREF
v19 = a1;
v18 = a2;
v17 = a2;
v16 = ZN3fmt3v106detail11is_negativeImTnNSt9enable_ifIXntsr9is_signedIT_EE5valueEiE4typeELi0EEEbS4_(a2) & 1;
if ( v16 )
v17 = (fmt::v10::detail *)-(long long)v17;
v15 = fmt::v10::detail::count_digits(v17, (unsigned long long)a2);
v14 = v15 + (unsigned long long)((v16 & 1) != 0);
v13 = *(_QWORD *)fmt::v10::detail::reserve<fmt::v10::appender>((long long)&v19);
v11 = v13;
v12 = (_BYTE *)fmt::v10::detail::to_pointer<char>(v13, v14);
if ( v12 )
{
if ( (v16 & 1) != 0 )
{
v2 = v12++;
*v2 = 45;
}
v9 = fmt::v10::detail::format_decimal<char,unsigned long>((long long)v12, v17, v15);
v10 = v3;
return v19;
}
else
{
if ( (v16 & 1) != 0 )
{
v8 = 45;
v7 = fmt::v10::appender::operator++((long long)&v13);
v4 = (_QWORD *)std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator*((long long)&v7);
std::back_insert_iterator<fmt::v10::detail::buffer<char>>::operator=(v4, (long long)&v8);
}
ZN3fmt3v106detail14format_decimalIcmNS0_8appenderETnNSt9enable_ifIXntsr3std10is_pointerINSt9remove_cvINSt16remove_referenceIT1_E4typeEE4typeEEE5valueEiE4typeELi0EEENS1_21format_decimal_resultIS7_EES7_T0_i(
v13,
v17,
v15);
v13 = v5;
return fmt::v10::detail::base_iterator<fmt::v10::appender>(v19, v5);
}
}
| |||
30,096 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
} | O3 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender, int, 0>(fmt::v10::appender, int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x19176c(%rip), %rcx # 0x22a960
movq (%rcx,%rax,8), %rdi
addq %r14, %rdi
movq %rdi, %r15
shrq $0x20, %r15
movl %esi, %eax
shrl $0x1f, %eax
sarq $0x20, %rdi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
addq %rdx, %rax
addq %rdi, %rax
cmpq %rax, %rcx
jae 0x99223
movq %rdx, %rax
jmp 0x9924a
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9924a
addq %rdx, %rdi
testl %esi, %esi
jns 0x9923d
movb $0x2d, (%rdi)
incq %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x992b6
jmp 0x992a7
testl %esi, %esi
jns 0x99273
leaq 0x1(%rax), %rsi
cmpq %rsi, %rcx
jae 0x99267
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x2d, (%rcx,%rax)
leaq 0x8(%rsp), %r12
movw $0x0, 0x8(%r12)
movq $0x0, (%r12)
movq %r12, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x992b6
movq %r12, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x9931e
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN3fmt3v106detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r14d, esi
neg r14d
cmovs r14d, esi
mov eax, r14d
or eax, 1
bsr eax, eax
lea rcx, _ZZN3fmt3v106detail15do_count_digitsEjE5table; fmt::v10::detail::do_count_digits(uint)::table
mov rdi, [rcx+rax*8]
add rdi, r14
mov r15, rdi
shr r15, 20h
mov eax, esi
shr eax, 1Fh
sar rdi, 20h
mov rdx, [rbx+10h]
mov rcx, [rbx+18h]
add rax, rdx
add rax, rdi
cmp rcx, rax
jnb short loc_99223
mov rax, rdx
jmp short loc_9924A
loc_99223:
mov [rbx+10h], rax
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_9924A
add rdi, rdx
test esi, esi
jns short loc_9923D
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
loc_9923D:
mov esi, r14d
mov edx, r15d
call _ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,uint>(char *,uint,int)
jmp short loc_992A7
loc_9924A:
test esi, esi
jns short loc_99273
lea rsi, [rax+1]
cmp rcx, rsi
jnb short loc_99267
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_99267:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov byte ptr [rcx+rax], 2Dh ; '-'
loc_99273:
lea r12, [rsp+38h+var_30]
mov word ptr [r12+8], 0
mov qword ptr [r12], 0
mov rdi, r12
mov esi, r14d
mov edx, r15d
call _ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i; fmt::v10::detail::format_decimal<char,uint>(char *,uint,int)
mov rdi, r12
mov rsi, rdx
mov rdx, rbx
call _ZN3fmt3v106detail17copy_str_noinlineIcPcNS0_8appenderEEET1_T0_S6_S5_; fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(char *,char *,fmt::v10::appender)
mov rbx, rax
loc_992A7:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
| long long ZN3fmt3v106detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_(
_QWORD *a1,
int a2)
{
_QWORD *v2; // rbx
long long v3; // r14
long long v4; // rax
unsigned long long v5; // r15
long long v6; // rdx
unsigned long long v7; // rcx
unsigned long long v8; // rax
long long v9; // rdi
_BYTE *v10; // rdi
unsigned long long v11; // rsi
long long v12; // rcx
long long v13; // rdx
long long v15; // [rsp+8h] [rbp-30h] BYREF
__int16 v16; // [rsp+10h] [rbp-28h]
v2 = a1;
v3 = (unsigned int)-a2;
if ( a2 > 0 )
v3 = (unsigned int)a2;
_BitScanReverse((unsigned int *)&v4, v3 | 1);
v5 = (unsigned long long)(v3 + fmt::v10::detail::do_count_digits(unsigned int)::table[v4]) >> 32;
v6 = a1[2];
v7 = a1[3];
v8 = ((v3 + fmt::v10::detail::do_count_digits(unsigned int)::table[v4]) >> 32) + v6 + ((unsigned int)a2 >> 31);
if ( v7 < v8 )
{
v8 = a1[2];
LABEL_9:
if ( a2 < 0 )
{
v11 = v8 + 1;
if ( v7 < v8 + 1 )
{
(*(void ( **)(_QWORD *))*v2)(v2);
v8 = v2[2];
v11 = v8 + 1;
}
v12 = v2[1];
v2[2] = v11;
*(_BYTE *)(v12 + v8) = 45;
}
v16 = 0;
v15 = 0LL;
fmt::v10::detail::format_decimal<char,unsigned int>(&v15, (unsigned int)v3, (unsigned int)v5);
return fmt::v10::detail::copy_str_noinline<char,char *,fmt::v10::appender>(&v15, v13, v2);
}
a1[2] = v8;
v9 = a1[1];
if ( !v9 )
goto LABEL_9;
v10 = (_BYTE *)(v6 + v9);
if ( a2 < 0 )
*v10++ = 45;
fmt::v10::detail::format_decimal<char,unsigned int>(v10, (unsigned int)v3, (unsigned int)v5);
return (long long)v2;
}
| _ZN3fmt3v106detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R14D,ESI
NEG R14D
CMOVS R14D,ESI
MOV EAX,R14D
OR EAX,0x1
BSR EAX,EAX
LEA RCX,[0x32a960]
MOV RDI,qword ptr [RCX + RAX*0x8]
ADD RDI,R14
MOV R15,RDI
SHR R15,0x20
MOV EAX,ESI
SHR EAX,0x1f
SAR RDI,0x20
MOV RDX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RBX + 0x18]
ADD RAX,RDX
ADD RAX,RDI
CMP RCX,RAX
JNC 0x00199223
MOV RAX,RDX
JMP 0x0019924a
LAB_00199223:
MOV qword ptr [RBX + 0x10],RAX
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0019924a
ADD RDI,RDX
TEST ESI,ESI
JNS 0x0019923d
MOV byte ptr [RDI],0x2d
INC RDI
LAB_0019923d:
MOV ESI,R14D
MOV EDX,R15D
CALL 0x001992b6
JMP 0x001992a7
LAB_0019924a:
TEST ESI,ESI
JNS 0x00199273
LEA RSI,[RAX + 0x1]
CMP RCX,RSI
JNC 0x00199267
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00199267:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],0x2d
LAB_00199273:
LEA R12,[RSP + 0x8]
MOV word ptr [R12 + 0x8],0x0
MOV qword ptr [R12],0x0
MOV RDI,R12
MOV ESI,R14D
MOV EDX,R15D
CALL 0x001992b6
MOV RDI,R12
MOV RSI,RDX
MOV RDX,RBX
CALL 0x0019931e
MOV RBX,RAX
LAB_001992a7:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 *
_ZN3fmt3v106detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuentsr3std7is_sameIS5_T_EE5valueEiE4typeELi0EEET0_S9_S5_
(int8 *param_1,uint param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
int8 *puVar4;
int8 extraout_RDX;
ulong uVar5;
char *pcVar6;
ulong uVar7;
int iVar8;
char acStack_30 [16];
uVar7 = (ulong)-param_2;
if (0 < (int)param_2) {
uVar7 = (ulong)param_2;
}
uVar2 = (uint)uVar7;
uVar1 = 0x1f;
if ((uVar2 | 1) != 0) {
for (; (uVar2 | 1) >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
uVar5 = param_1[2];
uVar3 = (param_2 >> 0x1f) + uVar5 +
((long)(*(long *)(fmt::v10::detail::do_count_digits(unsigned_int)::table +
(ulong)uVar1 * 8) + uVar7) >> 0x20);
iVar8 = (int)(*(long *)(fmt::v10::detail::do_count_digits(unsigned_int)::table + (ulong)uVar1 * 8)
+ uVar7 >> 0x20);
uVar7 = uVar5;
if (uVar3 <= (ulong)param_1[3]) {
param_1[2] = uVar3;
uVar7 = uVar3;
if (param_1[1] != 0) {
pcVar6 = (char *)(param_1[1] + uVar5);
if ((int)param_2 < 0) {
*pcVar6 = '-';
pcVar6 = pcVar6 + 1;
}
fmt::v10::detail::format_decimal<char,unsigned_int>(pcVar6,uVar2,iVar8);
return param_1;
}
}
if ((int)param_2 < 0) {
uVar5 = uVar7 + 1;
if ((ulong)param_1[3] < uVar5) {
(**(code **)*param_1)(param_1);
uVar7 = param_1[2];
uVar5 = uVar7 + 1;
}
param_1[2] = uVar5;
*(int1 *)(param_1[1] + uVar7) = 0x2d;
}
acStack_30[8] = '\0';
acStack_30[9] = '\0';
acStack_30[0] = '\0';
acStack_30[1] = '\0';
acStack_30[2] = '\0';
acStack_30[3] = '\0';
acStack_30[4] = '\0';
acStack_30[5] = '\0';
acStack_30[6] = '\0';
acStack_30[7] = '\0';
fmt::v10::detail::format_decimal<char,unsigned_int>(acStack_30,uVar2,iVar8);
puVar4 = (int8 *)
fmt::v10::detail::copy_str_noinline<char,char*,fmt::v10::appender>
(acStack_30,extraout_RDX,param_1);
return puVar4;
}
| |
30,097 | HeapGetFragmentation | seiftnesse[P]memoryallocator/src/custom_alloc_stats.c | float HeapGetFragmentation() {
if (!heap_initialized) {
HEAP_LOG("Heap not initialized, fragmentation=0\n");
return 0.0f;
}
// Count number of free segments and total free memory
int free_segments = 0;
size_t free_memory = 0;
segment_t *s = segments;
while (s) {
if (s->is_free) {
free_segments++;
free_memory += s->size * BLOCK_SIZE;
}
s = s->next;
}
// If no free memory, fragmentation is 0
if (free_memory == 0) {
HEAP_LOG("No free memory, fragmentation=0\n");
return 0.0f;
}
// Calculate average free segment size
float avg_segment_size = (float) free_memory / free_segments;
// Calculate fragmentation as 1 - (avg segment size / total free memory)
// This gives a value between 0 (no fragmentation) and close to 1 (high fragmentation)
float frag = 1.0f - (avg_segment_size / free_memory);
HEAP_LOG("Fragmentation calculation: free_segments=%d, free_memory=%zu, result=%.4f\n",
free_segments, free_memory, frag);
return frag;
} | O0 | c | HeapGetFragmentation:
pushq %rbp
movq %rsp, %rbp
leaq 0x2f45(%rip), %rax # 0x6080
cmpl $0x0, (%rax)
jne 0x314d
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3271
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x2f0d(%rip), %rax # 0x6070
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x31a5
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3197
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shll $0xc, %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x316a
cmpq $0x0, -0x10(%rbp)
jne 0x31b9
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x3271
movq -0x10(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x28(%rbp)
testq %rax, %rax
movss %xmm0, -0x24(%rbp)
js 0x31f2
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x30(%rbp)
testq %rax, %rax
movss %xmm0, -0x2c(%rbp)
js 0x3248
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
divss %xmm0, %xmm1
movss 0xe5e(%rip), %xmm0 # 0x40bc
subss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
| HeapGetFragmentation:
push rbp
mov rbp, rsp
lea rax, heap_initialized
cmp dword ptr [rax], 0
jnz short loc_314D
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp loc_3271
loc_314D:
mov [rbp+var_8], 0
mov [rbp+var_10], 0
lea rax, segments
mov rax, [rax]
mov [rbp+var_18], rax
loc_316A:
cmp [rbp+var_18], 0
jz short loc_31A5
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jz short loc_3197
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_8], eax
mov rax, [rbp+var_18]
mov eax, [rax+4]
shl eax, 0Ch
cdqe
add rax, [rbp+var_10]
mov [rbp+var_10], rax
loc_3197:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp short loc_316A
loc_31A5:
cmp [rbp+var_10], 0
jnz short loc_31B9
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp loc_3271
loc_31B9:
mov rax, [rbp+var_10]
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rbp+var_28], xmm1
test rax, rax
movss [rbp+var_24], xmm0
js short loc_31F2
movss xmm0, [rbp+var_28]
movss [rbp+var_24], xmm0
loc_31F2:
movss xmm0, [rbp+var_24]
cvtsi2ss xmm1, [rbp+var_8]
divss xmm0, xmm1
movss [rbp+var_1C], xmm0
movss xmm0, [rbp+var_1C]
movss [rbp+var_34], xmm0
mov rax, [rbp+var_10]
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rbp+var_30], xmm1
test rax, rax
movss [rbp+var_2C], xmm0
js short loc_3248
movss xmm0, [rbp+var_30]
movss [rbp+var_2C], xmm0
loc_3248:
movss xmm1, [rbp+var_34]
movss xmm0, [rbp+var_2C]
divss xmm1, xmm0
movss xmm0, cs:dword_40BC
subss xmm0, xmm1
movss [rbp+var_20], xmm0
movss xmm0, [rbp+var_20]
movss [rbp+var_4], xmm0
loc_3271:
movss xmm0, [rbp+var_4]
pop rbp
retn
| float HeapGetFragmentation()
{
float v1; // [rsp+8h] [rbp-2Ch]
float v2; // [rsp+10h] [rbp-24h]
long long i; // [rsp+1Ch] [rbp-18h]
long long v4; // [rsp+24h] [rbp-10h]
int v5; // [rsp+2Ch] [rbp-8h]
if ( !heap_initialized )
return 0.0;
v5 = 0;
v4 = 0LL;
for ( i = segments; i; i = *(_QWORD *)(i + 8) )
{
if ( *(_DWORD *)i )
{
++v5;
v4 += (int)(*(_DWORD *)(i + 4) << 12);
}
}
if ( !v4 )
return 0.0;
v2 = (float)(int)(((unsigned long long)v4 >> 1) | v4 & 1) + (float)(int)(((unsigned long long)v4 >> 1) | v4 & 1);
if ( v4 >= 0 )
v2 = (float)(int)v4;
v1 = (float)(int)(((unsigned long long)v4 >> 1) | v4 & 1) + (float)(int)(((unsigned long long)v4 >> 1) | v4 & 1);
if ( v4 >= 0 )
v1 = (float)(int)v4;
return 1.0 - (float)((float)(v2 / (float)v5) / v1);
}
| HeapGetFragmentation:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x106080]
CMP dword ptr [RAX],0x0
JNZ 0x0010314d
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x00103271
LAB_0010314d:
MOV dword ptr [RBP + -0x8],0x0
MOV qword ptr [RBP + -0x10],0x0
LEA RAX,[0x106070]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_0010316a:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001031a5
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JZ 0x00103197
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x4]
SHL EAX,0xc
CDQE
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
LAB_00103197:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0010316a
LAB_001031a5:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001031b9
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x00103271
LAB_001031b9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
SHR RDX,0x1
MOV ECX,EAX
AND ECX,0x1
OR RCX,RDX
CVTSI2SS XMM0,RCX
ADDSS XMM0,XMM0
CVTSI2SS XMM1,RAX
MOVSS dword ptr [RBP + -0x28],XMM1
TEST RAX,RAX
MOVSS dword ptr [RBP + -0x24],XMM0
JS 0x001031f2
MOVSS XMM0,dword ptr [RBP + -0x28]
MOVSS dword ptr [RBP + -0x24],XMM0
LAB_001031f2:
MOVSS XMM0,dword ptr [RBP + -0x24]
CVTSI2SS XMM1,dword ptr [RBP + -0x8]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS dword ptr [RBP + -0x34],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
SHR RDX,0x1
MOV ECX,EAX
AND ECX,0x1
OR RCX,RDX
CVTSI2SS XMM0,RCX
ADDSS XMM0,XMM0
CVTSI2SS XMM1,RAX
MOVSS dword ptr [RBP + -0x30],XMM1
TEST RAX,RAX
MOVSS dword ptr [RBP + -0x2c],XMM0
JS 0x00103248
MOVSS XMM0,dword ptr [RBP + -0x30]
MOVSS dword ptr [RBP + -0x2c],XMM0
LAB_00103248:
MOVSS XMM1,dword ptr [RBP + -0x34]
MOVSS XMM0,dword ptr [RBP + -0x2c]
DIVSS XMM1,XMM0
MOVSS XMM0,dword ptr [0x001040bc]
SUBSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x20],XMM0
MOVSS XMM0,dword ptr [RBP + -0x20]
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_00103271:
MOVSS XMM0,dword ptr [RBP + -0x4]
POP RBP
RET
|
float HeapGetFragmentation(void)
{
float local_34;
float local_2c;
int *local_20;
ulong local_18;
int local_10;
float local_c;
if (heap_initialized == 0) {
local_c = 0.0;
}
else {
local_10 = 0;
local_18 = 0;
for (local_20 = segments; local_20 != (int *)0x0; local_20 = *(int **)(local_20 + 2)) {
if (*local_20 != 0) {
local_10 = local_10 + 1;
local_18 = (long)(local_20[1] << 0xc) + local_18;
}
}
if (local_18 == 0) {
local_c = 0.0;
}
else {
local_2c = (float)local_18;
local_34 = (float)local_18;
local_c = DAT_001040bc - (local_2c / (float)local_10) / local_34;
}
}
return local_c;
}
| |
30,098 | HeapGetFragmentation | seiftnesse[P]memoryallocator/src/custom_alloc_stats.c | float HeapGetFragmentation() {
if (!heap_initialized) {
HEAP_LOG("Heap not initialized, fragmentation=0\n");
return 0.0f;
}
// Count number of free segments and total free memory
int free_segments = 0;
size_t free_memory = 0;
segment_t *s = segments;
while (s) {
if (s->is_free) {
free_segments++;
free_memory += s->size * BLOCK_SIZE;
}
s = s->next;
}
// If no free memory, fragmentation is 0
if (free_memory == 0) {
HEAP_LOG("No free memory, fragmentation=0\n");
return 0.0f;
}
// Calculate average free segment size
float avg_segment_size = (float) free_memory / free_segments;
// Calculate fragmentation as 1 - (avg segment size / total free memory)
// This gives a value between 0 (no fragmentation) and close to 1 (high fragmentation)
float frag = 1.0f - (avg_segment_size / free_memory);
HEAP_LOG("Fragmentation calculation: free_segments=%d, free_memory=%zu, result=%.4f\n",
free_segments, free_memory, frag);
return frag;
} | O3 | c | HeapGetFragmentation:
leaq 0x2dba(%rip), %rax # 0x5090
cmpl $0x0, (%rax)
sete %al
leaq 0x2d9d(%rip), %rcx # 0x5080
movq (%rcx), %rcx
testq %rcx, %rcx
sete %dl
orb %al, %dl
xorps %xmm0, %xmm0
jne 0x2353
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x0, (%rcx)
je 0x2309
incl %edx
movslq 0x4(%rcx), %rsi
shlq $0xc, %rsi
addq %rsi, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x22f7
testq %rax, %rax
je 0x2353
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
js 0x2327
cvtsi2ss %rax, %xmm1
jmp 0x233c
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
movaps %xmm1, %xmm2
divss %xmm0, %xmm2
divss %xmm1, %xmm2
movss 0xd91(%rip), %xmm0 # 0x30e0
subss %xmm2, %xmm0
retq
| HeapGetFragmentation:
lea rax, heap_initialized
cmp dword ptr [rax], 0
setz al
lea rcx, segments
mov rcx, [rcx]
test rcx, rcx
setz dl
or dl, al
xorps xmm0, xmm0
jnz short locret_2353
xor edx, edx
xor eax, eax
loc_22F7:
cmp dword ptr [rcx], 0
jz short loc_2309
inc edx
movsxd rsi, dword ptr [rcx+4]
shl rsi, 0Ch
add rax, rsi
loc_2309:
mov rcx, [rcx+8]
test rcx, rcx
jnz short loc_22F7
test rax, rax
jz short locret_2353
xorps xmm0, xmm0
cvtsi2ss xmm0, edx
js short loc_2327
cvtsi2ss xmm1, rax
jmp short loc_233C
loc_2327:
mov rcx, rax
shr rcx, 1
and eax, 1
or rax, rcx
cvtsi2ss xmm1, rax
addss xmm1, xmm1
loc_233C:
movaps xmm2, xmm1
divss xmm2, xmm0
divss xmm2, xmm1
movss xmm0, cs:dword_30E0
subss xmm0, xmm2
locret_2353:
retn
| float HeapGetFragmentation()
{
long long v0; // rcx
float result; // xmm0_4
int v2; // edx
long long v3; // rax
float v4; // xmm1_4
v0 = segments;
result = 0.0;
if ( heap_initialized != 0 && segments != 0 )
{
v2 = 0;
v3 = 0LL;
do
{
if ( *(_DWORD *)v0 )
{
++v2;
v3 += (long long)*(int *)(v0 + 4) << 12;
}
v0 = *(_QWORD *)(v0 + 8);
}
while ( v0 );
if ( v3 )
{
if ( v3 < 0 )
v4 = (float)(int)(((unsigned long long)v3 >> 1) | v3 & 1) + (float)(int)(((unsigned long long)v3 >> 1) | v3 & 1);
else
v4 = (float)(int)v3;
return 1.0 - (float)((float)(v4 / (float)v2) / v4);
}
}
return result;
}
| HeapGetFragmentation:
LEA RAX,[0x105090]
CMP dword ptr [RAX],0x0
SETZ AL
LEA RCX,[0x105080]
MOV RCX,qword ptr [RCX]
TEST RCX,RCX
SETZ DL
OR DL,AL
XORPS XMM0,XMM0
JNZ 0x00102353
XOR EDX,EDX
XOR EAX,EAX
LAB_001022f7:
CMP dword ptr [RCX],0x0
JZ 0x00102309
INC EDX
MOVSXD RSI,dword ptr [RCX + 0x4]
SHL RSI,0xc
ADD RAX,RSI
LAB_00102309:
MOV RCX,qword ptr [RCX + 0x8]
TEST RCX,RCX
JNZ 0x001022f7
TEST RAX,RAX
JZ 0x00102353
XORPS XMM0,XMM0
CVTSI2SS XMM0,EDX
JS 0x00102327
CVTSI2SS XMM1,RAX
JMP 0x0010233c
LAB_00102327:
MOV RCX,RAX
SHR RCX,0x1
AND EAX,0x1
OR RAX,RCX
CVTSI2SS XMM1,RAX
ADDSS XMM1,XMM1
LAB_0010233c:
MOVAPS XMM2,XMM1
DIVSS XMM2,XMM0
DIVSS XMM2,XMM1
MOVSS XMM0,dword ptr [0x001030e0]
SUBSS XMM0,XMM2
LAB_00102353:
RET
|
float HeapGetFragmentation(void)
{
ulong uVar1;
int *piVar2;
int iVar3;
float fVar4;
fVar4 = 0.0;
if (segments != (int *)0x0 && heap_initialized != 0) {
iVar3 = 0;
uVar1 = 0;
piVar2 = segments;
do {
if (*piVar2 != 0) {
iVar3 = iVar3 + 1;
uVar1 = uVar1 + (long)piVar2[1] * 0x1000;
}
piVar2 = *(int **)(piVar2 + 2);
} while (piVar2 != (int *)0x0);
if (uVar1 != 0) {
fVar4 = DAT_001030e0 - ((float)uVar1 / (float)iVar3) / (float)uVar1;
}
}
return fVar4;
}
| |
30,099 | mysql_stmt_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x4d552
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x4e777
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x4d5b5
movl (%r15), %r15d
jmp 0x4d62b
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x2e0454(%rip), %rax # 0x32d9c0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x35110
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x2e0439(%rip), %rax # 0x32d9d0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x35110
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x4d62b
movb $0x0, 0x15(%r15)
js 0x4d5c2
movb 0x8(%r15), %al
jmp 0x4d626
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x2e03e0(%rip), %rax # 0x32d9c0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x35110
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x2e03c5(%rip), %rax # 0x32d9d0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x35110
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_close_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_4D552
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_4D5B5
mov r15d, [r15]
jmp loc_4D62B
loc_4D552:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_4D62B
loc_4D5B5:
mov byte ptr [r15+15h], 0
js short loc_4D5C2
mov al, [r15+8]
jmp short loc_4D626
loc_4D5C2:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_4D626:
mov [rbx], al
xor r15d, r15d
loc_4D62B:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_close_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0014d552
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0014e777
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0014d5b5
MOV R15D,dword ptr [R15]
JMP 0x0014d62b
LAB_0014d552:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x42d9c0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00135110
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x42d9d0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00135110
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x0014d62b
LAB_0014d5b5:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0014d5c2
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0014d626
LAB_0014d5c2:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x42d9c0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00135110
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x42d9d0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00135110
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0014d626:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_0014d62b:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_close_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0042da40,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0042da10,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.