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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
35,200 | nglog::LogSink::ToString[abi:cxx11](nglog::LogSeverity, char const*, int, nglog::LogMessageTime const&, char const*, unsigned long) | ng-log[P]ng-log/src/logging.cc | string LogSink::ToString(LogSeverity severity, const char* file, int line,
const LogMessageTime& time, const char* message,
size_t message_len) {
ostringstream stream;
stream.fill('0');
stream << LogSeverityNames[severity][0];
if (FLAGS_log_year_in_prefix) {
stream << setw(4) << 1900 + time.year();
}
stream << setw(2) << 1 + time.month() << setw(2) << time.day() << ' '
<< setw(2) << time.hour() << ':' << setw(2) << time.min() << ':'
<< setw(2) << time.sec() << '.' << setw(6) << time.usec() << ' '
<< setfill(' ') << setw(5) << std::this_thread::get_id()
<< setfill('0') << ' ' << file << ':' << line << "] ";
// A call to `write' is enclosed in parenthneses to prevent possible macro
// expansion. On Windows, `write' could be a macro defined for portability.
(stream.write)(message, static_cast<std::streamsize>(message_len));
return stream.str();
} | O1 | cpp | nglog::LogSink::ToString[abi:cxx11](nglog::LogSeverity, char const*, int, nglog::LogMessageTime const&, char const*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %r9, 0x8(%rsp)
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x7730
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r14
addq $0x10, %r14
cmpb $0x0, 0xe1(%r14)
jne 0xc408
movq %r14, %rdi
movl $0x20, %esi
callq 0x74f0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x30, 0xe0(%r14)
movl %r13d, %eax
leaq 0x24136(%rip), %rcx # 0x30550
movq (%rcx,%rax,8), %rax
movb (%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x75f0
leaq 0x26660(%rip), %rax # 0x32a9d
cmpb $0x1, (%rax)
jne 0xc466
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x20(%rsp,%rax)
movl $0x76c, %esi # imm = 0x76C
addl 0x14(%r12), %esi
callq 0x7930
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x20(%rsp,%rax)
movl 0x10(%r12), %esi
incl %esi
callq 0x7930
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl 0xc(%r12), %esi
movq %rax, %rdi
callq 0x7930
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x75f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl 0x8(%r12), %esi
movq %rax, %rdi
callq 0x7930
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x75f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl 0x4(%r12), %esi
movq %rax, %rdi
callq 0x7930
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x75f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movl (%r12), %esi
movq %rax, %rdi
callq 0x7930
leaq 0x7(%rsp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x75f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x6, 0x10(%rax,%rcx)
movq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x74e0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x75f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r12, %r13
addq %rax, %r13
cmpb $0x0, 0xe1(%r12,%rax)
jne 0xc5b7
movq %r13, %rdi
movl $0x20, %esi
callq 0x74f0
movb %al, 0xe0(%r13)
movb $0x1, 0xe1(%r13)
movb $0x20, 0xe0(%r13)
movq (%r12), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x10(%r12,%rax)
callq 0x7470
testq %rax, %rax
je 0xc5ea
movq %r12, %rdi
movq %rax, %rsi
callq 0x7360
movq %rax, %r12
jmp 0xc5fe
leaq 0x183db(%rip), %rsi # 0x249cc
movl $0x24, %edx
movq %r12, %rdi
callq 0x75f0
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %r14
cmpb $0x0, 0xe1(%r12,%rax)
jne 0xc631
movq %r14, %rdi
movl $0x20, %esi
callq 0x74f0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
movb $0x30, 0xe0(%r14)
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x75f0
movq %rax, %r12
testq %r15, %r15
je 0xc66e
movq %r15, %rdi
callq 0x7200
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x75f0
jmp 0xc689
movq (%r12), %rax
movq -0x18(%rax), %rax
movq %r12, %rdi
addq %rax, %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x7910
leaq 0x7(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x75f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x7930
leaq 0x178b2(%rip), %rsi # 0x23f61
movl $0x2, %edx
movq %rax, %rdi
callq 0x75f0
movq 0x1c0(%rsp), %rdx
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x76e0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7870
movq 0x24871(%rip), %rsi # 0x30f58
leaq 0x10(%rsp), %rdi
callq 0x7290
leaq 0x80(%rsp), %rdi
callq 0x7180
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x2483b(%rip), %rsi # 0x30f58
leaq 0x10(%rsp), %rdi
callq 0x7290
leaq 0x80(%rsp), %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x7950
| _ZN5nglog7LogSink8ToStringB5cxx11ENS_11LogSeverityEPKciRKNS_14LogMessageTimeES3_m:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 188h
mov [rsp+1B8h+var_1B0], r9
mov r12, r8
mov ebp, ecx
mov r15, rdx
mov r13d, esi
mov rbx, rdi
lea r14, [rsp+1B8h+var_1A8]
mov rdi, r14
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [r14]
mov rax, [rax-18h]
lea r14, [rsp+rax+1B8h+var_1B8]
add r14, 10h
cmp byte ptr [r14+0E1h], 0
jnz short loc_C408
mov rdi, r14
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r14+0E0h], al
mov byte ptr [r14+0E1h], 1
loc_C408:
mov byte ptr [r14+0E0h], 30h ; '0'
mov eax, r13d
lea rcx, _ZN5nglogL16LogSeverityNamesE; nglog::LogSeverityNames
mov rax, [rcx+rax*8]
mov al, [rax]
lea rsi, [rsp+1B8h+var_1B1]
mov [rsi], al
lea rdi, [rsp+1B8h+var_1A8]
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, _ZN3fLB24FLAGS_log_year_in_prefixE; fLB::FLAGS_log_year_in_prefix
cmp byte ptr [rax], 1
jnz short loc_C466
lea rdi, [rsp+1B8h+var_1A8]
mov rax, [rdi]
mov rax, [rax-18h]
mov [rsp+rax+1B8h+var_198], 4
mov esi, 76Ch
add esi, [r12+14h]
call __ZNSolsEi; std::ostream::operator<<(int)
loc_C466:
lea rdi, [rsp+1B8h+var_1A8]
mov rax, [rdi]
mov rax, [rax-18h]
mov [rsp+rax+1B8h+var_198], 2
mov esi, [r12+10h]
inc esi
call __ZNSolsEi; std::ostream::operator<<(int)
mov rcx, [rax]
mov rcx, [rcx-18h]
mov qword ptr [rax+rcx+10h], 2
mov esi, [r12+0Ch]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 20h ; ' '
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rcx, [rax]
mov rcx, [rcx-18h]
mov qword ptr [rax+rcx+10h], 2
mov esi, [r12+8]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 3Ah ; ':'
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rcx, [rax]
mov rcx, [rcx-18h]
mov qword ptr [rax+rcx+10h], 2
mov esi, [r12+4]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 3Ah ; ':'
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rcx, [rax]
mov rcx, [rcx-18h]
mov qword ptr [rax+rcx+10h], 2
mov esi, [r12]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 2Eh ; '.'
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rcx, [rax]
mov rcx, [rcx-18h]
mov qword ptr [rax+rcx+10h], 6
mov rsi, [r12+40h]
mov rdi, rax
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 20h ; ' '
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r12, rax
mov rax, [rax]
mov rax, [rax-18h]
mov r13, r12
add r13, rax
cmp byte ptr [r12+rax+0E1h], 0
jnz short loc_C5B7
mov rdi, r13
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r13+0E0h], al
mov byte ptr [r13+0E1h], 1
loc_C5B7:
mov byte ptr [r13+0E0h], 20h ; ' '
mov rax, [r12]
mov rax, [rax-18h]
mov qword ptr [r12+rax+10h], 5
call _pthread_self
test rax, rax
jz short loc_C5EA
mov rdi, r12
mov rsi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r12, rax
jmp short loc_C5FE
loc_C5EA:
lea rsi, aThreadIdOfANon; "thread::id of a non-executing thread"
mov edx, 24h ; '$'
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_C5FE:
mov rax, [r12]
mov rax, [rax-18h]
lea r14, [r12+rax]
cmp byte ptr [r12+rax+0E1h], 0
jnz short loc_C631
mov rdi, r14
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r14+0E0h], al
mov byte ptr [r14+0E1h], 1
loc_C631:
mov byte ptr [r14+0E0h], 30h ; '0'
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 20h ; ' '
mov edx, 1
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r12, rax
test r15, r15
jz short loc_C66E
mov rdi, r15
call _strlen
mov rdi, r12
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_C689
loc_C66E:
mov rax, [r12]
mov rax, [rax-18h]
mov rdi, r12
add rdi, rax
mov esi, [r12+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_C689:
lea rsi, [rsp+1B8h+var_1B1]
mov byte ptr [rsi], 3Ah ; ':'
mov edx, 1
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rax
mov esi, ebp
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aLog_0+4; "] "
mov edx, 2
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdx, [rsp+1B8h+arg_0]; __int64
lea rdi, [rsp+1B8h+var_1A8]; this
mov rsi, [rsp+1B8h+var_1B0]; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
lea rsi, [rsp+1B8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1B8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1B8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 188h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_78]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long nglog::LogSink::ToString[abi:cxx11](
long long a1,
int a2,
long long a3,
unsigned int a4,
unsigned int *a5,
char *a6,
long long a7)
{
long long v10; // rax
_BYTE *v11; // r14
_QWORD *v12; // rax
long long v13; // rax
_QWORD *v14; // rax
long long v15; // rax
_QWORD *v16; // rax
long long v17; // rax
_QWORD *v18; // rax
long long v19; // rax
_QWORD *v20; // rax
long long v21; // rax
_QWORD *v22; // r12
long long v23; // rax
char *v24; // r13
long long v25; // rax
char *v26; // r14
_QWORD *v27; // rax
_QWORD *v28; // r12
long long v29; // rax
long long v30; // rax
long long v31; // rax
char v33; // [rsp+7h] [rbp-1B1h] BYREF
char *v34; // [rsp+8h] [rbp-1B0h]
long long v35; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v36[104]; // [rsp+18h] [rbp-1A0h] BYREF
_BYTE v37[312]; // [rsp+80h] [rbp-138h] BYREF
v34 = a6;
std::ostringstream::basic_ostringstream(&v35);
v10 = *(_QWORD *)(v35 - 24);
v11 = &v36[v10 - 8];
if ( !v37[v10 + 113] )
{
v11[224] = std::ios::widen(&v36[v10 - 8], 32LL);
v11[225] = 1;
}
v11[224] = 48;
v33 = *nglog::LogSeverityNames[a2];
std::__ostream_insert<char,std::char_traits<char>>(&v35, &v33, 1LL);
if ( fLB::FLAGS_log_year_in_prefix == 1 )
{
*(_QWORD *)&v36[*(_QWORD *)(v35 - 24) + 8] = 4LL;
std::ostream::operator<<(&v35, a5[5] + 1900);
}
*(_QWORD *)&v36[*(_QWORD *)(v35 - 24) + 8] = 2LL;
v12 = (_QWORD *)std::ostream::operator<<(&v35, a5[4] + 1);
*(_QWORD *)((char *)v12 + *(_QWORD *)(*v12 - 24LL) + 16) = 2LL;
v13 = std::ostream::operator<<(v12, a5[3]);
v33 = 32;
v14 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v13, &v33, 1LL);
*(_QWORD *)((char *)v14 + *(_QWORD *)(*v14 - 24LL) + 16) = 2LL;
v15 = std::ostream::operator<<(v14, a5[2]);
v33 = 58;
v16 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v15, &v33, 1LL);
*(_QWORD *)((char *)v16 + *(_QWORD *)(*v16 - 24LL) + 16) = 2LL;
v17 = std::ostream::operator<<(v16, a5[1]);
v33 = 58;
v18 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v17, &v33, 1LL);
*(_QWORD *)((char *)v18 + *(_QWORD *)(*v18 - 24LL) + 16) = 2LL;
v19 = std::ostream::operator<<(v18, *a5);
v33 = 46;
v20 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v19, &v33, 1LL);
*(_QWORD *)((char *)v20 + *(_QWORD *)(*v20 - 24LL) + 16) = 6LL;
v21 = std::ostream::_M_insert<long>(v20, *((_QWORD *)a5 + 8));
v33 = 32;
v22 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v21, &v33, 1LL);
v23 = *(_QWORD *)(*v22 - 24LL);
v24 = (char *)v22 + v23;
if ( !*((_BYTE *)v22 + v23 + 225) )
{
v24[224] = std::ios::widen((char *)v22 + v23, 32LL);
v24[225] = 1;
}
v24[224] = 32;
*(_QWORD *)((char *)v22 + *(_QWORD *)(*v22 - 24LL) + 16) = 5LL;
if ( pthread_self() )
v22 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v22);
else
std::__ostream_insert<char,std::char_traits<char>>(v22, "thread::id of a non-executing thread", 36LL);
v25 = *(_QWORD *)(*v22 - 24LL);
v26 = (char *)v22 + v25;
if ( !*((_BYTE *)v22 + v25 + 225) )
{
v26[224] = std::ios::widen((char *)v22 + v25, 32LL);
v26[225] = 1;
}
v26[224] = 48;
v33 = 32;
v27 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v22, &v33, 1LL);
v28 = v27;
if ( a3 )
{
v29 = strlen(a3);
std::__ostream_insert<char,std::char_traits<char>>(v28, a3, v29);
}
else
{
std::ios::clear(
(char *)v27 + *(_QWORD *)(*v27 - 24LL),
*(_DWORD *)((char *)v27 + *(_QWORD *)(*v27 - 24LL) + 32) | 1u);
}
v33 = 58;
v30 = std::__ostream_insert<char,std::char_traits<char>>(v28, &v33, 1LL);
v31 = std::ostream::operator<<(v30, a4);
std::__ostream_insert<char,std::char_traits<char>>(v31, "] ", 2LL);
std::ostream::write((std::ostream *)&v35, v34, a7);
std::stringbuf::str(a1, v36);
std::ostringstream::~ostringstream(&v35, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v37);
return a1;
}
| ToString[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x188
MOV qword ptr [RSP + 0x8],R9
MOV R12,R8
MOV EBP,ECX
MOV R15,RDX
MOV R13D,ESI
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV RDI,R14
CALL 0x00107730
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
LEA R14,[RSP + RAX*0x1]
ADD R14,0x10
CMP byte ptr [R14 + 0xe1],0x0
JNZ 0x0010c408
LAB_0010c3ec:
MOV RDI,R14
MOV ESI,0x20
CALL 0x001074f0
MOV byte ptr [R14 + 0xe0],AL
MOV byte ptr [R14 + 0xe1],0x1
LAB_0010c408:
MOV byte ptr [R14 + 0xe0],0x30
MOV EAX,R13D
LEA RCX,[0x130550]
MOV RAX,qword ptr [RCX + RAX*0x8]
MOV AL,byte ptr [RAX]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LEA RDI,[RSP + 0x10]
MOV EDX,0x1
CALL 0x001075f0
LEA RAX,[0x132a9d]
CMP byte ptr [RAX],0x1
JNZ 0x0010c466
LEA RDI,[RSP + 0x10]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [RSP + RAX*0x1 + 0x20],0x4
MOV ESI,0x76c
ADD ESI,dword ptr [R12 + 0x14]
CALL 0x00107930
LAB_0010c466:
LEA RDI,[RSP + 0x10]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [RSP + RAX*0x1 + 0x20],0x2
MOV ESI,dword ptr [R12 + 0x10]
INC ESI
CALL 0x00107930
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x10],0x2
MOV ESI,dword ptr [R12 + 0xc]
MOV RDI,RAX
CALL 0x00107930
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x20
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001075f0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x10],0x2
MOV ESI,dword ptr [R12 + 0x8]
MOV RDI,RAX
CALL 0x00107930
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x3a
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001075f0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x10],0x2
MOV ESI,dword ptr [R12 + 0x4]
MOV RDI,RAX
CALL 0x00107930
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x3a
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001075f0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x10],0x2
MOV ESI,dword ptr [R12]
MOV RDI,RAX
CALL 0x00107930
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x2e
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001075f0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x10],0x6
MOV RSI,qword ptr [R12 + 0x40]
MOV RDI,RAX
CALL 0x001074e0
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x20
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001075f0
MOV R12,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV R13,R12
ADD R13,RAX
CMP byte ptr [R12 + RAX*0x1 + 0xe1],0x0
JNZ 0x0010c5b7
MOV RDI,R13
MOV ESI,0x20
CALL 0x001074f0
MOV byte ptr [R13 + 0xe0],AL
MOV byte ptr [R13 + 0xe1],0x1
LAB_0010c5b7:
MOV byte ptr [R13 + 0xe0],0x20
MOV RAX,qword ptr [R12]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R12 + RAX*0x1 + 0x10],0x5
CALL 0x00107470
TEST RAX,RAX
JZ 0x0010c5ea
MOV RDI,R12
MOV RSI,RAX
CALL 0x00107360
MOV R12,RAX
JMP 0x0010c5fe
LAB_0010c5ea:
LEA RSI,[0x1249cc]
MOV EDX,0x24
MOV RDI,R12
CALL 0x001075f0
LAB_0010c5fe:
MOV RAX,qword ptr [R12]
MOV RAX,qword ptr [RAX + -0x18]
LEA R14,[R12 + RAX*0x1]
CMP byte ptr [R12 + RAX*0x1 + 0xe1],0x0
JNZ 0x0010c631
MOV RDI,R14
MOV ESI,0x20
CALL 0x001074f0
MOV byte ptr [R14 + 0xe0],AL
MOV byte ptr [R14 + 0xe1],0x1
LAB_0010c631:
MOV byte ptr [R14 + 0xe0],0x30
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x20
MOV EDX,0x1
MOV RDI,R12
CALL 0x001075f0
MOV R12,RAX
TEST R15,R15
JZ 0x0010c66e
MOV RDI,R15
CALL 0x00107200
MOV RDI,R12
MOV RSI,R15
MOV RDX,RAX
CALL 0x001075f0
JMP 0x0010c689
LAB_0010c66e:
MOV RAX,qword ptr [R12]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R12
ADD RDI,RAX
MOV ESI,dword ptr [R12 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00107910
LAB_0010c689:
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],0x3a
MOV EDX,0x1
MOV RDI,R12
CALL 0x001075f0
MOV RDI,RAX
MOV ESI,EBP
CALL 0x00107930
LEA RSI,[0x123f61]
MOV EDX,0x2
MOV RDI,RAX
CALL 0x001075f0
MOV RDX,qword ptr [RSP + 0x1c0]
LEA RDI,[RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001076e0
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x00107870
LAB_0010c6e0:
MOV RSI,qword ptr [0x00130f58]
LEA RDI,[RSP + 0x10]
CALL 0x00107290
LEA RDI,[RSP + 0x80]
CALL 0x00107180
MOV RAX,RBX
ADD RSP,0x188
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::LogSink::ToString[abi:cxx11](nglog::LogSeverity, char const*, int, nglog::LogMessageTime
const&, char const*, unsigned long) */
int8
nglog::LogSink::ToString_abi_cxx11_
(int8 param_1,uint param_2,char *param_3,int param_4,int *param_5,long param_6)
{
long lVar1;
char cVar2;
ostream oVar3;
ostream *poVar4;
pthread_t pVar5;
size_t sVar6;
ostream *poVar7;
int1 auStack_1b8 [7];
char local_1b1;
long local_1b0;
long local_1a8 [2];
int8 auStack_198 [12];
ios_base local_138 [112];
char acStack_c8 [152];
local_1b0 = param_6;
std::__cxx11::ostringstream::ostringstream((ostringstream *)local_1a8);
lVar1 = *(long *)(local_1a8[0] + -0x18);
if (acStack_c8[lVar1 + 1] == '\0') {
/* try { // try from 0010c3ec to 0010c6df has its CatchHandler @ 0010c713 */
cVar2 = std::ios::widen((char)auStack_1b8 + (char)lVar1 + '\x10');
acStack_c8[lVar1] = cVar2;
acStack_c8[lVar1 + 1] = '\x01';
}
acStack_c8[lVar1] = '0';
local_1b1 = **(char **)(LogSeverityNames + (ulong)param_2 * 8);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_1a8,&local_1b1,1);
if (fLB::FLAGS_log_year_in_prefix == '\x01') {
*(int8 *)((long)auStack_198 + *(long *)(local_1a8[0] + -0x18)) = 4;
std::ostream::operator<<((ostream *)local_1a8,param_5[5] + 0x76c);
}
*(int8 *)((long)auStack_198 + *(long *)(local_1a8[0] + -0x18)) = 2;
poVar4 = (ostream *)std::ostream::operator<<((ostream *)local_1a8,param_5[4] + 1);
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 2;
poVar4 = (ostream *)std::ostream::operator<<(poVar4,param_5[3]);
local_1b1 = ' ';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 2;
poVar4 = (ostream *)std::ostream::operator<<(poVar4,param_5[2]);
local_1b1 = ':';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 2;
poVar4 = (ostream *)std::ostream::operator<<(poVar4,param_5[1]);
local_1b1 = ':';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 2;
poVar4 = (ostream *)std::ostream::operator<<(poVar4,*param_5);
local_1b1 = '.';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 6;
poVar4 = std::ostream::_M_insert<long>((long)poVar4);
local_1b1 = ' ';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
poVar7 = poVar4 + *(long *)(*(long *)poVar4 + -0x18);
if (poVar4[*(long *)(*(long *)poVar4 + -0x18) + 0xe1] == (ostream)0x0) {
oVar3 = (ostream)std::ios::widen((char)poVar7);
poVar7[0xe0] = oVar3;
poVar7[0xe1] = (ostream)0x1;
}
poVar7[0xe0] = (ostream)0x20;
*(int8 *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x10) = 5;
pVar5 = pthread_self();
if (pVar5 == 0) {
std::__ostream_insert<char,std::char_traits<char>>
(poVar4,"thread::id of a non-executing thread",0x24);
}
else {
poVar4 = std::ostream::_M_insert<unsigned_long>((ulong)poVar4);
}
poVar7 = poVar4 + *(long *)(*(long *)poVar4 + -0x18);
if (poVar4[*(long *)(*(long *)poVar4 + -0x18) + 0xe1] == (ostream)0x0) {
oVar3 = (ostream)std::ios::widen((char)poVar7);
poVar7[0xe0] = oVar3;
poVar7[0xe1] = (ostream)0x1;
}
poVar7[0xe0] = (ostream)0x30;
local_1b1 = ' ';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
if (param_3 == (char *)0x0) {
std::ios::clear(poVar4 + *(long *)(*(long *)poVar4 + -0x18),
*(uint *)(poVar4 + *(long *)(*(long *)poVar4 + -0x18) + 0x20) | 1);
}
else {
sVar6 = strlen(param_3);
std::__ostream_insert<char,std::char_traits<char>>(poVar4,param_3,sVar6);
}
local_1b1 = ':';
poVar4 = std::__ostream_insert<char,std::char_traits<char>>(poVar4,&local_1b1,1);
poVar4 = (ostream *)std::ostream::operator<<(poVar4,param_4);
std::__ostream_insert<char,std::char_traits<char>>(poVar4,"] ",2);
std::ostream::write((char *)local_1a8,local_1b0);
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream((ostringstream *)local_1a8);
std::ios_base::~ios_base(local_138);
return param_1;
}
| |
35,201 | blst_uint32_from_scalar | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c | void blst_uint32_from_scalar(unsigned int ret[8], const pow256 a)
{
const union {
long one;
char little;
} is_endian = { 1 };
size_t i;
if ((uptr_t)ret==(uptr_t)a && is_endian.little)
return;
for(i = 0; i < 8; i++) {
unsigned int w = (unsigned int)(*a++);
w |= (unsigned int)(*a++) << 8;
w |= (unsigned int)(*a++) << 16;
w |= (unsigned int)(*a++) << 24;
ret[i] = w;
}
} | O3 | c | blst_uint32_from_scalar:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
je 0x65a48
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x8, %rax
jne 0x65a39
popq %rbp
retq
| blst_uint32_from_scalar:
push rbp
mov rbp, rsp
cmp rdi, rsi
jz short loc_65A48
xor eax, eax
loc_65A39:
mov ecx, [rsi+rax*4]
mov [rdi+rax*4], ecx
inc rax
cmp rax, 8
jnz short loc_65A39
loc_65A48:
pop rbp
retn
| void blst_uint32_from_scalar(long long a1, long long a2)
{
long long i; // rax
if ( a1 != a2 )
{
for ( i = 0LL; i != 8; ++i )
*(_DWORD *)(a1 + 4 * i) = *(_DWORD *)(a2 + 4 * i);
}
}
| blst_uint32_from_scalar:
PUSH RBP
MOV RBP,RSP
CMP RDI,RSI
JZ 0x00165a48
XOR EAX,EAX
LAB_00165a39:
MOV ECX,dword ptr [RSI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],ECX
INC RAX
CMP RAX,0x8
JNZ 0x00165a39
LAB_00165a48:
POP RBP
RET
|
void blst_uint32_from_scalar(long param_1,long param_2)
{
long lVar1;
if (param_1 != param_2) {
lVar1 = 0;
do {
*(int4 *)(param_1 + lVar1 * 4) = *(int4 *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != 8);
}
return;
}
| |
35,202 | testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | AlayaLite/build_O3/_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 << "]]>";
} | O3 | cpp | testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1fe0b(%rip), %rsi # 0x8763f
movl $0x9, %edx
callq 0x11b90
leaq 0x1fded(%rip), %rsi # 0x87632
movq %r14, %rdi
callq 0x115a0
testq %rax, %rax
je 0x678a0
movq %rax, %r13
leaq 0x1fdda(%rip), %r15 # 0x87636
leaq 0x1fdcf(%rip), %r12 # 0x87632
movq %r13, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x115f0
movl $0x12, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11b90
movq %r13, %r14
addq $0x3, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x115a0
movq %rax, %r13
testq %rax, %rax
jne 0x67863
jmp 0x678a5
testq %r14, %r14
je 0x678d8
movq %r14, %rdi
callq 0x114d0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x11b90
leaq 0x1fd70(%rip), %rsi # 0x87632
movl $0x3, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11b90
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x11d40
jmp 0x678bb
nop
| _ZN7testing8internal24XmlUnitTestResultPrinter21OutputXmlCDataSectionEPSoPKc:
push r15
push r14
push r13
push r12
push rbx
mov r14, rsi
mov rbx, rdi
lea rsi, aGtCdata+9; "<![CDATA["
mov edx, 9
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_87632; "]]>"
mov rdi, r14
call _strstr
test rax, rax
jz short loc_678A0
mov r13, rax
lea r15, aGtCdata; "]]>]]><![CDATA["
lea r12, asc_87632; "]]>"
loc_67863:
mov rdx, r13
sub rdx, r14; __int64
mov rdi, rbx; this
mov rsi, r14; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov edx, 12h
mov rdi, rbx
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, r13
add r14, 3
mov rdi, r14
mov rsi, r12
call _strstr
mov r13, rax
test rax, rax
jnz short loc_67863
jmp short loc_678A5
loc_678A0:
test r14, r14
jz short loc_678D8
loc_678A5:
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_678BB:
lea rsi, asc_87632; "]]>"
mov edx, 3
mov rdi, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_678D8:
mov rax, [rbx]
mov rax, [rax-18h]
lea rdi, [rbx+rax]
mov esi, [rbx+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
jmp short loc_678BB
| long long testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(
testing::internal::XmlUnitTestResultPrinter *this,
std::ostream *a2,
const char *a3)
{
const char *v3; // r14
long long v4; // rax
long long v5; // r13
long long v6; // rax
v3 = (const char *)a2;
std::__ostream_insert<char,std::char_traits<char>>(this, "<![CDATA[", 9LL);
v4 = strstr(a2, "]]>");
if ( v4 )
{
v5 = v4;
do
{
std::ostream::write(this, v3, v5 - (_QWORD)v3);
std::__ostream_insert<char,std::char_traits<char>>(this, "]]>]]><![CDATA[", 18LL);
v3 = (const char *)(v5 + 3);
v5 = strstr(v5 + 3, "]]>");
}
while ( v5 );
}
else if ( !a2 )
{
std::ios::clear(
(char *)this + *(_QWORD *)(*(_QWORD *)this - 24LL),
*(_DWORD *)((char *)this + *(_QWORD *)(*(_QWORD *)this - 24LL) + 32) | 1u);
return std::__ostream_insert<char,std::char_traits<char>>(this, "]]>", 3LL);
}
v6 = strlen(v3);
std::__ostream_insert<char,std::char_traits<char>>(this, v3, v6);
return std::__ostream_insert<char,std::char_traits<char>>(this, "]]>", 3LL);
}
| OutputXmlCDataSection:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x18763f]
MOV EDX,0x9
CALL 0x00111b90
LEA RSI,[0x187632]
MOV RDI,R14
CALL 0x001115a0
TEST RAX,RAX
JZ 0x001678a0
MOV R13,RAX
LEA R15,[0x187636]
LEA R12,[0x187632]
LAB_00167863:
MOV RDX,R13
SUB RDX,R14
MOV RDI,RBX
MOV RSI,R14
CALL 0x001115f0
MOV EDX,0x12
MOV RDI,RBX
MOV RSI,R15
CALL 0x00111b90
MOV R14,R13
ADD R14,0x3
MOV RDI,R14
MOV RSI,R12
CALL 0x001115a0
MOV R13,RAX
TEST RAX,RAX
JNZ 0x00167863
JMP 0x001678a5
LAB_001678a0:
TEST R14,R14
JZ 0x001678d8
LAB_001678a5:
MOV RDI,R14
CALL 0x001114d0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x00111b90
LAB_001678bb:
LEA RSI,[0x187632]
MOV EDX,0x3
MOV RDI,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00111b90
LAB_001678d8:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RBX + RAX*0x1]
MOV ESI,dword ptr [RBX + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00111d40
JMP 0x001678bb
|
/* testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) */
void testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection
(ostream *param_1,char *param_2)
{
char *pcVar1;
size_t sVar2;
std::__ostream_insert<char,std::char_traits<char>>(param_1,"<![CDATA[",9);
pcVar1 = strstr(param_2,"]]>");
if (pcVar1 == (char *)0x0) {
if (param_2 == (char *)0x0) {
std::ios::clear(param_1 + *(long *)(*(long *)param_1 + -0x18),
*(uint *)(param_1 + *(long *)(*(long *)param_1 + -0x18) + 0x20) | 1);
goto LAB_001678bb;
}
}
else {
do {
std::ostream::write((char *)param_1,(long)param_2);
std::__ostream_insert<char,std::char_traits<char>>(param_1,"]]>]]><![CDATA[",0x12);
param_2 = pcVar1 + 3;
pcVar1 = strstr(param_2,"]]>");
} while (pcVar1 != (char *)0x0);
}
sVar2 = strlen(param_2);
std::__ostream_insert<char,std::char_traits<char>>(param_1,param_2,sVar2);
LAB_001678bb:
std::__ostream_insert<char,std::char_traits<char>>(param_1,"]]>",3);
return;
}
| |
35,203 | inline_mysql_file_sync | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_sync(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File fd, myf flags)
{
int result= 0;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, fd, PSI_FILE_SYNC);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_sync(fd, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_sync(fd, flags);
return result;
} | O0 | c | inline_mysql_file_sync:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x276ce1(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x10, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x48445
leaq 0x276c9e(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5050
movl %eax, -0x24(%rbp)
leaq 0x276c6f(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4845a
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5050
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_sync_2:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 10h
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_48445
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_30]
xor ecx, ecx
mov esi, ecx
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_4845A
loc_48445:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_4845A:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_sync_2(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = 0;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 16LL);
if ( v6 )
{
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v6, 0LL, v11, v10);
v7 = my_sync(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[67])(v6, 0LL);
}
else
{
return (unsigned int)my_sync(v9, v8);
}
return v7;
}
| inline_mysql_file_sync:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x10
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00148445
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR ESI,ESI
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5050
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014845a
LAB_00148445:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5050
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014845a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_sync(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_2c = 0;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,0x10);
if (local_38 == 0) {
local_c = my_sync(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x210))(local_38,0,local_18,local_1c);
local_2c = my_sync(local_20,local_28);
(**(code **)(PSI_server + 0x218))(local_38,0);
local_c = local_2c;
}
return local_c;
}
| |
35,204 | my_strnncollsp_simple | eloqsql/strings/ctype-simple.c | int my_strnncollsp_simple(CHARSET_INFO * cs, const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *map= cs->sort_order, *end;
size_t length;
int res;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (map[*a++] != map[*b++])
return ((int) map[a[-1]] - (int) map[b[-1]]);
}
res= 0;
if (a_length != b_length)
{
int swap= 1;
/*
Check the next not space character of the longer key. If it's < ' ',
then it's smaller than the other key.
*/
if (a_length < b_length)
{
/* put shorter key in s */
a_length= b_length;
a= b;
swap= -1; /* swap sign of result */
res= -res;
}
for (end= a + a_length-length; a < end ; a++)
{
if (map[*a] != map[' '])
return (map[*a] < map[' ']) ? -swap : swap;
}
}
return res;
} | O0 | c | my_strnncollsp_simple:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x119b10
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x119b18
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x48(%rbp)
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x119b99
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x119b97
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl -0x1(%rdx), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x119c63
jmp 0x119b2b
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x119c5d
movl $0x1, -0x50(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x119bde
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x119c5b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
je 0x119c4b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x119c3d
xorl %eax, %eax
subl -0x50(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x119c43
movl -0x50(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x119c63
jmp 0x119c4d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x119bf3
jmp 0x119c5d
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_strnncollsp_simple:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_119B10
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
jmp short loc_119B18
loc_119B10:
mov rax, [rbp+var_30]
mov [rbp+var_60], rax
loc_119B18:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_60]
mov [rbp+var_48], rcx
add rax, rcx
mov [rbp+var_40], rax
loc_119B2B:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb short loc_119B99
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_28]
mov rsi, rdx
add rsi, 1
mov [rbp+var_28], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_119B97
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_28]
movzx edx, byte ptr [rdx-1]
movzx ecx, byte ptr [rcx+rdx]
sub eax, ecx
mov [rbp+var_4], eax
jmp loc_119C63
loc_119B97:
jmp short loc_119B2B
loc_119B99:
mov [rbp+var_4C], 0
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jz loc_119C5D
mov [rbp+var_50], 1
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_119BDE
mov rax, [rbp+var_30]
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov [rbp+var_50], 0FFFFFFFFh
xor eax, eax
sub eax, [rbp+var_4C]
mov [rbp+var_4C], eax
loc_119BDE:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_48]
add rax, rcx
mov [rbp+var_40], rax
loc_119BF3:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb short loc_119C5B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+20h]
cmp eax, ecx
jz short loc_119C4B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+20h]
cmp eax, ecx
jge short loc_119C3D
xor eax, eax
sub eax, [rbp+var_50]
mov [rbp+var_64], eax
jmp short loc_119C43
loc_119C3D:
mov eax, [rbp+var_50]
mov [rbp+var_64], eax
loc_119C43:
mov eax, [rbp+var_64]
mov [rbp+var_4], eax
jmp short loc_119C63
loc_119C4B:
jmp short $+2
loc_119C4D:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_119BF3
loc_119C5B:
jmp short $+2
loc_119C5D:
mov eax, [rbp+var_4C]
mov [rbp+var_4], eax
loc_119C63:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_strnncollsp_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned __int8 *v5; // rcx
unsigned __int8 *v6; // rdx
unsigned long long v9; // [rsp+4h] [rbp-60h]
unsigned int v10; // [rsp+14h] [rbp-50h]
unsigned __int8 *v11; // [rsp+24h] [rbp-40h]
long long v12; // [rsp+2Ch] [rbp-38h]
unsigned long long v14; // [rsp+44h] [rbp-20h]
unsigned __int8 *v15; // [rsp+4Ch] [rbp-18h]
v15 = a2;
v14 = a3;
v12 = *(_QWORD *)(a1 + 88);
if ( a3 >= a5 )
v9 = a5;
else
v9 = a3;
while ( v15 < &a2[v9] )
{
v5 = v15++;
v6 = a4++;
if ( *(unsigned __int8 *)(v12 + *v5) != *(unsigned __int8 *)(v12 + *v6) )
return (unsigned int)(*(unsigned __int8 *)(v12 + *(v15 - 1)) - *(unsigned __int8 *)(v12 + *(a4 - 1)));
}
if ( v14 != a5 )
{
v10 = 1;
if ( v14 < a5 )
{
v14 = a5;
v15 = a4;
v10 = -1;
}
v11 = &v15[v14 - v9];
while ( v15 < v11 )
{
if ( *(unsigned __int8 *)(v12 + *v15) != *(unsigned __int8 *)(v12 + 32) )
{
if ( *(unsigned __int8 *)(v12 + *v15) >= (int)*(unsigned __int8 *)(v12 + 32) )
return v10;
else
return -v10;
}
++v15;
}
}
return 0;
}
| |||
35,205 | my_strnncollsp_simple | eloqsql/strings/ctype-simple.c | int my_strnncollsp_simple(CHARSET_INFO * cs, const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *map= cs->sort_order, *end;
size_t length;
int res;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (map[*a++] != map[*b++])
return ((int) map[a[-1]] - (int) map[b[-1]]);
}
res= 0;
if (a_length != b_length)
{
int swap= 1;
/*
Check the next not space character of the longer key. If it's < ' ',
then it's smaller than the other key.
*/
if (a_length < b_length)
{
/* put shorter key in s */
a_length= b_length;
a= b;
swap= -1; /* swap sign of result */
res= -res;
}
for (end= a + a_length-length; a < end ; a++)
{
if (map[*a] != map[' '])
return (map[*a] < map[' ']) ? -swap : swap;
}
}
return res;
} | O3 | c | my_strnncollsp_simple:
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
cmpq %r8, %rdx
movq %r8, %r9
cmovbq %rdx, %r9
leaq (%rsi,%r9), %r10
cmpq %r10, %rsi
jae 0xb4ed5
movzbl (%rsi), %eax
incq %rsi
movzbl (%rdi,%rax), %eax
movzbl (%rcx), %r11d
incq %rcx
movzbl (%rdi,%r11), %r11d
cmpb %r11b, %al
je 0xb4eb0
subl %r11d, %eax
jmp 0xb4f2b
cmpq %r8, %rdx
jne 0xb4ede
xorl %eax, %eax
jmp 0xb4f2b
xorl %eax, %eax
cmpq %r8, %rdx
cmovaq %rdx, %r8
cmovbq %rcx, %rsi
movl $0x0, %ecx
sbbl %ecx, %ecx
leaq (%rsi,%r8), %rdx
subq %r9, %rdx
cmpq %rdx, %rsi
jae 0xb4f2b
orl $0x1, %ecx
movb 0x20(%rdi), %dl
subq %r9, %r8
xorl %eax, %eax
movzbl (%rsi,%rax), %r9d
movb (%rdi,%r9), %r9b
cmpb %dl, %r9b
jne 0xb4f21
incq %rax
cmpq %rax, %r8
jne 0xb4f09
jmp 0xb4eda
movl %ecx, %eax
negl %eax
cmpb %dl, %r9b
cmovael %ecx, %eax
popq %rbp
retq
| my_strnncollsp_simple:
push rbp
mov rbp, rsp
mov rdi, [rdi+58h]
cmp rdx, r8
mov r9, r8
cmovb r9, rdx
lea r10, [rsi+r9]
loc_B4EB0:
cmp rsi, r10
jnb short loc_B4ED5
movzx eax, byte ptr [rsi]
inc rsi
movzx eax, byte ptr [rdi+rax]
movzx r11d, byte ptr [rcx]
inc rcx
movzx r11d, byte ptr [rdi+r11]
cmp al, r11b
jz short loc_B4EB0
sub eax, r11d
jmp short loc_B4F2B
loc_B4ED5:
cmp rdx, r8
jnz short loc_B4EDE
loc_B4EDA:
xor eax, eax
jmp short loc_B4F2B
loc_B4EDE:
xor eax, eax
cmp rdx, r8
cmova r8, rdx
cmovb rsi, rcx
mov ecx, 0
sbb ecx, ecx
lea rdx, [rsi+r8]
sub rdx, r9
cmp rsi, rdx
jnb short loc_B4F2B
or ecx, 1
mov dl, [rdi+20h]
sub r8, r9
xor eax, eax
loc_B4F09:
movzx r9d, byte ptr [rsi+rax]
mov r9b, [rdi+r9]
cmp r9b, dl
jnz short loc_B4F21
inc rax
cmp r8, rax
jnz short loc_B4F09
jmp short loc_B4EDA
loc_B4F21:
mov eax, ecx
neg eax
cmp r9b, dl
cmovnb eax, ecx
loc_B4F2B:
pop rbp
retn
| long long my_strnncollsp_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
long long v5; // rdi
unsigned long long v6; // r9
unsigned __int8 *v7; // r10
long long v8; // rax
int v9; // eax
long long v10; // r11
int v11; // r11d
long long result; // rax
bool v13; // cf
unsigned int v14; // ecx
unsigned __int8 v15; // dl
unsigned long long v16; // r8
long long v17; // rax
unsigned __int8 v18; // r9
v5 = *(_QWORD *)(a1 + 88);
v6 = a5;
if ( a3 < a5 )
v6 = a3;
v7 = &a2[v6];
while ( a2 < v7 )
{
v8 = *a2++;
v9 = *(unsigned __int8 *)(v5 + v8);
v10 = *a4++;
v11 = *(unsigned __int8 *)(v5 + v10);
if ( (_BYTE)v9 != (_BYTE)v11 )
return (unsigned int)(v9 - v11);
}
if ( a3 == a5 )
return 0LL;
result = 0LL;
v13 = a3 < a5;
if ( a3 > a5 )
a5 = a3;
if ( v13 )
a2 = a4;
if ( a2 < &a2[a5 - v6] )
{
v14 = v13 ? -1 : 1;
v15 = *(_BYTE *)(v5 + 32);
v16 = a5 - v6;
v17 = 0LL;
while ( 1 )
{
v18 = *(_BYTE *)(v5 + a2[v17]);
if ( v18 != v15 )
break;
if ( v16 == ++v17 )
return 0LL;
}
result = -v14;
if ( v18 >= v15 )
return v14;
}
return result;
}
| my_strnncollsp_simple:
PUSH RBP
MOV RBP,RSP
MOV RDI,qword ptr [RDI + 0x58]
CMP RDX,R8
MOV R9,R8
CMOVC R9,RDX
LEA R10,[RSI + R9*0x1]
LAB_001b4eb0:
CMP RSI,R10
JNC 0x001b4ed5
MOVZX EAX,byte ptr [RSI]
INC RSI
MOVZX EAX,byte ptr [RDI + RAX*0x1]
MOVZX R11D,byte ptr [RCX]
INC RCX
MOVZX R11D,byte ptr [RDI + R11*0x1]
CMP AL,R11B
JZ 0x001b4eb0
SUB EAX,R11D
JMP 0x001b4f2b
LAB_001b4ed5:
CMP RDX,R8
JNZ 0x001b4ede
LAB_001b4eda:
XOR EAX,EAX
JMP 0x001b4f2b
LAB_001b4ede:
XOR EAX,EAX
CMP RDX,R8
CMOVA R8,RDX
CMOVC RSI,RCX
MOV ECX,0x0
SBB ECX,ECX
LEA RDX,[RSI + R8*0x1]
SUB RDX,R9
CMP RSI,RDX
JNC 0x001b4f2b
OR ECX,0x1
MOV DL,byte ptr [RDI + 0x20]
SUB R8,R9
XOR EAX,EAX
LAB_001b4f09:
MOVZX R9D,byte ptr [RSI + RAX*0x1]
MOV R9B,byte ptr [RDI + R9*0x1]
CMP R9B,DL
JNZ 0x001b4f21
INC RAX
CMP R8,RAX
JNZ 0x001b4f09
JMP 0x001b4eda
LAB_001b4f21:
MOV EAX,ECX
NEG EAX
CMP R9B,DL
CMOVNC EAX,ECX
LAB_001b4f2b:
POP RBP
RET
|
uint my_strnncollsp_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
lVar4 = *(long *)(param_1 + 0x58);
uVar8 = param_5;
if (param_3 < param_5) {
uVar8 = param_3;
}
pbVar1 = param_2 + uVar8;
while (param_2 < pbVar1) {
bVar2 = *param_2;
param_2 = param_2 + 1;
bVar3 = *param_4;
param_4 = param_4 + 1;
if (*(byte *)(lVar4 + (ulong)bVar2) != *(byte *)(lVar4 + (ulong)bVar3)) {
return (uint)*(byte *)(lVar4 + (ulong)bVar2) - (uint)*(byte *)(lVar4 + (ulong)bVar3);
}
}
if (param_3 != param_5) {
uVar7 = param_5;
if (param_5 < param_3) {
uVar7 = param_3;
}
if (param_3 < param_5) {
param_2 = param_4;
}
if (param_2 + (uVar7 - uVar8) <= param_2) {
return 0;
}
uVar6 = -(uint)(param_3 < param_5) | 1;
lVar5 = 0;
do {
if (*(byte *)(lVar4 + (ulong)param_2[lVar5]) != *(byte *)(lVar4 + 0x20)) {
if (*(byte *)(lVar4 + (ulong)param_2[lVar5]) < *(byte *)(lVar4 + 0x20)) {
return -uVar6;
}
return uVar6;
}
lVar5 = lVar5 + 1;
} while (uVar7 - uVar8 != lVar5);
}
return 0;
}
| |
35,206 | my_wc_mb_sjis | eloqsql/strings/ctype-sjis.c | static int
my_wc_mb_sjis(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (wc == 0x5c)
{
/*
Special case when converting from Unicode to SJIS:
U+005C -> [81][5F] FULL WIDTH REVERSE SOLIDUS
*/
code= MB2(0x815F);
goto mb;
}
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc; /* ASCII */
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_sjis[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
mb:
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208 */
return 2;
} | O3 | c | my_wc_mb_sjis:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %esi
jg 0xb6a06
movl $0x815f, %edi # imm = 0x815F
cmpq $0x5c, %rsi
je 0xb6a3c
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb6a56
movb %sil, (%rdx)
jmp 0xb6a35
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0xb6a56
leaq 0x18f618(%rip), %rdi # 0x246030
movzwl (%rdi,%rsi,2), %edi
testl %edi, %edi
je 0xb6a56
cmpl $0xff, %edi
ja 0xb6a3c
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb6a56
movb %dil, (%rdx)
movl $0x1, %eax
jmp 0xb6a56
leaq 0x2(%rdx), %rsi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rsi
ja 0xb6a56
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
popq %rbp
retq
| my_wc_mb_sjis:
push rbp
mov rbp, rsp
cmp esi, 7Fh
jg short loc_B6A06
mov edi, 815Fh
cmp rsi, 5Ch ; '\'
jz short loc_B6A3C
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_B6A56
mov [rdx], sil
jmp short loc_B6A35
loc_B6A06:
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_B6A56
lea rdi, unicode_to_sjis
movzx edi, word ptr [rdi+rsi*2]
test edi, edi
jz short loc_B6A56
cmp edi, 0FFh
ja short loc_B6A3C
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_B6A56
mov [rdx], dil
loc_B6A35:
mov eax, 1
jmp short loc_B6A56
loc_B6A3C:
lea rsi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rsi, rcx
ja short loc_B6A56
rol di, 8
mov [rdx], di
mov eax, 2
loc_B6A56:
pop rbp
retn
| long long my_wc_mb_sjis(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned int v4; // edi
long long result; // rax
if ( (int)a2 <= 127 )
{
LOWORD(v4) = -32417;
if ( a2 != 92 )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = a2;
return 1LL;
}
LABEL_11:
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v4, 8);
return 2LL;
}
return result;
}
result = 0LL;
if ( a2 <= 0xFFFF )
{
v4 = unicode_to_sjis[a2];
if ( unicode_to_sjis[a2] )
{
if ( v4 <= 0xFF )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = v4;
return 1LL;
}
goto LABEL_11;
}
}
return result;
}
| my_wc_mb_sjis:
PUSH RBP
MOV RBP,RSP
CMP ESI,0x7f
JG 0x001b6a06
MOV EDI,0x815f
CMP RSI,0x5c
JZ 0x001b6a3c
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b6a56
MOV byte ptr [RDX],SIL
JMP 0x001b6a35
LAB_001b6a06:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001b6a56
LEA RDI,[0x346030]
MOVZX EDI,word ptr [RDI + RSI*0x2]
TEST EDI,EDI
JZ 0x001b6a56
CMP EDI,0xff
JA 0x001b6a3c
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b6a56
MOV byte ptr [RDX],DIL
LAB_001b6a35:
MOV EAX,0x1
JMP 0x001b6a56
LAB_001b6a3c:
LEA RSI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RSI,RCX
JA 0x001b6a56
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
LAB_001b6a56:
POP RBP
RET
|
int8 my_wc_mb_sjis(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
if ((int)param_2 < 0x80) {
uVar1 = 0x815f;
if (param_2 == 0x5c) {
LAB_001b6a3c:
if (param_4 < param_3 + 1) {
return 0xffffff9a;
}
*param_3 = uVar1 << 8 | uVar1 >> 8;
return 2;
}
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)param_2;
}
else {
if (0xffff < param_2) {
return 0;
}
uVar1 = *(ushort *)(unicode_to_sjis + param_2 * 2);
if (uVar1 == 0) {
return 0;
}
if (0xff < uVar1) goto LAB_001b6a3c;
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)uVar1;
}
return 1;
}
| |
35,207 | minja::Parser::unexpected(minja::TemplateToken const&) const | monkey531[P]llama/common/minja.hpp | std::runtime_error unexpected(const TemplateToken & token) const {
return std::runtime_error("Unexpected " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
} | O2 | cpp | minja::Parser::unexpected(minja::TemplateToken const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x8ecc8
leaq 0x43a4a(%rip), %rsi # 0xd22e0
leaq 0x28(%rsp), %rdi
movq %r12, %rdx
callq 0x74aaa
movq (%r15), %rsi
movq 0x20(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x73fde
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6117f
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x27450
leaq 0x48(%rsp), %rdi
callq 0x27998
leaq 0x8(%rsp), %rdi
callq 0x27998
leaq 0x28(%rsp), %rdi
callq 0x27998
leaq 0x68(%rsp), %rdi
callq 0x27998
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x27998
jmp 0x8e921
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27998
jmp 0x8e930
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27998
jmp 0x8e93f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x27998
movq %rbx, %rdi
callq 0x27660
| _ZNK5minja6Parser10unexpectedERKNS_13TemplateTokenE:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov esi, [rdx+8]
lea r12, [rsp+0A8h+var_40]
mov rdi, r12
call _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE; minja::TemplateToken::typeToString(minja::TemplateToken::Type)
lea rsi, aUnexpected_0; "Unexpected "
lea rdi, [rsp+0A8h+var_80]
mov rdx, r12
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov rsi, [r15]
mov rdx, [r14+20h]
lea rdi, [rsp+0A8h+var_A0]
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
lea rdi, [rsp+0A8h+var_60]
lea rsi, [rsp+0A8h+var_80]
lea rdx, [rsp+0A8h+var_A0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, [rsp+0A8h+var_60]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8E921
mov rbx, rax
loc_8E921:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8E930
mov rbx, rax
loc_8E930:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8E93F
mov rbx, rax
loc_8E93F:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::unexpected(minja::Parser *this, const minja::TemplateToken *a2, long long a3)
{
_QWORD v5[4]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v6[4]; // [rsp+28h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+48h] [rbp-60h] BYREF
_BYTE v8[64]; // [rsp+68h] [rbp-40h] BYREF
minja::TemplateToken::typeToString[abi:cxx11](v8, *(unsigned int *)(a3 + 8));
std::operator+<char>((long long)v6, (long long)"Unexpected ", (long long)v8);
minja::error_location_suffix((long long)v5, *(_QWORD *)a2, *(_QWORD *)(a3 + 32));
std::operator+<char>((long long)v7, v6, v5);
std::runtime_error::runtime_error(this, v7);
std::string::~string(v7);
std::string::~string(v5);
std::string::~string(v6);
std::string::~string(v8);
return this;
}
| unexpected:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RDX + 0x8]
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x0018ecc8
LAB_0018e88f:
LEA RSI,[0x1d22e0]
LEA RDI,[RSP + 0x28]
MOV RDX,R12
CALL 0x00174aaa
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R14 + 0x20]
LAB_0018e8aa:
LEA RDI,[RSP + 0x8]
CALL 0x00173fde
LAB_0018e8b4:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x0016117f
LAB_0018e8c8:
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x00127450
LAB_0018e8d5:
LEA RDI,[RSP + 0x48]
CALL 0x00127998
LEA RDI,[RSP + 0x8]
CALL 0x00127998
LEA RDI,[RSP + 0x28]
CALL 0x00127998
LEA RDI,[RSP + 0x68]
CALL 0x00127998
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Parser::unexpected(minja::TemplateToken const&) const */
TemplateToken * minja::Parser::unexpected(TemplateToken *param_1)
{
long in_RDX;
int8 *in_RSI;
minja local_a0 [32];
string local_80 [32];
string local_60 [32];
TemplateToken local_40 [32];
TemplateToken::typeToString_abi_cxx11_(local_40,*(int4 *)(in_RDX + 8));
/* try { // try from 0018e88f to 0018e8a2 has its CatchHandler @ 0018e93c */
std::operator+((char *)local_80,(string *)"Unexpected ");
/* try { // try from 0018e8aa to 0018e8b3 has its CatchHandler @ 0018e92d */
error_location_suffix(local_a0,(string *)*in_RSI,*(ulong *)(in_RDX + 0x20));
/* try { // try from 0018e8b4 to 0018e8c7 has its CatchHandler @ 0018e91e */
std::operator+(local_60,local_80);
/* try { // try from 0018e8c8 to 0018e8d4 has its CatchHandler @ 0018e90f */
std::runtime_error::runtime_error((runtime_error *)param_1,local_60);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string((string *)local_a0);
std::__cxx11::string::~string(local_80);
std::__cxx11::string::~string((string *)local_40);
return param_1;
}
| |
35,208 | minja::Parser::unexpected(minja::TemplateToken const&) const | monkey531[P]llama/common/minja.hpp | std::runtime_error unexpected(const TemplateToken & token) const {
return std::runtime_error("Unexpected " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
} | O3 | cpp | minja::Parser::unexpected(minja::TemplateToken const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0xbd4b6
leaq 0x594ac(%rip), %rcx # 0x1163f0
movl $0xb, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1ddf0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xbcf7e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xbcf86
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x20(%r14), %rdx
leaq 0x48(%rsp), %rdi
callq 0x9b54c
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0xbcfd1
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
cmpq %rdi, %rax
jbe 0xbcff4
leaq 0x58(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0xbcfef
movq 0x58(%rsp), %rdi
cmpq %rdi, %rax
jbe 0xbd000
leaq 0x28(%rsp), %rdi
callq 0x1d310
jmp 0xbd00e
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1ddf0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0xbd032
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xbd038
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e430
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd07d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd098
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xbd0af
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd0ca
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd0ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbd0ff
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd11f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbd11f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xbd13b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1dc50
jmp 0xbd13b
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbd156
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1dc50
movq %rbx, %rdi
callq 0x1e660
| _ZNK5minja6Parser10unexpectedERKNS_13TemplateTokenE:
push r15; int
push r14; int
push r12; int
push rbx; int
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov esi, [rdx+8]
lea r12, [rsp+0A8h+var_40]
mov rdi, r12
call _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE; minja::TemplateToken::typeToString(minja::TemplateToken::Type)
lea rcx, aUnexpected_0; "Unexpected "
mov r8d, 0Bh
mov rdi, r12
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r12, [rsp+0A8h+var_70]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h; int
cmp rdx, rcx
jz short loc_BCF7E
mov [rsp+0A8h+var_80], rdx
mov rdx, [rcx]
mov [rsp+0A8h+var_70], rdx
jmp short loc_BCF86
loc_BCF7E:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_BCF86:
mov rdx, [rax+8]
mov qword ptr [rsp+0A8h+var_78], rdx; int
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [r15]; int
mov rdx, [r14+20h]; int
lea rdi, [rsp+0A8h+var_60]; int
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
mov rcx, [rsp+0A8h+var_80]
mov r8, qword ptr [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_58]
lea rax, [rdx+r8]
mov edi, 0Fh
cmp rcx, r12
jz short loc_BCFD1
mov rdi, [rsp+0A8h+var_70]
loc_BCFD1:
mov rsi, qword ptr [rsp+0A8h+var_60]
cmp rax, rdi
jbe short loc_BCFF4
lea r9, [rsp+0A8h+var_50]
mov edi, 0Fh
cmp rsi, r9
jz short loc_BCFEF
mov rdi, [rsp+0A8h+var_50]
loc_BCFEF:
cmp rax, rdi
jbe short loc_BD000
loc_BCFF4:
lea rdi, [rsp+0A8h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_BD00E
loc_BD000:
lea rdi, [rsp+0A8h+var_60]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_BD00E:
lea rdx, [rsp+0A8h+var_90]
mov [rdx-10h], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_BD032
mov [rsp+0A8h+var_A0], rsi
mov rdx, [rcx]
mov [rsp+0A8h+var_90], rdx
jmp short loc_BD038
loc_BD032:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_BD038:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0A8h+var_98], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
lea rsi, [rsp+0A8h+var_A0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD07D
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BD07D:
lea rax, [rsp+0A8h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD098
mov rsi, [rsp+0A8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BD098:
mov rdi, [rsp+0A8h+var_80]; void *
cmp rdi, r12
jz short loc_BD0AF
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BD0AF:
lea rax, [rsp+0A8h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD0CA
mov rsi, [rsp+0A8h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BD0CA:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD0FF
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BD0FF
mov rbx, rax
loc_BD0FF:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD11F
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BD11F
mov rbx, rax
loc_BD11F:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_BD13B
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BD13B
mov rbx, rax
loc_BD13B:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_BD156
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BD156:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::unexpected(minja::Parser *this, const minja::TemplateToken *a2, long long a3)
{
long long v5; // rax
__int128 *v6; // rcx
unsigned long long v7; // rax
unsigned long long v8; // rdi
unsigned long long v9; // rdi
void **v10; // rax
__int128 *v11; // rcx
void *v13[2]; // [rsp+8h] [rbp-A0h] BYREF
__int128 v14; // [rsp+18h] [rbp-90h] BYREF
void *v15; // [rsp+28h] [rbp-80h] BYREF
int v16[2]; // [rsp+30h] [rbp-78h]
__int128 v17; // [rsp+38h] [rbp-70h] BYREF
int v18[2]; // [rsp+48h] [rbp-60h] BYREF
long long v19; // [rsp+50h] [rbp-58h]
_QWORD v20[2]; // [rsp+58h] [rbp-50h] BYREF
void *v21[2]; // [rsp+68h] [rbp-40h] BYREF
long long v22; // [rsp+78h] [rbp-30h] BYREF
minja::TemplateToken::typeToString[abi:cxx11](v21, *(unsigned int *)(a3 + 8));
v5 = std::string::replace(v21, 0LL, 0LL, "Unexpected ", 11LL);
v15 = &v17;
v6 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v17 = *v6;
}
else
{
v15 = *(void **)v5;
*(_QWORD *)&v17 = *(_QWORD *)v6;
}
*(_QWORD *)v16 = *(_QWORD *)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
minja::error_location_suffix((long long)v18, *(_QWORD *)a2, *(_QWORD *)(a3 + 32));
v7 = v19 + *(_QWORD *)v16;
v8 = 15LL;
if ( v15 != &v17 )
v8 = v17;
if ( v7 <= v8 )
goto LABEL_10;
v9 = 15LL;
if ( *(_QWORD **)v18 != v20 )
v9 = v20[0];
if ( v7 <= v9 )
v10 = (void **)std::string::replace(v18, 0LL, 0LL, v15, *(_QWORD *)v16);
else
LABEL_10:
v10 = (void **)std::string::_M_append(&v15, *(_QWORD *)v18, v19);
v13[0] = &v14;
v11 = (__int128 *)(v10 + 2);
if ( *v10 == v10 + 2 )
{
v14 = *v11;
}
else
{
v13[0] = *v10;
*(_QWORD *)&v14 = *(_QWORD *)v11;
}
v13[1] = v10[1];
*v10 = v11;
v10[1] = 0LL;
*(_BYTE *)v11 = 0;
std::runtime_error::runtime_error(this, v13);
if ( v13[0] != &v14 )
operator delete(v13[0], v14 + 1);
if ( *(_QWORD **)v18 != v20 )
operator delete(*(void **)v18, v20[0] + 1LL);
if ( v15 != &v17 )
operator delete(v15, v17 + 1);
if ( v21[0] != &v22 )
operator delete(v21[0], v22 + 1);
return this;
}
| unexpected:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RDX + 0x8]
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x001bd4b6
LAB_001bcf3d:
LEA RCX,[0x2163f0]
MOV R8D,0xb
MOV RDI,R12
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011ddf0
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001bcf7e
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x001bcf86
LAB_001bcf7e:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_001bcf86:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R14 + 0x20]
LAB_001bcfa5:
LEA RDI,[RSP + 0x48]
CALL 0x0019b54c
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x50]
LEA RAX,[RDX + R8*0x1]
MOV EDI,0xf
CMP RCX,R12
JZ 0x001bcfd1
MOV RDI,qword ptr [RSP + 0x38]
LAB_001bcfd1:
MOV RSI,qword ptr [RSP + 0x48]
CMP RAX,RDI
JBE 0x001bcff4
LEA R9,[RSP + 0x58]
MOV EDI,0xf
CMP RSI,R9
JZ 0x001bcfef
MOV RDI,qword ptr [RSP + 0x58]
LAB_001bcfef:
CMP RAX,RDI
JBE 0x001bd000
LAB_001bcff4:
LEA RDI,[RSP + 0x28]
CALL 0x0011d310
JMP 0x001bd00e
LAB_001bd000:
LEA RDI,[RSP + 0x48]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011ddf0
LAB_001bd00e:
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x001bd032
MOV qword ptr [RSP + 0x8],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001bd038
LAB_001bd032:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_001bd038:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_001bd055:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011e430
LAB_001bd062:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001bd07d
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011dc50
LAB_001bd07d:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001bd098
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011dc50
LAB_001bd098:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x001bd0af
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011dc50
LAB_001bd0af:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001bd0ca
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0011dc50
LAB_001bd0ca:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Parser::unexpected(minja::TemplateToken const&) const */
TemplateToken * minja::Parser::unexpected(TemplateToken *param_1)
{
long *plVar1;
int8 *puVar2;
ulong *puVar3;
long in_RDX;
int8 *in_RSI;
ulong uVar4;
long *local_a0;
int8 local_98;
long local_90;
int8 uStack_88;
ulong *local_80;
long local_78;
ulong local_70;
long lStack_68;
ulong *local_60;
long local_58;
ulong local_50 [2];
long *local_40 [2];
long local_30 [2];
TemplateToken::typeToString_abi_cxx11_((TemplateToken *)local_40);
/* try { // try from 001bcf3d to 001bcf55 has its CatchHandler @ 001bd138 */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,0x2163f0);
puVar3 = (ulong *)(plVar1 + 2);
if ((ulong *)*plVar1 == puVar3) {
local_70 = *puVar3;
lStack_68 = plVar1[3];
local_80 = &local_70;
}
else {
local_70 = *puVar3;
local_80 = (ulong *)*plVar1;
}
local_78 = plVar1[1];
*plVar1 = (long)puVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 001bcfa5 to 001bcfae has its CatchHandler @ 001bd11c */
error_location_suffix((minja *)&local_60,(string *)*in_RSI,*(ulong *)(in_RDX + 0x20));
uVar4 = 0xf;
if (local_80 != &local_70) {
uVar4 = local_70;
}
if (uVar4 < (ulong)(local_58 + local_78)) {
uVar4 = 0xf;
if (local_60 != local_50) {
uVar4 = local_50[0];
}
if ((ulong)(local_58 + local_78) <= uVar4) {
puVar2 = (int8 *)
std::__cxx11::string::replace((ulong)&local_60,0,(char *)0x0,(ulong)local_80);
goto LAB_001bd00e;
}
}
/* try { // try from 001bcff4 to 001bd00d has its CatchHandler @ 001bd0fc */
puVar2 = (int8 *)std::__cxx11::string::_M_append((char *)&local_80,(ulong)local_60);
LAB_001bd00e:
local_a0 = &local_90;
plVar1 = puVar2 + 2;
if ((long *)*puVar2 == plVar1) {
local_90 = *plVar1;
uStack_88 = puVar2[3];
}
else {
local_90 = *plVar1;
local_a0 = (long *)*puVar2;
}
local_98 = puVar2[1];
*puVar2 = plVar1;
puVar2[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 001bd055 to 001bd061 has its CatchHandler @ 001bd0dc */
std::runtime_error::runtime_error((runtime_error *)param_1,(string *)&local_a0);
if (local_a0 != &local_90) {
operator_delete(local_a0,local_90 + 1);
}
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
if (local_80 != &local_70) {
operator_delete(local_80,local_70 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return param_1;
}
| |
35,209 | my_wc_mb_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_wc_mb_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *r, uchar *e)
{
int count;
if (r >= e)
return MY_CS_TOOSMALL;
if (wc < 0x80)
count= 1;
else if (wc < 0x800)
count= 2;
else if (wc < 0x10000)
count= 3;
else if (wc < 0x200000)
count= 4;
else return MY_CS_ILUNI;
if (r + count > e)
return MY_CS_TOOSMALLN(count);
switch (count) {
case 4: r[3] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0x10000;
/* fall through */
case 3: r[2] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0x800;
/* fall through */
case 2: r[1] = (uchar) (0x80 | (wc & 0x3f)); wc = wc >> 6; wc |= 0xc0;
/* fall through */
case 1: r[0] = (uchar) wc;
}
return count;
} | O3 | c | my_wc_mb_utf8mb4:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xcbff4
movl $0x1, %edi
cmpq $0x80, %rsi
jb 0xcbf8d
movl $0x2, %edi
cmpq $0x800, %rsi # imm = 0x800
jb 0xcbf8d
movl $0x3, %edi
cmpq $0x10000, %rsi # imm = 0x10000
jb 0xcbf8d
xorl %eax, %eax
movl $0x4, %edi
cmpq $0x1fffff, %rsi # imm = 0x1FFFFF
ja 0xcbff4
movl %edi, %eax
addq %rdx, %rax
cmpq %rcx, %rax
jbe 0xcbfa0
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
subl %edi, %eax
jmp 0xcbff4
leal -0x1(%rdi), %eax
leaq 0x28ac06(%rip), %rcx # 0x356bb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rdx)
shrq $0x6, %rsi
orq $0x10000, %rsi # imm = 0x10000
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdx)
shrq $0x6, %rsi
orq $0x800, %rsi # imm = 0x800
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdx)
shrq $0x6, %rsi
orq $0xc0, %rsi
movb %sil, (%rdx)
movl %edi, %eax
popq %rbp
retq
| my_wc_mb_utf8mb4:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_CBFF4
mov edi, 1
cmp rsi, 80h
jb short loc_CBF8D
mov edi, 2
cmp rsi, 800h
jb short loc_CBF8D
mov edi, 3
cmp rsi, offset stru_10000
jb short loc_CBF8D
xor eax, eax
mov edi, 4
cmp rsi, offset unk_1FFFFF
ja short loc_CBFF4
loc_CBF8D:
mov eax, edi
add rax, rdx
cmp rax, rcx
jbe short loc_CBFA0
mov eax, 0FFFFFF9Ch
sub eax, edi
jmp short loc_CBFF4
loc_CBFA0:
lea eax, [rdi-1]
lea rcx, jpt_CBFB1
movsxd rax, ds:(jpt_CBFB1 - 356BB0h)[rcx+rax*4]; switch 4 cases
add rax, rcx
jmp rax; switch jump
loc_CBFB3:
mov eax, esi; jumptable 00000000000CBFB1 case 3
and al, 3Fh
or al, 80h
mov [rdx+3], al
shr rsi, 6
or rsi, 10000h
loc_CBFC7:
mov eax, esi; jumptable 00000000000CBFB1 case 2
and al, 3Fh
or al, 80h
mov [rdx+2], al
shr rsi, 6
or rsi, 800h
loc_CBFDB:
mov eax, esi; jumptable 00000000000CBFB1 case 1
and al, 3Fh
or al, 80h
mov [rdx+1], al
shr rsi, 6
or rsi, 0C0h
loc_CBFEF:
mov [rdx], sil; jumptable 00000000000CBFB1 case 0
mov eax, edi
loc_CBFF4:
pop rbp
retn
| long long my_wc_mb_utf8mb4(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
unsigned int v5; // edi
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = 1;
if ( a2 < 0x80
|| (v5 = 2, a2 < 0x800)
|| (v5 = 3, a2 < (unsigned long long)&stru_10000)
|| (result = 0LL, v5 = 4, a2 <= (unsigned long long)&unk_1FFFFF) )
{
if ( (unsigned long long)&a3[v5] <= a4 )
{
switch ( v5 )
{
case 1u:
goto LABEL_12;
case 2u:
goto LABEL_11;
case 3u:
goto LABEL_10;
case 4u:
a3[3] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0x10000;
LABEL_10:
a3[2] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0x800;
LABEL_11:
a3[1] = a2 & 0x3F | 0x80;
a2 = (a2 >> 6) | 0xC0;
LABEL_12:
*a3 = a2;
result = v5;
break;
}
}
else
{
return -100 - v5;
}
}
}
return result;
}
| my_wc_mb_utf8mb4:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001cbff4
MOV EDI,0x1
CMP RSI,0x80
JC 0x001cbf8d
MOV EDI,0x2
CMP RSI,0x800
JC 0x001cbf8d
MOV EDI,0x3
CMP RSI,0x10000
JC 0x001cbf8d
XOR EAX,EAX
MOV EDI,0x4
CMP RSI,0x1fffff
JA 0x001cbff4
LAB_001cbf8d:
MOV EAX,EDI
ADD RAX,RDX
CMP RAX,RCX
JBE 0x001cbfa0
MOV EAX,0xffffff9c
SUB EAX,EDI
JMP 0x001cbff4
LAB_001cbfa0:
LEA EAX,[RDI + -0x1]
LEA RCX,[0x456bb0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
LAB_001cbff4:
POP RBP
RET
|
ulong my_wc_mb_utf8mb4(int8 param_1,ulong param_2,ulong param_3,ulong param_4)
{
ulong uVar1;
long lVar2;
uVar1 = 0xffffff9b;
if (param_3 < param_4) {
lVar2 = 1;
if ((((0x7f < param_2) && (lVar2 = 2, 0x7ff < param_2)) && (lVar2 = 3, 0xffff < param_2)) &&
(lVar2 = 4, 0x1fffff < param_2)) {
return 0;
}
if (lVar2 + param_3 <= param_4) {
/* WARNING: Could not recover jumptable at 0x001cbfb1. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar1 = (*(code *)(&DAT_00456bb0 + *(int *)(&DAT_00456bb0 + (ulong)((int)lVar2 - 1) * 4)))();
return uVar1;
}
uVar1 = (ulong)(-(int)lVar2 - 100);
}
return uVar1;
}
| |
35,210 | run_plugin_auth | eloqsql/libmariadb/plugins/auth/my_auth.c | int run_plugin_auth(MYSQL *mysql, char *data, uint data_len,
const char *data_plugin, const char *db)
{
const char *auth_plugin_name= NULL;
auth_plugin_t *auth_plugin;
MCPVIO_EXT mpvio;
ulong pkt_length;
int res;
/* determine the default/initial plugin to use */
if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
{
if (mysql->options.extension && mysql->options.extension->default_auth)
auth_plugin_name= mysql->options.extension->default_auth;
else if (data_plugin)
auth_plugin_name= data_plugin;
}
if (!auth_plugin_name)
{
if (mysql->server_capabilities & CLIENT_PROTOCOL_41)
auth_plugin_name= native_password_plugin_name;
else
auth_plugin_name= "mysql_old_password";
}
if (!(auth_plugin= (auth_plugin_t*) mysql_client_find_plugin(mysql,
auth_plugin_name, MYSQL_CLIENT_AUTHENTICATION_PLUGIN)))
auth_plugin= &dummy_fallback_client_plugin;
mysql->net.last_errno= 0; /* just in case */
if (data_plugin && strcmp(data_plugin, auth_plugin_name))
{
/* data was prepared for a different plugin, so we don't
send any data */
data= 0;
data_len= 0;
}
mpvio.mysql_change_user= data_plugin == 0;
mpvio.cached_server_reply.pkt= (uchar*)data;
mpvio.cached_server_reply.pkt_len= data_len;
mpvio.read_packet= client_mpvio_read_packet;
mpvio.write_packet= client_mpvio_write_packet;
mpvio.info= client_mpvio_info;
mpvio.mysql= mysql;
mpvio.packets_read= mpvio.packets_written= 0;
mpvio.db= db;
retry:
mpvio.plugin= auth_plugin;
if (auth_plugin_name &&
mysql->options.extension &&
mysql->options.extension->restricted_auth)
{
if (!strstr(mysql->options.extension->restricted_auth, auth_plugin_name))
{
my_set_error(mysql, CR_PLUGIN_NOT_ALLOWED, SQLSTATE_UNKNOWN, 0, data_plugin);
return 1;
}
}
mysql->net.read_pos[0]= 0;
res= auth_plugin->authenticate_user((struct st_plugin_vio *)&mpvio, mysql);
if ((res == CR_ERROR && !mysql->net.buff) ||
(res > CR_OK && mysql->net.read_pos[0] != 254))
{
/*
the plugin returned an error. write it down in mysql,
unless the error code is CR_ERROR and mysql->net.last_errno
is already set (the plugin has done it)
*/
if (res > CR_ERROR)
my_set_error(mysql, res, SQLSTATE_UNKNOWN, 0);
else
if (!mysql->net.last_errno) {
my_set_error(mysql, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, 0);
}
return 1;
}
/* read the OK packet (or use the cached value in mysql->net.read_pos */
if (res == CR_OK)
pkt_length= ma_net_safe_read(mysql);
else /* res == CR_OK_HANDSHAKE_COMPLETE or an error */
pkt_length= mpvio.last_read_packet_len;
if (pkt_length == packet_error)
{
if (mysql->net.last_errno == CR_SERVER_LOST)
my_set_error(mysql, CR_SERVER_LOST, SQLSTATE_UNKNOWN,
ER(CR_SERVER_LOST_EXTENDED),
"reading authorization packet",
errno);
return 1;
}
if (mysql->net.read_pos[0] == 254)
{
/* The server asked to use a different authentication plugin */
if (pkt_length == 1)
{
/* old "use short scramble" packet */
auth_plugin_name= old_password_plugin_name;
mpvio.cached_server_reply.pkt= (uchar*)mysql->scramble_buff;
mpvio.cached_server_reply.pkt_len= SCRAMBLE_LENGTH + 1;
}
else
{
/* new "use different plugin" packet */
uint len;
auth_plugin_name= (char*)mysql->net.read_pos + 1;
len= (uint)strlen(auth_plugin_name); /* safe as ma_net_read always appends \0 */
mpvio.cached_server_reply.pkt_len= pkt_length - len - 2;
mpvio.cached_server_reply.pkt= mysql->net.read_pos + len + 2;
}
if (!(auth_plugin= (auth_plugin_t *) mysql_client_find_plugin(mysql,
auth_plugin_name, MYSQL_CLIENT_AUTHENTICATION_PLUGIN)))
auth_plugin= &dummy_fallback_client_plugin;
goto retry;
}
/*
net->read_pos[0] should always be 0 here if the server implements
the protocol correctly
*/
if (mysql->net.read_pos[0] == 0)
return ma_read_ok_packet(mysql, mysql->net.read_pos + 1, pkt_length);
return 1;
} | O0 | c | run_plugin_auth:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x370(%rax), %rax
andq $0x80000, %rax # imm = 0x80000
cmpq $0x0, %rax
je 0x3f905
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x3f8f2
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f8f2
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3f903
cmpq $0x0, -0x28(%rbp)
je 0x3f901
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3f903
jmp 0x3f905
cmpq $0x0, -0x38(%rbp)
jne 0x3f93d
movq -0x10(%rbp), %rax
movq 0x370(%rax), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0x3f930
leaq 0xc29a(%rip), %rax # 0x4bbc4
movq %rax, -0x38(%rbp)
jmp 0x3f93b
leaq 0xc27a(%rip), %rax # 0x4bbb1
movq %rax, -0x38(%rbp)
jmp 0x3f93d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x2, %edx
callq 0x36210
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x3f964
leaq 0x1f4e8(%rip), %rax # 0x5ee48
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x3f99a
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x135f0
cmpl $0x0, %eax
je 0x3f99a
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq 0x331(%rip), %rax # 0x3fcf0
movq %rax, -0x90(%rbp)
leaq 0x463(%rip), %rax # 0x3fe30
movq %rax, -0x88(%rbp)
leaq 0x5a5(%rip), %rax # 0x3ff80
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3fa80
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x3fa80
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x150(%rax)
je 0x3fa80
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x150(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x13100
cmpq $0x0, %rax
jne 0x3fa7e
movq -0x10(%rbp), %rdi
leaq 0x20425(%rip), %rax # 0x5fe80
movq (%rax), %rdx
movq -0x28(%rbp), %r8
movl $0x1392, %esi # imm = 0x1392
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x15fd0
movl $0x1, -0x4(%rbp)
jmp 0x3fcde
jmp 0x3fa80
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq *%rax
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
jne 0x3faba
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3fad5
cmpl $-0x1, -0x9c(%rbp)
jle 0x3fb38
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
je 0x3fb38
cmpl $0x0, -0x9c(%rbp)
jle 0x3faff
movq -0x10(%rbp), %rdi
movl -0x9c(%rbp), %esi
leaq 0x20391(%rip), %rax # 0x5fe80
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x15fd0
jmp 0x3fb2c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jne 0x3fb2a
movq -0x10(%rbp), %rdi
leaq 0x20369(%rip), %rax # 0x5fe80
movq (%rax), %rdx
movl $0x7d0, %esi # imm = 0x7D0
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x15fd0
jmp 0x3fb2c
movl $0x1, -0x4(%rbp)
jmp 0x3fcde
cmpl $-0x1, -0x9c(%rbp)
jne 0x3fb53
movq -0x10(%rbp), %rdi
callq 0x15cc0
movq %rax, -0x98(%rbp)
jmp 0x3fb5e
movslq -0x44(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, -0x98(%rbp)
jne 0x3fbe9
movq -0x10(%rbp), %rax
cmpl $0x7dd, 0x90(%rax) # imm = 0x7DD
jne 0x3fbdd
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq 0x202f2(%rip), %rax # 0x5fe80
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
leaq 0x202f1(%rip), %rax # 0x5fe90
movq 0x1b8(%rax), %rax
movq %rax, -0xa8(%rbp)
callq 0x13050
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
movl (%rax), %r9d
movl $0x7dd, %esi # imm = 0x7DD
leaq 0xc54d(%rip), %r8 # 0x4c123
movb $0x0, %al
callq 0x15fd0
movl $0x1, -0x4(%rbp)
jmp 0x3fcde
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jne 0x3fca6
cmpq $0x1, -0x98(%rbp)
jne 0x3fc2b
leaq 0xbfa1(%rip), %rax # 0x4bbb1
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x48e, %rax # imm = 0x48E
movq %rax, -0x60(%rbp)
movl $0x15, -0x58(%rbp)
jmp 0x3fc7a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x131a0
movl %eax, -0xa0(%rbp)
movq -0x98(%rbp), %rax
movl -0xa0(%rbp), %ecx
subq %rcx, %rax
subq $0x2, %rax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xa0(%rbp), %ecx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x2, %edx
callq 0x36210
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x3fca1
leaq 0x1f1ab(%rip), %rax # 0x5ee48
movq %rax, -0x40(%rbp)
jmp 0x3f9fd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3fcd7
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x1, %rsi
movq -0x98(%rbp), %rdx
callq 0x1e6f0
movl %eax, -0x4(%rbp)
jmp 0x3fcde
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| run_plugin_auth:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], 0
mov rax, [rbp+var_10]
mov rax, [rax+370h]
and rax, 80000h
cmp rax, 0
jz short loc_3F905
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_3F8F2
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+8], 0
jz short loc_3F8F2
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rax, [rax+8]
mov [rbp+var_38], rax
jmp short loc_3F903
loc_3F8F2:
cmp [rbp+var_28], 0
jz short loc_3F901
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
loc_3F901:
jmp short $+2
loc_3F903:
jmp short $+2
loc_3F905:
cmp [rbp+var_38], 0
jnz short loc_3F93D
mov rax, [rbp+var_10]
mov rax, [rax+370h]
and rax, 200h
cmp rax, 0
jz short loc_3F930
lea rax, aMysqlNativePas; "mysql_native_password"
mov [rbp+var_38], rax
jmp short loc_3F93B
loc_3F930:
lea rax, aMysqlOldPasswo; "mysql_old_password"
mov [rbp+var_38], rax
loc_3F93B:
jmp short $+2
loc_3F93D:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 2
call mysql_client_find_plugin
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_3F964
lea rax, dummy_fallback_client_plugin
mov [rbp+var_40], rax
loc_3F964:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 0
cmp [rbp+var_28], 0
jz short loc_3F99A
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_38]
call _strcmp
cmp eax, 0
jz short loc_3F99A
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
loc_3F99A:
cmp [rbp+var_28], 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_48], al
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov eax, [rbp+var_1C]
mov [rbp+var_58], eax
lea rax, client_mpvio_read_packet
mov [rbp+var_90], rax
lea rax, client_mpvio_write_packet
mov [rbp+var_88], rax
lea rax, client_mpvio_info
mov [rbp+var_80], rax
mov rax, [rbp+var_10]
mov [rbp+var_78], rax
mov [rbp+var_4C], 0
mov [rbp+var_50], 0
mov rax, [rbp+var_30]
mov [rbp+var_68], rax
loc_3F9FD:
mov rax, [rbp+var_40]
mov [rbp+var_70], rax
cmp [rbp+var_38], 0
jz short loc_3FA80
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_3FA80
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+150h], 0
jz short loc_3FA80
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rdi, [rax+150h]
mov rsi, [rbp+var_38]
call _strstr
cmp rax, 0
jnz short loc_3FA7E
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov r8, [rbp+var_28]
mov esi, 1392h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov [rbp+var_4], 1
jmp loc_3FCDE
loc_3FA7E:
jmp short $+2
loc_3FA80:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
mov rax, [rax+58h]
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_90]
call rax
mov [rbp+var_9C], eax
cmp [rbp+var_9C], 0
jnz short loc_3FABA
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_3FAD5
loc_3FABA:
cmp [rbp+var_9C], 0FFFFFFFFh
jle short loc_3FB38
mov rax, [rbp+var_10]
mov rax, [rax+20h]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jz short loc_3FB38
loc_3FAD5:
cmp [rbp+var_9C], 0
jle short loc_3FAFF
mov rdi, [rbp+var_10]
mov esi, [rbp+var_9C]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp short loc_3FB2C
loc_3FAFF:
mov rax, [rbp+var_10]
cmp dword ptr [rax+90h], 0
jnz short loc_3FB2A
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D0h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
loc_3FB2A:
jmp short $+2
loc_3FB2C:
mov [rbp+var_4], 1
jmp loc_3FCDE
loc_3FB38:
cmp [rbp+var_9C], 0FFFFFFFFh
jnz short loc_3FB53
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov [rbp+var_98], rax
jmp short loc_3FB5E
loc_3FB53:
movsxd rax, [rbp+var_44]
mov [rbp+var_98], rax
loc_3FB5E:
mov eax, 0FFFFFFFFh
cmp [rbp+var_98], rax
jnz short loc_3FBE9
mov rax, [rbp+var_10]
cmp dword ptr [rax+90h], 7DDh
jnz short loc_3FBDD
mov rax, [rbp+var_10]
mov [rbp+var_B8], rax
lea rax, SQLSTATE_UNKNOWN
mov rax, [rax]
mov [rbp+var_B0], rax
lea rax, client_errors
mov rax, [rax+1B8h]
mov [rbp+var_A8], rax
call ___errno_location
mov rdi, [rbp+var_B8]
mov rdx, [rbp+var_B0]
mov rcx, [rbp+var_A8]
mov r9d, [rax]
mov esi, 7DDh
lea r8, aReadingAuthori; "reading authorization packet"
mov al, 0
call my_set_error
loc_3FBDD:
mov [rbp+var_4], 1
jmp loc_3FCDE
loc_3FBE9:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
movzx eax, byte ptr [rax]
cmp eax, 0FEh
jnz loc_3FCA6
cmp [rbp+var_98], 1
jnz short loc_3FC2B
lea rax, aMysqlOldPasswo; "mysql_old_password"
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
add rax, 48Eh
mov [rbp+var_60], rax
mov [rbp+var_58], 15h
jmp short loc_3FC7A
loc_3FC2B:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
add rax, 1
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
call _strlen
mov [rbp+var_A0], eax
mov rax, [rbp+var_98]
mov ecx, [rbp+var_A0]
sub rax, rcx
sub rax, 2
mov [rbp+var_58], eax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov ecx, [rbp+var_A0]
add rax, rcx
add rax, 2
mov [rbp+var_60], rax
loc_3FC7A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov edx, 2
call mysql_client_find_plugin
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_3FCA1
lea rax, dummy_fallback_client_plugin
mov [rbp+var_40], rax
loc_3FCA1:
jmp loc_3F9FD
loc_3FCA6:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
movzx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_3FCD7
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
add rsi, 1
mov rdx, [rbp+var_98]
call ma_read_ok_packet
mov [rbp+var_4], eax
jmp short loc_3FCDE
loc_3FCD7:
mov [rbp+var_4], 1
loc_3FCDE:
mov eax, [rbp+var_4]
add rsp, 0C0h
pop rbp
retn
| long long run_plugin_auth(long long a1, long long a2, int a3, const char *a4, long long a5)
{
long long v5; // rsi
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
unsigned int *v10; // rax
long long v12; // [rsp+8h] [rbp-B8h]
char *v13; // [rsp+10h] [rbp-B0h]
char *v14; // [rsp+18h] [rbp-A8h]
unsigned int v15; // [rsp+20h] [rbp-A0h]
signed int v16; // [rsp+24h] [rbp-9Ch]
long long v17; // [rsp+28h] [rbp-98h]
_QWORD v18[6]; // [rsp+30h] [rbp-90h] BYREF
long long v19; // [rsp+60h] [rbp-60h]
int v20; // [rsp+68h] [rbp-58h]
int v21; // [rsp+70h] [rbp-50h]
int v22; // [rsp+74h] [rbp-4Ch]
bool v23; // [rsp+78h] [rbp-48h]
int v24; // [rsp+7Ch] [rbp-44h]
void (**plugin)(void); // [rsp+80h] [rbp-40h]
const char *v26; // [rsp+88h] [rbp-38h]
long long v27; // [rsp+90h] [rbp-30h]
const char *v28; // [rsp+98h] [rbp-28h]
int v29; // [rsp+A4h] [rbp-1Ch]
long long v30; // [rsp+A8h] [rbp-18h]
long long v31; // [rsp+B0h] [rbp-10h]
v31 = a1;
v30 = a2;
v29 = a3;
v28 = a4;
v27 = a5;
v26 = 0LL;
if ( (*(_QWORD *)(a1 + 880) & 0x80000LL) != 0 )
{
if ( *(_QWORD *)(v31 + 1152) && *(_QWORD *)(*(_QWORD *)(v31 + 1152) + 8LL) )
{
v26 = *(const char **)(*(_QWORD *)(v31 + 1152) + 8LL);
}
else if ( v28 )
{
v26 = v28;
}
}
if ( !v26 )
{
if ( (*(_QWORD *)(v31 + 880) & 0x200LL) != 0 )
v26 = "mysql_native_password";
else
v26 = "mysql_old_password";
}
plugin = mysql_client_find_plugin(v31, v26, 2u);
if ( !plugin )
plugin = (void (**)(void))&dummy_fallback_client_plugin;
*(_DWORD *)(v31 + 144) = 0;
if ( v28 && (unsigned int)strcmp(v28, v26) )
{
v30 = 0LL;
v29 = 0;
}
v23 = v28 == 0LL;
v19 = v30;
v20 = v29;
v18[0] = client_mpvio_read_packet;
v18[1] = client_mpvio_write_packet;
v18[2] = client_mpvio_info;
v18[3] = v31;
v22 = 0;
v21 = 0;
v18[5] = v27;
while ( 1 )
{
v18[4] = plugin;
if ( v26
&& *(_QWORD *)(v31 + 1152)
&& *(_QWORD *)(*(_QWORD *)(v31 + 1152) + 336LL)
&& !strstr(*(_QWORD *)(*(_QWORD *)(v31 + 1152) + 336LL), v26) )
{
my_set_error(v31, 0x1392u, (long long)SQLSTATE_UNKNOWN, 0LL, v28);
return 1;
}
**(_BYTE **)(v31 + 32) = 0;
v5 = v31;
v16 = ((long long ( *)(_QWORD *, long long))plugin[11])(v18, v31);
if ( !v16 && !*(_QWORD *)(v31 + 8) || v16 > -1 && **(unsigned __int8 **)(v31 + 32) != 254 )
{
if ( v16 <= 0 )
{
if ( !*(_DWORD *)(v31 + 144) )
my_set_error(v31, 0x7D0u, (long long)SQLSTATE_UNKNOWN, 0LL);
}
else
{
my_set_error(v31, v16, (long long)SQLSTATE_UNKNOWN, 0LL);
}
return 1;
}
v17 = v16 == -1 ? ma_net_safe_read(v31, v5, v6, v7, v8, v9) : v24;
if ( v17 == 0xFFFFFFFFLL )
break;
if ( **(unsigned __int8 **)(v31 + 32) != 254 )
{
if ( **(_BYTE **)(v31 + 32) )
return 1;
else
return (unsigned int)ma_read_ok_packet(v31, (unsigned __int8 *)(*(_QWORD *)(v31 + 32) + 1LL), v17);
}
if ( v17 == 1 )
{
v26 = "mysql_old_password";
v19 = v31 + 1166;
v20 = 21;
}
else
{
v26 = (const char *)(*(_QWORD *)(v31 + 32) + 1LL);
v15 = strlen(v26);
v20 = v17 - v15 - 2;
v19 = v15 + *(_QWORD *)(v31 + 32) + 2LL;
}
plugin = mysql_client_find_plugin(v31, v26, 2u);
if ( !plugin )
plugin = (void (**)(void))&dummy_fallback_client_plugin;
}
if ( *(_DWORD *)(v31 + 144) == 2013 )
{
v12 = v31;
v13 = SQLSTATE_UNKNOWN;
v14 = client_errors[55];
v10 = (unsigned int *)__errno_location();
my_set_error(v12, 0x7DDu, (long long)v13, (long long)v14, "reading authorization packet", *v10);
}
return 1;
}
| run_plugin_auth:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x370]
AND RAX,0x80000
CMP RAX,0x0
JZ 0x0013f905
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0013f8f2
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0013f8f2
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013f903
LAB_0013f8f2:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013f901
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
LAB_0013f901:
JMP 0x0013f903
LAB_0013f903:
JMP 0x0013f905
LAB_0013f905:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0013f93d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x370]
AND RAX,0x200
CMP RAX,0x0
JZ 0x0013f930
LEA RAX,[0x14bbc4]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013f93b
LAB_0013f930:
LEA RAX,[0x14bbb1]
MOV qword ptr [RBP + -0x38],RAX
LAB_0013f93b:
JMP 0x0013f93d
LAB_0013f93d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x2
CALL 0x00136210
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0013f964
LEA RAX,[0x15ee48]
MOV qword ptr [RBP + -0x40],RAX
LAB_0013f964:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x0
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013f99a
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001135f0
CMP EAX,0x0
JZ 0x0013f99a
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
LAB_0013f99a:
CMP qword ptr [RBP + -0x28],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x48],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x58],EAX
LEA RAX,[0x13fcf0]
MOV qword ptr [RBP + -0x90],RAX
LEA RAX,[0x13fe30]
MOV qword ptr [RBP + -0x88],RAX
LEA RAX,[0x13ff80]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0x4c],0x0
MOV dword ptr [RBP + -0x50],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
LAB_0013f9fd:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0013fa80
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0013fa80
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x150],0x0
JZ 0x0013fa80
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RDI,qword ptr [RAX + 0x150]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00113100
CMP RAX,0x0
JNZ 0x0013fa7e
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fe80]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x28]
MOV ESI,0x1392
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00115fd0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013fcde
LAB_0013fa7e:
JMP 0x0013fa80
LAB_0013fa80:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x58]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0x90]
CALL RAX
MOV dword ptr [RBP + -0x9c],EAX
CMP dword ptr [RBP + -0x9c],0x0
JNZ 0x0013faba
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0013fad5
LAB_0013faba:
CMP dword ptr [RBP + -0x9c],-0x1
JLE 0x0013fb38
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JZ 0x0013fb38
LAB_0013fad5:
CMP dword ptr [RBP + -0x9c],0x0
JLE 0x0013faff
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x9c]
LEA RAX,[0x15fe80]
MOV RDX,qword ptr [RAX]
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00115fd0
JMP 0x0013fb2c
LAB_0013faff:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x90],0x0
JNZ 0x0013fb2a
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fe80]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d0
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00115fd0
LAB_0013fb2a:
JMP 0x0013fb2c
LAB_0013fb2c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013fcde
LAB_0013fb38:
CMP dword ptr [RBP + -0x9c],-0x1
JNZ 0x0013fb53
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00115cc0
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0013fb5e
LAB_0013fb53:
MOVSXD RAX,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0x98],RAX
LAB_0013fb5e:
MOV EAX,0xffffffff
CMP qword ptr [RBP + -0x98],RAX
JNZ 0x0013fbe9
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x90],0x7dd
JNZ 0x0013fbdd
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xb8],RAX
LEA RAX,[0x15fe80]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xb0],RAX
LEA RAX,[0x15fe90]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV qword ptr [RBP + -0xa8],RAX
CALL 0x00113050
MOV RDI,qword ptr [RBP + -0xb8]
MOV RDX,qword ptr [RBP + -0xb0]
MOV RCX,qword ptr [RBP + -0xa8]
MOV R9D,dword ptr [RAX]
MOV ESI,0x7dd
LEA R8,[0x14c123]
MOV AL,0x0
CALL 0x00115fd0
LAB_0013fbdd:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013fcde
LAB_0013fbe9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfe
JNZ 0x0013fca6
CMP qword ptr [RBP + -0x98],0x1
JNZ 0x0013fc2b
LEA RAX,[0x14bbb1]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x48e
MOV qword ptr [RBP + -0x60],RAX
MOV dword ptr [RBP + -0x58],0x15
JMP 0x0013fc7a
LAB_0013fc2b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001131a0
MOV dword ptr [RBP + -0xa0],EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,dword ptr [RBP + -0xa0]
SUB RAX,RCX
SUB RAX,0x2
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV ECX,dword ptr [RBP + -0xa0]
ADD RAX,RCX
ADD RAX,0x2
MOV qword ptr [RBP + -0x60],RAX
LAB_0013fc7a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x2
CALL 0x00136210
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0013fca1
LEA RAX,[0x15ee48]
MOV qword ptr [RBP + -0x40],RAX
LAB_0013fca1:
JMP 0x0013f9fd
LAB_0013fca6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0013fcd7
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x98]
CALL 0x0011e6f0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013fcde
LAB_0013fcd7:
MOV dword ptr [RBP + -0x4],0x1
LAB_0013fcde:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xc0
POP RBP
RET
|
int4 run_plugin_auth(long param_1,long param_2,int param_3,char *param_4,int8 param_5)
{
int *puVar1;
int *puVar2;
long lVar3;
int iVar4;
char *pcVar5;
int *piVar6;
size_t sVar7;
long local_a0;
code *local_98;
code *local_90;
code *local_88;
long local_80;
int1 *local_78;
int8 local_70;
long local_68;
int local_60;
int4 local_58;
int4 local_54;
int1 local_50;
int local_4c;
int1 *local_48;
char *local_40;
int8 local_38;
char *local_30;
int local_24;
long local_20;
long local_18;
int4 local_c;
local_40 = (char *)0x0;
if ((*(ulong *)(param_1 + 0x370) & 0x80000) != 0) {
if ((*(long *)(param_1 + 0x480) == 0) || (*(long *)(*(long *)(param_1 + 0x480) + 8) == 0)) {
if (param_4 != (char *)0x0) {
local_40 = param_4;
}
}
else {
local_40 = *(char **)(*(long *)(param_1 + 0x480) + 8);
}
}
if (local_40 == (char *)0x0) {
if ((*(ulong *)(param_1 + 0x370) & 0x200) == 0) {
local_40 = "mysql_old_password";
}
else {
local_40 = "mysql_native_password";
}
}
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
local_48 = (int1 *)mysql_client_find_plugin(param_1,local_40,2);
if (local_48 == (int1 *)0x0) {
local_48 = dummy_fallback_client_plugin;
}
*(int4 *)(local_18 + 0x90) = 0;
if ((local_30 != (char *)0x0) && (iVar4 = strcmp(local_30,local_40), iVar4 != 0)) {
local_20 = 0;
local_24 = 0;
}
local_50 = local_30 == (char *)0x0;
local_68 = local_20;
local_60 = local_24;
local_98 = client_mpvio_read_packet;
local_90 = client_mpvio_write_packet;
local_88 = client_mpvio_info;
local_80 = local_18;
local_54 = 0;
local_58 = 0;
local_70 = local_38;
while( true ) {
local_78 = local_48;
if ((((local_40 != (char *)0x0) && (*(long *)(local_18 + 0x480) != 0)) &&
(*(long *)(*(long *)(local_18 + 0x480) + 0x150) != 0)) &&
(pcVar5 = strstr(*(char **)(*(long *)(local_18 + 0x480) + 0x150),local_40),
pcVar5 == (char *)0x0)) {
my_set_error(local_18,0x1392,SQLSTATE_UNKNOWN,0,local_30);
return 1;
}
**(int1 **)(local_18 + 0x20) = 0;
iVar4 = (**(code **)(local_48 + 0x58))(&local_98,local_18);
if (((iVar4 == 0) && (*(long *)(local_18 + 8) == 0)) ||
((-1 < iVar4 && (**(char **)(local_18 + 0x20) != -2)))) {
if (iVar4 < 1) {
if (*(int *)(local_18 + 0x90) == 0) {
my_set_error(local_18,2000,SQLSTATE_UNKNOWN,0);
}
}
else {
my_set_error(local_18,iVar4,SQLSTATE_UNKNOWN,0);
}
return 1;
}
if (iVar4 == -1) {
local_a0 = ma_net_safe_read(local_18);
}
else {
local_a0 = (long)local_4c;
}
lVar3 = local_18;
puVar2 = PTR_s_Lost_connection_to_server_at___s_00160048;
puVar1 = SQLSTATE_UNKNOWN;
if (local_a0 == 0xffffffff) break;
if (**(char **)(local_18 + 0x20) != -2) {
if (**(char **)(local_18 + 0x20) == '\0') {
local_c = ma_read_ok_packet(local_18,*(long *)(local_18 + 0x20) + 1,local_a0);
}
else {
local_c = 1;
}
return local_c;
}
if (local_a0 == 1) {
local_40 = "mysql_old_password";
local_68 = local_18 + 0x48e;
local_60 = 0x15;
}
else {
local_40 = (char *)(*(long *)(local_18 + 0x20) + 1);
sVar7 = strlen(local_40);
local_60 = ((int)local_a0 - (int)sVar7) + -2;
local_68 = *(long *)(local_18 + 0x20) + (sVar7 & 0xffffffff) + 2;
}
local_48 = (int1 *)mysql_client_find_plugin(local_18,local_40,2);
if (local_48 == (int1 *)0x0) {
local_48 = dummy_fallback_client_plugin;
}
}
if (*(int *)(local_18 + 0x90) == 0x7dd) {
piVar6 = __errno_location();
my_set_error(lVar3,0x7dd,puVar1,puVar2,"reading authorization packet",*piVar6);
}
return 1;
}
| |
35,211 | pfs_start_file_close_wait_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_start_file_close_wait_v1(PSI_file_locker *locker,
const char *src_file,
uint src_line)
{
PFS_thread *thread;
const char *name;
uint len;
PFS_file *pfs_file;
PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
assert(state != NULL);
switch (state->m_operation)
{
case PSI_FILE_DELETE:
thread= reinterpret_cast<PFS_thread*> (state->m_thread);
name= state->m_name;
len= (uint)strlen(name);
pfs_file= find_or_create_file(thread, NULL, name, len, false);
state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
break;
case PSI_FILE_STREAM_CLOSE:
case PSI_FILE_CLOSE:
break;
default:
assert(false);
break;
}
pfs_start_file_wait_v1(locker, 0, src_file, src_line);
return;
} | O3 | cpp | pfs_start_file_close_wait_v1:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xe, 0x4(%rdi)
jne 0x42ef8
movq 0x10(%r15), %r12
movq 0x20(%r15), %r13
movq %r12, %rdi
callq 0x26150
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x362d0
movq %rax, 0x8(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42b31
| pfs_start_file_close_wait_v1:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, edx
mov r14, rsi
mov r15, rdi
cmp dword ptr [rdi+4], 0Eh
jnz short loc_42EF8
mov r12, [r15+10h]
mov r13, [r15+20h]
mov rdi, r12
call _strlen
mov rdi, r13
xor esi, esi
mov rdx, r12
mov ecx, eax
xor r8d, r8d
call _Z19find_or_create_fileP10PFS_threadP14PFS_file_classPKcjb; find_or_create_file(PFS_thread *,PFS_file_class *,char const*,uint,bool)
mov [r15+8], rax
loc_42EF8:
mov rdi, r15
xor esi, esi
mov rdx, r14
mov ecx, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp pfs_start_file_wait_v1
| long long pfs_start_file_close_wait_v1(long long a1, long long a2, int a3)
{
_BYTE *v4; // r12
long long v5; // r13
unsigned int v6; // eax
if ( *(_DWORD *)(a1 + 4) == 14 )
{
v4 = *(_BYTE **)(a1 + 16);
v5 = *(_QWORD *)(a1 + 32);
v6 = strlen(v4);
*(_QWORD *)(a1 + 8) = find_or_create_file(v5, 0LL, v4, v6, 0);
}
return pfs_start_file_wait_v1((int *)a1, 0LL, a2, a3);
}
| pfs_start_file_close_wait_v1:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
CMP dword ptr [RDI + 0x4],0xe
JNZ 0x00142ef8
MOV R12,qword ptr [R15 + 0x10]
MOV R13,qword ptr [R15 + 0x20]
MOV RDI,R12
CALL 0x00126150
MOV RDI,R13
XOR ESI,ESI
MOV RDX,R12
MOV ECX,EAX
XOR R8D,R8D
CALL 0x001362d0
MOV qword ptr [R15 + 0x8],RAX
LAB_00142ef8:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R14
MOV ECX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00142b31
|
void pfs_start_file_close_wait_v1(long param_1,int8 param_2,int4 param_3)
{
char *__s;
PFS_thread *pPVar1;
size_t sVar2;
int8 uVar3;
if (*(int *)(param_1 + 4) == 0xe) {
__s = *(char **)(param_1 + 0x10);
pPVar1 = *(PFS_thread **)(param_1 + 0x20);
sVar2 = strlen(__s);
uVar3 = find_or_create_file(pPVar1,(PFS_file_class *)0x0,__s,(uint)sVar2,false);
*(int8 *)(param_1 + 8) = uVar3;
}
pfs_start_file_wait_v1(param_1,0,param_2,param_3);
return;
}
| |
35,212 | cleanup_dirname | eloqsql/mysys/mf_pack.c | size_t cleanup_dirname(register char *to, const char *from)
{
reg5 size_t length;
reg2 char * pos;
reg3 char * from_ptr;
reg4 char * start;
char parent[5], /* for "FN_PARENTDIR" */
buff[FN_REFLEN + 1],*end_parentdir;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("cleanup_dirname");
DBUG_PRINT("enter",("from: '%s'",from));
start=buff;
from_ptr=(char *) from;
#ifdef FN_DEVCHAR
if ((pos=strrchr(from_ptr,FN_DEVCHAR)) != 0)
{ /* Skip device part */
length=(size_t) (pos-from_ptr)+1;
start=strnmov(buff,from_ptr,length); from_ptr+=length;
}
#endif
parent[0]=FN_LIBCHAR;
length=(size_t) (strmov(parent+1,FN_PARENTDIR)-parent);
for (pos=start ; (*pos= *from_ptr++) != 0 ; pos++)
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from_ptr - 1, from_ptr + 2)))
{
for (l-- ; l ; *++pos= *from_ptr++, l--);
start= pos + 1; /* Don't look inside multi-byte char */
continue;
}
#endif
if (*pos == '/')
*pos = FN_LIBCHAR;
if (*pos == FN_LIBCHAR)
{
if ((size_t) (pos-start) > length && memcmp(pos-length,parent,length) == 0)
{ /* If .../../; skip prev */
pos-=length;
if (pos != start)
{ /* not /../ */
pos--;
if (*pos == FN_HOMELIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (!home_dir)
{
pos+=length+1; /* Don't unpack ~/.. */
continue;
}
pos=strmov(buff,home_dir)-1; /* Unpacks ~/.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
if (*pos == FN_CURLIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (my_getwd(curr_dir,FN_REFLEN,MYF(0)))
{
pos+=length+1; /* Don't unpack ./.. */
continue;
}
pos=strmov(buff,curr_dir)-1; /* Unpacks ./.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
end_parentdir=pos;
while (pos >= start && *pos != FN_LIBCHAR) /* remove prev dir */
pos--;
if (pos[1] == FN_HOMELIB ||
(pos >= start && memcmp(pos, parent, length) == 0))
{ /* Don't remove ~user/ */
pos=strmov(end_parentdir+1,parent);
*pos=FN_LIBCHAR;
continue;
}
}
}
else if ((size_t) (pos-start) == length-1 &&
!memcmp(start,parent+1,length-1))
start=pos; /* Starts with "../" */
else if (pos-start > 0 && pos[-1] == FN_LIBCHAR)
{
#ifdef FN_NETWORK_DRIVES
if (pos-start != 1)
#endif
pos--; /* Remove dupplicate '/' */
}
else if (pos-start > 1 && pos[-1] == FN_CURLIB && pos[-2] == FN_LIBCHAR)
pos-=2; /* Skip /./ */
}
}
(void) strmov(to,buff);
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_RETURN((size_t) (pos-buff));
} | O3 | c | cleanup_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, -0x248(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x35(%rbp), %r15
movb $0x2f, (%r15)
movw $0x2e2e, 0x1(%r15) # imm = 0x2E2E
movb $0x0, 0x3(%r15)
leaq -0x240(%rbp), %r12
movq %r12, %r13
movzbl (%r14), %eax
movb %al, (%r12)
cmpl $0x2f, %eax
je 0x31e4e
testl %eax, %eax
jne 0x32006
jmp 0x32011
movb $0x2f, (%r12)
movq %r12, %rax
subq %r13, %rax
cmpq $0x4, %rax
jb 0x31f25
movzwl -0x3(%r12), %ecx
xorw -0x35(%rbp), %cx
movb -0x1(%r12), %dl
xorb -0x33(%rbp), %dl
movzbl %dl, %edx
orw %cx, %dx
jne 0x31f42
leaq -0x3(%r12), %rax
cmpq %r13, %rax
je 0x31f89
leaq -0x4(%r12), %rbx
movb -0x4(%r12), %al
cmpb $0x7e, %al
jne 0x31ee8
cmpq %r13, %rbx
je 0x31eae
cmpb $0x2f, -0x5(%r12)
jne 0x31fad
leaq 0x349363(%rip), %rax # 0x37b218
movq (%rax), %rsi
testq %rsi, %rsi
je 0x32006
leaq -0x240(%rbp), %rdi
callq 0x24310
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
xorl %edx, %edx
cmpb $0x2f, -0x1(%rax)
sete %dl
notq %rdx
cmoveq %rcx, %rbx
movb (%rax,%rdx), %al
cmpb $0x2e, %al
jne 0x31fad
cmpq %r13, %rbx
leaq 0x349336(%rip), %r12 # 0x37b230
je 0x31f06
cmpb $0x2f, -0x1(%rbx)
jne 0x31fad
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
xorl %edx, %edx
callq 0x2cd60
testl %eax, %eax
je 0x31f8e
addq $0x4, %rbx
movq %rbx, %r12
jmp 0x32006
cmpq $0x2, %rax
jne 0x31f42
movzwl (%r13), %eax
cmpw -0x34(%rbp), %ax
je 0x31f84
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
je 0x31f55
jmp 0x31f67
testq %rax, %rax
jle 0x32006
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
jne 0x31f5d
decq %r12
jmp 0x32006
cmpq $0x1, %rax
je 0x32006
cmpb $0x2e, %cl
jne 0x32006
leaq -0x2(%r12), %rax
cmpb $0x2f, -0x2(%r12)
cmoveq %rax, %r12
jmp 0x32006
movq %r12, %r13
jmp 0x32006
movq %rax, %r12
jmp 0x32006
leaq -0x240(%rbp), %rdi
movq %r12, %rsi
callq 0x24310
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
cmpb $0x2f, -0x1(%rax)
cmoveq %rcx, %rbx
movq %rbx, %r12
cmpq %r13, %rbx
jb 0x31fc7
movq %rbx, %r12
cmpb $0x2f, (%r12)
je 0x31fd1
decq %r12
cmpq %r13, %r12
jae 0x31fb8
cmpb $0x7e, 0x1(%r12)
je 0x31ff2
jmp 0x32006
cmpb $0x7e, 0x1(%r12)
je 0x31ff2
movzwl (%r12), %eax
xorw -0x35(%rbp), %ax
movb 0x2(%r12), %cl
xorb -0x33(%rbp), %cl
movzbl %cl, %ecx
orw %ax, %cx
jne 0x32006
incq %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24310
movq %rax, %r12
movb $0x2f, (%rax)
incq %r14
incq %r12
jmp 0x31e34
leaq -0x240(%rbp), %rbx
movq -0x248(%rbp), %rdi
movq %rbx, %rsi
callq 0x242a0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x3204e
subq %rbx, %r12
movq %r12, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24390
| cleanup_dirname:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov [rbp+var_248], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_35]
mov byte ptr [r15], 2Fh ; '/'
mov word ptr [r15+1], 2E2Eh
mov byte ptr [r15+3], 0
lea r12, [rbp+var_240]
mov r13, r12
loc_31E34:
movzx eax, byte ptr [r14]
mov [r12], al
cmp eax, 2Fh ; '/'
jz short loc_31E4E
test eax, eax
jnz loc_32006
jmp loc_32011
loc_31E4E:
mov byte ptr [r12], 2Fh ; '/'
mov rax, r12
sub rax, r13
cmp rax, 4
jb loc_31F25
movzx ecx, word ptr [r12-3]
xor cx, [rbp+var_35]
mov dl, [r12-1]
xor dl, [rbp+var_33]
movzx edx, dl
or dx, cx
jnz loc_31F42
lea rax, [r12-3]
cmp rax, r13
jz loc_31F89
lea rbx, [r12-4]
mov al, [r12-4]
cmp al, 7Eh ; '~'
jnz short loc_31EE8
cmp rbx, r13
jz short loc_31EAE
cmp byte ptr [r12-5], 2Fh ; '/'
jnz loc_31FAD
loc_31EAE:
lea rax, home_dir
mov rsi, [rax]
test rsi, rsi
jz loc_32006
lea rdi, [rbp+var_240]
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
xor edx, edx
cmp byte ptr [rax-1], 2Fh ; '/'
setz dl
not rdx
cmovz rbx, rcx
mov al, [rax+rdx]
loc_31EE8:
cmp al, 2Eh ; '.'
jnz loc_31FAD
cmp rbx, r13
lea r12, curr_dir
jz short loc_31F06
cmp byte ptr [rbx-1], 2Fh ; '/'
jnz loc_31FAD
loc_31F06:
mov esi, 200h
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jz short loc_31F8E
add rbx, 4
mov r12, rbx
jmp loc_32006
loc_31F25:
cmp rax, 2
jnz short loc_31F42
movzx eax, word ptr [r13+0]
cmp ax, [rbp+var_35+1]
jz short loc_31F84
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jz short loc_31F55
jmp short loc_31F67
loc_31F42:
test rax, rax
jle loc_32006
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jnz short loc_31F5D
loc_31F55:
dec r12
jmp loc_32006
loc_31F5D:
cmp rax, 1
jz loc_32006
loc_31F67:
cmp cl, 2Eh ; '.'
jnz loc_32006
lea rax, [r12-2]
cmp byte ptr [r12-2], 2Fh ; '/'
cmovz r12, rax
jmp loc_32006
loc_31F84:
mov r13, r12
jmp short loc_32006
loc_31F89:
mov r12, rax
jmp short loc_32006
loc_31F8E:
lea rdi, [rbp+var_240]
mov rsi, r12
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
cmp byte ptr [rax-1], 2Fh ; '/'
cmovz rbx, rcx
loc_31FAD:
mov r12, rbx
cmp rbx, r13
jb short loc_31FC7
mov r12, rbx
loc_31FB8:
cmp byte ptr [r12], 2Fh ; '/'
jz short loc_31FD1
dec r12
cmp r12, r13
jnb short loc_31FB8
loc_31FC7:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_31FF2
jmp short loc_32006
loc_31FD1:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_31FF2
movzx eax, word ptr [r12]
xor ax, [rbp+var_35]
mov cl, [r12+2]
xor cl, [rbp+var_33]
movzx ecx, cl
or cx, ax
jnz short loc_32006
loc_31FF2:
inc rbx
mov rdi, rbx
mov rsi, r15
call _stpcpy
mov r12, rax
mov byte ptr [rax], 2Fh ; '/'
loc_32006:
inc r14
inc r12
jmp loc_31E34
loc_32011:
lea rbx, [rbp+var_240]
mov rdi, [rbp+var_248]
mov rsi, rbx
call _strcpy
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_3204E
sub r12, rbx
mov rax, r12
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3204E:
call ___stack_chk_fail
| long long cleanup_dirname(long long a1, unsigned __int8 *a2)
{
_BYTE *v3; // r12
_WORD *v4; // r13
int v5; // eax
long long v6; // rax
_BYTE *v7; // rbx
char v8; // al
long long v9; // rax
char v10; // cl
long long v11; // rax
long long v13; // [rsp+8h] [rbp-248h]
_BYTE v14[523]; // [rsp+10h] [rbp-240h] BYREF
char v15[5]; // [rsp+21Bh] [rbp-35h] BYREF
unsigned long long v16; // [rsp+220h] [rbp-30h]
v13 = a1;
v16 = __readfsqword(0x28u);
strcpy(v15, "/..");
v3 = v14;
v4 = v14;
while ( 1 )
{
v5 = *a2;
*v3 = v5;
if ( v5 != 47 )
break;
*v3 = 47;
v6 = v3 - (_BYTE *)v4;
if ( (unsigned long long)(v3 - (_BYTE *)v4) < 4 )
{
if ( v6 == 2 )
{
if ( *v4 == *(_WORD *)&v15[1] )
{
v4 = v3;
goto LABEL_45;
}
v10 = *(v3 - 1);
if ( v10 == 47 )
goto LABEL_26;
LABEL_28:
if ( v10 == 46 && *(v3 - 2) == 47 )
v3 -= 2;
goto LABEL_45;
}
}
else if ( !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)(v3 - 3)) | (unsigned __int8)(v15[2] ^ *(v3 - 1))) )
{
if ( v3 - 3 == (_BYTE *)v4 )
{
v3 -= 3;
goto LABEL_45;
}
v7 = v3 - 4;
v8 = *(v3 - 4);
if ( v8 == 126 )
{
if ( v7 == (_BYTE *)v4 || *(v3 - 5) == 47 )
{
if ( !home_dir )
goto LABEL_45;
v9 = stpcpy(v14, home_dir);
v7 = (_BYTE *)(v9 - 1);
if ( *(_BYTE *)(v9 - 1) == 47 )
v7 = (_BYTE *)(v9 - 2);
v8 = *(_BYTE *)(v9 + ~(unsigned long long)(*(_BYTE *)(v9 - 1) == 47));
goto LABEL_15;
}
}
else
{
LABEL_15:
if ( v8 == 46 && (v7 == (_BYTE *)v4 || *(v7 - 1) == 47) )
{
if ( (unsigned int)my_getwd(curr_dir, 512LL, 0) )
{
v3 = v7 + 4;
goto LABEL_45;
}
v11 = stpcpy(v14, curr_dir);
v7 = (_BYTE *)(v11 - 1);
if ( *(_BYTE *)(v11 - 1) == 47 )
v7 = (_BYTE *)(v11 - 2);
}
}
v3 = v7;
if ( v7 < (_BYTE *)v4 )
{
LABEL_40:
if ( v3[1] == 126 )
goto LABEL_44;
}
else
{
v3 = v7;
while ( *v3 != 47 )
{
if ( --v3 < (_BYTE *)v4 )
goto LABEL_40;
}
if ( v3[1] == 126 || !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)v3) | (unsigned __int8)(v15[2] ^ v3[2])) )
{
LABEL_44:
v3 = (_BYTE *)stpcpy(v7 + 1, v15);
*v3 = 47;
goto LABEL_45;
}
}
goto LABEL_45;
}
if ( v6 <= 0 )
goto LABEL_45;
v10 = *(v3 - 1);
if ( v10 == 47 )
{
LABEL_26:
--v3;
goto LABEL_45;
}
if ( v6 != 1 )
goto LABEL_28;
LABEL_45:
++a2;
++v3;
}
if ( v5 )
goto LABEL_45;
strcpy(v13, v14);
return v3 - v14;
}
| cleanup_dirname:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV qword ptr [RBP + -0x248],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x35]
MOV byte ptr [R15],0x2f
MOV word ptr [R15 + 0x1],0x2e2e
MOV byte ptr [R15 + 0x3],0x0
LEA R12,[RBP + -0x240]
MOV R13,R12
LAB_00131e34:
MOVZX EAX,byte ptr [R14]
MOV byte ptr [R12],AL
CMP EAX,0x2f
JZ 0x00131e4e
TEST EAX,EAX
JNZ 0x00132006
JMP 0x00132011
LAB_00131e4e:
MOV byte ptr [R12],0x2f
MOV RAX,R12
SUB RAX,R13
CMP RAX,0x4
JC 0x00131f25
MOVZX ECX,word ptr [R12 + -0x3]
XOR CX,word ptr [RBP + -0x35]
MOV DL,byte ptr [R12 + -0x1]
XOR DL,byte ptr [RBP + -0x33]
MOVZX EDX,DL
OR DX,CX
JNZ 0x00131f42
LEA RAX,[R12 + -0x3]
CMP RAX,R13
JZ 0x00131f89
LEA RBX,[R12 + -0x4]
MOV AL,byte ptr [R12 + -0x4]
CMP AL,0x7e
JNZ 0x00131ee8
CMP RBX,R13
JZ 0x00131eae
CMP byte ptr [R12 + -0x5],0x2f
JNZ 0x00131fad
LAB_00131eae:
LEA RAX,[0x47b218]
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x00132006
LEA RDI,[RBP + -0x240]
CALL 0x00124310
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
XOR EDX,EDX
CMP byte ptr [RAX + -0x1],0x2f
SETZ DL
NOT RDX
CMOVZ RBX,RCX
MOV AL,byte ptr [RAX + RDX*0x1]
LAB_00131ee8:
CMP AL,0x2e
JNZ 0x00131fad
CMP RBX,R13
LEA R12,[0x47b230]
JZ 0x00131f06
CMP byte ptr [RBX + -0x1],0x2f
JNZ 0x00131fad
LAB_00131f06:
MOV ESI,0x200
MOV RDI,R12
XOR EDX,EDX
CALL 0x0012cd60
TEST EAX,EAX
JZ 0x00131f8e
ADD RBX,0x4
MOV R12,RBX
JMP 0x00132006
LAB_00131f25:
CMP RAX,0x2
JNZ 0x00131f42
MOVZX EAX,word ptr [R13]
CMP AX,word ptr [RBP + -0x34]
JZ 0x00131f84
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JZ 0x00131f55
JMP 0x00131f67
LAB_00131f42:
TEST RAX,RAX
JLE 0x00132006
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JNZ 0x00131f5d
LAB_00131f55:
DEC R12
JMP 0x00132006
LAB_00131f5d:
CMP RAX,0x1
JZ 0x00132006
LAB_00131f67:
CMP CL,0x2e
JNZ 0x00132006
LEA RAX,[R12 + -0x2]
CMP byte ptr [R12 + -0x2],0x2f
CMOVZ R12,RAX
JMP 0x00132006
LAB_00131f84:
MOV R13,R12
JMP 0x00132006
LAB_00131f89:
MOV R12,RAX
JMP 0x00132006
LAB_00131f8e:
LEA RDI,[RBP + -0x240]
MOV RSI,R12
CALL 0x00124310
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
CMP byte ptr [RAX + -0x1],0x2f
CMOVZ RBX,RCX
LAB_00131fad:
MOV R12,RBX
CMP RBX,R13
JC 0x00131fc7
MOV R12,RBX
LAB_00131fb8:
CMP byte ptr [R12],0x2f
JZ 0x00131fd1
DEC R12
CMP R12,R13
JNC 0x00131fb8
LAB_00131fc7:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x00131ff2
JMP 0x00132006
LAB_00131fd1:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x00131ff2
MOVZX EAX,word ptr [R12]
XOR AX,word ptr [RBP + -0x35]
MOV CL,byte ptr [R12 + 0x2]
XOR CL,byte ptr [RBP + -0x33]
MOVZX ECX,CL
OR CX,AX
JNZ 0x00132006
LAB_00131ff2:
INC RBX
MOV RDI,RBX
MOV RSI,R15
CALL 0x00124310
MOV R12,RAX
MOV byte ptr [RAX],0x2f
LAB_00132006:
INC R14
INC R12
JMP 0x00131e34
LAB_00132011:
LEA RBX,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x248]
MOV RSI,RBX
CALL 0x001242a0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0013204e
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013204e:
CALL 0x00124390
|
long cleanup_dirname(char *param_1,char *param_2)
{
char cVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
short *psVar5;
short *psVar6;
short *psVar7;
short *psVar8;
short *psVar9;
long in_FS_OFFSET;
short local_248 [261];
int1 local_3d [2];
char cStack_3b;
int1 local_3a;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
_local_3d = 0x2e2e2f;
local_3a = 0;
psVar7 = local_248;
psVar8 = psVar7;
do {
cVar1 = *param_2;
*(char *)psVar7 = cVar1;
psVar5 = psVar7;
psVar9 = psVar8;
if (cVar1 == '/') {
*(char *)psVar7 = '/';
uVar3 = (long)psVar7 - (long)psVar8;
if (uVar3 < 4) {
if (uVar3 != 2) goto LAB_00131f42;
psVar9 = psVar7;
if (*psVar8 == stack0xffffffffffffffc4) goto LAB_00132006;
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') goto LAB_00131f55;
LAB_00131f67:
psVar9 = psVar8;
if ((cVar1 == '.') && ((char)psVar7[-1] == '/')) {
psVar5 = psVar7 + -1;
}
}
else if (*(char *)((long)psVar7 + -1) == cStack_3b &&
(int1 [2])*(short *)((long)psVar7 + -3) == local_3d) {
psVar5 = (short *)((long)psVar7 + -3);
if (psVar5 == psVar8) goto LAB_00132006;
psVar5 = psVar7 + -2;
cVar1 = (char)psVar7[-2];
if (cVar1 == '~') {
if ((psVar5 == psVar8) || (psVar6 = psVar5, *(char *)((long)psVar7 + -5) == '/')) {
psVar5 = psVar7;
if (home_dir == (char *)0x0) goto LAB_00132006;
pcVar4 = stpcpy((char *)local_248,home_dir);
psVar5 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
}
cVar1 = pcVar4[~(ulong)(pcVar4[-1] == '/')];
goto LAB_00131ee8;
}
}
else {
LAB_00131ee8:
psVar6 = psVar5;
if ((cVar1 == '.') && ((psVar5 == psVar8 || (*(char *)((long)psVar5 + -1) == '/')))) {
iVar2 = my_getwd(&curr_dir,0x200,0);
if (iVar2 != 0) {
psVar5 = psVar5 + 2;
goto LAB_00132006;
}
pcVar4 = stpcpy((char *)local_248,&curr_dir);
psVar5 = (short *)(pcVar4 + -1);
psVar6 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
psVar6 = (short *)(pcVar4 + -2);
}
}
}
for (; psVar8 <= psVar5; psVar5 = (short *)((long)psVar5 + -1)) {
if ((char)*psVar5 == '/') {
if (*(char *)((long)psVar5 + 1) == '~') goto LAB_00131ff2;
if ((char)psVar5[1] != cStack_3b || (int1 [2])*psVar5 != local_3d)
goto LAB_00132006;
goto LAB_00131ff2;
}
}
if (*(char *)((long)psVar5 + 1) == '~') {
LAB_00131ff2:
psVar5 = (short *)stpcpy((char *)((long)psVar6 + 1),local_3d);
*(int1 *)psVar5 = 0x2f;
}
}
else {
LAB_00131f42:
if (0 < (long)uVar3) {
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') {
LAB_00131f55:
psVar5 = (short *)((long)psVar7 + -1);
psVar9 = psVar8;
}
else if (uVar3 != 1) goto LAB_00131f67;
}
}
}
else if (cVar1 == '\0') {
strcpy(param_1,(char *)local_248);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)psVar7 - (long)local_248;
}
LAB_00132006:
param_2 = param_2 + 1;
psVar7 = (short *)((long)psVar5 + 1);
psVar8 = psVar9;
} while( true );
}
| |
35,213 | wsrep_rec_get_foreign_key(unsigned char*, unsigned long*, unsigned char const*, dict_index_t*, dict_index_t*, unsigned long) | eloqsql/storage/innobase/rem/rem0rec.cc | int
wsrep_rec_get_foreign_key(
byte *buf, /* out: extracted key */
ulint *buf_len, /* in/out: length of buf */
const rec_t* rec, /* in: physical record */
dict_index_t* index_for, /* in: index in foreign table */
dict_index_t* index_ref, /* in: index in referenced table */
ibool new_protocol) /* in: protocol > 1 */
{
const byte* data;
ulint len;
ulint key_len = 0;
ulint i;
uint key_parts;
mem_heap_t* heap = NULL;
rec_offs offsets_[REC_OFFS_NORMAL_SIZE];
const rec_offs* offsets;
ut_ad(index_for);
ut_ad(index_ref);
rec_offs_init(offsets_);
offsets = rec_get_offsets(rec, index_for, offsets_,
index_for->n_core_fields,
ULINT_UNDEFINED, &heap);
ut_ad(rec_offs_validate(rec, NULL, offsets));
ut_ad(rec);
key_parts = dict_index_get_n_unique_in_tree(index_for);
for (i = 0;
i < key_parts &&
(index_for->type & DICT_CLUSTERED || i < key_parts - 1);
i++) {
dict_field_t* field_f =
dict_index_get_nth_field(index_for, i);
const dict_col_t* col_f = dict_field_get_col(field_f);
dict_field_t* field_r =
dict_index_get_nth_field(index_ref, i);
const dict_col_t* col_r = dict_field_get_col(field_r);
ut_ad(!rec_offs_nth_default(offsets, i));
data = rec_get_nth_field(rec, offsets, i, &len);
if (key_len + ((len != UNIV_SQL_NULL) ? len + 1 : 1) >
*buf_len) {
fprintf(stderr,
"WSREP: FK key len exceeded "
ULINTPF " " ULINTPF " " ULINTPF "\n",
key_len, len, *buf_len);
goto err_out;
}
if (len == UNIV_SQL_NULL) {
ut_a(!(col_f->prtype & DATA_NOT_NULL));
*buf++ = 1;
key_len++;
} else if (!new_protocol) {
if (!(col_r->prtype & DATA_NOT_NULL)) {
*buf++ = 0;
key_len++;
}
memcpy(buf, data, len);
*buf_len = wsrep_innobase_mysql_sort(
(int)(col_f->prtype & DATA_MYSQL_TYPE_MASK),
dtype_get_charset_coll(col_f->prtype),
buf, static_cast<uint>(len),
static_cast<uint>(*buf_len));
} else { /* new protocol */
if (!(col_r->prtype & DATA_NOT_NULL)) {
*buf++ = 0;
key_len++;
}
switch (col_f->mtype) {
case DATA_INT: {
byte* ptr = buf+len;
for (;;) {
ptr--;
*ptr = *data;
if (ptr == buf) {
break;
}
data++;
}
if (!(col_f->prtype & DATA_UNSIGNED)) {
buf[len-1] = (byte) (buf[len-1] ^ 128);
}
break;
}
case DATA_VARCHAR:
case DATA_VARMYSQL:
case DATA_CHAR:
case DATA_MYSQL:
/* Copy the actual data */
memcpy(buf, data, len);
len = wsrep_innobase_mysql_sort(
(int)
(col_f->prtype & DATA_MYSQL_TYPE_MASK),
dtype_get_charset_coll(col_f->prtype),
buf, len, *buf_len);
break;
case DATA_BLOB:
case DATA_BINARY:
case DATA_FIXBINARY:
case DATA_GEOMETRY:
memcpy(buf, data, len);
break;
case DATA_FLOAT:
{
float f = mach_float_read(data);
memcpy(buf, &f, sizeof(float));
}
break;
case DATA_DOUBLE:
{
double d = mach_double_read(data);
memcpy(buf, &d, sizeof(double));
}
break;
default:
break;
}
key_len += len;
buf += len;
}
}
rec_validate(rec, offsets);
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);
}
*buf_len = key_len;
return DB_SUCCESS;
err_out:
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);
}
return DB_ERROR;
} | O3 | cpp | wsrep_rec_get_foreign_key(unsigned char*, unsigned long*, unsigned char const*, dict_index_t*, dict_index_t*, unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %rcx, %r14
movq %rdx, %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq -0x58(%rbp), %r9
movq $0x0, (%r9)
leaq -0x2d0(%rbp), %rdx
movw $0x12c, (%rdx) # imm = 0x12C
movq 0x28(%rcx), %rcx
shrq $0x34, %rcx
movl $0x3ff, %ebx # imm = 0x3FF
andq %rbx, %rcx
movq %rax, -0x50(%rbp)
movq %rax, %rdi
movq %r14, %rsi
movq $-0x1, %r8
callq 0xc0a570
movq %rax, %r9
testb $0x40, 0x24(%r14)
movq 0x28(%r14), %rdi
movl $0x20, %eax
movl $0xb, %ecx
cmovel %eax, %ecx
shrq %cl, %rdi
andq %rbx, %rdi
je 0xc0df81
movq %r14, %rdx
movabsq $0x4000000000, %r10 # imm = 0x4000000000
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
leal (%rdi,%r11), %eax
movq %rax, -0x60(%rbp)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %rdx, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
testq %r10, 0x20(%rdx)
jne 0xc0dd72
cmpq -0x60(%rbp), %r12
jae 0xc0df84
testq %r12, %r12
je 0xc0dd85
movzwl 0x4(%r9,%r12,2), %esi
andl $0x3fff, %esi # imm = 0x3FFF
jmp 0xc0dd87
xorl %esi, %esi
movzwl 0x6(%r9,%r12,2), %eax
movl %eax, %ecx
andl $0xc000, %ecx # imm = 0xC000
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x8000, %ecx # imm = 0x8000
je 0xc0ddbb
cmpl $0xc000, %ecx # imm = 0xC000
jne 0xc0ddb0
leaq -0x1(%r11), %rbx
jmp 0xc0ddbb
andl $0x3fff, %eax # imm = 0x3FFF
subq %rsi, %rax
movq %rax, %rbx
leaq 0x1(%rbx), %rax
cmpq %r11, %rbx
movl $0x1, %ecx
cmoveq %rcx, %rax
addq %r14, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %r8
cmpq %r8, %rax
ja 0xc0dfb6
movq 0x38(%rdx), %rcx
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax), %r13
cmpq %r11, %rbx
jne 0xc0de11
testb $0x1, 0x1(%r13)
jne 0xc0dfe9
movb $0x1, (%r15)
incq %r15
incq %r14
jmp 0xc0df73
movq -0x68(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%rax), %rax
addq -0x50(%rbp), %rsi
movq (%rax), %rax
cmpq $0x0, -0x70(%rbp)
je 0xc0deb1
btl $0x8, %eax
jb 0xc0de3f
movb $0x0, (%r15)
incq %r15
incq %r14
movzbl 0x4(%r13), %eax
decl %eax
cmpl $0xd, %eax
ja 0xc0df6d
leaq 0x356602(%rip), %rcx # 0xf64458
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6281d0
movl (%r13), %esi
movzbl %sil, %edi
shrl $0x10, %esi
andl $0x7fff, %esi # imm = 0x7FFF
movq -0x30(%rbp), %rax
movq (%rax), %r8
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb9d072
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movabsq $0x4000000000, %r10 # imm = 0x4000000000
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %rdx
movq %rax, %rbx
jmp 0xc0df6d
btl $0x8, %eax
jb 0xc0dec1
movb $0x0, (%r15)
incq %r15
incq %r14
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6281d0
movl (%r13), %esi
movzbl %sil, %edi
shrl $0x10, %esi
andl $0x7fff, %esi # imm = 0x7FFF
movl %ebx, %ecx
movq -0x30(%rbp), %rbx
movl (%rbx), %r8d
movq %r15, %rdx
callq 0xb9d072
movq %rax, (%rbx)
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %r9
movq -0x38(%rbp), %rdi
movabsq $0x4000000000, %r10 # imm = 0x4000000000
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
jmp 0xc0df73
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6281d0
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movabsq $0x4000000000, %r10 # imm = 0x4000000000
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %rdx
jmp 0xc0df6d
movss (%rsi), %xmm0
movss %xmm0, (%r15)
jmp 0xc0df6d
movsd (%rsi), %xmm0
movsd %xmm0, (%r15)
jmp 0xc0df6d
movq %rbx, %rax
movb (%rsi), %cl
movb %cl, -0x1(%r15,%rax)
incq %rsi
decq %rax
jne 0xc0df51
testb $0x2, 0x1(%r13)
jne 0xc0df6d
xorb $-0x80, -0x1(%rbx,%r15)
addq %rbx, %r14
addq %rbx, %r15
incq %r12
cmpq %rdi, %r12
jne 0xc0dd62
jmp 0xc0df84
xorl %r14d, %r14d
movq -0x50(%rbp), %rdi
movq %r9, %rsi
callq 0xc0c8a5
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
jne 0xc0dfee
movq -0x30(%rbp), %rax
movq %r14, (%rax)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8d2deb(%rip), %rax # 0x14e0da8
movq (%rax), %rdi
leaq 0x201f94(%rip), %rsi # 0xe0ff5b
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x628460
movq -0x58(%rbp), %rdi
movl $0xb, %ebx
testq %rdi, %rdi
je 0xc0dfa2
callq 0xc0d866
jmp 0xc0dfa2
callq 0x687c91
callq 0xc0d866
jmp 0xc0df99
| _Z25wsrep_rec_get_foreign_keyPhPmPKhP12dict_index_tS4_m:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2A8h
mov [rbp+var_70], r9
mov [rbp+var_68], r8
mov r14, rcx
mov rax, rdx
mov [rbp+var_30], rsi
mov r15, rdi
lea r9, [rbp+var_58]
mov qword ptr [r9], 0
lea rdx, [rbp+var_2D0]
mov word ptr [rdx], 12Ch
mov rcx, [rcx+28h]
shr rcx, 34h
mov ebx, 3FFh
and rcx, rbx
mov [rbp+var_50], rax
mov rdi, rax
mov rsi, r14
mov r8, 0FFFFFFFFFFFFFFFFh
call _Z20rec_get_offsets_funcPKhPK12dict_index_tPtmmPP16mem_block_info_t; rec_get_offsets_func(uchar const*,dict_index_t const*,ushort *,ulong,ulong,mem_block_info_t **)
mov r9, rax
test byte ptr [r14+24h], 40h
mov rdi, [r14+28h]
mov eax, 20h ; ' '
mov ecx, 0Bh
cmovz ecx, eax
shr rdi, cl
and rdi, rbx
jz loc_C0DF81
mov rdx, r14
mov r10, 4000000000h
mov r11d, 0FFFFFFFFh
lea eax, [rdi+r11]
mov [rbp+var_60], rax
xor r14d, r14d
xor r12d, r12d
mov [rbp+var_48], rdx
mov [rbp+var_40], r9
mov [rbp+var_38], rdi
loc_C0DD62:
test [rdx+20h], r10
jnz short loc_C0DD72
cmp r12, [rbp+var_60]
jnb loc_C0DF84
loc_C0DD72:
test r12, r12
jz short loc_C0DD85
movzx esi, word ptr [r9+r12*2+4]
and esi, 3FFFh
jmp short loc_C0DD87
loc_C0DD85:
xor esi, esi
loc_C0DD87:
movzx eax, word ptr [r9+r12*2+6]
mov ecx, eax
and ecx, 0C000h
mov ebx, 0FFFFFFFFh
cmp ecx, 8000h
jz short loc_C0DDBB
cmp ecx, 0C000h
jnz short loc_C0DDB0
lea rbx, [r11-1]
jmp short loc_C0DDBB
loc_C0DDB0:
and eax, 3FFFh
sub rax, rsi
mov rbx, rax
loc_C0DDBB:
lea rax, [rbx+1]
cmp rbx, r11
mov ecx, 1
cmovz rax, rcx
add rax, r14
mov rcx, [rbp+var_30]
mov r8, [rcx]
cmp rax, r8
ja loc_C0DFB6
mov rcx, [rdx+38h]
lea rax, ds:0[r12*8]
lea rax, [rax+rax*2]
mov r13, [rcx+rax]
cmp rbx, r11
jnz short loc_C0DE11
test byte ptr [r13+1], 1
jnz loc_C0DFE9
mov byte ptr [r15], 1
inc r15
inc r14
jmp loc_C0DF73
loc_C0DE11:
mov rcx, [rbp+var_68]
mov rcx, [rcx+38h]
mov rax, [rcx+rax]
add rsi, [rbp+var_50]
mov rax, [rax]
cmp [rbp+var_70], 0
jz loc_C0DEB1
bt eax, 8
jb short loc_C0DE3F
mov byte ptr [r15], 0
inc r15
inc r14
loc_C0DE3F:
movzx eax, byte ptr [r13+4]
dec eax; switch 14 cases
cmp eax, 0Dh
ja def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
lea rcx, jpt_C0DE5D
movsxd rax, ds:(jpt_C0DE5D - 0F64458h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_C0DE5F:
mov rdi, r15; jumptable 0000000000C0DE5D cases 1,2,12,13
mov rdx, rbx
call _memcpy
mov esi, [r13+0]
movzx edi, sil; int
shr esi, 10h
and esi, 7FFFh; unsigned int
mov rax, [rbp+var_30]
mov r8, [rax]; unsigned __int64
mov rdx, r15; unsigned __int8 *
mov rcx, rbx; unsigned __int64
call _Z25wsrep_innobase_mysql_sortijPhmm; wsrep_innobase_mysql_sort(int,uint,uchar *,ulong,ulong)
mov r11d, 0FFFFFFFFh
mov r10, 4000000000h
mov rdi, [rbp+var_38]
mov r9, [rbp+var_40]
mov rdx, [rbp+var_48]
mov rbx, rax
jmp def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
loc_C0DEB1:
bt eax, 8
jb short loc_C0DEC1
mov byte ptr [r15], 0
inc r15
inc r14
loc_C0DEC1:
mov rdi, r15
mov rdx, rbx
call _memcpy
mov esi, [r13+0]
movzx edi, sil; int
shr esi, 10h
and esi, 7FFFh; unsigned int
mov ecx, ebx; unsigned __int64
mov rbx, [rbp+var_30]
mov r8d, [rbx]; unsigned __int64
mov rdx, r15; unsigned __int8 *
call _Z25wsrep_innobase_mysql_sortijPhmm; wsrep_innobase_mysql_sort(int,uint,uchar *,ulong,ulong)
mov [rbx], rax
mov rdx, [rbp+var_48]
mov r9, [rbp+var_40]
mov rdi, [rbp+var_38]
mov r10, 4000000000h
mov r11d, 0FFFFFFFFh
jmp short loc_C0DF73
loc_C0DF0F:
mov rdi, r15; jumptable 0000000000C0DE5D cases 3-5,14
mov rdx, rbx
call _memcpy
mov r11d, 0FFFFFFFFh
mov r10, 4000000000h
mov rdi, [rbp+var_38]
mov r9, [rbp+var_40]
mov rdx, [rbp+var_48]
jmp short def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
loc_C0DF38:
movss xmm0, dword ptr [rsi]; jumptable 0000000000C0DE5D case 9
movss dword ptr [r15], xmm0
jmp short def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
loc_C0DF43:
movsd xmm0, qword ptr [rsi]; jumptable 0000000000C0DE5D case 10
movsd qword ptr [r15], xmm0
jmp short def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
loc_C0DF4E:
mov rax, rbx; jumptable 0000000000C0DE5D case 6
loc_C0DF51:
mov cl, [rsi]
mov [r15+rax-1], cl
inc rsi
dec rax
jnz short loc_C0DF51
test byte ptr [r13+1], 2
jnz short def_C0DE5D; jumptable 0000000000C0DE5D default case, cases 7,8,11
xor byte ptr [rbx+r15-1], 80h
def_C0DE5D:
add r14, rbx; jumptable 0000000000C0DE5D default case, cases 7,8,11
add r15, rbx
loc_C0DF73:
inc r12
cmp r12, rdi
jnz loc_C0DD62
jmp short loc_C0DF84
loc_C0DF81:
xor r14d, r14d
loc_C0DF84:
mov rdi, [rbp+var_50]; unsigned __int8 *
mov rsi, r9; unsigned __int16 *
call _Z12rec_validatePKhPKt; rec_validate(uchar const*,ushort const*)
mov rdi, [rbp+var_58]
test rdi, rdi
jnz short loc_C0DFEE
loc_C0DF99:
mov rax, [rbp+var_30]
mov [rax], r14
xor ebx, ebx
loc_C0DFA2:
mov eax, ebx
add rsp, 2A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C0DFB6:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aWsrepFkKeyLenE; "WSREP: FK key len exceeded %zu %zu %zu"...
mov rdx, r14
mov rcx, rbx
xor eax, eax
call _fprintf
mov rdi, [rbp+var_58]
mov ebx, 0Bh
test rdi, rdi
jz short loc_C0DFA2
call _ZL13mem_heap_freeP16mem_block_info_t_11; mem_heap_free(mem_block_info_t *)
jmp short loc_C0DFA2
loc_C0DFE9:
call _Z25wsrep_rec_get_foreign_keyPhPmPKhP12dict_index_tS4_m_cold_1; wsrep_rec_get_foreign_key(uchar *,ulong *,uchar const*,dict_index_t *,dict_index_t *,ulong) [clone]
loc_C0DFEE:
call _ZL13mem_heap_freeP16mem_block_info_t_11; mem_heap_free(mem_block_info_t *)
jmp short loc_C0DF99
| long long wsrep_rec_get_foreign_key(
unsigned __int8 *a1,
unsigned long long *a2,
unsigned __int8 *a3,
dict_index_t *a4,
dict_index_t *a5,
long long a6)
{
long long v8; // rcx
unsigned __int16 *offsets_func; // r9
char v10; // cl
long long v11; // rdi
dict_index_t *v12; // rdx
long long v13; // r14
unsigned long long v14; // r12
long long v15; // rsi
int v16; // ecx
unsigned long long v17; // rbx
long long v18; // rax
long long v19; // r13
unsigned __int8 *v20; // rsi
long long v21; // rax
unsigned long long v22; // rax
unsigned long long v23; // rcx
_QWORD *v24; // rbx
unsigned long long v25; // rax
unsigned int v26; // ebx
unsigned __int16 v28[304]; // [rsp+0h] [rbp-2D0h] BYREF
long long v29; // [rsp+260h] [rbp-70h]
dict_index_t *v30; // [rsp+268h] [rbp-68h]
unsigned long long v31; // [rsp+270h] [rbp-60h]
_QWORD *v32; // [rsp+278h] [rbp-58h] BYREF
unsigned __int8 *v33; // [rsp+280h] [rbp-50h]
dict_index_t *v34; // [rsp+288h] [rbp-48h]
unsigned __int16 *v35; // [rsp+290h] [rbp-40h]
long long v36; // [rsp+298h] [rbp-38h]
long long *v37; // [rsp+2A0h] [rbp-30h]
v29 = a6;
v30 = a5;
v37 = (long long *)a2;
v32 = 0LL;
v28[0] = 300;
v8 = (*((_QWORD *)a4 + 5) >> 52) & 0x3FFLL;
v33 = a3;
offsets_func = rec_get_offsets_func((long long)a3, (long long)a4, v28, v8, 0xFFFFFFFFFFFFFFFFLL, (long long *)&v32);
v10 = 11;
if ( (*((_BYTE *)a4 + 36) & 0x40) == 0 )
v10 = 32;
v11 = (*((_QWORD *)a4 + 5) >> v10) & 0x3FFLL;
if ( v11 )
{
v12 = a4;
v31 = (unsigned int)(v11 - 1);
v13 = 0LL;
v14 = 0LL;
v34 = v12;
v35 = offsets_func;
v36 = v11;
while ( (*((_QWORD *)v12 + 4) & 0x4000000000LL) != 0 || v14 < v31 )
{
if ( v14 )
v15 = offsets_func[v14 + 2] & 0x3FFF;
else
v15 = 0LL;
v16 = offsets_func[v14 + 3] & 0xC000;
v17 = 0xFFFFFFFFLL;
if ( v16 != 0x8000 )
{
if ( v16 == 49152 )
v17 = 4294967294LL;
else
v17 = (offsets_func[v14 + 3] & 0x3FFF) - v15;
}
v18 = v17 + 1;
if ( v17 == 0xFFFFFFFF )
v18 = 1LL;
if ( v13 + v18 > (unsigned long long)*v37 )
{
fprintf(stderr, "WSREP: FK key len exceeded %zu %zu %zu\n", v13, v17, *v37);
v26 = 11;
if ( v32 )
mem_heap_free(v32);
return v26;
}
v19 = *(_QWORD *)(*((_QWORD *)v12 + 7) + 24 * v14);
if ( v17 == 0xFFFFFFFF )
{
if ( (*(_BYTE *)(v19 + 1) & 1) != 0 )
wsrep_rec_get_foreign_key(v11, v15);
*a1++ = 1;
++v13;
}
else
{
v20 = &v33[v15];
v21 = **(_QWORD **)(*((_QWORD *)v30 + 7) + 24 * v14);
if ( v29 )
{
if ( (v21 & 0x100) == 0 )
{
*a1++ = 0;
++v13;
}
switch ( *(_BYTE *)(v19 + 4) )
{
case 1:
case 2:
case 0xC:
case 0xD:
memcpy(a1, v20, v17);
v22 = wsrep_innobase_mysql_sort(
(unsigned __int8)*(_DWORD *)v19,
HIWORD(*(_DWORD *)v19) & 0x7FFF,
a1,
v17,
*v37);
v11 = v36;
offsets_func = v35;
v12 = v34;
v17 = v22;
break;
case 3:
case 4:
case 5:
case 0xE:
memcpy(a1, v20, v17);
v11 = v36;
offsets_func = v35;
v12 = v34;
break;
case 6:
v25 = v17;
do
a1[--v25] = *v20++;
while ( v25 );
if ( (*(_BYTE *)(v19 + 1) & 2) == 0 )
a1[v17 - 1] ^= 0x80u;
break;
case 9:
*(_DWORD *)a1 = *(_DWORD *)v20;
break;
case 0xA:
*(_QWORD *)a1 = *(_QWORD *)v20;
break;
default:
break;
}
v13 += v17;
a1 += v17;
}
else
{
if ( (v21 & 0x100) == 0 )
{
*a1++ = 0;
++v13;
}
memcpy(a1, v20, v17);
v23 = (unsigned int)v17;
v24 = v37;
*v24 = wsrep_innobase_mysql_sort(
(unsigned __int8)*(_DWORD *)v19,
HIWORD(*(_DWORD *)v19) & 0x7FFF,
a1,
v23,
*(unsigned int *)v37);
v12 = v34;
offsets_func = v35;
v11 = v36;
}
}
if ( ++v14 == v11 )
break;
}
}
else
{
v13 = 0LL;
}
rec_validate(v33, offsets_func);
if ( v32 )
mem_heap_free(v32);
*v37 = v13;
return 0;
}
| ~table_esms_by_account_by_event_name:
PUSH RBP
MOV RBP,RSP
MOV ESI,0x398
POP RBP
JMP 0x00728290
|
/* table_esms_by_account_by_event_name::~table_esms_by_account_by_event_name() */
void __thiscall
table_esms_by_account_by_event_name::~table_esms_by_account_by_event_name
(table_esms_by_account_by_event_name *this)
{
operator_delete(this,0x398);
return;
}
| |
35,214 | ma_pvio_read_async | eloqsql/libmariadb/libmariadb/ma_pvio.c | static size_t ma_pvio_read_async(MARIADB_PVIO *pvio, uchar *buffer, size_t length)
{
ssize_t res= 0;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
int timeout= pvio->timeout[PVIO_READ_TIMEOUT];
if (!pvio->methods->async_read)
{
PVIO_SET_ERROR(pvio->mysql, CR_ASYNC_NOT_SUPPORTED, unknown_sqlstate, 0);
return -1;
}
for (;;)
{
if (pvio->methods->async_read)
res= pvio->methods->async_read(pvio, buffer, length);
if (res >= 0 || IS_BLOCKING_ERROR())
return res;
b->events_to_wait_for= MYSQL_WAIT_READ;
if (timeout >= 0)
{
b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
b->timeout_value= timeout;
}
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
return -1;
}
} | O0 | c | ma_pvio_read_async:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5517c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x5516f
movq -0x10(%rbp), %rax
movq 0x50(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x1f4872(%rip), %rax # 0x2499d0
movq (%rax), %rdx
movl $0x138a, %esi # imm = 0x138A
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq *%r8
movq $-0x1, -0x8(%rbp)
jmp 0x55264
jmp 0x5517e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x551ab
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x551c6
callq 0x389e0
cmpl $0xb, (%rax)
je 0x551d3
callq 0x389e0
cmpl $0x4, (%rax)
je 0x551d3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55264
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
cmpl $0x0, -0x34(%rbp)
jl 0x551f8
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5521a
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%rax
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x71030
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x55246
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
xorl %edi, %edi
callq *%rax
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5525f
movq $-0x1, -0x8(%rbp)
jmp 0x55264
jmp 0x5517e
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| ma_pvio_read_async:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 0
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax+28h]
mov [rbp+var_34], eax
mov rax, [rbp+var_10]
mov rax, [rax+48h]
cmp qword ptr [rax+18h], 0
jnz short loc_5517C
mov rax, [rbp+var_10]
cmp qword ptr [rax+50h], 0
jz short loc_5516F
mov rax, [rbp+var_10]
mov r8, [rax+50h]
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 138Ah
xor eax, eax
mov ecx, eax
mov al, 0
call r8
loc_5516F:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp loc_55264
loc_5517C:
jmp short $+2
loc_5517E:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
cmp qword ptr [rax+18h], 0
jz short loc_551AB
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rax, [rax+18h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_28], rax
loc_551AB:
cmp [rbp+var_28], 0
jge short loc_551C6
call ___errno_location
cmp dword ptr [rax], 0Bh
jz short loc_551D3
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_551D3
loc_551C6:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_55264
loc_551D3:
mov rax, [rbp+var_30]
mov dword ptr [rax], 1
cmp [rbp+var_34], 0
jl short loc_551F8
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 8
mov [rax], ecx
mov ecx, [rbp+var_34]
mov rax, [rbp+var_30]
mov [rax+10h], ecx
loc_551F8:
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_5521A
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
mov edi, 1
call rax
loc_5521A:
mov rdi, [rbp+var_30]
add rdi, 38h ; '8'
call my_context_yield
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_55246
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
xor edi, edi
call rax
loc_55246:
mov rax, [rbp+var_30]
mov eax, [rax+4]
and eax, 8
cmp eax, 0
jz short loc_5525F
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_55264
loc_5525F:
jmp loc_5517E
loc_55264:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long ma_pvio_read_async(long long a1, long long a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
v6 = 0LL;
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
v4 = *(_DWORD *)(a1 + 40);
if ( *(_QWORD *)(*(_QWORD *)(a1 + 72) + 24LL) )
{
do
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 72) + 24LL) )
v6 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 72) + 24LL))(a1, a2, a3);
if ( v6 >= 0 || *(_DWORD *)__errno_location() != 11 && *(_DWORD *)__errno_location() != 4 )
return v6;
*(_DWORD *)v5 = 1;
if ( v4 >= 0 )
{
*(_DWORD *)v5 |= 8u;
*(_DWORD *)(v5 + 16) = v4;
}
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(long long, _QWORD))(v5 + 32))(1LL, *(_QWORD *)(v5 + 40));
my_context_yield(v5 + 56);
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(_QWORD, _QWORD))(v5 + 32))(0LL, *(_QWORD *)(v5 + 40));
}
while ( (*(_DWORD *)(v5 + 4) & 8) == 0 );
return -1LL;
}
else
{
if ( *(_QWORD *)(a1 + 80) )
(*(void ( **)(_QWORD, long long, char *, _QWORD))(a1 + 80))(
*(_QWORD *)(a1 + 64),
5002LL,
SQLSTATE_UNKNOWN,
0LL);
return -1LL;
}
}
| ma_pvio_read_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x0015517c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x0015516f
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x138a
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL R8
LAB_0015516f:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00155264
LAB_0015517c:
JMP 0x0015517e
LAB_0015517e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001551ab
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV qword ptr [RBP + -0x28],RAX
LAB_001551ab:
CMP qword ptr [RBP + -0x28],0x0
JGE 0x001551c6
CALL 0x001389e0
CMP dword ptr [RAX],0xb
JZ 0x001551d3
CALL 0x001389e0
CMP dword ptr [RAX],0x4
JZ 0x001551d3
LAB_001551c6:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00155264
LAB_001551d3:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x1
CMP dword ptr [RBP + -0x34],0x0
JL 0x001551f8
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x8
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],ECX
LAB_001551f8:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0015521a
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_0015521a:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x38
CALL 0x00171030
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00155246
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
XOR EDI,EDI
CALL RAX
LAB_00155246:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0015525f
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00155264
LAB_0015525f:
JMP 0x0015517e
LAB_00155264:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long ma_pvio_read_async(long param_1,int8 param_2,int8 param_3)
{
uint uVar1;
uint *puVar2;
int *piVar3;
long local_30;
local_30 = 0;
puVar2 = *(uint **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
uVar1 = *(uint *)(param_1 + 0x28);
if (*(long *)(*(long *)(param_1 + 0x48) + 0x18) == 0) {
if (*(long *)(param_1 + 0x50) != 0) {
(**(code **)(param_1 + 0x50))(*(int8 *)(param_1 + 0x40),0x138a,SQLSTATE_UNKNOWN,0);
}
}
else {
do {
if (*(long *)(*(long *)(param_1 + 0x48) + 0x18) != 0) {
local_30 = (**(code **)(*(long *)(param_1 + 0x48) + 0x18))(param_1,param_2,param_3);
}
if ((-1 < local_30) ||
((piVar3 = __errno_location(), *piVar3 != 0xb &&
(piVar3 = __errno_location(), *piVar3 != 4)))) {
return local_30;
}
*puVar2 = 1;
if (-1 < (int)uVar1) {
*puVar2 = *puVar2 | 8;
puVar2[4] = uVar1;
}
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(1,*(int8 *)(puVar2 + 10));
}
my_context_yield(puVar2 + 0xe);
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(0,*(int8 *)(puVar2 + 10));
}
} while ((puVar2[1] & 8) == 0);
}
return -1;
}
| |
35,215 | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)) | monkey531[P]llama/common/arg.h | common_arg(
const std::initializer_list<const char *> & args,
const char * value_hint,
const std::string & help,
void (*handler)(common_params & params, const std::string &)
) : args(args), value_hint(value_hint), help(help), handler_string(handler) {} | O3 | c | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)):
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, %rbp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
leaq 0x3(%rsp), %rcx
leaq 0x2(%rsp), %r8
movl $0x1, %edx
callq 0x57fac
leaq 0x38(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rcx, 0x58(%rbx)
leaq 0x60(%rbx), %r13
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
leaq 0x1(%rsp), %rcx
movq %r13, %rdi
callq 0x5802e
movq %r12, 0x78(%rbx)
leaq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
movq %rax, 0x90(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x22484
movb $0x0, 0xb0(%rbx)
movq $0x0, 0xb8(%rbx)
movq %r14, 0xc0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x549e8
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x1b8c0
jmp 0x549e8
movq %rax, %r14
leaq 0x30(%rbx), %rdi
callq 0x58074
movq %rbx, %rdi
callq 0x58074
movq %r14, %rdi
callq 0x1bf90
nop
| _ZN10common_argC2ERKSt16initializer_listIPKcES2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsSD_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r12, rdx
mov rbp, rsi
mov rbx, rdi
lea rsi, [rsp+38h+var_34]
mov dword ptr [rsi], 0
lea rcx, [rsp+38h+var_35]
lea r8, [rsp+38h+var_36]
mov edx, 1
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
lea rax, [rbx+38h]
xor ecx, ecx
mov [rbx+40h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
mov [rbx+48h], rax
mov [rbx+50h], rax
mov [rbx+58h], rcx
lea r13, [rbx+60h]
mov rsi, [rbp+0]
mov rdx, [rbp+8]
lea rcx, [rsp+38h+var_37]
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
mov [rbx+78h], r12
lea rdi, [rbx+90h]
lea rax, [rbx+0A0h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+80h], xmm0
mov [rbx+90h], rax
mov rsi, [r15]
mov rdx, [r15+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov byte ptr [rbx+0B0h], 0
mov qword ptr [rbx+0B8h], 0
mov [rbx+0C0h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+0C8h], xmm0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [r13+0]; void *
test rdi, rdi
jz short loc_549E8
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_549E8
mov r14, rax
loc_549E8:
lea rdi, [rbx+30h]
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, rbx
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long common_arg::common_arg(long long a1, _QWORD *a2, long long a3, long long a4, long long a5)
{
int v5; // eax
long long result; // rax
int v10; // [rsp+0h] [rbp-38h] BYREF
_DWORD v11[13]; // [rsp+4h] [rbp-34h] BYREF
v10 = v5;
v11[0] = 0;
std::set<llama_example>::set(a1, v11, 1LL, (char *)&v10 + 3, (char *)&v10 + 2);
*(_QWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 72) = a1 + 56;
*(_QWORD *)(a1 + 80) = a1 + 56;
*(_QWORD *)(a1 + 88) = 0LL;
std::vector<char const*>::vector(a1 + 96, *a2, a2[1], (char *)&v10 + 1);
*(_QWORD *)(a1 + 120) = a3;
*(_OWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 144) = a1 + 160;
result = std::string::_M_construct<char *>(a1 + 144, *(_BYTE **)a4, *(_QWORD *)a4 + *(_QWORD *)(a4 + 8));
*(_BYTE *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 184) = 0LL;
*(_QWORD *)(a1 + 192) = a5;
*(_OWORD *)(a1 + 200) = 0LL;
return result;
}
| common_arg:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV RBP,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],0x0
LEA RCX,[RSP + 0x3]
LEA R8,[RSP + 0x2]
MOV EDX,0x1
CALL 0x00157fac
LEA RAX,[RBX + 0x38]
XOR ECX,ECX
MOV qword ptr [RBX + 0x40],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [RBX + 0x48],RAX
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],RCX
LEA R13,[RBX + 0x60]
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
LAB_0015495a:
LEA RCX,[RSP + 0x1]
MOV RDI,R13
CALL 0x0015802e
MOV qword ptr [RBX + 0x78],R12
LEA RDI,[RBX + 0x90]
LEA RAX,[RBX + 0xa0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x80],XMM0
MOV qword ptr [RBX + 0x90],RAX
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_00154994:
CALL 0x00122484
LAB_00154999:
MOV byte ptr [RBX + 0xb0],0x0
MOV qword ptr [RBX + 0xb8],0x0
MOV qword ptr [RBX + 0xc0],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xc8],XMM0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, char const*,
std::__cxx11::string const&, void (*)(common_params&, std::__cxx11::string const&)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,char *param_2,string *param_3,
_func_void_common_params_ptr_string_ptr *param_4)
{
int4 in_EAX;
int8 in_R9;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,&stack0xffffffffffffffcc,1,&stack0xffffffffffffffcb,&stack0xffffffffffffffca,in_R9
,in_EAX);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(common_arg **)(this + 0x48) = this + 0x38;
*(common_arg **)(this + 0x50) = this + 0x38;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 0015495a to 00154966 has its CatchHandler @ 001549e5 */
std::vector<char_const*,std::allocator<char_const*>>::vector
((vector<char_const*,std::allocator<char_const*>> *)(this + 0x60),*(int8 *)param_1
,*(int8 *)(param_1 + 8),&stack0xffffffffffffffc9);
*(char **)(this + 0x78) = param_2;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
*(common_arg **)(this + 0x90) = this + 0xa0;
/* try { // try from 00154994 to 00154998 has its CatchHandler @ 001549cb */
std::__cxx11::string::_M_construct<char*>
(this + 0x90,*(long *)param_3,*(long *)(param_3 + 8) + *(long *)param_3);
this[0xb0] = (common_arg)0x0;
*(int8 *)(this + 0xb8) = 0;
*(_func_void_common_params_ptr_string_ptr **)(this + 0xc0) = param_4;
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = 0;
return;
}
| |
35,216 | set_global_from_ddl_log_entry(st_ddl_log_entry const*) | eloqsql/sql/ddl_log.cc | static void set_global_from_ddl_log_entry(const DDL_LOG_ENTRY *ddl_log_entry)
{
uchar *file_entry_buf= global_ddl_log.file_entry_buf, *pos, *end;
mysql_mutex_assert_owner(&LOCK_gdl);
file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (uchar) ddl_log_entry->entry_type;
file_entry_buf[DDL_LOG_ACTION_TYPE_POS]= (uchar) ddl_log_entry->action_type;
file_entry_buf[DDL_LOG_PHASE_POS]= (uchar) ddl_log_entry->phase;
int4store(file_entry_buf+DDL_LOG_NEXT_ENTRY_POS, ddl_log_entry->next_entry);
int2store(file_entry_buf+DDL_LOG_FLAG_POS, ddl_log_entry->flags);
int8store(file_entry_buf+DDL_LOG_XID_POS, ddl_log_entry->xid);
memcpy(file_entry_buf+DDL_LOG_UUID_POS, ddl_log_entry->uuid, MY_UUID_SIZE);
int8store(file_entry_buf+DDL_LOG_ID_POS, ddl_log_entry->unique_id);
bzero(file_entry_buf+DDL_LOG_END_POS,
global_ddl_log.name_pos - DDL_LOG_END_POS);
pos= file_entry_buf + global_ddl_log.name_pos;
end= file_entry_buf + global_ddl_log.io_size;
pos= store_string(pos, end, &ddl_log_entry->handler_name);
pos= store_string(pos, end, &ddl_log_entry->db);
pos= store_string(pos, end, &ddl_log_entry->name);
pos= store_string(pos, end, &ddl_log_entry->from_handler_name);
pos= store_string(pos, end, &ddl_log_entry->from_db);
pos= store_string(pos, end, &ddl_log_entry->from_name);
pos= store_string(pos, end, &ddl_log_entry->tmp_name);
pos= store_string(pos, end, &ddl_log_entry->extra_name);
bzero(pos, global_ddl_log.io_size - (pos - file_entry_buf));
} | O3 | cpp | set_global_from_ddl_log_entry(st_ddl_log_entry const*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xd7a331(%rip), %rbx # 0x1567038
movb 0xac(%rdi), %al
movb %al, (%rbx)
movb 0xb0(%rdi), %al
movb %al, 0x1(%rbx)
movb 0xb4(%rdi), %al
movb %al, 0x2(%rbx)
movl 0xa0(%rdi), %eax
movl %eax, 0x4(%rbx)
movzwl 0xa8(%rdi), %eax
movw %ax, 0x8(%rbx)
movq 0x90(%rdi), %rax
movq %rax, 0xa(%rbx)
movups 0x80(%rdi), %xmm0
movups %xmm0, 0x12(%rbx)
movq 0x98(%rdi), %rax
movq %rax, 0x22(%rbx)
leaq 0x2a(%rbx), %rdi
movl 0xd7a2f7(%rip), %r12d # 0x1567058
leal 0x6(%r12), %edx
xorl %esi, %esi
callq 0x61b760
addq %rbx, %r12
movl 0xd7a2e5(%rip), %r15d # 0x156705c
addq %rbx, %r15
leaq 0x20(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x62ecbf
leaq 0x30(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62ecbf
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x62ecbf
leaq 0x50(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62ecbf
leaq 0x40(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62ecbf
leaq 0x10(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62ecbf
leaq 0x60(%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62ecbf
addq $0x70, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x62ecbf
movl 0xd7a262(%rip), %ecx # 0x156705c
subq %rax, %rbx
addq %rcx, %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61b760
| _ZL29set_global_from_ddl_log_entryPK16st_ddl_log_entry:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdi
mov rbx, qword ptr cs:_ZL14global_ddl_log; global_ddl_log
mov al, [rdi+0ACh]
mov [rbx], al
mov al, [rdi+0B0h]
mov [rbx+1], al
mov al, [rdi+0B4h]
mov [rbx+2], al
mov eax, [rdi+0A0h]
mov [rbx+4], eax
movzx eax, word ptr [rdi+0A8h]
mov [rbx+8], ax
mov rax, [rdi+90h]
mov [rbx+0Ah], rax
movups xmm0, xmmword ptr [rdi+80h]
movups xmmword ptr [rbx+12h], xmm0
mov rax, [rdi+98h]
mov [rbx+22h], rax
lea rdi, [rbx+2Ah]
mov r12d, cs:dword_1567058
lea edx, [r12+6]
xor esi, esi
call _memset
add r12, rbx
mov r15d, cs:dword_156705C
add r15, rbx
lea rdx, [r14+20h]
mov rdi, r12
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
lea rdx, [r14+30h]
mov rdi, rax
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
mov rdi, rax
mov rsi, r15
mov rdx, r14
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
lea rdx, [r14+50h]
mov rdi, rax
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
lea rdx, [r14+40h]
mov rdi, rax
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
lea rdx, [r14+10h]
mov rdi, rax
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
lea rdx, [r14+60h]
mov rdi, rax
mov rsi, r15
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
add r14, 70h ; 'p'
mov rdi, rax
mov rsi, r15
mov rdx, r14
call _ZL12store_stringPhS_PK25st_mysql_const_lex_string; store_string(uchar *,uchar *,st_mysql_const_lex_string const*)
mov ecx, cs:dword_156705C
sub rbx, rax
add rbx, rcx
mov rdi, rax
xor esi, esi
mov rdx, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _memset
| long long set_global_from_ddl_log_entry(long long a1)
{
long long v1; // rbx
long long v2; // r12
unsigned long long v3; // r15
_WORD *v4; // rax
_WORD *v5; // rax
_WORD *v6; // rax
_WORD *v7; // rax
_WORD *v8; // rax
_WORD *v9; // rax
_WORD *v10; // rax
long long v11; // rax
v1 = global_ddl_log;
*(_BYTE *)global_ddl_log = *(_BYTE *)(a1 + 172);
*(_BYTE *)(v1 + 1) = *(_BYTE *)(a1 + 176);
*(_BYTE *)(v1 + 2) = *(_BYTE *)(a1 + 180);
*(_DWORD *)(v1 + 4) = *(_DWORD *)(a1 + 160);
*(_WORD *)(v1 + 8) = *(_WORD *)(a1 + 168);
*(_QWORD *)(v1 + 10) = *(_QWORD *)(a1 + 144);
*(_OWORD *)(v1 + 18) = *(_OWORD *)(a1 + 128);
*(_QWORD *)(v1 + 34) = *(_QWORD *)(a1 + 152);
v2 = (unsigned int)dword_1567058;
memset(v1 + 42, 0LL, (unsigned int)(dword_1567058 + 6));
v3 = v1 + (unsigned int)dword_156705C;
v4 = (_WORD *)store_string((_WORD *)(v1 + v2), v3, (_QWORD *)(a1 + 32));
v5 = (_WORD *)store_string(v4, v3, (_QWORD *)(a1 + 48));
v6 = (_WORD *)store_string(v5, v3, (_QWORD *)a1);
v7 = (_WORD *)store_string(v6, v3, (_QWORD *)(a1 + 80));
v8 = (_WORD *)store_string(v7, v3, (_QWORD *)(a1 + 64));
v9 = (_WORD *)store_string(v8, v3, (_QWORD *)(a1 + 16));
v10 = (_WORD *)store_string(v9, v3, (_QWORD *)(a1 + 96));
v11 = store_string(v10, v3, (_QWORD *)(a1 + 112));
return memset(v11, 0LL, (unsigned int)dword_156705C + v1 - v11);
}
| ~sp_cursor:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x1455610]
MOV qword ptr [RDI],RAX
LAB_007ecd00:
CALL 0x007f0232
POP RBP
RET
|
/* sp_cursor::~sp_cursor() */
void __thiscall sp_cursor::~sp_cursor(sp_cursor *this)
{
*(int ***)this = &PTR__sp_cursor_01455610;
/* try { // try from 007ecd00 to 007ecd04 has its CatchHandler @ 007ecd07 */
destroy(this);
return;
}
| |
35,217 | my_strnxfrm_latin1_de | eloqsql/strings/ctype-latin1.c | static size_t
my_strnxfrm_latin1_de(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar* src, size_t srclen, uint flags)
{
uchar *de= dst + dstlen;
const uchar *se= src + srclen;
uchar *d0= dst;
for ( ; src < se && dst < de && nweights; src++, nweights--)
{
uchar chr= combo1map[*src];
*dst++= chr;
if ((chr= combo2map[*src]) && dst < de && nweights > 1)
{
*dst++= chr;
nweights--;
}
}
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, de, nweights, flags, 0);
} | O0 | c | my_strnxfrm_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x462ea
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x38(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x462ea
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x462f6
jmp 0x46387
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x10070a(%rip), %rax # 0x146a10
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1007e0(%rip), %rax # 0x146b10
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4636b
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x4636b
cmpl $0x1, -0x1c(%rbp)
jbe 0x4636b
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4636d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x462c2
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x49390
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_strnxfrm_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_48], rax
loc_462C2:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_4A], al
jnb short loc_462EA
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_38]
mov [rbp+var_4A], al
jnb short loc_462EA
cmp [rbp+var_1C], 0
setnz al
mov [rbp+var_4A], al
loc_462EA:
mov al, [rbp+var_4A]
test al, 1
jnz short loc_462F6
jmp loc_46387
loc_462F6:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_49], al
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_49], al
movzx eax, al
cmp eax, 0
jz short loc_4636B
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_4636B
cmp [rbp+var_1C], 1
jbe short loc_4636B
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
loc_4636B:
jmp short $+2
loc_4636D:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp loc_462C2
loc_46387:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 60h
pop rbp
retn
| long long my_strnxfrm_latin1_de(
int a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 *a5,
long long a6,
int a7)
{
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // rax
bool v10; // [rsp+16h] [rbp-4Ah]
unsigned __int8 v11; // [rsp+17h] [rbp-49h]
unsigned long long v12; // [rsp+28h] [rbp-38h]
unsigned __int8 *v13; // [rsp+38h] [rbp-28h]
unsigned __int8 *v15; // [rsp+50h] [rbp-10h]
v15 = a2;
v13 = a5;
v12 = (unsigned long long)&a2[a3];
while ( 1 )
{
v10 = 0;
if ( v13 < &a5[a6] )
{
v10 = 0;
if ( (unsigned long long)v15 < v12 )
v10 = a4 != 0;
}
if ( !v10 )
break;
v7 = v15++;
*v7 = combo1map[*v13];
v11 = combo2map[*v13];
if ( v11 && (unsigned long long)v15 < v12 && a4 > 1 )
{
v8 = v15++;
*v8 = v11;
--a4;
}
++v13;
--a4;
}
return my_strxfrm_pad_desc_and_reverse(a1, (_DWORD)a2, (_DWORD)v15, v12, a4, a7, 0);
}
| my_strnxfrm_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RAX
LAB_001462c2:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x001462ea
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x001462ea
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_001462ea:
MOV AL,byte ptr [RBP + -0x4a]
TEST AL,0x1
JNZ 0x001462f6
JMP 0x00146387
LAB_001462f6:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x246a10]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x246b10]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014636b
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0014636b
CMP dword ptr [RBP + -0x1c],0x1
JBE 0x0014636b
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_0014636b:
JMP 0x0014636d
LAB_0014636d:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001462c2
LAB_00146387:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00149390
ADD RSP,0x60
POP RBP
RET
|
void my_strnxfrm_latin1_de
(int8 param_1,char *param_2,long param_3,uint param_4,byte *param_5,
long param_6,int4 param_7)
{
char *pcVar1;
char *pcVar2;
bool bVar3;
byte *local_30;
uint local_24;
char *local_18;
pcVar1 = param_2 + param_3;
local_30 = param_5;
local_24 = param_4;
local_18 = param_2;
while( true ) {
bVar3 = false;
if ((local_30 < param_5 + param_6) && (bVar3 = false, local_18 < pcVar1)) {
bVar3 = local_24 != 0;
}
if (!bVar3) break;
pcVar2 = local_18 + 1;
*local_18 = combo1map[*local_30];
if (((combo2map[*local_30] != '\0') && (pcVar2 < pcVar1)) && (1 < local_24)) {
*pcVar2 = combo2map[*local_30];
local_24 = local_24 - 1;
pcVar2 = local_18 + 2;
}
local_18 = pcVar2;
local_30 = local_30 + 1;
local_24 = local_24 - 1;
}
my_strxfrm_pad_desc_and_reverse(param_1,param_2,local_18,pcVar1,local_24,param_7,0);
return;
}
| |
35,218 | js_shr_slow | bluesky950520[P]quickjs/quickjs.c | static no_inline int js_shr_slow(JSContext *ctx, JSValue *sp)
{
JSValue op1, op2;
uint32_t v1, v2, r;
op1 = sp[-2];
op2 = sp[-1];
op1 = JS_ToNumericFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
op2 = JS_ToNumericFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
if ((JS_VALUE_GET_TAG(op1) == JS_TAG_BIG_INT ||
JS_VALUE_GET_TAG(op2) == JS_TAG_BIG_INT)) {
JS_ThrowTypeError(ctx, "BigInt operands are forbidden for >>>");
JS_FreeValue(ctx, op1);
JS_FreeValue(ctx, op2);
goto exception;
}
/* cannot give an exception */
JS_ToUint32Free(ctx, &v1, op1);
JS_ToUint32Free(ctx, &v2, op2);
r = v1 >> (v2 & 0x1f);
sp[-2] = js_uint32(r);
return 0;
exception:
sp[-2] = JS_UNDEFINED;
sp[-1] = JS_UNDEFINED;
return -1;
} | O1 | c | js_shr_slow:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq -0x20(%rsi), %rsi
movq -0x18(%rbx), %rdx
movq -0x10(%rbx), %rbp
movq -0x8(%rbx), %r13
movl $0x1, %ecx
callq 0x42b20
movq %rdx, %r15
movl %r15d, %r12d
cmpq $0x6, %r12
jne 0x40f5b
movq 0x18(%r14), %rdi
movq %rbp, %rsi
movq %r13, %rdx
jmp 0x40f8e
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x42b20
movq %rax, %rbp
movq %rdx, %r13
movl %r13d, %eax
cmpq $0x6, %rax
jne 0x40fbc
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
xorl %eax, %eax
movl %eax, -0x20(%rbx)
movl $0x3, %ecx
movq %rcx, -0x18(%rbx)
movl %eax, -0x10(%rbx)
movq %rcx, -0x8(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffff7, %ecx # imm = 0xFFFFFFF7
cmpl %ecx, %r12d
je 0x41026
cmpl %ecx, %eax
je 0x41026
leaq 0x14(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
callq 0x279c3
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x279c3
movl (%r12), %edx
movb (%r15), %cl
shrl %cl, %edx
xorl %eax, %eax
testl %edx, %edx
cvtsi2sd %rdx, %xmm0
movq %xmm0, %rcx
cmovnsq %rdx, %rcx
movl $0x7, %edx
cmovnsq %rax, %rdx
movq %rcx, -0x20(%rbx)
movq %rdx, -0x18(%rbx)
jmp 0x40fad
leaq 0x5e678(%rip), %rsi # 0x9f6a5
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
jmp 0x40f4f
| js_shr_slow:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rsi, [rsi-20h]
mov rdx, [rbx-18h]
mov rbp, [rbx-10h]
mov r13, [rbx-8]
mov ecx, 1
call JS_ToNumberHintFree
mov r15, rdx
mov r12d, r15d
cmp r12, 6
jnz short loc_40F5B
loc_40F4F:
mov rdi, [r14+18h]
mov rsi, rbp
mov rdx, r13
jmp short loc_40F8E
loc_40F5B:
mov [rsp+48h+var_40], rax
mov rdi, r14
mov rsi, rbp
mov rdx, r13
mov ecx, 1
call JS_ToNumberHintFree
mov rbp, rax
mov r13, rdx
mov eax, r13d
cmp rax, 6
jnz short loc_40FBC
mov rdi, [r14+18h]
mov rsi, [rsp+48h+var_40]
mov rdx, r15
loc_40F8E:
call JS_FreeValueRT
xor eax, eax
mov [rbx-20h], eax
mov ecx, 3
mov [rbx-18h], rcx
mov [rbx-10h], eax
mov [rbx-8], rcx
mov eax, 0FFFFFFFFh
loc_40FAD:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40FBC:
mov ecx, 0FFFFFFF7h
cmp r12d, ecx
jz short loc_41026
cmp eax, ecx
jz short loc_41026
lea r12, [rsp+48h+var_34]
mov rdi, r14
mov rsi, r12
mov rdx, [rsp+48h+var_40]
mov rcx, r15
call JS_ToInt32Free
lea r15, [rsp+48h+var_38]
mov rdi, r14
mov rsi, r15
mov rdx, rbp
mov rcx, r13
call JS_ToInt32Free
mov edx, [r12]
mov cl, [r15]
shr edx, cl
xor eax, eax
test edx, edx
cvtsi2sd xmm0, rdx
movq rcx, xmm0
cmovns rcx, rdx
mov edx, 7
cmovns rdx, rax
mov [rbx-20h], rcx
mov [rbx-18h], rdx
jmp short loc_40FAD
loc_41026:
lea rsi, aBigintOperands; "BigInt operands are forbidden for >>>"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov rdi, [r14+18h]
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call JS_FreeValueRT
jmp loc_40F4F
| long long js_shr_slow(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long v11; // rbp
long long v12; // r13
long long v13; // rax
long long v14; // rdx
long long v15; // r15
int v16; // r12d
long long v17; // rdi
_DWORD *v18; // rsi
long long v19; // rdx
long long v20; // rdx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long result; // rax
char v26; // [rsp+0h] [rbp-48h]
_DWORD *v27; // [rsp+8h] [rbp-40h]
int v28; // [rsp+10h] [rbp-38h] BYREF
unsigned int v29[13]; // [rsp+14h] [rbp-34h] BYREF
v11 = *(_QWORD *)(a2 - 16);
v12 = *(_QWORD *)(a2 - 8);
v13 = JS_ToNumberHintFree(a1, *(_QWORD *)(a2 - 32), *(_QWORD *)(a2 - 24), 1LL);
v15 = v14;
v16 = v14;
if ( (unsigned int)v14 == 6LL )
goto LABEL_2;
v27 = (_DWORD *)v13;
v11 = JS_ToNumberHintFree(a1, v11, v12, 1LL);
v12 = v20;
if ( (unsigned int)v20 == 6LL )
{
v17 = *(_QWORD *)(a1 + 24);
v18 = v27;
v19 = v15;
goto LABEL_5;
}
if ( v16 == -9 || (_DWORD)v20 == -9 )
{
JS_ThrowTypeError(
a1,
(long long)"BigInt operands are forbidden for >>>",
v20,
4294967287LL,
v21,
v22,
a3,
a4,
a5,
a6,
v23,
v24,
a9,
a10,
v26);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v27, v15);
LABEL_2:
v17 = *(_QWORD *)(a1 + 24);
v18 = (_DWORD *)v11;
v19 = v12;
LABEL_5:
JS_FreeValueRT(v17, v18, v19);
*(_DWORD *)(a2 - 32) = 0;
*(_QWORD *)(a2 - 24) = 3LL;
*(_DWORD *)(a2 - 16) = 0;
*(_QWORD *)(a2 - 8) = 3LL;
return 0xFFFFFFFFLL;
}
JS_ToInt32Free(a1, (int *)v29, (unsigned long long)v27, v15);
JS_ToInt32Free(a1, &v28, v11, v12);
result = 0LL;
*(_QWORD *)(a2 - 32) = v29[0] >> v28;
*(_QWORD *)(a2 - 24) = 0LL;
return result;
}
| js_shr_slow:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RSI + -0x20]
MOV RDX,qword ptr [RBX + -0x18]
MOV RBP,qword ptr [RBX + -0x10]
MOV R13,qword ptr [RBX + -0x8]
MOV ECX,0x1
CALL 0x00142b20
MOV R15,RDX
MOV R12D,R15D
CMP R12,0x6
JNZ 0x00140f5b
LAB_00140f4f:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,RBP
MOV RDX,R13
JMP 0x00140f8e
LAB_00140f5b:
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,R14
MOV RSI,RBP
MOV RDX,R13
MOV ECX,0x1
CALL 0x00142b20
MOV RBP,RAX
MOV R13,RDX
MOV EAX,R13D
CMP RAX,0x6
JNZ 0x00140fbc
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
LAB_00140f8e:
CALL 0x0011d8c6
XOR EAX,EAX
MOV dword ptr [RBX + -0x20],EAX
MOV ECX,0x3
MOV qword ptr [RBX + -0x18],RCX
MOV dword ptr [RBX + -0x10],EAX
MOV qword ptr [RBX + -0x8],RCX
MOV EAX,0xffffffff
LAB_00140fad:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140fbc:
MOV ECX,0xfffffff7
CMP R12D,ECX
JZ 0x00141026
CMP EAX,ECX
JZ 0x00141026
LEA R12,[RSP + 0x14]
MOV RDI,R14
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,R15
CALL 0x001279c3
LEA R15,[RSP + 0x10]
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBP
MOV RCX,R13
CALL 0x001279c3
MOV EDX,dword ptr [R12]
MOV CL,byte ptr [R15]
SHR EDX,CL
XOR EAX,EAX
TEST EDX,EDX
CVTSI2SD XMM0,RDX
MOVQ RCX,XMM0
CMOVNS RCX,RDX
MOV EDX,0x7
CMOVNS RDX,RAX
MOV qword ptr [RBX + -0x20],RCX
MOV qword ptr [RBX + -0x18],RDX
JMP 0x00140fad
LAB_00141026:
LEA RSI,[0x19f6a5]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0011d8c6
JMP 0x00140f4f
|
int8 js_shr_slow(long param_1,long param_2)
{
int8 uVar1;
double dVar2;
ulong uVar3;
int8 uVar4;
int1 auVar5 [16];
int1 auVar6 [16];
byte local_38 [4];
uint local_34;
uVar4 = *(int8 *)*(int1 (*) [16])(param_2 + -0x10);
uVar1 = *(int8 *)(param_2 + -8);
auVar6 = *(int1 (*) [16])(param_2 + -0x10);
auVar5 = JS_ToNumberHintFree(param_1,*(int8 *)(param_2 + -0x20),
*(int8 *)(param_2 + -0x18),1);
uVar3 = auVar5._8_8_;
if ((uVar3 & 0xffffffff) != 6) {
auVar6 = JS_ToNumberHintFree(param_1,uVar4,uVar1,1);
if ((auVar6._8_8_ & 0xffffffff) == 6) {
uVar4 = *(int8 *)(param_1 + 0x18);
goto LAB_00140f8e;
}
if ((auVar5._8_4_ != -9) && (auVar6._8_4_ != -9)) {
JS_ToInt32Free(param_1,&local_34,auVar5._0_8_,uVar3);
JS_ToInt32Free(param_1,local_38,auVar6._0_8_,auVar6._8_8_);
local_34 = local_34 >> (local_38[0] & 0x1f);
dVar2 = (double)local_34;
if (-1 < (int)local_34) {
dVar2 = (double)(ulong)local_34;
}
uVar4 = 7;
if (-1 < (int)local_34) {
uVar4 = 0;
}
*(double *)(param_2 + -0x20) = dVar2;
*(int8 *)(param_2 + -0x18) = uVar4;
return 0;
}
JS_ThrowTypeError(param_1,"BigInt operands are forbidden for >>>");
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar5._0_8_,uVar3);
}
auVar5 = auVar6;
uVar4 = *(int8 *)(param_1 + 0x18);
LAB_00140f8e:
JS_FreeValueRT(uVar4,auVar5._0_8_,auVar5._8_8_);
*(int4 *)(param_2 + -0x20) = 0;
*(int8 *)(param_2 + -0x18) = 3;
*(int4 *)(param_2 + -0x10) = 0;
*(int8 *)(param_2 + -8) = 3;
return 0xffffffff;
}
| |
35,219 | ma_remove_not_visible_states | eloqsql/storage/maria/ma_state.c | MARIA_STATE_HISTORY
*_ma_remove_not_visible_states(MARIA_STATE_HISTORY *org_history,
my_bool all,
my_bool trnman_is_locked)
{
TrID last_trid;
MARIA_STATE_HISTORY *history, **parent, *next;
DBUG_ENTER("_ma_remove_not_visible_states");
if (!org_history)
DBUG_RETURN(0); /* Not versioned table */
last_trid= org_history->trid;
parent= &org_history->next;
for (history= org_history->next; history; history= next)
{
next= history->next;
if (!trnman_exists_active_transactions(history->trid, last_trid,
trnman_is_locked))
{
DBUG_PRINT("info", ("removing history->trid: %lu next: %lu",
(ulong) history->trid, (ulong) last_trid));
my_free(history);
continue;
}
*parent= history;
parent= &history->next;
last_trid= history->trid;
}
*parent= 0;
if (all && parent == &org_history->next)
{
/* There is only one state left. Delete this if it's visible for all */
if (last_trid < trnman_get_min_trid())
{
my_free(org_history);
org_history= 0;
}
}
DBUG_RETURN(org_history);
} | O3 | c | ma_remove_not_visible_states:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x33b7f
movl %esi, -0x2c(%rbp)
movq (%rdi), %r13
movq 0x8(%rdi), %r14
testq %r13, %r13
movq %rdi, -0x38(%rbp)
je 0x33b4b
movsbl %dl, %r12d
movq %rdi, %rbx
movq (%r13), %r15
movq 0x8(%r13), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x41ca9
testb %al, %al
je 0x33b39
movq %r13, (%rbx)
movq 0x8(%r13), %r14
movq %r13, %rbx
jmp 0x33b41
movq %r13, %rdi
callq 0xbf54e
movq %r15, %r13
testq %r15, %r15
jne 0x33b16
jmp 0x33b4e
movq %rdi, %rbx
movq $0x0, (%rbx)
cmpb $0x0, -0x2c(%rbp)
sete %al
movq -0x38(%rbp), %rcx
cmpq %rcx, %rbx
movq %rcx, %rbx
setne %cl
orb %al, %cl
jne 0x33b81
callq 0x41bbe
cmpq %rax, %r14
jae 0x33b81
movq %rbx, %rdi
callq 0xbf54e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_remove_not_visible_states:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
test rdi, rdi
jz loc_33B7F
mov [rbp+var_2C], esi
mov r13, [rdi]
mov r14, [rdi+8]
test r13, r13
mov [rbp+var_38], rdi
jz short loc_33B4B
movsx r12d, dl
mov rbx, rdi
loc_33B16:
mov r15, [r13+0]
mov rdi, [r13+8]
mov rsi, r14
mov edx, r12d
call trnman_exists_active_transactions
test al, al
jz short loc_33B39
mov [rbx], r13
mov r14, [r13+8]
mov rbx, r13
jmp short loc_33B41
loc_33B39:
mov rdi, r13
call my_free
loc_33B41:
mov r13, r15
test r15, r15
jnz short loc_33B16
jmp short loc_33B4E
loc_33B4B:
mov rbx, rdi
loc_33B4E:
mov qword ptr [rbx], 0
cmp byte ptr [rbp+var_2C], 0
setz al
mov rcx, [rbp+var_38]
cmp rbx, rcx
mov rbx, rcx
setnz cl
or cl, al
jnz short loc_33B81
call trnman_get_min_trid
cmp r14, rax
jnb short loc_33B81
mov rdi, rbx
call my_free
loc_33B7F:
xor ebx, ebx
loc_33B81:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * ma_remove_not_visible_states(_QWORD *a1, char a2, char a3)
{
_QWORD *v3; // r13
unsigned long long v4; // r14
unsigned int v5; // r12d
_QWORD *v6; // rbx
_QWORD *v7; // r15
bool v8; // zf
_QWORD *v9; // rbx
if ( !a1 )
return 0LL;
v3 = (_QWORD *)*a1;
v4 = a1[1];
if ( *a1 )
{
v5 = a3;
v6 = a1;
do
{
v7 = (_QWORD *)*v3;
if ( (unsigned __int8)trnman_exists_active_transactions(v3[1], v4, v5) )
{
*v6 = v3;
v4 = v3[1];
v6 = v3;
}
else
{
my_free(v3);
}
v3 = v7;
}
while ( v7 );
}
else
{
v6 = a1;
}
*v6 = 0LL;
v8 = v6 == a1;
v9 = a1;
if ( a2 != 0 && v8 && v4 < trnman_get_min_trid() )
{
my_free(a1);
return 0LL;
}
return v9;
}
| _ma_remove_not_visible_states:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
TEST RDI,RDI
JZ 0x00133b7f
MOV dword ptr [RBP + -0x2c],ESI
MOV R13,qword ptr [RDI]
MOV R14,qword ptr [RDI + 0x8]
TEST R13,R13
MOV qword ptr [RBP + -0x38],RDI
JZ 0x00133b4b
MOVSX R12D,DL
MOV RBX,RDI
LAB_00133b16:
MOV R15,qword ptr [R13]
MOV RDI,qword ptr [R13 + 0x8]
MOV RSI,R14
MOV EDX,R12D
CALL 0x00141ca9
TEST AL,AL
JZ 0x00133b39
MOV qword ptr [RBX],R13
MOV R14,qword ptr [R13 + 0x8]
MOV RBX,R13
JMP 0x00133b41
LAB_00133b39:
MOV RDI,R13
CALL 0x001bf54e
LAB_00133b41:
MOV R13,R15
TEST R15,R15
JNZ 0x00133b16
JMP 0x00133b4e
LAB_00133b4b:
MOV RBX,RDI
LAB_00133b4e:
MOV qword ptr [RBX],0x0
CMP byte ptr [RBP + -0x2c],0x0
SETZ AL
MOV RCX,qword ptr [RBP + -0x38]
CMP RBX,RCX
MOV RBX,RCX
SETNZ CL
OR CL,AL
JNZ 0x00133b81
CALL 0x00141bbe
CMP R14,RAX
JNC 0x00133b81
MOV RDI,RBX
CALL 0x001bf54e
LAB_00133b7f:
XOR EBX,EBX
LAB_00133b81:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * _ma_remove_not_visible_states(int8 *param_1,char param_2,char param_3)
{
int8 *puVar1;
char cVar2;
ulong uVar3;
int8 *puVar4;
int8 *puVar5;
ulong uVar6;
if (param_1 != (int8 *)0x0) {
uVar6 = param_1[1];
puVar4 = param_1;
if ((int8 *)*param_1 != (int8 *)0x0) {
puVar5 = (int8 *)*param_1;
do {
puVar1 = (int8 *)*puVar5;
cVar2 = trnman_exists_active_transactions(puVar5[1],uVar6,(int)param_3);
if (cVar2 == '\0') {
my_free(puVar5);
}
else {
*puVar4 = puVar5;
uVar6 = puVar5[1];
puVar4 = puVar5;
}
puVar5 = puVar1;
} while (puVar1 != (int8 *)0x0);
}
*puVar4 = 0;
if (puVar4 != param_1 || param_2 == '\0') {
return param_1;
}
uVar3 = trnman_get_min_trid();
if (uVar3 <= uVar6) {
return param_1;
}
my_free(param_1);
}
return (int8 *)0x0;
}
| |
35,220 | find_end | corpus-core[P]colibri-stateless/src/util/json_validate.c | static const char* find_end(const char* pos, char start, char end) {
int level = 1;
for (; *pos; pos++) {
if (*pos == start)
level++;
else if (*pos == end) {
level--;
if (!level) return pos;
}
}
return NULL;
} | O0 | c | find_end:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa5e29
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa5ded
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa5e19
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa5e17
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xa5e15
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa5e31
jmp 0xa5e17
jmp 0xa5e19
jmp 0xa5e1b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa5dca
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| find_end_0:
push rbp
mov rbp, rsp
mov al, dl
mov cl, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], cl
mov [rbp+var_12], al
mov [rbp+var_18], 1
loc_A5DCA:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_A5E29
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_11]
cmp eax, ecx
jnz short loc_A5DED
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
jmp short loc_A5E19
loc_A5DED:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_12]
cmp eax, ecx
jnz short loc_A5E17
mov eax, [rbp+var_18]
add eax, 0FFFFFFFFh
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jnz short loc_A5E15
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp short loc_A5E31
loc_A5E15:
jmp short $+2
loc_A5E17:
jmp short $+2
loc_A5E19:
jmp short $+2
loc_A5E1B:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_A5DCA
loc_A5E29:
mov [rbp+var_8], 0
loc_A5E31:
mov rax, [rbp+var_8]
pop rbp
retn
| _BYTE * find_end_0(_BYTE *a1, char a2, char a3)
{
int v4; // [rsp+0h] [rbp-18h]
v4 = 1;
while ( *a1 )
{
if ( (char)*a1 == a2 )
{
++v4;
}
else if ( (char)*a1 == a3 && !--v4 )
{
return a1;
}
++a1;
}
return 0LL;
}
| find_end:
PUSH RBP
MOV RBP,RSP
MOV AL,DL
MOV CL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],CL
MOV byte ptr [RBP + -0x12],AL
MOV dword ptr [RBP + -0x18],0x1
LAB_001a5dca:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x001a5e29
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x11]
CMP EAX,ECX
JNZ 0x001a5ded
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001a5e19
LAB_001a5ded:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x12]
CMP EAX,ECX
JNZ 0x001a5e17
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001a5e15
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a5e31
LAB_001a5e15:
JMP 0x001a5e17
LAB_001a5e17:
JMP 0x001a5e19
LAB_001a5e19:
JMP 0x001a5e1b
LAB_001a5e1b:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001a5dca
LAB_001a5e29:
MOV qword ptr [RBP + -0x8],0x0
LAB_001a5e31:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * find_end(char *param_1,char param_2,char param_3)
{
int local_20;
char *local_18;
local_20 = 1;
local_18 = param_1;
do {
if (*local_18 == '\0') {
return (char *)0x0;
}
if (*local_18 == param_2) {
local_20 = local_20 + 1;
}
else if ((*local_18 == param_3) && (local_20 = local_20 + -1, local_20 == 0)) {
return local_18;
}
local_18 = local_18 + 1;
} while( true );
}
| |
35,221 | js_set_isDisjointFrom | bluesky950520[P]quickjs/quickjs.c | static JSValue js_set_isDisjointFrom(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, iter, keys, has, next, rv, rval;
BOOL done, found;
JSMapState *s;
int64_t size;
int ok;
has = JS_UNDEFINED;
iter = JS_UNDEFINED;
keys = JS_UNDEFINED;
next = JS_UNDEFINED;
rval = JS_EXCEPTION;
s = JS_GetOpaque2(ctx, this_val, JS_CLASS_SET);
if (!s)
goto exception;
// order matters!
if (js_setlike_get_size(ctx, argv[0], &size) < 0)
goto exception;
if (js_setlike_get_has(ctx, argv[0], &has) < 0)
goto exception;
if (js_setlike_get_keys(ctx, argv[0], &keys) < 0)
goto exception;
if (s->record_count > size) {
iter = JS_Call(ctx, keys, argv[0], 0, NULL);
if (JS_IsException(iter))
goto exception;
next = JS_GetProperty(ctx, iter, JS_ATOM_next);
if (JS_IsException(next))
goto exception;
found = FALSE;
do {
item = JS_IteratorNext(ctx, iter, next, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done) // item is JS_UNDEFINED
break;
item = map_normalize_key(ctx, item);
found = (NULL != map_find_record(ctx, s, item));
JS_FreeValue(ctx, item);
} while (!found);
} else {
iter = js_create_map_iterator(ctx, this_val, 0, NULL, MAGIC_SET);
if (JS_IsException(iter))
goto exception;
found = FALSE;
do {
item = js_map_iterator_next(ctx, iter, 0, NULL, &done, MAGIC_SET);
if (JS_IsException(item))
goto exception;
if (done) // item is JS_UNDEFINED
break;
rv = JS_Call(ctx, has, argv[0], 1, &item);
JS_FreeValue(ctx, item);
ok = JS_ToBoolFree(ctx, rv); // returns -1 if rv is JS_EXCEPTION
if (ok < 0)
goto exception;
found = (ok > 0);
} while (!found);
}
rval = !found ? JS_TRUE : JS_FALSE;
exception:
JS_FreeValue(ctx, has);
JS_FreeValue(ctx, keys);
JS_FreeValue(ctx, iter);
JS_FreeValue(ctx, next);
return rval;
} | O1 | c | js_set_isDisjointFrom:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movl %r12d, 0x58(%rsp)
movl $0x3, %ecx
movq %rcx, 0x60(%rsp)
movl %r12d, 0x68(%rsp)
movl $0x3, %eax
movq %rax, 0x40(%rsp)
movq %rcx, 0x70(%rsp)
movl $0x24, %ecx
callq 0x275b5
testq %rax, %rax
je 0x5027a
movq %rax, %r15
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x90(%rsp), %rcx
movq %rbx, %rdi
callq 0x51de9
testl %eax, %eax
js 0x50277
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x58(%rsp), %rcx
movq %rbx, %rdi
callq 0x51ebd
testl %eax, %eax
js 0x50277
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
callq 0x51f57
testl %eax, %eax
js 0x50277
movl 0x18(%r15), %eax
cmpq %rax, 0x90(%rsp)
jge 0x502e9
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%r13), %rcx
movq 0x8(%r13), %r8
movl $0x0, 0x78(%rsp)
movq $0x3, 0x80(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x284ca
movq %rax, %rbp
cmpl $0x6, %edx
movl $0x6, %r14d
jne 0x50410
xorl %r13d, %r13d
movq %rdx, %r15
jmp 0x5028b
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x3, %r15d
xorl %r13d, %r13d
movl $0x6, %r14d
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq 0x40(%rsp), %rdx
callq 0x1d8c6
movq %r13, %rax
movq %r14, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movl $0x1, %r9d
callq 0x4ffa9
movq %rax, %rbp
movq %rdx, %r15
xorl %r12d, %r12d
cmpl $0x6, %r15d
je 0x50282
movq %rbp, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x88(%rsp)
xorl %ebp, %ebp
movl $0x1, (%rsp)
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %r15, %rdx
leaq 0x3c(%rsp), %r9
callq 0x51ff1
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
cmpl $0x6, %edx
je 0x5050d
cmpl $0x0, 0x3c(%rsp)
jne 0x50401
movq %r15, %r12
movq (%r13), %rcx
movq 0x8(%r13), %r8
movl $0x0, 0x78(%rsp)
movq $0x3, 0x80(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq 0x88(%rsp), %rdx
movl $0x1, %r9d
callq 0x284ca
movq %rax, %r14
movq %rdx, %r15
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22d0d
testl %eax, %eax
js 0x50520
setne %al
movzbl %al, %ebp
movq %r12, %r15
movl $0x0, %r12d
je 0x5032e
movl $0x3, %eax
movq %rax, 0x40(%rsp)
jmp 0x504fc
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x6b, %ecx
movq %rbp, %r8
movq %rdx, 0x28(%rsp)
movq %rdx, %r9
callq 0x22fa3
movq %rax, %r12
xorl %r13d, %r13d
movq %rdx, 0x40(%rsp)
cmpl $0x6, %edx
je 0x5054e
movq %rbp, 0x30(%rsp)
xorl %ebp, %ebp
leaq 0x3c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rcx
movq 0x40(%rsp), %r8
xorl %r9d, %r9d
callq 0x41afc
movq %rdx, %rcx
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, %edx
cmpq $0x6, %rdx
je 0x50543
cmpl $0x0, 0x3c(%rsp)
jne 0x504f7
xorq $0x7, %rdx
movq %rax, %rsi
btrq $0x3f, %rsi
orq %rdx, %rsi
jne 0x504ba
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4748d
movq %rax, %r14
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
xorl %ebp, %ebp
testq %r14, %r14
setne %bpl
je 0x50456
movq 0x28(%rsp), %r15
xorl %r13d, %r13d
testl %ebp, %ebp
sete %r13b
movl $0x1, %r14d
jmp 0x50516
xorl %r13d, %r13d
movl $0x6, %r14d
movq 0x30(%rsp), %rbp
jmp 0x5028b
movl $0x3, %eax
movq %rax, 0x40(%rsp)
xorl %r13d, %r13d
movl $0x6, %r14d
movq 0x30(%rsp), %rbp
movq %r12, %r15
xorl %r12d, %r12d
jmp 0x5028b
movl $0x6, %r14d
movq 0x30(%rsp), %rbp
movq 0x28(%rsp), %r15
jmp 0x5028b
| js_set_isDisjointFrom:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r13, r8
mov rbp, rdx
mov r14, rsi
mov rbx, rdi
xor r12d, r12d
mov dword ptr [rsp+0C8h+var_70], r12d
mov ecx, 3
mov [rsp+0C8h+var_68], rcx
mov dword ptr [rsp+0C8h+var_60], r12d
mov eax, 3
mov [rsp+0C8h+var_88], rax
mov [rsp+0C8h+var_58], rcx
mov ecx, 24h ; '$'
call JS_GetOpaque2
test rax, rax
jz loc_5027A
mov r15, rax
mov rsi, [r13+0]
mov rdx, [r13+8]
lea rcx, [rsp+0C8h+var_38]
mov rdi, rbx
call js_setlike_get_size
test eax, eax
js loc_50277
mov rsi, [r13+0]
mov rdx, [r13+8]
lea rcx, [rsp+0C8h+var_70]
mov rdi, rbx
call js_setlike_get_has
test eax, eax
js loc_50277
mov rsi, [r13+0]
mov rdx, [r13+8]
lea rcx, [rsp+0C8h+var_60]
mov rdi, rbx
call js_setlike_get_keys
test eax, eax
js short loc_50277
mov eax, [r15+18h]
cmp [rsp+0C8h+var_38], rax
jge loc_502E9
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
mov rcx, [r13+0]
mov r8, [r13+8]
mov dword ptr [rsp+0C8h+var_50], 0
mov qword ptr [rsp+0C8h+var_50+8], 3
movups xmm0, [rsp+0C8h+var_50]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B0], 2
mov [rsp+0C8h+var_B8], 0
xor r12d, r12d
mov rdi, rbx
xor r9d, r9d
call JS_CallInternal
mov rbp, rax
cmp edx, 6
mov r14d, 6
jnz loc_50410
xor r13d, r13d
mov r15, rdx
jmp short loc_5028B
loc_50277:
xor r12d, r12d
loc_5027A:
xor ebp, ebp
mov r15d, 3
loc_50282:
xor r13d, r13d
mov r14d, 6
loc_5028B:
mov rsi, [rsp+0C8h+var_70]
mov rdx, [rsp+0C8h+var_68]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, rbp
mov rdx, r15
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, [rsp+0C8h+var_88]
call JS_FreeValueRT
mov rax, r13
mov rdx, r14
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_502E9:
mov rdi, rbx
mov rsi, r14
mov rdx, rbp
mov r9d, 1
call js_create_map_iterator
mov rbp, rax
mov r15, rdx
xor r12d, r12d
cmp r15d, 6
jz loc_50282
mov [rsp+0C8h+var_98], rbp
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_A0], rax
mov rax, [rsp+0C8h+var_68]
mov [rsp+0C8h+var_40], rax
xor ebp, ebp
loc_5032E:
mov dword ptr [rsp+0C8h+var_C8], 1
mov rdi, rbx
mov rsi, [rsp+0C8h+var_98]
mov rdx, r15
lea r9, [rsp+0C8h+var_8C]
call js_map_iterator_next
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_78], rdx
cmp edx, 6
jz loc_5050D
cmp [rsp+0C8h+var_8C], 0
jnz loc_50401
mov r12, r15
mov rcx, [r13+0]
mov r8, [r13+8]
mov dword ptr [rsp+0C8h+var_50], 0
mov qword ptr [rsp+0C8h+var_50+8], 3
movups xmm0, [rsp+0C8h+var_50]
movups [rsp+0C8h+var_C8], xmm0
lea rax, [rsp+0C8h+var_80]
mov [rsp+0C8h+var_B8], rax
mov [rsp+0C8h+var_B0], 2
mov rdi, rbx
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_40]
mov r9d, 1
call JS_CallInternal
mov r14, rax
mov r15, rdx
mov rsi, [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_ToBoolFree
test eax, eax
js loc_50520
setnz al
movzx ebp, al
mov r15, r12
mov r12d, 0
jz loc_5032E
loc_50401:
mov eax, 3
mov [rsp+0C8h+var_88], rax
jmp loc_504FC
loc_50410:
mov dword ptr [rsp+0C8h+var_C8+8], 0
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, rbx
mov rsi, rbp
mov ecx, 6Bh ; 'k'
mov r8, rbp
mov [rsp+0C8h+var_A0], rdx
mov r9, rdx
call JS_GetPropertyInternal2
mov r12, rax
xor r13d, r13d
mov [rsp+0C8h+var_88], rdx
cmp edx, 6
jz loc_5054E
mov [rsp+0C8h+var_98], rbp
xor ebp, ebp
loc_50456:
lea rax, [rsp+0C8h+var_8C]
mov qword ptr [rsp+0C8h+var_C8+8], rax
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, rbx
mov rsi, [rsp+0C8h+var_98]
mov rdx, [rsp+0C8h+var_A0]
mov rcx, r12
mov r8, [rsp+0C8h+var_88]
xor r9d, r9d
call JS_IteratorNext
mov rcx, rdx
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_78], rdx
mov edx, ecx
cmp rdx, 6
jz loc_50543
cmp [rsp+0C8h+var_8C], 0
jnz short loc_504F7
xor rdx, 7
mov rsi, rax
btr rsi, 3Fh ; '?'
or rsi, rdx
jnz short loc_504BA
xor eax, eax
xor ecx, ecx
loc_504BA:
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_78], rcx
mov rdi, rbx
mov rsi, r15
mov rdx, rax
call map_find_record
mov r14, rax
mov rsi, [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
mov rdi, [rbx+18h]
call JS_FreeValueRT
xor ebp, ebp
test r14, r14
setnz bpl
jz loc_50456
loc_504F7:
mov r15, [rsp+0C8h+var_A0]
loc_504FC:
xor r13d, r13d
test ebp, ebp
setz r13b
mov r14d, 1
jmp short loc_50516
loc_5050D:
xor r13d, r13d
mov r14d, 6
loc_50516:
mov rbp, [rsp+0C8h+var_98]
jmp loc_5028B
loc_50520:
mov eax, 3
mov [rsp+0C8h+var_88], rax
xor r13d, r13d
mov r14d, 6
mov rbp, [rsp+0C8h+var_98]
mov r15, r12
xor r12d, r12d
jmp loc_5028B
loc_50543:
mov r14d, 6
mov rbp, [rsp+0C8h+var_98]
loc_5054E:
mov r15, [rsp+0C8h+var_A0]
jmp loc_5028B
| _BOOL8 js_set_isDisjointFrom(
long long a1,
_DWORD *a2,
long long a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13)
{
_DWORD *PropertyInternal2; // r12
long long Opaque2; // rax
long long v17; // r15
long long v18; // rcx
long long v19; // r8
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rcx
long long v23; // r8
double v24; // xmm0_8
unsigned long long v25; // rax
long long v26; // rdx
_DWORD *v27; // rbp
_BOOL8 v28; // r13
long long v29; // r15
unsigned long long map_iterator; // rax
int v32; // ecx
int v33; // r8d
long long v34; // rdx
BOOL v35; // ebp
__m128 v36; // xmm4
__m128 v37; // xmm5
long long v38; // rdx
long long v39; // r12
long long v40; // rcx
long long v41; // r8
unsigned long long v42; // r14
long long v43; // rdx
long long v44; // r15
int v45; // eax
long long v46; // rdx
unsigned long long v47; // rax
long long v48; // rdx
long long v49; // rcx
long long record; // r14
_DWORD *v51; // [rsp+28h] [rbp-A0h]
long long v52; // [rsp+28h] [rbp-A0h]
_DWORD *v53; // [rsp+30h] [rbp-98h]
int v54; // [rsp+3Ch] [rbp-8Ch] BYREF
long long v55; // [rsp+40h] [rbp-88h]
_DWORD *v56; // [rsp+48h] [rbp-80h] BYREF
long long v57; // [rsp+50h] [rbp-78h]
_DWORD *v58; // [rsp+58h] [rbp-70h] BYREF
long long v59; // [rsp+60h] [rbp-68h]
_DWORD *v60; // [rsp+68h] [rbp-60h] BYREF
long long v61; // [rsp+70h] [rbp-58h]
__m128 v62; // [rsp+78h] [rbp-50h]
long long v63; // [rsp+88h] [rbp-40h]
long long v64[7]; // [rsp+90h] [rbp-38h] BYREF
PropertyInternal2 = 0LL;
LODWORD(v58) = 0;
v59 = 3LL;
LODWORD(v60) = 0;
v55 = 3LL;
v61 = 3LL;
Opaque2 = JS_GetOpaque2(a1, (long long)a2, a3, 0x24u);
if ( !Opaque2 )
goto LABEL_9;
v17 = Opaque2;
if ( (int)js_setlike_get_size(a1, *a13, a13[1], v64) < 0
|| (int)js_setlike_get_has(a1, *a13, a13[1], &v58) < 0
|| (int)js_setlike_get_keys(a1, *a13, a13[1], &v60) < 0 )
{
PropertyInternal2 = 0LL;
LABEL_9:
v27 = 0LL;
v29 = 3LL;
LABEL_10:
v28 = 0LL;
goto LABEL_11;
}
if ( v64[0] >= *(unsigned int *)(v17 + 24) )
{
map_iterator = js_create_map_iterator(a1, a2, a3, v18, v19, 1);
v27 = (_DWORD *)map_iterator;
v29 = v34;
PropertyInternal2 = 0LL;
if ( (_DWORD)v34 != 6 )
{
v53 = (_DWORD *)map_iterator;
v51 = v58;
v63 = v59;
v35 = 0;
while ( 1 )
{
v56 = (_DWORD *)js_map_iterator_next(a1, (_DWORD)v53, v29, v32, v33, (unsigned int)&v54, 1);
v57 = v38;
if ( (_DWORD)v38 == 6 )
break;
if ( v54 )
goto LABEL_18;
v39 = v29;
v40 = *a13;
v41 = a13[1];
v62.m128_i32[0] = 0;
v62.m128_u64[1] = 3LL;
v42 = JS_CallInternal(
a1,
(long long)v51,
v63,
v40,
v41,
1LL,
v62,
a5,
a6,
a7,
v36,
v37,
a10,
a11,
0,
3,
(long long)&v56,
2u);
v44 = v43;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v56, v57);
v45 = JS_ToBoolFree(a1, v42, v44);
if ( v45 < 0 )
{
v55 = 3LL;
v28 = 0LL;
v27 = v53;
v29 = v39;
PropertyInternal2 = 0LL;
goto LABEL_11;
}
v35 = v45 != 0;
v29 = v39;
PropertyInternal2 = 0LL;
if ( v45 )
{
LABEL_18:
v55 = 3LL;
LABEL_27:
v28 = !v35;
goto LABEL_29;
}
}
v28 = 0LL;
LABEL_29:
v27 = v53;
goto LABEL_11;
}
goto LABEL_10;
}
v22 = *a13;
v23 = a13[1];
v62.m128_i32[0] = 0;
v62.m128_u64[1] = 3LL;
v24 = *(double *)v62.m128_u64;
PropertyInternal2 = 0LL;
v25 = JS_CallInternal(a1, (long long)v60, v61, v22, v23, 0LL, v62, a5, a6, a7, v20, v21, a10, a11, 0, 3, 0LL, 2u);
v27 = (_DWORD *)v25;
if ( (_DWORD)v26 == 6 )
{
v28 = 0LL;
v29 = v26;
}
else
{
v52 = v26;
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, v25, v26, 0x6Bu, v25, v26, 0LL, 0);
v28 = 0LL;
v55 = v46;
if ( (_DWORD)v46 != 6 )
{
v53 = v27;
v35 = 0;
while ( 1 )
{
v47 = JS_IteratorNext(a1, (int)v53, v52, (int)PropertyInternal2, v55, 0, 0LL, &v54);
v49 = v48;
v56 = (_DWORD *)v47;
v57 = v48;
if ( (unsigned int)v48 == 6LL )
break;
if ( !v54 )
{
if ( !((unsigned int)v48 ^ 7LL | v47 & 0x7FFFFFFFFFFFFFFFLL) )
{
v47 = 0LL;
v49 = 0LL;
}
v56 = (_DWORD *)v47;
v57 = v49;
record = map_find_record(a1, v17, (_DWORD *)v47, v49, v24, (__m128d)a5);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v56, v57);
v35 = record != 0;
if ( !record )
continue;
}
v29 = v52;
goto LABEL_27;
}
v27 = v53;
}
v29 = v52;
}
LABEL_11:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v58, v59);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v60, v61);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v27, v29);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PropertyInternal2, v55);
return v28;
}
| |||
35,222 | js_set_isDisjointFrom | bluesky950520[P]quickjs/quickjs.c | static JSValue js_set_isDisjointFrom(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, iter, keys, has, next, rv, rval;
BOOL done, found;
JSMapState *s;
int64_t size;
int ok;
has = JS_UNDEFINED;
iter = JS_UNDEFINED;
keys = JS_UNDEFINED;
next = JS_UNDEFINED;
rval = JS_EXCEPTION;
s = JS_GetOpaque2(ctx, this_val, JS_CLASS_SET);
if (!s)
goto exception;
// order matters!
if (js_setlike_get_size(ctx, argv[0], &size) < 0)
goto exception;
if (js_setlike_get_has(ctx, argv[0], &has) < 0)
goto exception;
if (js_setlike_get_keys(ctx, argv[0], &keys) < 0)
goto exception;
if (s->record_count > size) {
iter = JS_Call(ctx, keys, argv[0], 0, NULL);
if (JS_IsException(iter))
goto exception;
next = JS_GetProperty(ctx, iter, JS_ATOM_next);
if (JS_IsException(next))
goto exception;
found = FALSE;
do {
item = JS_IteratorNext(ctx, iter, next, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done) // item is JS_UNDEFINED
break;
item = map_normalize_key(ctx, item);
found = (NULL != map_find_record(ctx, s, item));
JS_FreeValue(ctx, item);
} while (!found);
} else {
iter = js_create_map_iterator(ctx, this_val, 0, NULL, MAGIC_SET);
if (JS_IsException(iter))
goto exception;
found = FALSE;
do {
item = js_map_iterator_next(ctx, iter, 0, NULL, &done, MAGIC_SET);
if (JS_IsException(item))
goto exception;
if (done) // item is JS_UNDEFINED
break;
rv = JS_Call(ctx, has, argv[0], 1, &item);
JS_FreeValue(ctx, item);
ok = JS_ToBoolFree(ctx, rv); // returns -1 if rv is JS_EXCEPTION
if (ok < 0)
goto exception;
found = (ok > 0);
} while (!found);
}
rval = !found ? JS_TRUE : JS_FALSE;
exception:
JS_FreeValue(ctx, has);
JS_FreeValue(ctx, keys);
JS_FreeValue(ctx, iter);
JS_FreeValue(ctx, next);
return rval;
} | O2 | c | js_set_isDisjointFrom:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rdx, %r13
andl $0x0, 0x40(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
pushq $0x3
popq %r14
movq %r14, 0x48(%rsp)
andl $0x0, 0x50(%rsp)
movq %r14, 0x58(%rsp)
pushq $0x24
popq %rcx
callq 0x21207
testq %rax, %rax
je 0x44de5
movq %rax, %r15
movq (%r12), %rsi
movq 0x8(%r12), %rdx
leaq 0x60(%rsp), %rcx
movq %rbx, %rdi
callq 0x4643b
testl %eax, %eax
js 0x44de5
movq (%r12), %rsi
movq 0x8(%r12), %rdx
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
callq 0x464cf
testl %eax, %eax
js 0x44de5
movq (%r12), %rsi
movq 0x8(%r12), %rdx
leaq 0x50(%rsp), %rcx
movq %rbx, %rdi
callq 0x46558
testl %eax, %eax
js 0x44de5
movl 0x18(%r15), %eax
cmpq %rax, 0x60(%rsp)
jge 0x44e52
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq (%r12), %rcx
movq 0x8(%r12), %r8
andq $0x0, (%rsp)
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x21eb6
movq %rax, %r13
movq %rdx, %rbp
cmpl $0x6, %ebp
je 0x44e6f
pushq $0x6b
popq %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1b043
movq %rdx, %r14
cmpl $0x6, %r14d
movq %rax, 0x10(%rsp)
je 0x44df4
movq %rax, %r12
movq %r13, 0x38(%rsp)
movq %r14, 0x30(%rsp)
andq $0x0, (%rsp)
leaq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x398cc
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movl %edx, %ecx
cmpq $0x6, %rcx
je 0x44f42
cmpl $0x0, 0x1c(%rsp)
jne 0x44f4e
movq %rbp, %r14
xorq $0x7, %rcx
movq %rax, %rsi
btrq $0x3f, %rsi
orq %rcx, %rsi
movl $0x0, %r13d
movl $0x0, %ebp
je 0x44d97
movq %rax, %r13
movq %rdx, %rbp
movq %r13, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3d80d
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1801e
testq %r12, %r12
movq 0x10(%rsp), %r12
movq 0x38(%rsp), %r13
movq %r14, %rbp
movq 0x30(%rsp), %r14
je 0x44d2b
pushq $0x1
jmp 0x44f44
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movq %r14, %rbp
xorl %r12d, %r12d
pushq $0x6
popq %r15
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1801e
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1801e
movq %r12, %rax
movq %r15, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x44ab2
movq %rax, %r13
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x44e7d
movq $0x0, 0x10(%rsp)
jmp 0x44df4
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
leaq 0x1c(%rsp), %r9
callq 0x465e1
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
cmpl $0x6, %edx
je 0x44f24
cmpl $0x0, 0x1c(%rsp)
jne 0x44f2d
movq (%r12), %rcx
movq 0x8(%r12), %r8
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
pushq $0x1
popq %r9
callq 0x21eb6
movq %rax, %r15
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
callq 0x1cdfa
testl %eax, %eax
js 0x44f24
je 0x44e91
xorl %r12d, %r12d
pushq $0x1
jmp 0x44f29
xorl %r12d, %r12d
pushq $0x6
popq %r15
jmp 0x44f34
pushq $0x1
popq %r15
movq %r15, %r12
movq $0x0, 0x10(%rsp)
jmp 0x44dfb
pushq $0x6
popq %r15
xorl %r12d, %r12d
jmp 0x44dfb
pushq $0x1
popq %r15
movq %r15, %r12
jmp 0x44dfb
| js_set_isDisjointFrom:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12, r8
mov r13, rdx
and dword ptr [rsp+98h+var_58], 0
mov rbp, rsi
mov rbx, rdi
push 3
pop r14
mov [rsp+98h+var_50], r14
and dword ptr [rsp+98h+var_48], 0
mov [rsp+98h+var_40], r14
push 24h ; '$'
pop rcx
call JS_GetOpaque2
test rax, rax
jz loc_44DE5
mov r15, rax
mov rsi, [r12]
mov rdx, [r12+8]
lea rcx, [rsp+98h+var_38]
mov rdi, rbx
call js_setlike_get_size
test eax, eax
js loc_44DE5
mov rsi, [r12]
mov rdx, [r12+8]
lea rcx, [rsp+98h+var_58]
mov rdi, rbx
call js_setlike_get_has
test eax, eax
js loc_44DE5
mov rsi, [r12]
mov rdx, [r12+8]
lea rcx, [rsp+98h+var_48]
mov rdi, rbx
call js_setlike_get_keys
test eax, eax
js loc_44DE5
mov eax, [r15+18h]
cmp [rsp+98h+var_38], rax
jge loc_44E52
mov rsi, [rsp+98h+var_48]
mov rdx, [rsp+98h+var_40]
mov rcx, [r12]
mov r8, [r12+8]
and [rsp+98h+var_98], 0
mov rdi, rbx
xor r9d, r9d
call JS_Call
mov r13, rax
mov rbp, rdx
cmp ebp, 6
jz loc_44E6F
push 6Bh ; 'k'
pop rcx
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
call JS_GetProperty
mov r14, rdx
cmp r14d, 6
mov [rsp+98h+var_88], rax
jz loc_44DF4
mov r12, rax
mov [rsp+98h+var_60], r13
mov [rsp+98h+var_68], r14
loc_44D2B:
and [rsp+98h+var_98], 0
lea rax, [rsp+98h+var_7C]
mov [rsp+98h+var_90], rax
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
mov rcx, r12
mov r8, r14
xor r9d, r9d
call JS_IteratorNext
mov [rsp+98h+var_78], rax
mov [rsp+98h+var_70], rdx
mov ecx, edx
cmp rcx, 6
jz loc_44F42
cmp [rsp+98h+var_7C], 0
jnz loc_44F4E
mov r14, rbp
xor rcx, 7
mov rsi, rax
btr rsi, 3Fh ; '?'
or rsi, rcx
mov r13d, 0
mov ebp, 0
jz short loc_44D97
mov r13, rax
mov rbp, rdx
loc_44D97:
mov [rsp+98h+var_78], r13
mov [rsp+98h+var_70], rbp
mov rdi, rbx
mov rsi, r15
mov rdx, r13
mov rcx, rbp
call map_find_record
mov r12, rax
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
call JS_FreeValue
test r12, r12
mov r12, [rsp+98h+var_88]
mov r13, [rsp+98h+var_60]
mov rbp, r14
mov r14, [rsp+98h+var_68]
jz loc_44D2B
push 1
jmp loc_44F44
loc_44DE5:
mov [rsp+98h+var_88], 0
xor r13d, r13d
mov rbp, r14
loc_44DF4:
xor r12d, r12d
push 6
pop r15
loc_44DFB:
mov rsi, [rsp+98h+var_58]
mov rdx, [rsp+98h+var_50]
mov rdi, rbx
call JS_FreeValue
mov rsi, [rsp+98h+var_48]
mov rdx, [rsp+98h+var_40]
mov rdi, rbx
call JS_FreeValue
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+98h+var_88]
mov rdx, r14
call JS_FreeValue
mov rax, r12
mov rdx, r15
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_44E52:
push 1
pop r9
mov rdi, rbx
mov rsi, rbp
mov rdx, r13
call js_create_map_iterator
mov r13, rax
mov rbp, rdx
cmp ebp, 6
jnz short loc_44E7D
loc_44E6F:
mov [rsp+98h+var_88], 0
jmp loc_44DF4
loc_44E7D:
mov rax, [rsp+98h+var_58]
mov [rsp+98h+var_60], rax
mov rax, [rsp+98h+var_50]
mov [rsp+98h+var_68], rax
loc_44E91:
mov dword ptr [rsp+98h+var_98], 1
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
lea r9, [rsp+98h+var_7C]
call js_map_iterator_next
mov [rsp+98h+var_78], rax
mov [rsp+98h+var_70], rdx
cmp edx, 6
jz short loc_44F24
cmp [rsp+98h+var_7C], 0
jnz short loc_44F2D
mov rcx, [r12]
mov r8, [r12+8]
lea rax, [rsp+98h+var_78]
mov [rsp+98h+var_98], rax
mov rdi, rbx
mov rsi, [rsp+98h+var_60]
mov rdx, [rsp+98h+var_68]
push 1
pop r9
call JS_Call
mov r15, rax
mov [rsp+98h+var_88], rdx
mov rsi, [rsp+98h+var_78]
mov rdx, [rsp+98h+var_70]
mov rdi, rbx
call JS_FreeValue
mov rdi, rbx
mov rsi, r15
mov rdx, [rsp+98h+var_88]
call JS_ToBoolFree
test eax, eax
js short loc_44F24
jz loc_44E91
xor r12d, r12d
push 1
jmp short loc_44F29
loc_44F24:
xor r12d, r12d
push 6
loc_44F29:
pop r15
jmp short loc_44F34
loc_44F2D:
push 1
pop r15
mov r12, r15
loc_44F34:
mov [rsp+98h+var_88], 0
jmp loc_44DFB
loc_44F42:
push 6
loc_44F44:
pop r15
xor r12d, r12d
jmp loc_44DFB
loc_44F4E:
push 1
pop r15
mov r12, r15
jmp loc_44DFB
| long long js_set_isDisjointFrom(long long a1, _DWORD *a2, long long a3, __m128d a4, long long a5, _QWORD *a6)
{
long long v8; // r14
long long Opaque2; // rax
long long v10; // r15
long long v11; // rcx
long long v12; // r8
long long v13; // rax
long long v14; // rdx
unsigned long long map_iterator; // r13
long long v16; // rbp
long long Property; // rax
long long v18; // rdx
int v19; // r12d
unsigned long long v20; // rax
long long v21; // rdx
long long v22; // r14
_DWORD *v23; // r13
long long v24; // rbp
long long record; // r12
bool v26; // zf
long long v27; // r12
int v29; // ecx
int v30; // r8d
long long v31; // rdx
long long v32; // rdx
long long v33; // r15
long long v34; // rdx
int v35; // eax
long long v36; // [rsp+10h] [rbp-88h]
long long v37; // [rsp+10h] [rbp-88h]
int v38; // [rsp+1Ch] [rbp-7Ch] BYREF
_DWORD *v39; // [rsp+20h] [rbp-78h] BYREF
long long v40; // [rsp+28h] [rbp-70h]
long long v41; // [rsp+30h] [rbp-68h]
long long v42; // [rsp+38h] [rbp-60h]
long long v43; // [rsp+40h] [rbp-58h] BYREF
long long v44; // [rsp+48h] [rbp-50h]
long long v45; // [rsp+50h] [rbp-48h] BYREF
long long v46; // [rsp+58h] [rbp-40h]
long long v47[7]; // [rsp+60h] [rbp-38h] BYREF
LODWORD(v43) = 0;
v8 = 3LL;
v44 = 3LL;
LODWORD(v45) = 0;
v46 = 3LL;
Opaque2 = JS_GetOpaque2(a1, (long long)a2, a3, 0x24u);
if ( !Opaque2
|| (v10 = Opaque2, (int)js_setlike_get_size(a1, *a6, a6[1], v47) < 0)
|| (int)js_setlike_get_has(a1, *a6, a6[1], &v43) < 0
|| (int)js_setlike_get_keys(a1, *a6, a6[1], &v45) < 0 )
{
v36 = 0LL;
map_iterator = 0LL;
v16 = 3LL;
goto LABEL_16;
}
if ( v47[0] < *(unsigned int *)(v10 + 24) )
{
v13 = JS_Call(a1, v45, v46, *a6, a6[1], 0, 0LL);
map_iterator = v13;
v16 = v14;
if ( (_DWORD)v14 != 6 )
{
Property = JS_GetProperty(a1, v13, v14, 107);
v8 = v18;
v36 = Property;
if ( (_DWORD)v18 != 6 )
{
v19 = Property;
v42 = map_iterator;
v41 = v18;
while ( 1 )
{
v20 = JS_IteratorNext(a1, map_iterator, v16, v19, v8, 0, 0LL, &v38);
v39 = (_DWORD *)v20;
v40 = v21;
if ( (unsigned int)v21 == 6LL )
{
LABEL_29:
v27 = 0LL;
goto LABEL_17;
}
if ( v38 )
break;
v22 = v16;
v23 = 0LL;
v24 = 0LL;
if ( (unsigned int)v21 ^ 7LL | v20 & 0x7FFFFFFFFFFFFFFFLL )
{
v23 = (_DWORD *)v20;
v24 = v21;
}
v39 = v23;
v40 = v24;
record = map_find_record(a1, v10, v23, v24, a4);
JS_FreeValue(a1, (long long)v23, v24);
v26 = record == 0;
v19 = v36;
map_iterator = v42;
v16 = v22;
v8 = v41;
if ( !v26 )
goto LABEL_29;
}
v27 = 1LL;
goto LABEL_17;
}
LABEL_16:
v27 = 0LL;
goto LABEL_17;
}
LABEL_19:
v36 = 0LL;
goto LABEL_16;
}
map_iterator = js_create_map_iterator(a1, a2, a3, v11, v12, 1);
v16 = v31;
if ( (_DWORD)v31 == 6 )
goto LABEL_19;
v42 = v43;
v41 = v44;
while ( 1 )
{
v39 = (_DWORD *)js_map_iterator_next(a1, map_iterator, v16, v29, v30, (unsigned int)&v38, 1);
v40 = v32;
if ( (_DWORD)v32 == 6 )
{
LABEL_26:
v27 = 0LL;
goto LABEL_28;
}
if ( v38 )
break;
v33 = JS_Call(a1, v42, v41, *a6, a6[1], 1, (long long)&v39);
v37 = v34;
JS_FreeValue(a1, (long long)v39, v40);
v35 = JS_ToBoolFree(a1, v33, v37);
if ( v35 < 0 )
goto LABEL_26;
if ( v35 )
{
v27 = 0LL;
goto LABEL_28;
}
}
v27 = 1LL;
LABEL_28:
v36 = 0LL;
LABEL_17:
JS_FreeValue(a1, v43, v44);
JS_FreeValue(a1, v45, v46);
JS_FreeValue(a1, map_iterator, v16);
JS_FreeValue(a1, v36, v8);
return v27;
}
| js_set_isDisjointFrom:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12,R8
MOV R13,RDX
AND dword ptr [RSP + 0x40],0x0
MOV RBP,RSI
MOV RBX,RDI
PUSH 0x3
POP R14
MOV qword ptr [RSP + 0x48],R14
AND dword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],R14
PUSH 0x24
POP RCX
CALL 0x00121207
TEST RAX,RAX
JZ 0x00144de5
MOV R15,RAX
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[RSP + 0x60]
MOV RDI,RBX
CALL 0x0014643b
TEST EAX,EAX
JS 0x00144de5
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[RSP + 0x40]
MOV RDI,RBX
CALL 0x001464cf
TEST EAX,EAX
JS 0x00144de5
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[RSP + 0x50]
MOV RDI,RBX
CALL 0x00146558
TEST EAX,EAX
JS 0x00144de5
MOV EAX,dword ptr [R15 + 0x18]
CMP qword ptr [RSP + 0x60],RAX
JGE 0x00144e52
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [R12]
MOV R8,qword ptr [R12 + 0x8]
AND qword ptr [RSP],0x0
MOV RDI,RBX
XOR R9D,R9D
CALL 0x00121eb6
MOV R13,RAX
MOV RBP,RDX
CMP EBP,0x6
JZ 0x00144e6f
PUSH 0x6b
POP RCX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011b043
MOV R14,RDX
CMP R14D,0x6
MOV qword ptr [RSP + 0x10],RAX
JZ 0x00144df4
MOV R12,RAX
MOV qword ptr [RSP + 0x38],R13
MOV qword ptr [RSP + 0x30],R14
LAB_00144d2b:
AND qword ptr [RSP],0x0
LEA RAX,[RSP + 0x1c]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
MOV RCX,R12
MOV R8,R14
XOR R9D,R9D
CALL 0x001398cc
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV ECX,EDX
CMP RCX,0x6
JZ 0x00144f42
CMP dword ptr [RSP + 0x1c],0x0
JNZ 0x00144f4e
MOV R14,RBP
XOR RCX,0x7
MOV RSI,RAX
BTR RSI,0x3f
OR RSI,RCX
MOV R13D,0x0
MOV EBP,0x0
JZ 0x00144d97
MOV R13,RAX
MOV RBP,RDX
LAB_00144d97:
MOV qword ptr [RSP + 0x20],R13
MOV qword ptr [RSP + 0x28],RBP
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
MOV RCX,RBP
CALL 0x0013d80d
MOV R12,RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011801e
TEST R12,R12
MOV R12,qword ptr [RSP + 0x10]
MOV R13,qword ptr [RSP + 0x38]
MOV RBP,R14
MOV R14,qword ptr [RSP + 0x30]
JZ 0x00144d2b
PUSH 0x1
JMP 0x00144f44
LAB_00144de5:
MOV qword ptr [RSP + 0x10],0x0
XOR R13D,R13D
MOV RBP,R14
LAB_00144df4:
XOR R12D,R12D
PUSH 0x6
POP R15
LAB_00144dfb:
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV RDI,RBX
CALL 0x0011801e
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RDI,RBX
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R14
CALL 0x0011801e
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00144e52:
PUSH 0x1
POP R9
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R13
CALL 0x00144ab2
MOV R13,RAX
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x00144e7d
LAB_00144e6f:
MOV qword ptr [RSP + 0x10],0x0
JMP 0x00144df4
LAB_00144e7d:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x30],RAX
LAB_00144e91:
MOV dword ptr [RSP],0x1
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
LEA R9,[RSP + 0x1c]
CALL 0x001465e1
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
CMP EDX,0x6
JZ 0x00144f24
CMP dword ptr [RSP + 0x1c],0x0
JNZ 0x00144f2d
MOV RCX,qword ptr [R12]
MOV R8,qword ptr [R12 + 0x8]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
PUSH 0x1
POP R9
CALL 0x00121eb6
MOV R15,RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,RBX
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,R15
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x00144f24
JZ 0x00144e91
XOR R12D,R12D
PUSH 0x1
JMP 0x00144f29
LAB_00144f24:
XOR R12D,R12D
PUSH 0x6
LAB_00144f29:
POP R15
JMP 0x00144f34
LAB_00144f2d:
PUSH 0x1
POP R15
MOV R12,R15
LAB_00144f34:
MOV qword ptr [RSP + 0x10],0x0
JMP 0x00144dfb
LAB_00144f42:
PUSH 0x6
LAB_00144f44:
POP R15
XOR R12D,R12D
JMP 0x00144dfb
LAB_00144f4e:
PUSH 0x1
POP R15
MOV R12,R15
JMP 0x00144dfb
|
int1 [16]
js_set_isDisjointFrom
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
long lVar2;
long lVar4;
ulong uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int8 uStackY_a0;
int8 local_88;
int local_7c;
int1 local_78 [16];
int8 local_68;
int8 local_60;
int4 local_58;
int4 uStack_54;
int8 local_50;
int4 local_48;
int4 uStack_44;
int8 local_40;
long local_38;
int8 uVar3;
local_58 = 0;
local_50 = 3;
local_48 = 0;
local_40 = 3;
lVar2 = JS_GetOpaque2();
if ((((lVar2 == 0) ||
(iVar1 = js_setlike_get_size(param_1,*param_5,param_5[1],&local_38), iVar1 < 0)) ||
(iVar1 = js_setlike_get_has(param_1,*param_5,param_5[1],&local_58), iVar1 < 0)) ||
(iVar1 = js_setlike_get_keys(param_1,*param_5,param_5[1],&local_48), iVar1 < 0)) {
auVar10 = ZEXT816(3) << 0x40;
auVar9 = ZEXT816(3) << 0x40;
}
else {
if (local_38 < (long)(ulong)*(uint *)(lVar2 + 0x18)) {
auVar9 = JS_Call(param_1,CONCAT44(uStack_44,local_48),local_40,*param_5,param_5[1],0,0);
uVar7 = auVar9._8_8_;
if (auVar9._8_4_ != 6) {
auVar10 = JS_GetProperty(param_1,auVar9._0_8_,uVar7,0x6b);
uVar3 = auVar10._0_8_;
uVar6 = auVar10._8_8_;
uVar8 = auVar9._0_8_;
if (auVar10._8_4_ != 6) {
do {
local_60 = uVar8;
local_68 = uVar6;
uVar8 = local_60;
uVar6 = local_68;
auVar10._8_8_ = local_68;
auVar10._0_8_ = uVar3;
auVar9._8_8_ = uVar7;
auVar9._0_8_ = local_60;
auVar11 = JS_IteratorNext(param_1,local_60,uVar7,uVar3,local_68,0,0,&local_7c);
uVar5 = auVar11._8_8_ & 0xffffffff;
if (uVar5 == 6) {
uStackY_a0 = 6;
goto LAB_00144f44;
}
if (local_7c != 0) {
uStackY_a0 = 1;
uVar6 = 1;
uVar7 = uStackY_a0;
goto LAB_00144dfb;
}
local_78 = ZEXT816(0);
if ((auVar11 & (int1 [16])0x7fffffffffffffff) != (int1 [16])0x0 ||
uVar5 != 7) {
local_78 = auVar11;
}
uVar6 = local_78._8_8_;
uVar8 = local_78._0_8_;
lVar4 = map_find_record(param_1,lVar2,uVar8,uVar6);
JS_FreeValue(param_1,uVar8,uVar6);
uVar6 = local_68;
uVar8 = local_60;
} while (lVar4 == 0);
uStackY_a0 = 1;
auVar11 = local_78;
LAB_00144f44:
auVar10._8_8_ = uVar6;
auVar9._0_8_ = uVar8;
uVar7 = 0;
uVar6 = uStackY_a0;
goto LAB_00144dfb;
}
goto LAB_00144df4;
}
}
else {
auVar9 = js_create_map_iterator(param_1,param_2,param_3);
if (auVar9._8_4_ != 6) {
local_60 = CONCAT44(uStack_54,local_58);
local_68 = local_50;
do {
auVar11 = js_map_iterator_next(param_1,auVar9._0_8_,auVar9._8_8_);
local_78 = auVar11;
if (auVar11._8_4_ == 6) {
LAB_00144f24:
uStackY_a0 = 6;
goto LAB_00144f29;
}
if (local_7c != 0) {
uVar7 = 1;
uVar6 = uVar7;
goto LAB_00144f34;
}
auVar10 = JS_Call(param_1,local_60,local_68,*param_5,param_5[1],1,local_78);
JS_FreeValue(param_1,local_78._0_8_,local_78._8_8_);
iVar1 = JS_ToBoolFree(param_1,auVar10._0_8_,auVar10._8_8_);
if (iVar1 < 0) goto LAB_00144f24;
} while (iVar1 == 0);
uStackY_a0 = 1;
LAB_00144f29:
uVar7 = 0;
uVar6 = uStackY_a0;
auVar11 = local_78;
LAB_00144f34:
auVar10 = ZEXT816(3) << 0x40;
goto LAB_00144dfb;
}
}
auVar10 = ZEXT816(3) << 0x40;
}
LAB_00144df4:
auVar11._8_8_ = local_78._8_8_;
auVar11._0_8_ = local_78._0_8_;
uVar7 = 0;
uVar6 = 6;
LAB_00144dfb:
local_88 = auVar10._0_8_;
local_78 = auVar11;
JS_FreeValue(param_1,CONCAT44(uStack_54,local_58),local_50);
JS_FreeValue(param_1,CONCAT44(uStack_44,local_48),local_40);
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
JS_FreeValue(param_1,local_88,auVar10._8_8_);
auVar12._8_8_ = uVar6;
auVar12._0_8_ = uVar7;
return auVar12;
}
| |
35,223 | ftxui::(anonymous namespace)::InputBase::HandleArrowRight() | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/input.cpp | bool HandleArrowRight() {
if (cursor_position() == (int)content->size()) {
return false;
}
cursor_position() = GlyphNext(content(), cursor_position());
return true;
} | O1 | cpp | ftxui::(anonymous namespace)::InputBase::HandleArrowRight():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
addq $0xf8, %rbx
movq %rbx, %rdi
callq 0x2cdc2
movl (%rax), %ebp
movq %r14, %rdi
callq 0x2c944
movl 0x8(%rax), %r15d
cmpl %r15d, %ebp
je 0x2c04c
movq %r14, %rdi
callq 0x2c944
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cdc2
movslq (%rax), %rsi
movq %r14, %rdi
callq 0x3b991
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cdc2
movl %r14d, (%rax)
cmpl %r15d, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN5ftxui12_GLOBAL__N_19InputBase16HandleArrowRightEv:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdi
lea r14, [rdi+28h]
add rbx, 0F8h
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov ebp, [rax]
mov rdi, r14
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7AddressEv; ftxui::Ref<std::string>::Address(void)
mov r15d, [rax+8]
cmp ebp, r15d
jz short loc_2C04C
mov rdi, r14
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7AddressEv; ftxui::Ref<std::string>::Address(void)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
movsxd rsi, dword ptr [rax]
mov rdi, r14
call _ZN5ftxui9GlyphNextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphNext(std::string const&,ulong)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov [rax], r14d
loc_2C04C:
cmp ebp, r15d
setnz al
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| bool ftxui::`anonymous namespace'::InputBase::HandleArrowRight(
ftxui::_anonymous_namespace_::InputBase *this)
{
char *v1; // rbx
int v2; // ebp
int v3; // r15d
long long v4; // r14
int *v5; // rax
v1 = (char *)this + 248;
v2 = *(_DWORD *)ftxui::Ref<int>::Address((char *)this + 248);
v3 = *(_DWORD *)(ftxui::Ref<std::string>::Address((char *)this + 40) + 8);
if ( v2 != v3 )
{
v4 = ftxui::Ref<std::string>::Address((char *)this + 40);
v5 = (int *)ftxui::Ref<int>::Address(v1);
LODWORD(v4) = ftxui::GlyphNext(v4, *v5);
*(_DWORD *)ftxui::Ref<int>::Address(v1) = v4;
}
return v2 != v3;
}
| HandleArrowRight:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[RDI + 0x28]
ADD RBX,0xf8
MOV RDI,RBX
CALL 0x0012cdc2
MOV EBP,dword ptr [RAX]
MOV RDI,R14
CALL 0x0012c944
MOV R15D,dword ptr [RAX + 0x8]
CMP EBP,R15D
JZ 0x0012c04c
MOV RDI,R14
CALL 0x0012c944
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012cdc2
MOVSXD RSI,dword ptr [RAX]
MOV RDI,R14
CALL 0x0013b991
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012cdc2
MOV dword ptr [RAX],R14D
LAB_0012c04c:
CMP EBP,R15D
SETNZ AL
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::HandleArrowRight() */
bool __thiscall ftxui::(anonymous_namespace)::InputBase::HandleArrowRight(InputBase *this)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
string *psVar5;
int4 uVar6;
int4 *puVar7;
Ref<int> *this_00;
this_00 = (Ref<int> *)(this + 0xf8);
piVar3 = (int *)Ref<int>::Address(this_00);
iVar1 = *piVar3;
lVar4 = Ref<std::__cxx11::string>::Address((Ref<std::__cxx11::string> *)(this + 0x28));
iVar2 = *(int *)(lVar4 + 8);
if (iVar1 != iVar2) {
psVar5 = (string *)
Ref<std::__cxx11::string>::Address((Ref<std::__cxx11::string> *)(this + 0x28));
piVar3 = (int *)Ref<int>::Address(this_00);
uVar6 = GlyphNext(psVar5,(long)*piVar3);
puVar7 = (int4 *)Ref<int>::Address(this_00);
*puVar7 = uVar6;
}
return iVar1 != iVar2;
}
| |
35,224 | mysql_stmt_next_result | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mysql_stmt_next_result(MYSQL_STMT *stmt)
{
int rc= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_EXECUTED)
{
SET_CLIENT_ERROR(stmt->mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (!mysql_stmt_more_results(stmt))
return(-1);
if (stmt->state > MYSQL_STMT_EXECUTED &&
stmt->state < MYSQL_STMT_FETCH_DONE)
madb_reset_stmt(stmt, MADB_RESET_ERROR | MADB_RESET_BUFFER | MADB_RESET_LONGDATA);
stmt->state= MYSQL_STMT_WAITING_USE_OR_STORE;
if (mysql_next_result(stmt->mysql))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
SET_CLIENT_STMT_ERROR(stmt, stmt->mysql->net.last_errno, stmt->mysql->net.sqlstate,
stmt->mysql->net.last_error);
return(1);
}
if (stmt->mysql->status == MYSQL_STATUS_GET_RESULT)
stmt->mysql->status= MYSQL_STATUS_STMT_RESULT;
if (stmt->mysql->field_count)
rc= madb_alloc_stmt_fields(stmt);
else
{
stmt->upsert_status.affected_rows= stmt->mysql->affected_rows;
stmt->upsert_status.last_insert_id= stmt->mysql->insert_id;
stmt->upsert_status.server_status= stmt->mysql->server_status;
stmt->upsert_status.warning_count= stmt->mysql->warning_count;
}
stmt->field_count= stmt->mysql->field_count;
stmt->result.rows= 0;
return(rc);
} | O3 | c | mysql_stmt_next_result:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x22cbb
movl 0x50(%rbx), %eax
cmpl $0x1, %eax
ja 0x22d01
movl $0x7de, %r15d # imm = 0x7DE
movl %r15d, 0x90(%rdi)
movl $0x297, %edi # imm = 0x297
addq 0x38(%rbx), %rdi
leaq 0x27edd(%rip), %r12 # 0x4ab20
movq (%r12), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%rbx), %rax
xorl %r14d, %r14d
movb %r14b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%rbx), %rdi
leaq 0x27ec1(%rip), %r13 # 0x4ab30
movq 0x70(%r13), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%rbx), %rax
movb %r14b, 0x296(%rax)
movl %r15d, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
movq (%r12), %rsi
movl $0x5, %edx
callq 0x13220
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movq 0x70(%r13), %rsi
jmp 0x22d8e
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x27e4d(%rip), %rax # 0x4ab20
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x27e38(%rip), %rax # 0x4ab30
movq 0x68(%rax), %rsi
jmp 0x22d8e
movzwl 0x380(%rdi), %ecx
testl $0x1008, %ecx # imm = 0x1008
je 0x22db7
cmpl $0x2, %eax
sete %cl
cmpl $0x6, %eax
setae %al
orb %cl, %al
jne 0x22d35
movq %rbx, %rdi
movl $0xb, %esi
callq 0x212f4
movq 0x38(%rbx), %rdi
movl $0x3, 0x50(%rbx)
callq 0x1a439
testl %eax, %eax
je 0x22dbf
movl $0x6, 0x50(%rbx)
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x22da5
movq 0x38(%rbx), %r15
cmpl $0x1, 0x488(%r15)
jne 0x22ddc
movl $0x8, 0x488(%r15)
movq 0x38(%rbx), %r15
movl 0x37c(%r15), %eax
testl %eax, %eax
je 0x22e4b
movq 0x340(%rbx), %r14
movl %eax, 0x60(%rbx)
cmpq $0x0, 0x2f8(%r15)
je 0x22ee0
movq %r14, %rdi
xorl %esi, %esi
callq 0x1e81b
movq 0x2f8(%r15), %rdi
movl 0x37c(%r15), %esi
movq %r14, %rdx
callq 0x1b8da
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x22e86
movl 0x60(%rbx), %eax
imulq $0x70, %rax, %rsi
movq %r14, %rdi
callq 0x1e703
movq %rax, 0x78(%rbx)
testq %rax, %rax
je 0x22e86
movq %rax, %rdi
movl 0x60(%rbx), %eax
jmp 0x22ee4
movq 0x338(%r15), %rax
movq %rax, 0xf8(%rbx)
movq 0x340(%r15), %rax
movq %rax, 0x100(%rbx)
movl 0x380(%r15), %eax
movl %eax, 0xf4(%rbx)
movl 0x388(%r15), %eax
movl %eax, 0xf0(%rbx)
xorl %r14d, %r14d
jmp 0x22efb
movl $0x7d8, 0x108(%rbx) # imm = 0x7D8
leaq 0x30d(%rbx), %rdi
leaq 0x27c82(%rip), %rax # 0x4ab20
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x27c6d(%rip), %rax # 0x4ab30
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movl $0x1, %r14d
jmp 0x22efb
movq 0x78(%rbx), %rdi
movl %eax, %eax
imulq $0x70, %rax, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x13260
movb $0x0, 0xe8(%rbx)
movq 0x38(%rbx), %rax
movl 0x37c(%rax), %eax
movl %eax, 0x60(%rbx)
movq $0x0, 0xc8(%rbx)
jmp 0x22da5
| mysql_stmt_next_result:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+38h]
test rdi, rdi
jz loc_22CBB
mov eax, [rbx+50h]
cmp eax, 1
ja loc_22D01
mov r15d, 7DEh
mov [rdi+90h], r15d
mov edi, 297h
add rdi, [rbx+38h]
lea r12, SQLSTATE_UNKNOWN
mov rsi, [r12]
mov edx, 5
call _strncpy
mov rax, [rbx+38h]
xor r14d, r14d
mov [rax+29Ch], r14b
mov edi, 97h
add rdi, [rbx+38h]
lea r13, client_errors
mov rsi, [r13+70h]
mov edx, 1FFh
call _strncpy
mov rax, [rbx+38h]
mov [rax+296h], r14b
mov [rbx+108h], r15d
lea rdi, [rbx+30Dh]
mov rsi, [r12]
mov edx, 5
call _strncpy
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov rsi, [r13+70h]
jmp loc_22D8E
loc_22CBB:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
jmp loc_22D8E
loc_22D01:
movzx ecx, word ptr [rdi+380h]
test ecx, 1008h
jz loc_22DB7
cmp eax, 2
setz cl
cmp eax, 6
setnb al
or al, cl
jnz short loc_22D35
mov rdi, rbx
mov esi, 0Bh
call madb_reset_stmt
mov rdi, [rbx+38h]
loc_22D35:
mov dword ptr [rbx+50h], 3
call mysql_next_result
test eax, eax
jz short loc_22DBF
mov dword ptr [rbx+50h], 6
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
loc_22D8E:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r14d, 1
loc_22DA5:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_22DB7:
mov r14d, 0FFFFFFFFh
jmp short loc_22DA5
loc_22DBF:
mov r15, [rbx+38h]
cmp dword ptr [r15+488h], 1
jnz short loc_22DDC
mov dword ptr [r15+488h], 8
mov r15, [rbx+38h]
loc_22DDC:
mov eax, [r15+37Ch]
test eax, eax
jz short loc_22E4B
mov r14, [rbx+340h]
mov [rbx+60h], eax
cmp qword ptr [r15+2F8h], 0
jz loc_22EE0
mov rdi, r14
xor esi, esi
call ma_free_root
mov rdi, [r15+2F8h]
mov esi, [r15+37Ch]
mov rdx, r14
call ma_duplicate_resultset_metadata
mov [rbx+58h], rax
test rax, rax
jz short loc_22E86
mov eax, [rbx+60h]
imul rsi, rax, 70h ; 'p'
mov rdi, r14
call ma_alloc_root
mov [rbx+78h], rax
test rax, rax
jz short loc_22E86
mov rdi, rax
mov eax, [rbx+60h]
jmp loc_22EE4
loc_22E4B:
mov rax, [r15+338h]
mov [rbx+0F8h], rax
mov rax, [r15+340h]
mov [rbx+100h], rax
mov eax, [r15+380h]
mov [rbx+0F4h], eax
mov eax, [r15+388h]
mov [rbx+0F0h], eax
xor r14d, r14d
jmp short loc_22EFB
loc_22E86:
mov dword ptr [rbx+108h], 7D8h
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r14d, 1
jmp short loc_22EFB
loc_22EE0:
mov rdi, [rbx+78h]
loc_22EE4:
mov eax, eax
imul rdx, rax, 70h ; 'p'
xor r14d, r14d
xor esi, esi
call _memset
mov byte ptr [rbx+0E8h], 0
loc_22EFB:
mov rax, [rbx+38h]
mov eax, [rax+37Ch]
mov [rbx+60h], eax
mov qword ptr [rbx+0C8h], 0
jmp loc_22DA5
| long long mysql_stmt_next_result(long long a1)
{
long long v2; // rdi
unsigned int v3; // eax
long long v4; // rdi
char *v5; // rsi
long long v6; // rsi
unsigned int v7; // r14d
long long v9; // r15
unsigned int v10; // eax
long long v11; // r14
long long v12; // rax
char *v13; // rax
char *v14; // rdi
v2 = *(_QWORD *)(a1 + 56);
if ( !v2 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v4 = a1 + 268;
v5 = client_errors[13];
goto LABEL_10;
}
v3 = *(_DWORD *)(a1 + 80);
if ( v3 > 1 )
{
if ( (*(_WORD *)(v2 + 896) & 0x1008) == 0 )
return (unsigned int)-1;
if ( v3 != 2 && v3 < 6 )
{
madb_reset_stmt(a1, 11);
v2 = *(_QWORD *)(a1 + 56);
}
*(_DWORD *)(a1 + 80) = 3;
if ( (unsigned int)mysql_next_result(v2) )
{
*(_DWORD *)(a1 + 80) = 6;
v6 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v6 + 144);
strncpy(a1 + 781, v6 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v4 = a1 + 268;
v5 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
goto LABEL_10;
}
v9 = *(_QWORD *)(a1 + 56);
if ( *(_DWORD *)(v9 + 1160) == 1 )
{
*(_DWORD *)(v9 + 1160) = 8;
v9 = *(_QWORD *)(a1 + 56);
}
v10 = *(_DWORD *)(v9 + 892);
if ( v10 )
{
v11 = *(_QWORD *)(a1 + 832);
*(_DWORD *)(a1 + 96) = v10;
if ( !*(_QWORD *)(v9 + 760) )
{
v14 = *(char **)(a1 + 120);
goto LABEL_23;
}
ma_free_root(v11, 0);
v12 = ma_duplicate_resultset_metadata(*(_QWORD *)(v9 + 760), *(unsigned int *)(v9 + 892), v11);
*(_QWORD *)(a1 + 88) = v12;
if ( v12 )
{
v13 = ma_alloc_root(v11, 112LL * *(unsigned int *)(a1 + 96));
*(_QWORD *)(a1 + 120) = v13;
if ( v13 )
{
v14 = v13;
v10 = *(_DWORD *)(a1 + 96);
LABEL_23:
v7 = 0;
memset(v14, 0LL, 112LL * v10);
*(_BYTE *)(a1 + 232) = 0;
goto LABEL_24;
}
}
*(_DWORD *)(a1 + 264) = 2008;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[8], 512LL);
*(_BYTE *)(a1 + 779) = 0;
v7 = 1;
}
else
{
*(_QWORD *)(a1 + 248) = *(_QWORD *)(v9 + 824);
*(_QWORD *)(a1 + 256) = *(_QWORD *)(v9 + 832);
*(_DWORD *)(a1 + 244) = *(_DWORD *)(v9 + 896);
*(_DWORD *)(a1 + 240) = *(_DWORD *)(v9 + 904);
v7 = 0;
}
LABEL_24:
*(_DWORD *)(a1 + 96) = *(_DWORD *)(*(_QWORD *)(a1 + 56) + 892LL);
*(_QWORD *)(a1 + 200) = 0LL;
return v7;
}
*(_DWORD *)(v2 + 144) = 2014;
strncpy(*(_QWORD *)(a1 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a1 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 662LL) = 0;
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v4 = a1 + 268;
v5 = client_errors[14];
LABEL_10:
strncpy(v4, v5, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
| mysql_stmt_next_result:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00122cbb
MOV EAX,dword ptr [RBX + 0x50]
CMP EAX,0x1
JA 0x00122d01
MOV R15D,0x7de
MOV dword ptr [RDI + 0x90],R15D
MOV EDI,0x297
ADD RDI,qword ptr [RBX + 0x38]
LEA R12,[0x14ab20]
MOV RSI,qword ptr [R12]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [RBX + 0x38]
XOR R14D,R14D
MOV byte ptr [RAX + 0x29c],R14B
MOV EDI,0x97
ADD RDI,qword ptr [RBX + 0x38]
LEA R13,[0x14ab30]
MOV RSI,qword ptr [R13 + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [RBX + 0x38]
MOV byte ptr [RAX + 0x296],R14B
MOV dword ptr [RBX + 0x108],R15D
LEA RDI,[RBX + 0x30d]
MOV RSI,qword ptr [R12]
MOV EDX,0x5
CALL 0x00113220
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV RSI,qword ptr [R13 + 0x70]
JMP 0x00122d8e
LAB_00122cbb:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x14ab20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x14ab30]
MOV RSI,qword ptr [RAX + 0x68]
JMP 0x00122d8e
LAB_00122d01:
MOVZX ECX,word ptr [RDI + 0x380]
TEST ECX,0x1008
JZ 0x00122db7
CMP EAX,0x2
SETZ CL
CMP EAX,0x6
SETNC AL
OR AL,CL
JNZ 0x00122d35
MOV RDI,RBX
MOV ESI,0xb
CALL 0x001212f4
MOV RDI,qword ptr [RBX + 0x38]
LAB_00122d35:
MOV dword ptr [RBX + 0x50],0x3
CALL 0x0011a439
TEST EAX,EAX
JZ 0x00122dbf
MOV dword ptr [RBX + 0x50],0x6
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
LAB_00122d8e:
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV R14D,0x1
LAB_00122da5:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00122db7:
MOV R14D,0xffffffff
JMP 0x00122da5
LAB_00122dbf:
MOV R15,qword ptr [RBX + 0x38]
CMP dword ptr [R15 + 0x488],0x1
JNZ 0x00122ddc
MOV dword ptr [R15 + 0x488],0x8
MOV R15,qword ptr [RBX + 0x38]
LAB_00122ddc:
MOV EAX,dword ptr [R15 + 0x37c]
TEST EAX,EAX
JZ 0x00122e4b
MOV R14,qword ptr [RBX + 0x340]
MOV dword ptr [RBX + 0x60],EAX
CMP qword ptr [R15 + 0x2f8],0x0
JZ 0x00122ee0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0011e81b
MOV RDI,qword ptr [R15 + 0x2f8]
MOV ESI,dword ptr [R15 + 0x37c]
MOV RDX,R14
CALL 0x0011b8da
MOV qword ptr [RBX + 0x58],RAX
TEST RAX,RAX
JZ 0x00122e86
MOV EAX,dword ptr [RBX + 0x60]
IMUL RSI,RAX,0x70
MOV RDI,R14
CALL 0x0011e703
MOV qword ptr [RBX + 0x78],RAX
TEST RAX,RAX
JZ 0x00122e86
MOV RDI,RAX
MOV EAX,dword ptr [RBX + 0x60]
JMP 0x00122ee4
LAB_00122e4b:
MOV RAX,qword ptr [R15 + 0x338]
MOV qword ptr [RBX + 0xf8],RAX
MOV RAX,qword ptr [R15 + 0x340]
MOV qword ptr [RBX + 0x100],RAX
MOV EAX,dword ptr [R15 + 0x380]
MOV dword ptr [RBX + 0xf4],EAX
MOV EAX,dword ptr [R15 + 0x388]
MOV dword ptr [RBX + 0xf0],EAX
XOR R14D,R14D
JMP 0x00122efb
LAB_00122e86:
MOV dword ptr [RBX + 0x108],0x7d8
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x14ab20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x14ab30]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV R14D,0x1
JMP 0x00122efb
LAB_00122ee0:
MOV RDI,qword ptr [RBX + 0x78]
LAB_00122ee4:
MOV EAX,EAX
IMUL RDX,RAX,0x70
XOR R14D,R14D
XOR ESI,ESI
CALL 0x00113260
MOV byte ptr [RBX + 0xe8],0x0
LAB_00122efb:
MOV RAX,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RAX + 0x37c]
MOV dword ptr [RBX + 0x60],EAX
MOV qword ptr [RBX + 0xc8],0x0
JMP 0x00122da5
|
int8 mysql_stmt_next_result(long param_1)
{
int iVar1;
uint uVar2;
long lVar3;
void *__s;
char *__src;
int8 uVar4;
lVar3 = *(long *)(param_1 + 0x38);
if (lVar3 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_0014ab98;
LAB_00122d8e:
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
uVar2 = *(uint *)(param_1 + 0x50);
if (uVar2 < 2) {
*(int4 *)(lVar3 + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_1 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_1 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_1 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0014aba0,0x1ff);
*(int1 *)(*(long *)(param_1 + 0x38) + 0x296) = 0;
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Commands_out_of_sync__you_can_t_r_0014aba0;
goto LAB_00122d8e;
}
if ((*(ushort *)(lVar3 + 0x380) & 0x1008) == 0) {
return 0xffffffff;
}
if (uVar2 < 6 && uVar2 != 2) {
madb_reset_stmt(param_1);
lVar3 = *(long *)(param_1 + 0x38);
}
*(int4 *)(param_1 + 0x50) = 3;
iVar1 = mysql_next_result(lVar3);
if (iVar1 != 0) {
*(int4 *)(param_1 + 0x50) = 6;
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
__src = (char *)(*(long *)(param_1 + 0x38) + 0x97);
goto LAB_00122d8e;
}
lVar3 = *(long *)(param_1 + 0x38);
if (*(int *)(lVar3 + 0x488) == 1) {
*(int4 *)(lVar3 + 0x488) = 8;
lVar3 = *(long *)(param_1 + 0x38);
}
uVar2 = *(uint *)(lVar3 + 0x37c);
if (uVar2 == 0) {
*(int8 *)(param_1 + 0xf8) = *(int8 *)(lVar3 + 0x338);
*(int8 *)(param_1 + 0x100) = *(int8 *)(lVar3 + 0x340);
*(int4 *)(param_1 + 0xf4) = *(int4 *)(lVar3 + 0x380);
*(int4 *)(param_1 + 0xf0) = *(int4 *)(lVar3 + 0x388);
uVar4 = 0;
goto LAB_00122efb;
}
uVar4 = *(int8 *)(param_1 + 0x340);
*(uint *)(param_1 + 0x60) = uVar2;
if (*(long *)(lVar3 + 0x2f8) == 0) {
__s = *(void **)(param_1 + 0x78);
LAB_00122ee4:
uVar4 = 0;
memset(__s,0,(ulong)uVar2 * 0x70);
*(int1 *)(param_1 + 0xe8) = 0;
}
else {
ma_free_root(uVar4,0);
lVar3 = ma_duplicate_resultset_metadata
(*(int8 *)(lVar3 + 0x2f8),*(int4 *)(lVar3 + 0x37c),uVar4);
*(long *)(param_1 + 0x58) = lVar3;
if (lVar3 != 0) {
__s = (void *)ma_alloc_root(uVar4);
*(void **)(param_1 + 0x78) = __s;
if (__s != (void *)0x0) {
uVar2 = *(uint *)(param_1 + 0x60);
goto LAB_00122ee4;
}
}
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Client_run_out_of_memory_0014ab70,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
}
LAB_00122efb:
*(int4 *)(param_1 + 0x60) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x37c);
*(int8 *)(param_1 + 200) = 0;
return uVar4;
}
| |
35,225 | llama_model_loader::require_weight(char const*) const | monkey531[P]llama/src/llama-model-loader.cpp | const llama_model_loader::llama_tensor_weight & llama_model_loader::require_weight(const char * name) const {
const llama_tensor_weight * weight = get_weight(name);
if (!weight) {
throw std::runtime_error(format("%s: tensor '%s' not found", __func__, name));
}
return *weight;
} | O3 | cpp | llama_model_loader::require_weight(char const*) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
callq 0x649e0
testq %rax, %rax
je 0xaf2ee
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x65cb0
movq %rax, %rbx
leaq 0x67fb4(%rip), %rsi # 0x1172b6
leaq 0x67fc7(%rip), %rdx # 0x1172d0
movq %rsp, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x6b940
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6aa30
xorl %ebp, %ebp
movq 0xadcc3(%rip), %rsi # 0x15cff0
movq 0xad9bc(%rip), %rdx # 0x15ccf0
movq %rbx, %rdi
callq 0x6b270
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf35a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x681a0
testb %bpl, %bpl
jne 0xaf364
jmp 0xaf36c
movq %rax, %r14
movq %rbx, %rdi
callq 0x66d40
movq %r14, %rdi
callq 0x6b5d0
| _ZNK18llama_model_loader14require_weightEPKc:
push rbp
push r14
push rbx
sub rsp, 20h
mov r14, rsi
call __ZNK18llama_model_loader10get_weightEPKc; llama_model_loader::get_weight(char const*)
test rax, rax
jz short loc_AF2EE
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_AF2EE:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aSTensorSNotFou; "%s: tensor '%s' not found"
lea rdx, aRequireWeight; "require_weight"
mov rdi, rsp
mov rcx, r14
xor eax, eax
call __Z6formatB5cxx11PKcz; format(char const*,...)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+38h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AF35A
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF35A:
test bpl, bpl
jnz short loc_AF364
jmp short loc_AF36C
mov r14, rax
loc_AF364:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AF36C:
mov rdi, r14
call __Unwind_Resume
| long long llama_model_loader::require_weight(llama_model_loader *this, const char *a2)
{
long long result; // rax
void *exception; // rbx
int v4; // r8d
int v5; // r9d
_BYTE v6[16]; // [rsp+0h] [rbp-38h] BYREF
result = llama_model_loader::get_weight(this, a2);
if ( !result )
{
exception = __cxa_allocate_exception(0x10uLL);
format[abi:cxx11](
(unsigned int)v6,
(unsigned int)"%s: tensor '%s' not found",
(unsigned int)"require_weight",
(_DWORD)a2,
v4,
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;
}
| require_weight:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
CALL 0x001649e0
TEST RAX,RAX
JZ 0x001af2ee
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_001af2ee:
MOV EDI,0x10
CALL 0x00165cb0
MOV RBX,RAX
LAB_001af2fb:
LEA RSI,[0x2172b6]
LEA RDX,[0x2172d0]
MOV RDI,RSP
MOV RCX,R14
XOR EAX,EAX
CALL 0x0016b940
MOV BPL,0x1
LAB_001af319:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0016aa30
XOR EBP,EBP
MOV RSI,qword ptr [0x0025cff0]
MOV RDX,qword ptr [0x0025ccf0]
MOV RDI,RBX
CALL 0x0016b270
|
/* llama_model_loader::require_weight(char const*) const */
void __thiscall llama_model_loader::require_weight(llama_model_loader *this,char *param_1)
{
long lVar1;
runtime_error *this_00;
string asStack_38 [32];
lVar1 = get_weight(this,param_1);
if (lVar1 != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001af2fb to 001af315 has its CatchHandler @ 001af361 */
format_abi_cxx11_((char *)asStack_38,"%s: tensor \'%s\' not found","require_weight",param_1);
/* try { // try from 001af319 to 001af33b has its CatchHandler @ 001af33c */
std::runtime_error::runtime_error(this_00,asStack_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0025cff0,PTR__runtime_error_0025ccf0);
}
| |
35,226 | reset_partitioned_key_cache_counters | eloqsql/mysys/mf_keycache.c | static int
reset_partitioned_key_cache_counters(const char *name __attribute__((unused)),
PARTITIONED_KEY_CACHE_CB *keycache)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_reset_key_cache_counters");
for (i = 0; i < partitions; i++)
{
reset_simple_key_cache_counters(name, keycache->partition_array[i]);
}
DBUG_RETURN(0);
} | O3 | c | reset_partitioned_key_cache_counters:
movl 0x1c(%rsi), %eax
testq %rax, %rax
je 0xb732c
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movq 0x8(%rsi), %rdx
movq (%rdx,%rcx,8), %rdx
cmpb $0x0, (%rdx)
je 0xb7323
movups %xmm0, 0x148(%rdx)
movups %xmm0, 0x138(%rdx)
movq $0x0, 0x158(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0xb72fd
popq %rbp
xorl %eax, %eax
retq
| reset_partitioned_key_cache_counters:
mov eax, [rsi+1Ch]
test rax, rax
jz short loc_B732C
push rbp
mov rbp, rsp
xor ecx, ecx
xorps xmm0, xmm0
loc_B72FD:
mov rdx, [rsi+8]
mov rdx, [rdx+rcx*8]
cmp byte ptr [rdx], 0
jz short loc_B7323
movups xmmword ptr [rdx+148h], xmm0
movups xmmword ptr [rdx+138h], xmm0
mov qword ptr [rdx+158h], 0
loc_B7323:
inc rcx
cmp rax, rcx
jnz short loc_B72FD
pop rbp
loc_B732C:
xor eax, eax
retn
| long long reset_partitioned_key_cache_counters(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // rdx
v2 = *(unsigned int *)(a2 + 28);
if ( *(_DWORD *)(a2 + 28) )
{
v3 = 0LL;
do
{
v4 = *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8 * v3);
if ( *(_BYTE *)v4 )
{
*(_OWORD *)(v4 + 328) = 0LL;
*(_OWORD *)(v4 + 312) = 0LL;
*(_QWORD *)(v4 + 344) = 0LL;
}
++v3;
}
while ( v2 != v3 );
}
return 0LL;
}
| reset_partitioned_key_cache_counters:
MOV EAX,dword ptr [RSI + 0x1c]
TEST RAX,RAX
JZ 0x001b732c
PUSH RBP
MOV RBP,RSP
XOR ECX,ECX
XORPS XMM0,XMM0
LAB_001b72fd:
MOV RDX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP byte ptr [RDX],0x0
JZ 0x001b7323
MOVUPS xmmword ptr [RDX + 0x148],XMM0
MOVUPS xmmword ptr [RDX + 0x138],XMM0
MOV qword ptr [RDX + 0x158],0x0
LAB_001b7323:
INC RCX
CMP RAX,RCX
JNZ 0x001b72fd
POP RBP
LAB_001b732c:
XOR EAX,EAX
RET
|
int8 reset_partitioned_key_cache_counters(int8 param_1,long param_2)
{
uint uVar1;
char *pcVar2;
ulong uVar3;
uVar1 = *(uint *)(param_2 + 0x1c);
if ((ulong)uVar1 != 0) {
uVar3 = 0;
do {
pcVar2 = *(char **)(*(long *)(param_2 + 8) + uVar3 * 8);
if (*pcVar2 != '\0') {
pcVar2[0x148] = '\0';
pcVar2[0x149] = '\0';
pcVar2[0x14a] = '\0';
pcVar2[0x14b] = '\0';
pcVar2[0x14c] = '\0';
pcVar2[0x14d] = '\0';
pcVar2[0x14e] = '\0';
pcVar2[0x14f] = '\0';
pcVar2[0x150] = '\0';
pcVar2[0x151] = '\0';
pcVar2[0x152] = '\0';
pcVar2[0x153] = '\0';
pcVar2[0x154] = '\0';
pcVar2[0x155] = '\0';
pcVar2[0x156] = '\0';
pcVar2[0x157] = '\0';
pcVar2[0x138] = '\0';
pcVar2[0x139] = '\0';
pcVar2[0x13a] = '\0';
pcVar2[0x13b] = '\0';
pcVar2[0x13c] = '\0';
pcVar2[0x13d] = '\0';
pcVar2[0x13e] = '\0';
pcVar2[0x13f] = '\0';
pcVar2[0x140] = '\0';
pcVar2[0x141] = '\0';
pcVar2[0x142] = '\0';
pcVar2[0x143] = '\0';
pcVar2[0x144] = '\0';
pcVar2[0x145] = '\0';
pcVar2[0x146] = '\0';
pcVar2[0x147] = '\0';
pcVar2[0x158] = '\0';
pcVar2[0x159] = '\0';
pcVar2[0x15a] = '\0';
pcVar2[0x15b] = '\0';
pcVar2[0x15c] = '\0';
pcVar2[0x15d] = '\0';
pcVar2[0x15e] = '\0';
pcVar2[0x15f] = '\0';
}
uVar3 = uVar3 + 1;
} while (uVar1 != uVar3);
}
return 0;
}
| |
35,227 | mp_sub_mul1 | bluesky950520[P]quickjs/libbf.c | static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b)
{
limb_t i, l;
dlimb_t t;
l = 0;
for(i = 0; i < n; i++) {
t = tabr[i] - (dlimb_t)taba[i] * (dlimb_t)b - l;
tabr[i] = t;
l = -(t >> LIMB_BITS);
}
return l;
} | O0 | c | mp_sub_mul1:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0xf6442
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rdx
movq (%rax,%rdx,8), %rcx
movq -0x10(%rsp), %rax
movq (%rax,%rdx,8), %rax
movq -0x20(%rsp), %rdx
mulq %rdx
movq %rax, %rsi
xorl %eax, %eax
subq %rsi, %rcx
sbbq %rdx, %rax
movq -0x30(%rsp), %rdx
subq %rdx, %rcx
sbbq $0x0, %rax
movq %rcx, -0x48(%rsp)
movq %rax, -0x40(%rsp)
movq -0x48(%rsp), %rdx
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rsp), %rax
negq %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0xf63c6
movq -0x30(%rsp), %rax
retq
nopl (%rax,%rax)
| mp_sub_mul1:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], rdx
mov [rsp+var_20], rcx
mov [rsp+var_30], 0
mov [rsp+var_28], 0
loc_F63C6:
mov rax, [rsp+var_28]
cmp rax, [rsp+var_18]
jnb short loc_F6442
mov rax, [rsp+var_8]
mov rdx, [rsp+var_28]
mov rcx, [rax+rdx*8]
mov rax, [rsp+var_10]
mov rax, [rax+rdx*8]
mov rdx, [rsp+var_20]
mul rdx
mov rsi, rax
xor eax, eax
sub rcx, rsi
sbb rax, rdx
mov rdx, [rsp+var_30]
sub rcx, rdx
sbb rax, 0
mov [rsp+var_48], rcx
mov [rsp+var_40], rax
mov rdx, [rsp+var_48]
mov rax, [rsp+var_8]
mov rcx, [rsp+var_28]
mov [rax+rcx*8], rdx
mov rax, [rsp+var_40]
neg rax
mov [rsp+var_30], rax
mov rax, [rsp+var_28]
add rax, 1
mov [rsp+var_28], rax
jmp short loc_F63C6
loc_F6442:
mov rax, [rsp+var_30]
retn
| long long mp_sub_mul1(long long a1, long long a2, unsigned long long a3, unsigned long long a4)
{
unsigned __int128 v4; // kr00_16
long long v6; // [rsp+18h] [rbp-30h]
unsigned long long i; // [rsp+20h] [rbp-28h]
v6 = 0LL;
for ( i = 0LL; i < a3; ++i )
{
v4 = *(unsigned long long *)(a1 + 8 * i) - a4 * (unsigned __int128)*(unsigned long long *)(a2 + 8 * i);
*(_QWORD *)(a1 + 8 * i) = v4 - v6;
v6 = -(long long)((v4 - (unsigned long long)v6) >> 64);
}
return v6;
}
| mp_sub_mul1:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x18],RDX
MOV qword ptr [RSP + -0x20],RCX
MOV qword ptr [RSP + -0x30],0x0
MOV qword ptr [RSP + -0x28],0x0
LAB_001f63c6:
MOV RAX,qword ptr [RSP + -0x28]
CMP RAX,qword ptr [RSP + -0x18]
JNC 0x001f6442
MOV RAX,qword ptr [RSP + -0x8]
MOV RDX,qword ptr [RSP + -0x28]
MOV RCX,qword ptr [RAX + RDX*0x8]
MOV RAX,qword ptr [RSP + -0x10]
MOV RAX,qword ptr [RAX + RDX*0x8]
MOV RDX,qword ptr [RSP + -0x20]
MUL RDX
MOV RSI,RAX
XOR EAX,EAX
SUB RCX,RSI
SBB RAX,RDX
MOV RDX,qword ptr [RSP + -0x30]
SUB RCX,RDX
SBB RAX,0x0
MOV qword ptr [RSP + -0x48],RCX
MOV qword ptr [RSP + -0x40],RAX
MOV RDX,qword ptr [RSP + -0x48]
MOV RAX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RSP + -0x28]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP + -0x40]
NEG RAX
MOV qword ptr [RSP + -0x30],RAX
MOV RAX,qword ptr [RSP + -0x28]
ADD RAX,0x1
MOV qword ptr [RSP + -0x28],RAX
JMP 0x001f63c6
LAB_001f6442:
MOV RAX,qword ptr [RSP + -0x30]
RET
|
ulong mp_sub_mul1(long param_1,long param_2,ulong param_3,ulong param_4)
{
ulong uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
ulong uVar4;
ulong uVar5;
int8 local_30;
int8 local_28;
local_30 = 0;
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
uVar1 = *(ulong *)(param_1 + local_28 * 8);
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_2 + local_28 * 8);
auVar3._8_8_ = 0;
auVar3._0_8_ = param_4;
uVar4 = SUB168(auVar2 * auVar3,0);
uVar5 = uVar1 - uVar4;
*(ulong *)(param_1 + local_28 * 8) = uVar5 - local_30;
local_30 = -((-(ulong)(uVar1 < uVar4) - SUB168(auVar2 * auVar3,8)) - (ulong)(uVar5 < local_30));
}
return local_30;
}
| |
35,228 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>) | monkey531[P]llama/common/json.hpp | void push_back(initializer_list_t init)
{
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
}
else
{
push_back(basic_json(init));
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8240b
movq 0x10(%r14), %rax
testq %rax, %rax
cmoveq %r14, %rax
cmpb $0x3, (%rax)
jne 0x8240b
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa4e90
movq %r15, %rdi
callq 0xbc720
movq %rax, %r15
addq $0x18, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa4e90
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xbc360
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc26c
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %rbx, %rdi
callq 0x61a6a
movq -0x20(%rbx), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x823ef
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1ba60
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %rbx, %rdi
callq 0x61a6a
leaq 0x10(%rsp), %rbx
jmp 0x82436
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x82902
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbc3d6
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %rbx, %rdi
callq 0x61a6a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8acd2
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %r14, %rdi
callq 0x61a6a
jmp 0x8247b
jmp 0x82478
movq %rax, %rbx
leaq 0x10(%rsp), %r14
jmp 0x8248a
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c5ee
movq %r14, %rdi
callq 0x61a6a
movq %rbx, %rdi
callq 0x1c250
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backESt16initializer_listINS0_6detail8json_refISD_EEE:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
cmp byte ptr [rdi], 1
setz al
cmp rdx, 2
setz cl
and cl, al
cmp cl, 1
jnz loc_8240B
mov rax, [r14+10h]
test rax, rax
cmovz rax, r14
cmp byte ptr [rax], 3
jnz loc_8240B
lea r15, [rsp+68h+var_58]
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_; 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>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov r15, rax
add r14, 18h
mov rdi, rsp
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
lea r14, [rsp+68h+var_48]
mov rdx, rsp
mov rdi, r14
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E; 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>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
lea rbx, [rsp+68h+var_28]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-20h]; void *
lea rax, [rsp+68h+var_38]
cmp rdi, rax
jz short loc_823EF
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_823EF:
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rbx, [rsp+68h+var_58]
jmp short loc_82436
loc_8240B:
lea r15, [rsp+68h+var_48]
mov rdi, r15
mov rsi, r14
mov ecx, 1
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_; 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>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
lea rbx, [rsp+68h+var_48]
loc_82436:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_8247B
jmp short $+2
loc_82478:
mov rbx, rax
loc_8247B:
lea r14, [rsp+arg_8]
jmp short loc_8248A
mov rbx, rax
lea r14, [rsp+arg_18]
loc_8248A:
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
_BYTE *a1,
long long a2,
long long a3)
{
_BYTE *v3; // rax
long long v4; // r15
char *v5; // rbx
char v7[16]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v8[16]; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
char v11[40]; // [rsp+40h] [rbp-28h] BYREF
if ( *a1 != 1 || a3 != 2 )
goto LABEL_8;
v3 = *(_BYTE **)(a2 + 16);
if ( !v3 )
v3 = (_BYTE *)a2;
if ( *v3 == 3 )
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v8,
a2);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(v8);
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v7,
a2 + 24);
ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v9,
v4,
v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v11);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v7);
v5 = v8;
}
else
{
LABEL_8:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v9,
a2,
a3,
1LL,
2LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
v5 = (char *)v9;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v5);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v5);
}
| push_back:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CMP byte ptr [RDI],0x1
SETZ AL
CMP RDX,0x2
SETZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x0018240b
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
CMOVZ RAX,R14
CMP byte ptr [RAX],0x3
JNZ 0x0018240b
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,R14
CALL 0x001a4e90
LAB_00182385:
MOV RDI,R15
CALL 0x001bc720
MOV R15,RAX
ADD R14,0x18
LAB_00182394:
MOV RDI,RSP
MOV RSI,R14
CALL 0x001a4e90
LEA R14,[RSP + 0x20]
MOV RDX,RSP
MOV RDI,R14
MOV RSI,R15
CALL 0x001bc360
LAB_001823b2:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001bc26c
LAB_001823bd:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0015c5ee
MOV RDI,RBX
CALL 0x00161a6a
MOV RDI,qword ptr [RBX + -0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x001823ef
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011ba60
LAB_001823ef:
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0015c5ee
MOV RDI,RBX
CALL 0x00161a6a
LEA RBX,[RSP + 0x10]
JMP 0x00182436
LAB_0018240b:
LEA R15,[RSP + 0x20]
MOV RDI,R15
MOV RSI,R14
MOV ECX,0x1
MOV R8D,0x2
CALL 0x00182902
LAB_00182426:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001bc3d6
LAB_00182431:
LEA RBX,[RSP + 0x20]
LAB_00182436:
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0015c5ee
MOV RDI,RBX
CALL 0x00161a6a
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2,long param_3)
{
char *pcVar1;
string *psVar2;
data *this;
data adStack_68 [16];
basic_json local_58 [16];
long *local_48 [2];
long local_38 [2];
data local_28 [16];
if (param_3 == 2 &&
*param_1 ==
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
pcVar1 = *(char **)(param_2 + 0x10);
if (*(char **)(param_2 + 0x10) == (char *)0x0) {
pcVar1 = param_2;
}
if (*pcVar1 == '\x03') {
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 00182385 to 0018238c has its CatchHandler @ 00182478 */
psVar2 = get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_58);
/* try { // try from 00182394 to 0018239e has its CatchHandler @ 00182476 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
_ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_48,psVar2,adStack_68);
/* try { // try from 001823b2 to 001823bc has its CatchHandler @ 00182452 */
push_back(param_1,(pair *)local_48);
assert_invariant(SUB81(local_28,0));
data::~data(local_28);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
assert_invariant(SUB81(adStack_68,0));
data::~data(adStack_68);
this = (data *)local_58;
goto LAB_00182436;
}
}
basic_json((basic_json *)local_48,param_2,param_3,1,2);
/* try { // try from 00182426 to 00182430 has its CatchHandler @ 00182482 */
push_back(param_1,(basic_json *)local_48);
this = (data *)local_48;
LAB_00182436:
assert_invariant(SUB81(this,0));
data::~data(this);
return;
}
| |
35,229 | trnman_free_trn | eloqsql/storage/maria/trnman.c | static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
} | O0 | c | trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x4260e
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0x13b88a(%rip), %rsi # 0x17dea7
movl $0x22d, %edx # imm = 0x22D
callq 0x42530
movq -0x8(%rbp), %rax
movw $0x0, 0xac(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x425a0
movq 0x46ad80(%rip), %rax # 0x4ad3c8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
lock
cmpxchgq %rcx, 0x46ad57(%rip) # 0x4ad3c8
movq %rax, %rcx
sete %al
movb %al, -0x29(%rbp)
movq %rcx, -0x28(%rbp)
testb $0x1, %al
jne 0x4268a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4264c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| trnman_free_trn:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
jmp short $+2
loc_4260E:
mov rdi, [rbp+var_8]
add rdi, 10h
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 22Dh
call inline_mysql_mutex_lock_3
mov rax, [rbp+var_8]
mov word ptr [rax+0ACh], 0
mov rdi, [rbp+var_8]
add rdi, 10h
call inline_mysql_mutex_unlock_3
mov rax, cs:pool
mov [rbp+var_10], rax
loc_4264C:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
lock cmpxchg cs:pool, rcx
mov rcx, rax
setz al
mov [rbp+var_29], al
mov [rbp+var_28], rcx
test al, 1
jnz short loc_4268A
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_4268A:
mov al, [rbp+var_29]
and al, 1
mov [rbp+var_19], al
mov al, [rbp+var_19]
xor al, 0FFh
test al, 1
jnz short loc_4264C
add rsp, 30h
pop rbp
retn
| char trnman_free_trn(signed long long a1)
{
signed long long v1; // rax
signed long long v2; // rtt
char result; // al
bool v4; // [rsp+7h] [rbp-29h]
signed long long v5; // [rsp+20h] [rbp-10h]
inline_mysql_mutex_lock_3(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x22Du);
*(_WORD *)(a1 + 172) = 0;
inline_mysql_mutex_unlock_3(a1 + 16);
v5 = pool;
do
{
*(_QWORD *)(a1 + 104) = v5;
v2 = v5;
v1 = _InterlockedCompareExchange64(&pool, a1, v5);
v4 = v2 == v1;
if ( v2 != v1 )
v5 = v1;
result = ~v4;
}
while ( !v4 );
return result;
}
| trnman_free_trn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0014260e
LAB_0014260e:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
LEA RSI,[0x27dea7]
MOV EDX,0x22d
CALL 0x00142530
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0xac],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
CALL 0x001425a0
MOV RAX,qword ptr [0x005ad3c8]
MOV qword ptr [RBP + -0x10],RAX
LAB_0014264c:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
CMPXCHG.LOCK qword ptr [0x005ad3c8],RCX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x28],RCX
TEST AL,0x1
JNZ 0x0014268a
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0014268a:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV AL,byte ptr [RBP + -0x19]
XOR AL,0xff
TEST AL,0x1
JNZ 0x0014264c
ADD RSP,0x30
POP RBP
RET
|
void trnman_free_trn(long param_1)
{
long lVar1;
bool bVar2;
long local_18;
inline_mysql_mutex_lock
(param_1 + 0x10,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d)
;
*(int2 *)(param_1 + 0xac) = 0;
inline_mysql_mutex_unlock(param_1 + 0x10);
local_18 = pool;
do {
*(long *)(param_1 + 0x68) = local_18;
LOCK();
bVar2 = local_18 != pool;
lVar1 = param_1;
if (bVar2) {
local_18 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar2);
return;
}
| |
35,230 | trnman_free_trn | eloqsql/storage/maria/trnman.c | static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
} | O3 | c | trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x50(%rdi)
jne 0x4141a
movq %r14, %rdi
callq 0x2a230
movw $0x0, 0xac(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
jne 0x41430
movq %r14, %rdi
callq 0x2a1f0
movq 0x3e4432(%rip), %rax # 0x425838
movq %rax, 0x68(%rbx)
lock
cmpxchgq %rbx, 0x3e4425(%rip) # 0x425838
jne 0x41406
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb7a26(%rip), %rsi # 0xf8e47
movq %r14, %rdi
movl $0x22d, %edx # imm = 0x22D
callq 0x312ea
jmp 0x413e5
leaq 0x36d5e1(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x413f7
| trnman_free_trn:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+10h]
cmp qword ptr [rdi+50h], 0
jnz short loc_4141A
mov rdi, r14
call _pthread_mutex_lock
loc_413E5:
mov word ptr [rbx+0ACh], 0
mov rdi, [rbx+50h]
test rdi, rdi
jnz short loc_41430
loc_413F7:
mov rdi, r14
call _pthread_mutex_unlock
mov rax, cs:pool
loc_41406:
mov [rbx+68h], rax
lock cmpxchg cs:pool, rbx
jnz short loc_41406
pop rbx
pop r14
pop rbp
retn
loc_4141A:
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 22Dh
call psi_mutex_lock
jmp short loc_413E5
loc_41430:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_413F7
| signed long long trnman_free_trn(signed long long a1)
{
signed long long result; // rax
signed long long v2; // rtt
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x22Du);
else
pthread_mutex_lock(a1 + 16);
*(_WORD *)(a1 + 172) = 0;
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
result = pool;
do
{
*(_QWORD *)(a1 + 104) = result;
v2 = result;
result = _InterlockedCompareExchange64(&pool, a1, result);
}
while ( v2 != result );
return result;
}
| trnman_free_trn:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x10]
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x0014141a
MOV RDI,R14
CALL 0x0012a230
LAB_001413e5:
MOV word ptr [RBX + 0xac],0x0
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JNZ 0x00141430
LAB_001413f7:
MOV RDI,R14
CALL 0x0012a1f0
MOV RAX,qword ptr [0x00525838]
LAB_00141406:
MOV qword ptr [RBX + 0x68],RAX
CMPXCHG.LOCK qword ptr [0x00525838],RBX
JNZ 0x00141406
POP RBX
POP R14
POP RBP
RET
LAB_0014141a:
LEA RSI,[0x1f8e47]
MOV RDI,R14
MOV EDX,0x22d
CALL 0x001312ea
JMP 0x001413e5
LAB_00141430:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001413f7
|
void trnman_free_trn(long param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
bool bVar3;
__mutex = (pthread_mutex_t *)(param_1 + 0x10);
if (*(long *)(param_1 + 0x50) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d);
}
*(int2 *)(param_1 + 0xac) = 0;
if (*(long *)(param_1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar2 = pool;
do {
*(long *)(param_1 + 0x68) = lVar2;
LOCK();
bVar3 = lVar2 != pool;
lVar1 = param_1;
if (bVar3) {
lVar2 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar3);
return;
}
| |
35,231 | wait_for_lock | eloqsql/mysys/thr_lock.c | static enum enum_thr_lock_result
wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
my_bool in_wait_list, ulong lock_wait_timeout)
{
struct st_my_thread_var *thread_var= my_thread_var;
mysql_cond_t *cond= &thread_var->suspend;
struct timespec wait_timeout;
enum enum_thr_lock_result result= THR_LOCK_ABORTED;
PSI_stage_info old_stage;
my_bool use_wait_callbacks= FALSE;
DBUG_ENTER("wait_for_lock");
/*
One can use this to signal when a thread is going to wait for a lock.
See debug_sync.cc.
Beware of waiting for a signal here. The lock has acquired its mutex.
While waiting on a signal here, the locking thread could not acquire
the mutex to release the lock. One could lock up the table
completely.
In detail it works so: When thr_lock() tries to acquire a table
lock, it locks the lock->mutex, checks if it can have the lock, and
if not, it calls wait_for_lock(). Here it unlocks the table lock
while waiting on a condition. The sync point is located before this
wait for condition. If we have a waiting action here, we hold the
the table locks mutex all the time. Any attempt to look at the table
lock by another thread blocks it immediately on lock->mutex. This
can easily become an unexpected and unobvious blockage. So be
warned: Do not request a WAIT_FOR action for the 'wait_for_lock'
sync point unless you really know what you do.
*/
DEBUG_SYNC_C("wait_for_lock");
if (!in_wait_list)
{
(*wait->last)=data; /* Wait for lock */
data->prev= wait->last;
wait->last= &data->next;
}
statistic_increment(locks_waited, &THR_LOCK_lock);
/* Set up control struct to allow others to abort locks */
thread_var->current_mutex= &data->lock->mutex;
thread_var->current_cond= cond;
data->cond= cond;
proc_info_hook(NULL, &stage_waiting_for_table_level_lock,
&old_stage,
__func__, __FILE__, __LINE__);
/*
Since before_lock_wait potentially can create more threads to
scheduler work for, we don't want to call the before_lock_wait
callback unless it will really start to wait.
For similar reasons, we do not want to call before_lock_wait and
after_lock_wait for each lap around the loop, so we restrict
ourselves to call it before_lock_wait once before starting to wait
and once after the thread has exited the wait loop.
*/
if ((!thread_var->abort || in_wait_list) && before_lock_wait)
{
use_wait_callbacks= TRUE;
(*before_lock_wait)();
}
set_timespec(wait_timeout, lock_wait_timeout);
while (!thread_var->abort || in_wait_list)
{
int rc= mysql_cond_timedwait(cond, &data->lock->mutex, &wait_timeout);
/*
We must break the wait if one of the following occurs:
- the connection has been aborted (!thread_var->abort), but
this is not a delayed insert thread (in_wait_list). For a delayed
insert thread the proper action at shutdown is, apparently, to
acquire the lock and complete the insert.
- the lock has been granted (data->cond is set to NULL by the granter),
or the waiting has been aborted (additionally data->type is set to
TL_UNLOCK).
- the wait has timed out (rc == ETIMEDOUT)
Order of checks below is important to not report about timeout
if the predicate is true.
*/
if (data->cond == 0)
{
DBUG_PRINT("thr_lock", ("lock granted/aborted"));
break;
}
if (rc == ETIMEDOUT || rc == ETIME)
{
/* purecov: begin inspected */
DBUG_PRINT("thr_lock", ("lock timed out"));
result= THR_LOCK_WAIT_TIMEOUT;
break;
/* purecov: end */
}
}
/*
We call the after_lock_wait callback once the wait loop has
finished.
*/
if (after_lock_wait && use_wait_callbacks)
(*after_lock_wait)();
DBUG_PRINT("thr_lock", ("aborted: %d in_wait_list: %d",
thread_var->abort, in_wait_list));
if (data->cond || data->type == TL_UNLOCK)
{
if (data->cond) /* aborted or timed out */
{
if (((*data->prev)=data->next)) /* remove from wait-list */
data->next->prev= data->prev;
else
wait->last=data->prev;
data->type= TL_UNLOCK; /* No lock */
check_locks(data->lock, "killed or timed out wait_for_lock", data->type,
1);
wake_up_waiters(data->lock);
}
else
{
DBUG_PRINT("thr_lock", ("lock aborted"));
check_locks(data->lock, "aborted wait_for_lock", data->type, 0);
}
}
else
{
result= THR_LOCK_SUCCESS;
if (data->lock->get_status &&
(*data->lock->get_status)(data->status_param,
data->type == TL_WRITE_CONCURRENT_INSERT))
result= THR_LOCK_ABORTED;
check_locks(data->lock,"got wait_for_lock", data->type, 0);
}
mysql_mutex_unlock(&data->lock->mutex);
/* The following must be done after unlock of lock->mutex */
mysql_mutex_lock(&thread_var->mutex);
thread_var->current_mutex= 0;
thread_var->current_cond= 0;
mysql_mutex_unlock(&thread_var->mutex);
proc_info_hook(NULL, &old_stage, NULL, __func__, __FILE__, __LINE__);
DBUG_RETURN(result);
} | O0 | c | wait_for_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
callq 0xf7440
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x44(%rbp)
movb $0x0, -0x61(%rbp)
jmp 0xfa60e
cmpb $0x0, -0x11(%rbp)
jne 0xfa643
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xb8a266(%rip), %rax # 0xc848b0
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xb8a258(%rip), %rax # 0xc848b0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x18, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
xorl %eax, %eax
movl %eax, %edi
leaq 0x1c6280(%rip), %rsi # 0x2c0918
leaq -0x60(%rbp), %rdx
leaq 0x59712(%rip), %rcx # 0x153db5
leaq 0x5b2c5(%rip), %r8 # 0x15596f
movl $0x219, %r9d # imm = 0x219
leaq 0x1c65d9(%rip), %rax # 0x2c0c90
callq *(%rax)
movq -0x28(%rbp), %rax
movl 0xe0(%rax), %eax
cmpl $0x0, %eax
je 0xfa6d1
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0xfa6e5
cmpq $0x0, 0xb8a1df(%rip) # 0xc848b8
je 0xfa6e5
movb $0x1, -0x61(%rbp)
callq *0xb8a1d3(%rip) # 0xc848b8
jmp 0xfa6e7
callq 0xf1450
movq %rax, -0x78(%rbp)
imulq $0x3e8, -0x78(%rbp), %rax # imm = 0x3E8
imulq $0x3b9aca00, -0x20(%rbp), %rcx # imm = 0x3B9ACA00
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
movq -0x70(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rdx, -0x38(%rbp)
jmp 0xfa72d
movq -0x28(%rbp), %rax
movl 0xe0(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x7d(%rbp)
je 0xfa74e
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x7d(%rbp)
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0xfa757
jmp 0xfa7ac
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdx
leaq 0x5b1fd(%rip), %rcx # 0x15596f
movl $0x22e, %r8d # imm = 0x22E
callq 0xfb160
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xfa791
jmp 0xfa78d
jmp 0xfa78f
jmp 0xfa7ac
cmpl $0x6e, -0x7c(%rbp)
je 0xfa79d
cmpl $0x3e, -0x7c(%rbp)
jne 0xfa7aa
jmp 0xfa79f
jmp 0xfa7a1
movl $0x2, -0x44(%rbp)
jmp 0xfa7ac
jmp 0xfa72d
cmpq $0x0, 0xb8a10c(%rip) # 0xc848c0
je 0xfa7c5
movsbl -0x61(%rbp), %eax
cmpl $0x0, %eax
je 0xfa7c5
callq *0xb8a0fb(%rip) # 0xc848c0
jmp 0xfa7c7
jmp 0xfa7c9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xfa7de
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0xfa84a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xfa842
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xfa818
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xfa828
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf9040
jmp 0xfa848
jmp 0xfa844
jmp 0xfa846
jmp 0xfa848
jmp 0xfa8a1
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xb0(%rax)
je 0xfa89f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xb0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x10(%rbp), %rcx
cmpl $0x8, 0x40(%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movsbl %cl, %esi
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0xfa89f
movl $0x1, -0x44(%rbp)
jmp 0xfa8a1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
callq 0xf8cf0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
leaq 0x5b0ae(%rip), %rsi # 0x15596f
movl $0x274, %edx # imm = 0x274
callq 0xf8c80
movq -0x28(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0xf8cf0
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rsi
leaq 0x594b0(%rip), %rcx # 0x153db5
leaq 0x5b063(%rip), %r8 # 0x15596f
movl $0x279, %r9d # imm = 0x279
leaq 0x1c6377(%rip), %rax # 0x2c0c90
movq %rdx, %rdi
callq *(%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| wait_for_lock:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov [rbp+var_20], rcx
call _my_thread_var
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rax, 8
mov [rbp+var_30], rax
mov [rbp+var_44], 1
mov [rbp+var_61], 0
jmp short $+2
loc_FA60E:
cmp [rbp+var_11], 0
jnz short loc_FA643
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rcx, [rbp+var_10]
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+8], rcx
loc_FA643:
lea rax, locks_waited
mov rcx, [rax]
add rcx, 1
lea rax, locks_waited
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
add rcx, 18h
mov rax, [rbp+var_28]
mov [rax+98h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+0A0h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
xor eax, eax
mov edi, eax
lea rsi, stage_waiting_for_table_level_lock
lea rdx, [rbp+var_60]
lea rcx, aUnknown; "<unknown>"
lea r8, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 219h
lea rax, proc_info_hook
call qword ptr [rax]
mov rax, [rbp+var_28]
mov eax, [rax+0E0h]
cmp eax, 0
jz short loc_FA6D1
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_FA6E5
loc_FA6D1:
cmp cs:before_lock_wait, 0
jz short loc_FA6E5
mov [rbp+var_61], 1
call cs:before_lock_wait
loc_FA6E5:
jmp short $+2
loc_FA6E7:
call my_hrtime
mov [rbp+var_78], rax
imul rax, [rbp+var_78], 3E8h
imul rcx, [rbp+var_20], 3B9ACA00h
add rax, rcx
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_70]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_38], rdx
jmp short $+2
loc_FA72D:
mov rax, [rbp+var_28]
mov ecx, [rax+0E0h]
mov al, 1
cmp ecx, 0
mov [rbp+var_7D], al
jz short loc_FA74E
movsx eax, [rbp+var_11]
cmp eax, 0
setnz al
mov [rbp+var_7D], al
loc_FA74E:
mov al, [rbp+var_7D]
test al, 1
jnz short loc_FA757
jmp short loc_FA7AC
loc_FA757:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_10]
mov rsi, [rax+18h]
add rsi, 18h
lea rdx, [rbp+var_40]
lea rcx, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 22Eh
call inline_mysql_cond_timedwait_2
mov [rbp+var_7C], eax
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jnz short loc_FA791
jmp short $+2
loc_FA78D:
jmp short $+2
loc_FA78F:
jmp short loc_FA7AC
loc_FA791:
cmp [rbp+var_7C], 6Eh ; 'n'
jz short loc_FA79D
cmp [rbp+var_7C], 3Eh ; '>'
jnz short loc_FA7AA
loc_FA79D:
jmp short $+2
loc_FA79F:
jmp short $+2
loc_FA7A1:
mov [rbp+var_44], 2
jmp short loc_FA7AC
loc_FA7AA:
jmp short loc_FA72D
loc_FA7AC:
cmp cs:after_lock_wait, 0
jz short loc_FA7C5
movsx eax, [rbp+var_61]
cmp eax, 0
jz short loc_FA7C5
call cs:after_lock_wait
loc_FA7C5:
jmp short $+2
loc_FA7C7:
jmp short $+2
loc_FA7C9:
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jnz short loc_FA7DE
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 0
jnz short loc_FA84A
loc_FA7DE:
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jz short loc_FA842
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_FA818
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_FA828
loc_FA818:
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+8], rcx
loc_FA828:
mov rax, [rbp+var_10]
mov dword ptr [rax+40h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
call wake_up_waiters
jmp short loc_FA848
loc_FA842:
jmp short $+2
loc_FA844:
jmp short $+2
loc_FA846:
jmp short $+2
loc_FA848:
jmp short loc_FA8A1
loc_FA84A:
mov [rbp+var_44], 0
mov rax, [rbp+var_10]
mov rax, [rax+18h]
cmp qword ptr [rax+0B0h], 0
jz short loc_FA89F
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov rax, [rax+0B0h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+28h]
mov rcx, [rbp+var_10]
cmp dword ptr [rcx+40h], 8
setz cl
and cl, 1
movzx ecx, cl
movsx esi, cl
call rax
movsx eax, al
cmp eax, 0
jz short loc_FA89F
mov [rbp+var_44], 1
loc_FA89F:
jmp short $+2
loc_FA8A1:
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
call inline_mysql_mutex_unlock_28
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 274h
call inline_mysql_mutex_lock_27
mov rax, [rbp+var_28]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_28]
mov qword ptr [rax+0A0h], 0
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
call inline_mysql_mutex_unlock_28
xor eax, eax
mov edx, eax
lea rsi, [rbp+var_60]
lea rcx, aUnknown; "<unknown>"
lea r8, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 279h
lea rax, proc_info_hook
mov rdi, rdx
call qword ptr [rax]
mov eax, [rbp+var_44]
mov [rbp+var_84], eax
mov eax, [rbp+var_84]
add rsp, 90h
pop rbp
retn
| long long wait_for_lock(long long a1, const char *a2, char a3, long long a4)
{
long long v4; // rax
bool v6; // [rsp+13h] [rbp-7Dh]
int v7; // [rsp+14h] [rbp-7Ch]
unsigned long long v8; // [rsp+20h] [rbp-70h]
char v9; // [rsp+2Fh] [rbp-61h]
unsigned int v10; // [rsp+4Ch] [rbp-44h]
_QWORD v11[2]; // [rsp+50h] [rbp-40h] BYREF
long long v12; // [rsp+60h] [rbp-30h]
long long v13; // [rsp+68h] [rbp-28h]
long long v14; // [rsp+70h] [rbp-20h]
char v15; // [rsp+7Fh] [rbp-11h]
const char *v16; // [rsp+80h] [rbp-10h]
long long v17; // [rsp+88h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = my_thread_var(a1, a2);
v12 = v13 + 8;
v10 = 1;
v9 = 0;
if ( !v15 )
{
**(_QWORD **)(v17 + 8) = v16;
*((_QWORD *)v16 + 2) = *(_QWORD *)(v17 + 8);
*(_QWORD *)(v17 + 8) = v16 + 8;
}
++locks_waited;
*(_QWORD *)(v13 + 152) = *((_QWORD *)v16 + 3) + 24LL;
*(_QWORD *)(v13 + 160) = v12;
*((_QWORD *)v16 + 4) = v12;
proc_info_hook();
if ( (!*(_DWORD *)(v13 + 224) || v15) && before_lock_wait )
{
v9 = 1;
before_lock_wait(0LL, &stage_waiting_for_table_level_lock);
}
v8 = 1000000000 * v14 + 1000 * my_hrtime();
v11[0] = v8 / 0x3B9ACA00;
v11[1] = v8 % 0x3B9ACA00;
while ( 1 )
{
v6 = 1;
if ( *(_DWORD *)(v13 + 224) )
v6 = v15 != 0;
if ( !v6 )
break;
v7 = inline_mysql_cond_timedwait_2(
v12,
*((_QWORD *)v16 + 3) + 24LL,
v11,
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
558LL);
if ( !*((_QWORD *)v16 + 4) )
break;
if ( v7 == 110 || v7 == 62 )
{
v10 = 2;
break;
}
}
if ( after_lock_wait && v9 )
after_lock_wait();
if ( !*((_QWORD *)v16 + 4) && *((_DWORD *)v16 + 16) )
{
v10 = 0;
if ( *(_QWORD *)(*((_QWORD *)v16 + 3) + 176LL) )
v10 = (*(unsigned __int8 ( **)(_QWORD, bool))(*((_QWORD *)v16 + 3) + 176LL))(
*((_QWORD *)v16 + 5),
*((_DWORD *)v16 + 16) == 8) != 0;
}
else if ( *((_QWORD *)v16 + 4) )
{
v4 = *((_QWORD *)v16 + 1);
**((_QWORD **)v16 + 2) = v4;
if ( v4 )
*(_QWORD *)(*((_QWORD *)v16 + 1) + 16LL) = *((_QWORD *)v16 + 2);
else
*(_QWORD *)(v17 + 8) = *((_QWORD *)v16 + 2);
*((_DWORD *)v16 + 16) = 0;
wake_up_waiters(*((_QWORD *)v16 + 3));
}
inline_mysql_mutex_unlock_28(*((_QWORD *)v16 + 3) + 24LL);
inline_mysql_mutex_lock_27(v13 + 64, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x274u);
*(_QWORD *)(v13 + 152) = 0LL;
*(_QWORD *)(v13 + 160) = 0LL;
inline_mysql_mutex_unlock_28(v13 + 64);
proc_info_hook();
return v10;
}
| wait_for_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],RCX
CALL 0x001f7440
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x44],0x1
MOV byte ptr [RBP + -0x61],0x0
JMP 0x001fa60e
LAB_001fa60e:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x001fa643
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_001fa643:
LEA RAX,[0xd848b0]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0xd848b0]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0xa0],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
XOR EAX,EAX
MOV EDI,EAX
LEA RSI,[0x3c0918]
LEA RDX,[RBP + -0x60]
LEA RCX,[0x253db5]
LEA R8,[0x25596f]
MOV R9D,0x219
LEA RAX,[0x3c0c90]
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0xe0]
CMP EAX,0x0
JZ 0x001fa6d1
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x001fa6e5
LAB_001fa6d1:
CMP qword ptr [0x00d848b8],0x0
JZ 0x001fa6e5
MOV byte ptr [RBP + -0x61],0x1
CALL qword ptr [0x00d848b8]
LAB_001fa6e5:
JMP 0x001fa6e7
LAB_001fa6e7:
CALL 0x001f1450
MOV qword ptr [RBP + -0x78],RAX
IMUL RAX,qword ptr [RBP + -0x78],0x3e8
IMUL RCX,qword ptr [RBP + -0x20],0x3b9aca00
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x38],RDX
JMP 0x001fa72d
LAB_001fa72d:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0xe0]
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x7d],AL
JZ 0x001fa74e
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x7d],AL
LAB_001fa74e:
MOV AL,byte ptr [RBP + -0x7d]
TEST AL,0x1
JNZ 0x001fa757
JMP 0x001fa7ac
LAB_001fa757:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x18
LEA RDX,[RBP + -0x40]
LEA RCX,[0x25596f]
MOV R8D,0x22e
CALL 0x001fb160
MOV dword ptr [RBP + -0x7c],EAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x001fa791
JMP 0x001fa78d
LAB_001fa78d:
JMP 0x001fa78f
LAB_001fa78f:
JMP 0x001fa7ac
LAB_001fa791:
CMP dword ptr [RBP + -0x7c],0x6e
JZ 0x001fa79d
CMP dword ptr [RBP + -0x7c],0x3e
JNZ 0x001fa7aa
LAB_001fa79d:
JMP 0x001fa79f
LAB_001fa79f:
JMP 0x001fa7a1
LAB_001fa7a1:
MOV dword ptr [RBP + -0x44],0x2
JMP 0x001fa7ac
LAB_001fa7aa:
JMP 0x001fa72d
LAB_001fa7ac:
CMP qword ptr [0x00d848c0],0x0
JZ 0x001fa7c5
MOVSX EAX,byte ptr [RBP + -0x61]
CMP EAX,0x0
JZ 0x001fa7c5
CALL qword ptr [0x00d848c0]
LAB_001fa7c5:
JMP 0x001fa7c7
LAB_001fa7c7:
JMP 0x001fa7c9
LAB_001fa7c9:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x001fa7de
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x0
JNZ 0x001fa84a
LAB_001fa7de:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001fa842
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001fa818
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001fa828
LAB_001fa818:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_001fa828:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x001f9040
JMP 0x001fa848
LAB_001fa842:
JMP 0x001fa844
LAB_001fa844:
JMP 0x001fa846
LAB_001fa846:
JMP 0x001fa848
LAB_001fa848:
JMP 0x001fa8a1
LAB_001fa84a:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
CMP qword ptr [RAX + 0xb0],0x0
JZ 0x001fa89f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP dword ptr [RCX + 0x40],0x8
SETZ CL
AND CL,0x1
MOVZX ECX,CL
MOVSX ESI,CL
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001fa89f
MOV dword ptr [RBP + -0x44],0x1
LAB_001fa89f:
JMP 0x001fa8a1
LAB_001fa8a1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
CALL 0x001f8cf0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
LEA RSI,[0x25596f]
MOV EDX,0x274
CALL 0x001f8c80
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0xa0],0x0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
CALL 0x001f8cf0
XOR EAX,EAX
MOV EDX,EAX
LEA RSI,[RBP + -0x60]
LEA RCX,[0x253db5]
LEA R8,[0x25596f]
MOV R9D,0x279
LEA RAX,[0x3c0c90]
MOV RDI,RDX
CALL qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x84],EAX
MOV EAX,dword ptr [RBP + -0x84]
ADD RSP,0x90
POP RBP
RET
|
int4 wait_for_lock(long param_1,long param_2,char param_3,long param_4)
{
char cVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong extraout_RDX;
ulong extraout_RDX_00;
bool bVar5;
int1 local_68 [28];
int4 local_4c;
ulong local_48;
ulong local_40;
long local_38;
long local_30;
long local_28;
char local_19;
long local_18;
long local_10;
local_28 = param_4;
local_19 = param_3;
local_18 = param_2;
local_10 = param_1;
local_30 = _my_thread_var();
local_38 = local_30 + 8;
local_4c = 1;
bVar5 = false;
if (local_19 == '\0') {
**(long **)(local_10 + 8) = local_18;
*(int8 *)(local_18 + 0x10) = *(int8 *)(local_10 + 8);
*(long *)(local_10 + 8) = local_18 + 8;
}
locks_waited = locks_waited + 1;
*(long *)(local_30 + 0x98) = *(long *)(local_18 + 0x18) + 0x18;
*(long *)(local_30 + 0xa0) = local_38;
*(long *)(local_18 + 0x20) = local_38;
(*(code *)proc_info_hook)
(0,stage_waiting_for_table_level_lock,local_68,"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x219);
if (((*(int *)(local_30 + 0xe0) == 0) || (local_19 != '\0')) && (before_lock_wait != (code *)0x0))
{
bVar5 = true;
(*before_lock_wait)();
}
lVar3 = my_hrtime();
uVar4 = lVar3 * 1000 + local_28 * 1000000000;
local_48 = uVar4 / 1000000000;
uVar4 = uVar4 % 1000000000;
local_40 = uVar4;
do {
if ((*(int *)(local_30 + 0xe0) != 0 && local_19 == '\0') ||
(iVar2 = inline_mysql_cond_timedwait
(local_38,*(long *)(local_18 + 0x18) + 0x18,&local_48,
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x22e),
uVar4 = extraout_RDX, *(long *)(local_18 + 0x20) == 0)) goto LAB_001fa7ac;
} while ((iVar2 != 0x6e) && (iVar2 != 0x3e));
local_4c = 2;
LAB_001fa7ac:
if ((after_lock_wait != (code *)0x0) && (bVar5)) {
(*after_lock_wait)();
uVar4 = extraout_RDX_00;
}
if ((*(long *)(local_18 + 0x20) == 0) && (*(int *)(local_18 + 0x40) != 0)) {
local_4c = 0;
if ((*(long *)(*(long *)(local_18 + 0x18) + 0xb0) != 0) &&
(bVar5 = *(int *)(local_18 + 0x40) == 8,
cVar1 = (**(code **)(*(long *)(local_18 + 0x18) + 0xb0))
(*(int8 *)(local_18 + 0x28),bVar5,uVar4,bVar5), cVar1 != '\0')) {
local_4c = 1;
}
}
else if (*(long *)(local_18 + 0x20) != 0) {
lVar3 = *(long *)(local_18 + 8);
**(long **)(local_18 + 0x10) = lVar3;
if (lVar3 == 0) {
*(int8 *)(local_10 + 8) = *(int8 *)(local_18 + 0x10);
}
else {
*(int8 *)(*(long *)(local_18 + 8) + 0x10) = *(int8 *)(local_18 + 0x10);
}
*(int4 *)(local_18 + 0x40) = 0;
wake_up_waiters(*(int8 *)(local_18 + 0x18));
}
inline_mysql_mutex_unlock(*(long *)(local_18 + 0x18) + 0x18);
inline_mysql_mutex_lock
(local_30 + 0x40,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x274);
*(int8 *)(local_30 + 0x98) = 0;
*(int8 *)(local_30 + 0xa0) = 0;
inline_mysql_mutex_unlock(local_30 + 0x40);
(*(code *)proc_info_hook)
(0,local_68,0,"<unknown>","/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x279);
return local_4c;
}
| |
35,232 | testing::internal::ParseFlagValue(char const*, char const*, bool) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | static const char* ParseFlagValue(const char* str, const char* flag_name,
bool def_optional) {
// str and flag must not be NULL.
if (str == nullptr || flag_name == nullptr) return nullptr;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str =
std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
const size_t flag_len = flag_str.length();
if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
// Skips the flag name.
const char* flag_end = str + flag_len;
// When def_optional is true, it's OK to not have a "=value" part.
if (def_optional && (flag_end[0] == '\0')) {
return flag_end;
}
// If def_optional is true and there are more characters after the
// flag name, or if def_optional is false, there must be a '=' after
// the flag name.
if (flag_end[0] != '=') return nullptr;
// Returns the string after "=".
return flag_end + 1;
} | O1 | cpp | testing::internal::ParseFlagValue(char const*, char const*, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x2f532
xorl %ebx, %ebx
jmp 0x2f687
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14550(%rip), %rsi # 0x43a9b
leaq 0x1454b(%rip), %rdx # 0x43a9d
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x39504
leaq 0x12d3f(%rip), %rsi # 0x422a5
movq %r15, %rdi
callq 0x8a50
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f595
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2f59c
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rsi
callq 0x8a50
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2f5e7
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2f5ef
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f61e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f635
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x28(%rsp), %r14
movq 0x30(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8220
testl %eax, %eax
je 0x2f655
xorl %ebx, %ebx
jmp 0x2f672
addq %r15, %rbx
testb %bpl, %bpl
je 0x2f662
cmpb $0x0, (%rbx)
je 0x2f672
xorl %eax, %eax
cmpb $0x3d, (%rbx)
leaq 0x1(%rbx), %rcx
cmoveq %rcx, %rax
movq %rax, %rbx
cmpq %r13, %r14
je 0x2f687
movq 0x38(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x84e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f6b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x2f6b8
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f6cf
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internalL14ParseFlagValueEPKcS2_b:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
test rdi, rdi
setz al
test rsi, rsi
setz cl
or cl, al
jz short loc_2F532
xor ebx, ebx
jmp loc_2F687
loc_2F532:
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea r12, [rsp+98h+var_40]
mov [r12-10h], r12
lea rsi, aTheValueOfFlag+12h; "--"
lea rdx, aTheValueOfFlag+14h; ""
lea r15, [rsp+98h+var_50]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aGtest; "gtest_"
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+98h+var_80]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2F595
mov [rsp+98h+var_90], rdx
mov rdx, [rcx]
mov [rsp+98h+var_80], rdx
jmp short loc_2F59C
loc_2F595:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_2F59C:
mov rdx, [rax+8]
lea rdi, [rsp+98h+var_90]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+98h+var_60]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2F5E7
mov [rsp+98h+var_70], rdx
mov rdx, [rcx]
mov [rsp+98h+var_60], rdx
jmp short loc_2F5EF
loc_2F5E7:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_2F5EF:
mov rdx, [rax+8]
mov [rsp+98h+var_68], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r15
jz short loc_2F61E
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F61E:
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, r12
jz short loc_2F635
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F635:
mov r14, [rsp+98h+var_70]
mov r15, [rsp+98h+var_68]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _strncmp
test eax, eax
jz short loc_2F655
xor ebx, ebx
jmp short loc_2F672
loc_2F655:
add rbx, r15
test bpl, bpl
jz short loc_2F662
cmp byte ptr [rbx], 0
jz short loc_2F672
loc_2F662:
xor eax, eax
cmp byte ptr [rbx], 3Dh ; '='
lea rcx, [rbx+1]
cmovz rax, rcx
mov rbx, rax
loc_2F672:
cmp r14, r13
jz short loc_2F687
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_2F687:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_2F6B8
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2F6B8
mov rbx, rax
loc_2F6B8:
mov rdi, [rsp+arg_40]; void *
cmp rdi, r12
jz short loc_2F6CF
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2F6CF:
mov rdi, rbx
call __Unwind_Resume
| _BYTE * testing::internal::ParseFlagValue(testing::internal *this, const char *a2, const char *a3)
{
_BYTE *v3; // rbx
char v4; // bp
long long v5; // rax
__int128 *v6; // rcx
long long v7; // rax
__int128 *v8; // rcx
__int128 *v9; // r14
long long v10; // r15
_BYTE *v11; // rax
void *v13[2]; // [rsp+8h] [rbp-90h] BYREF
__int128 v14; // [rsp+18h] [rbp-80h] BYREF
void *v15; // [rsp+28h] [rbp-70h]
long long v16; // [rsp+30h] [rbp-68h]
__int128 v17; // [rsp+38h] [rbp-60h] BYREF
void *v18[2]; // [rsp+48h] [rbp-50h] BYREF
_QWORD v19[8]; // [rsp+58h] [rbp-40h] BYREF
if ( this == 0LL || a2 == 0LL )
return 0LL;
v4 = (char)a3;
v18[0] = v19;
std::string::_M_construct<char const*>(v18, "--", "");
v5 = std::string::append(v18, "gtest_");
v13[0] = &v14;
v6 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v14 = *v6;
}
else
{
v13[0] = *(void **)v5;
*(_QWORD *)&v14 = *(_QWORD *)v6;
}
v13[1] = *(void **)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
v7 = std::string::append(v13, a2);
v15 = &v17;
v8 = (__int128 *)(v7 + 16);
if ( *(_QWORD *)v7 == v7 + 16 )
{
v17 = *v8;
}
else
{
v15 = *(void **)v7;
*(_QWORD *)&v17 = *(_QWORD *)v8;
}
v16 = *(_QWORD *)(v7 + 8);
*(_QWORD *)v7 = v8;
*(_QWORD *)(v7 + 8) = 0LL;
*(_BYTE *)(v7 + 16) = 0;
if ( v13[0] != &v14 )
operator delete(v13[0], v14 + 1);
if ( v18[0] != v19 )
operator delete(v18[0], v19[0] + 1LL);
v9 = (__int128 *)v15;
v10 = v16;
if ( !(unsigned int)strncmp(this, v15, v16) )
{
v3 = (char *)this + v10;
if ( !v4 || *v3 )
{
v11 = 0LL;
if ( *v3 == 61 )
v11 = v3 + 1;
v3 = v11;
}
}
else
{
v3 = 0LL;
}
if ( v9 != &v17 )
operator delete(v9, v17 + 1);
return v3;
}
| ParseFlagValue:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
TEST RDI,RDI
SETZ AL
TEST RSI,RSI
SETZ CL
OR CL,AL
JZ 0x0012f532
XOR EBX,EBX
JMP 0x0012f687
LAB_0012f532:
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RSP + 0x58]
MOV qword ptr [R12 + -0x10],R12
LEA RSI,[0x143a9b]
LEA RDX,[0x143a9d]
LEA R15,[RSP + 0x48]
MOV RDI,R15
CALL 0x00139504
LAB_0012f55f:
LEA RSI,[0x1422a5]
MOV RDI,R15
CALL 0x00108a50
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0012f595
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x0012f59c
LAB_0012f595:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_0012f59c:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_0012f5b8:
MOV RSI,R14
CALL 0x00108a50
LAB_0012f5c0:
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0012f5e7
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x0012f5ef
LAB_0012f5e7:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_0012f5ef:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0012f61e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001084e0
LAB_0012f61e:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R12
JZ 0x0012f635
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001084e0
LAB_0012f635:
MOV R14,qword ptr [RSP + 0x28]
MOV R15,qword ptr [RSP + 0x30]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00108220
TEST EAX,EAX
JZ 0x0012f655
XOR EBX,EBX
JMP 0x0012f672
LAB_0012f655:
ADD RBX,R15
TEST BPL,BPL
JZ 0x0012f662
CMP byte ptr [RBX],0x0
JZ 0x0012f672
LAB_0012f662:
XOR EAX,EAX
CMP byte ptr [RBX],0x3d
LEA RCX,[RBX + 0x1]
CMOVZ RAX,RCX
MOV RBX,RAX
LAB_0012f672:
CMP R14,R13
JZ 0x0012f687
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
MOV RDI,R14
CALL 0x001084e0
LAB_0012f687:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::ParseFlagValue(char const*, char const*, bool) */
char * testing::internal::ParseFlagValue(char *param_1,char *param_2,bool param_3)
{
size_t sVar1;
int iVar2;
long *plVar3;
long *plVar4;
char *pcVar5;
char *pcVar6;
long *local_90;
long local_88;
long local_80;
long lStack_78;
long *local_70;
size_t local_68;
long local_60;
long lStack_58;
long *local_50 [2];
long local_40 [2];
if (param_2 == (char *)0x0 || param_1 == (char *)0x0) {
pcVar5 = (char *)0x0;
}
else {
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char_const*>(local_50,"--","");
/* try { // try from 0012f55f to 0012f56d has its CatchHandler @ 0012f6b5 */
plVar3 = (long *)std::__cxx11::string::append((char *)local_50);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_80 = *plVar4;
lStack_78 = plVar3[3];
local_90 = &local_80;
}
else {
local_80 = *plVar4;
local_90 = (long *)*plVar3;
}
local_88 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 0012f5b8 to 0012f5bf has its CatchHandler @ 0012f699 */
plVar3 = (long *)std::__cxx11::string::append((char *)&local_90);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_60 = *plVar4;
lStack_58 = plVar3[3];
local_70 = &local_60;
}
else {
local_60 = *plVar4;
local_70 = (long *)*plVar3;
}
local_68 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
if (local_90 != &local_80) {
operator_delete(local_90,local_80 + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
sVar1 = local_68;
plVar3 = local_70;
iVar2 = strncmp(param_1,(char *)local_70,local_68);
if (iVar2 == 0) {
pcVar6 = param_1 + sVar1;
if ((!param_3) || (pcVar5 = pcVar6, *pcVar6 != '\0')) {
pcVar5 = (char *)0x0;
if (*pcVar6 == '=') {
pcVar5 = pcVar6 + 1;
}
}
}
else {
pcVar5 = (char *)0x0;
}
if (plVar3 != &local_60) {
operator_delete(plVar3,local_60 + 1);
}
}
return pcVar5;
}
| |
35,233 | minja::Value::pop(minja::Value const&) | monkey531[P]llama/common/./minja.hpp | Value pop(const Value& index) {
if (is_array()) {
if (array_->empty())
throw std::runtime_error("pop from empty list");
if (index.is_null()) {
auto ret = array_->back();
array_->pop_back();
return ret;
} else if (!index.is_number_integer()) {
throw std::runtime_error("pop index must be an integer: " + index.dump());
} else {
auto i = index.get<int>();
if (i < 0 || i >= static_cast<int>(array_->size()))
throw std::runtime_error("pop index out of range: " + index.dump());
auto it = array_->begin() + (i < 0 ? array_->size() + i : i);
auto ret = *it;
array_->erase(it);
return ret;
}
} else if (is_object()) {
if (!index.is_hashable())
throw std::runtime_error("Unashable type: " + index.dump());
auto it = object_->find(index.primitive_);
if (it == object_->end())
throw std::runtime_error("Key not found: " + index.dump());
auto ret = it->second;
object_->erase(it);
return ret;
} else {
throw std::runtime_error("Value is not an array or object: " + dump());
}
} | O3 | cpp | minja::Value::pop(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rbp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x54151
movq 0x8(%rax), %rsi
cmpq %rsi, (%rax)
je 0x5425f
cmpq $0x0, 0x20(%rbx)
movb 0x40(%rbx), %al
jne 0x541b6
cmpq $0x0, 0x10(%rbx)
jne 0x541b6
testb %al, %al
jne 0x541b6
cmpq $0x0, 0x30(%rbx)
jne 0x541b6
addq $-0x50, %rsi
movq %rbp, %rdi
callq 0x4ed98
movq 0x10(%r15), %rdi
movq 0x8(%rdi), %rsi
addq $-0x50, %rsi
movq %rsi, 0x8(%rdi)
callq 0x4412e
jmp 0x5424d
movq 0x20(%r15), %r14
testq %r14, %r14
je 0x542f1
cmpq $0x0, 0x10(%rbx)
jne 0x54351
cmpq $0x0, 0x20(%rbx)
jne 0x54351
cmpq $0x0, 0x30(%rbx)
jne 0x54351
movq (%r14), %r13
movq 0x8(%r14), %r12
cmpq %r12, %r13
je 0x54226
movq %rbp, 0x40(%rsp)
leaq 0x40(%rbx), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4e6da
testb %al, %al
jne 0x54216
addq $0x60, %r13
movq 0x8(%r14), %r12
cmpq %r12, %r13
jne 0x54198
jmp 0x54219
addb $-0x5, %al
cmpb $0x2, %al
jae 0x5440e
movq %rbx, %rdi
callq 0x51e3a
testl %eax, %eax
js 0x54291
movq 0x10(%r15), %rcx
movq (%rcx), %r12
movq 0x8(%rcx), %rcx
subq %r12, %rcx
shrq $0x4, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
cmpl %ecx, %eax
jge 0x54291
movl %eax, %eax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %r12
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4ed98
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x557de
jmp 0x5424d
movq %r13, %r12
movq 0x20(%r15), %rax
movq 0x8(%rax), %r13
movq 0x40(%rsp), %rbp
cmpq %r13, %r12
je 0x543b1
leaq 0x10(%r12), %rsi
movq %rbp, %rdi
callq 0x4ed98
movq 0x20(%r15), %rdi
leaq 0x60(%r12), %rdx
movq %r12, %rsi
callq 0x5585a
movq %rbp, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x67071(%rip), %rsi # 0xbb2e4
movq %rax, %rdi
callq 0x18270
movq 0x9bd6e(%rip), %rsi # 0xefff0
movq 0x9bcf7(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x67060(%rip), %rsi # 0xbb317
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bd13(%rip), %rsi # 0xefff0
movq 0x9bc9c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66cc5(%rip), %rsi # 0xbafdc
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bcb3(%rip), %rsi # 0xefff0
movq 0x9bc3c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66b19(%rip), %rsi # 0xbae90
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bc53(%rip), %rsi # 0xefff0
movq 0x9bbdc(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66f59(%rip), %rsi # 0xbb330
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bbf3(%rip), %rsi # 0xefff0
movq 0x9bb7c(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54469
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x66ec4(%rip), %rsi # 0xbb2f8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9bb96(%rip), %rsi # 0xefff0
movq 0x9bb1f(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
jmp 0x54479
jmp 0x544b9
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54497
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x544b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x544e8
jmp 0x544fd
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x544e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x544e8
jmp 0x544e5
jmp 0x544e5
jmp 0x544e5
jmp 0x544e5
jmp 0x544f2
jmp 0x544e5
movq %rax, %rbx
movq %r14, %rdi
callq 0x18500
jmp 0x544fd
movq %rax, %rbx
movq %rbp, %rdi
callq 0x3d8e4
movq %rbx, %rdi
callq 0x18b90
nop
| _ZN5minja5Value3popERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdx
mov r15, rsi
mov rbp, rdi
mov rax, [rsi+10h]
test rax, rax
jz short loc_54151
mov rsi, [rax+8]
cmp [rax], rsi
jz loc_5425F
cmp qword ptr [rbx+20h], 0
mov al, [rbx+40h]
jnz loc_541B6
cmp qword ptr [rbx+10h], 0
jnz loc_541B6
test al, al
jnz loc_541B6
cmp qword ptr [rbx+30h], 0
jnz loc_541B6
add rsi, 0FFFFFFFFFFFFFFB0h; minja::Value *
mov rdi, rbp; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+10h]
mov rsi, [rdi+8]
add rsi, 0FFFFFFFFFFFFFFB0h
mov [rdi+8], rsi
call _ZN9__gnu_cxx13new_allocatorIN5minja5ValueEE7destroyIS2_EEvPT_; __gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(minja::Value *)
jmp loc_5424D
loc_54151:
mov r14, [r15+20h]
test r14, r14
jz loc_542F1
cmp qword ptr [rbx+10h], 0
jnz loc_54351
cmp qword ptr [rbx+20h], 0
jnz loc_54351
cmp qword ptr [rbx+30h], 0
jnz loc_54351
mov r13, [r14]
mov r12, [r14+8]
cmp r13, r12
jz loc_54226
mov [rsp+78h+var_38], rbp
lea rbp, [rbx+40h]
loc_54198:
mov rdi, r13
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_54216
add r13, 60h ; '`'
mov r12, [r14+8]
cmp r13, r12
jnz short loc_54198
jmp short loc_54219
loc_541B6:
add al, 0FBh
cmp al, 2
jnb loc_5440E
mov rdi, rbx
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
test eax, eax
js loc_54291
mov rcx, [r15+10h]
mov r12, [rcx]
mov rcx, [rcx+8]
sub rcx, r12
shr rcx, 4
imul ecx, 0CCCCCCCDh
cmp eax, ecx
jge loc_54291
mov eax, eax
lea rax, [rax+rax*4]
shl rax, 4
add r12, rax
mov rdi, rbp; this
mov rsi, r12; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+10h]
mov rsi, r12
call _ZNSt6vectorIN5minja5ValueESaIS1_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPS1_S3_EE; std::vector<minja::Value>::_M_erase(__gnu_cxx::__normal_iterator<minja::Value*,std::vector<minja::Value>>)
jmp short loc_5424D
loc_54216:
mov r12, r13
loc_54219:
mov rax, [r15+20h]
mov r13, [rax+8]
mov rbp, [rsp+78h+var_38]
loc_54226:
cmp r12, r13
jz loc_543B1
lea rsi, [r12+10h]; minja::Value *
mov rdi, rbp; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
mov rdi, [r15+20h]
lea rdx, [r12+60h]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEESR_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::erase(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>*,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>)
loc_5424D:
mov rax, rbp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5425F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aPopFromEmptyLi; "pop from empty list"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_54291:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aPopIndexOutOfR; "pop index out of range: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_542F1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_54351:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_54469
loc_543B1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aKeyNotFound_0; "Key not found: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_54469
loc_5440E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, rbx
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aPopIndexMustBe; "pop index must be an integer: "
lea rdi, [rsp+78h+var_58]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_58]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_54469:
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
jmp short loc_54479
jmp short loc_544B9
loc_54479:
mov rbx, rax
lea rax, [rsp+78h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_54497
mov rsi, [rsp+78h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_54497:
lea rax, [rsp+78h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_544B2
mov rsi, [rsp+78h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_544B2:
test bpl, bpl
jnz short loc_544E8
jmp short loc_544FD
loc_544B9:
mov rbx, rax
lea rax, [rsp+78h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_544E8
mov rsi, [rsp+78h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_544E8
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544E5
jmp short loc_544F2
jmp short $+2
loc_544E5:
mov rbx, rax
loc_544E8:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_544FD
loc_544F2:
mov rbx, rax
mov rdi, rbp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_544FD:
mov rdi, rbx
call __Unwind_Resume
| minja::Value * minja::Value::pop(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
minja::Value *v6; // rbp
_QWORD *v7; // rax
long long v8; // rsi
char v9; // al
long long v10; // rdi
long long v11; // rsi
unsigned __int8 **v12; // r14
unsigned __int8 *v13; // r13
unsigned __int8 *v14; // r12
int v15; // eax
_QWORD *v16; // rcx
const minja::Value *v17; // r12
std::runtime_error *exception; // r14
void *v20; // r14
void *v21; // r14
void *v22; // r14
void *v23; // r14
void *v24; // r14
_BYTE v25[16]; // [rsp+0h] [rbp-78h] BYREF
_BYTE v26[16]; // [rsp+20h] [rbp-58h] BYREF
minja::Value *v27; // [rsp+40h] [rbp-38h]
v6 = this;
v7 = (_QWORD *)*((_QWORD *)a2 + 2);
if ( v7 )
{
v8 = v7[1];
if ( *v7 == v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "pop from empty list");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v9 = *(_BYTE *)(a3 + 64);
if ( *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 16) || v9 || *(_QWORD *)(a3 + 48) )
{
if ( (unsigned __int8)(v9 - 5) >= 2u )
{
v24 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"pop index must be an integer: ", (long long)v25);
std::runtime_error::runtime_error(v24, v26);
__cxa_throw(
v24,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v15 = minja::Value::get<int>((_QWORD *)a3);
if ( v15 < 0 || (v16 = (_QWORD *)*((_QWORD *)a2 + 2), v15 >= (int)(-858993459 * ((v16[1] - *v16) >> 4))) )
{
v20 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"pop index out of range: ", (long long)v25);
std::runtime_error::runtime_error(v20, v26);
__cxa_throw(
v20,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v17 = (const minja::Value *)(80LL * (unsigned int)v15 + *v16);
minja::Value::Value(this, v17);
std::vector<minja::Value>::_M_erase(*((_QWORD *)a2 + 2), v17);
}
else
{
minja::Value::Value(this, (const minja::Value *)(v8 - 80));
v10 = *((_QWORD *)a2 + 2);
v11 = *(_QWORD *)(v10 + 8) - 80LL;
*(_QWORD *)(v10 + 8) = v11;
__gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(v10, v11);
}
}
else
{
v12 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v12 )
{
v21 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Value is not an array or object: ", (long long)v25);
std::runtime_error::runtime_error(v21, v26);
__cxa_throw(
v21,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
v22 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Unashable type: ", (long long)v25);
std::runtime_error::runtime_error(v22, v26);
__cxa_throw(
v22,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v13 = *v12;
v14 = v12[1];
if ( *v12 != v14 )
{
v27 = this;
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v13, (unsigned __int8 *)(a3 + 64), a4) )
{
v13 += 96;
v14 = v12[1];
if ( v13 == v14 )
goto LABEL_22;
}
v14 = v13;
LABEL_22:
v13 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
v6 = v27;
}
if ( v14 == v13 )
{
v23 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a3, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v26, (long long)"Key not found: ", (long long)v25);
std::runtime_error::runtime_error(v23, v26);
__cxa_throw(
v23,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::Value(v6, (const minja::Value *)(v14 + 16));
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::erase(
*((_QWORD *)a2 + 4),
v14,
v14 + 96);
}
return v6;
}
| pop:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV R15,RSI
MOV RBP,RDI
MOV RAX,qword ptr [RSI + 0x10]
TEST RAX,RAX
JZ 0x00154151
MOV RSI,qword ptr [RAX + 0x8]
CMP qword ptr [RAX],RSI
JZ 0x0015425f
CMP qword ptr [RBX + 0x20],0x0
MOV AL,byte ptr [RBX + 0x40]
JNZ 0x001541b6
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x001541b6
TEST AL,AL
JNZ 0x001541b6
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x001541b6
ADD RSI,-0x50
MOV RDI,RBP
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x10]
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,-0x50
MOV qword ptr [RDI + 0x8],RSI
CALL 0x0014412e
JMP 0x0015424d
LAB_00154151:
MOV R14,qword ptr [R15 + 0x20]
TEST R14,R14
JZ 0x001542f1
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x00154351
CMP qword ptr [RBX + 0x20],0x0
JNZ 0x00154351
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x00154351
MOV R13,qword ptr [R14]
MOV R12,qword ptr [R14 + 0x8]
CMP R13,R12
JZ 0x00154226
MOV qword ptr [RSP + 0x40],RBP
LEA RBP,[RBX + 0x40]
LAB_00154198:
MOV RDI,R13
MOV RSI,RBP
CALL 0x0014e6da
TEST AL,AL
JNZ 0x00154216
ADD R13,0x60
MOV R12,qword ptr [R14 + 0x8]
CMP R13,R12
JNZ 0x00154198
JMP 0x00154219
LAB_001541b6:
ADD AL,0xfb
CMP AL,0x2
JNC 0x0015440e
MOV RDI,RBX
CALL 0x00151e3a
TEST EAX,EAX
JS 0x00154291
MOV RCX,qword ptr [R15 + 0x10]
MOV R12,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,R12
SHR RCX,0x4
IMUL ECX,ECX,-0x33333333
CMP EAX,ECX
JGE 0x00154291
MOV EAX,EAX
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD R12,RAX
MOV RDI,RBP
MOV RSI,R12
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x10]
LAB_0015420c:
MOV RSI,R12
CALL 0x001557de
LAB_00154214:
JMP 0x0015424d
LAB_00154216:
MOV R12,R13
LAB_00154219:
MOV RAX,qword ptr [R15 + 0x20]
MOV R13,qword ptr [RAX + 0x8]
MOV RBP,qword ptr [RSP + 0x40]
LAB_00154226:
CMP R12,R13
JZ 0x001543b1
LEA RSI,[R12 + 0x10]
MOV RDI,RBP
CALL 0x0014ed98
MOV RDI,qword ptr [R15 + 0x20]
LEA RDX,[R12 + 0x60]
LAB_00154245:
MOV RSI,R12
CALL 0x0015585a
LAB_0015424d:
MOV RAX,RBP
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015425f:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015426c:
LEA RSI,[0x1bb2e4]
MOV RDI,RAX
CALL 0x00118270
LAB_0015427b:
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_00154291:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015429e:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_001542b0:
LEA RSI,[0x1bb317]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_001542c7:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_001542f1:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_001542fe:
MOV RDI,RSP
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154310:
LEA RSI,[0x1bafdc]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154327:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_00154351:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015435e:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00154370:
LEA RSI,[0x1bae90]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154387:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_001543b1:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_001543be:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_001543d0:
LEA RSI,[0x1bb330]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_001543e7:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_0015440e:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0015441b:
MOV RDI,RSP
MOV RSI,RBX
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_0015442d:
LEA RSI,[0x1bb2f8]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_00154444:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::Value::pop(minja::Value const&) */
Value * minja::Value::pop(Value *param_1)
{
long *plVar1;
new_allocator<minja::Value> *this;
long lVar2;
char cVar3;
uint uVar4;
runtime_error *prVar5;
int iVar6;
Value *in_RDX;
bool bVar7;
long in_RSI;
int iVar8;
Value *pVVar9;
basic_json *pbVar10;
basic_json *pbVar11;
int1 auStack_78 [32];
string local_58 [32];
Value *local_38;
plVar1 = *(long **)(in_RSI + 0x10);
bVar7 = SUB81(in_RDX,0);
iVar8 = (int)auStack_78;
if (plVar1 == (long *)0x0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 == (long *)0x0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001542fe to 0015430f has its CatchHandler @ 001544df */
dump_abi_cxx11_(iVar8,SUB81(in_RSI,0));
/* try { // try from 00154310 to 00154323 has its CatchHandler @ 00154477 */
std::operator+((char *)local_58,(string *)"Value is not an array or object: ");
/* try { // try from 00154327 to 0015434b has its CatchHandler @ 00154475 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015435e to 0015436f has its CatchHandler @ 001544dd */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 00154370 to 00154383 has its CatchHandler @ 00154473 */
std::operator+((char *)local_58,(string *)"Unashable type: ");
/* try { // try from 00154387 to 001543ab has its CatchHandler @ 00154471 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
pbVar11 = (basic_json *)*plVar1;
pbVar10 = (basic_json *)plVar1[1];
if (pbVar11 != pbVar10) {
local_38 = param_1;
do {
pbVar10 = pbVar11;
cVar3 = nlohmann::json_abi_v3_11_3::operator==(pbVar10,(basic_json *)(in_RDX + 0x40));
if (cVar3 != '\0') break;
pbVar11 = pbVar10 + 0x60;
pbVar10 = (basic_json *)plVar1[1];
} while (pbVar11 != pbVar10);
pbVar11 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
param_1 = local_38;
}
if (pbVar10 == pbVar11) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001543be to 001543cf has its CatchHandler @ 001544db */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 001543d0 to 001543e3 has its CatchHandler @ 0015446f */
std::operator+((char *)local_58,(string *)"Key not found: ");
/* try { // try from 001543e7 to 0015440b has its CatchHandler @ 0015446d */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
Value(param_1,(Value *)(pbVar10 + 0x10));
/* try { // try from 00154245 to 0015424c has its CatchHandler @ 001544f2 */
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::erase(*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(in_RSI + 0x20),pbVar10,pbVar10 + 0x60);
}
else {
if (*plVar1 == plVar1[1]) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015426c to 0015427a has its CatchHandler @ 001544e5 */
std::runtime_error::runtime_error(prVar5,"pop from empty list");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (((*(long *)(in_RDX + 0x20) == 0) && (*(long *)(in_RDX + 0x10) == 0)) &&
((in_RDX[0x40] == (Value)0x0 && (*(long *)(in_RDX + 0x30) == 0)))) {
Value(param_1,(Value *)(plVar1[1] + -0x50));
this = *(new_allocator<minja::Value> **)(in_RSI + 0x10);
lVar2 = *(long *)(this + 8);
*(Value **)(this + 8) = (Value *)(lVar2 + -0x50);
__gnu_cxx::new_allocator<minja::Value>::destroy<minja::Value>(this,(Value *)(lVar2 + -0x50));
}
else {
if (1 < (byte)((char)in_RDX[0x40] - 5U)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015441b to 0015442c has its CatchHandler @ 001544d9 */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 0015442d to 00154440 has its CatchHandler @ 0015446b */
std::operator+((char *)local_58,(string *)"pop index must be an integer: ");
/* try { // try from 00154444 to 00154468 has its CatchHandler @ 00154469 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
uVar4 = get<int>(in_RDX);
if (((int)uVar4 < 0) ||
(lVar2 = **(long **)(in_RSI + 0x10),
iVar6 = (int)((ulong)((*(long **)(in_RSI + 0x10))[1] - lVar2) >> 4),
SBORROW4(uVar4,iVar6 * -0x33333333) == (int)(uVar4 + iVar6 * 0x33333333) < 0)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015429e to 001542af has its CatchHandler @ 001544e3 */
dump_abi_cxx11_(iVar8,bVar7);
/* try { // try from 001542b0 to 001542c3 has its CatchHandler @ 001544b9 */
std::operator+((char *)local_58,(string *)"pop index out of range: ");
/* try { // try from 001542c7 to 001542eb has its CatchHandler @ 00154479 */
std::runtime_error::runtime_error(prVar5,local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
pVVar9 = (Value *)(lVar2 + (ulong)uVar4 * 0x50);
Value(param_1,pVVar9);
/* try { // try from 0015420c to 00154213 has its CatchHandler @ 001544e1 */
std::vector<minja::Value,std::allocator<minja::Value>>::_M_erase
(*(vector<minja::Value,std::allocator<minja::Value>> **)(in_RSI + 0x10),pVVar9);
}
}
return param_1;
}
| |
35,234 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get() | monkey531[P]llama/common/json.hpp | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x1f046
movb $0x0, 0x18(%rbx)
jmp 0x1f05b
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1f08a
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
movl 0x14(%rbx), %eax
cmpl $-0x1, %eax
je 0x1f073
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x4eda4
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x1f084
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x1f058
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_1F046
mov byte ptr [rbx+18h], 0
jmp short loc_1F05B
loc_1F046:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_1F08A
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_1F058:
mov [rbx+14h], eax
loc_1F05B:
mov eax, [rbx+14h]
cmp eax, 0FFFFFFFFh
jz short loc_1F073
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
loc_1F073:
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_1F084
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
loc_1F084:
add rsp, 10h
pop rbx
retn
loc_1F08A:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_1F058
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(
__m128i *a1)
{
unsigned __int8 *v1; // rcx
int v2; // eax
long long result; // rax
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
}
else
{
v1 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v2 = -1;
}
else
{
v2 = *v1;
a1->m128i_i64[0] = (long long)(v1 + 1);
}
a1[1].m128i_i32[1] = v2;
}
if ( a1[1].m128i_i32[1] != -1 )
std::vector<char>::emplace_back<char>(&a1[3].m128i_u64[1]);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result == 10 )
{
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
}
return result;
}
| get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x0011f046
MOV byte ptr [RBX + 0x18],0x0
JMP 0x0011f05b
LAB_0011f046:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x0011f08a
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_0011f058:
MOV dword ptr [RBX + 0x14],EAX
LAB_0011f05b:
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,-0x1
JZ 0x0011f073
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x0014eda4
LAB_0011f073:
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x0011f084
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
LAB_0011f084:
ADD RSP,0x10
POP RBX
RET
LAB_0011f08a:
PUSH -0x1
POP RAX
JMP 0x0011f058
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::get() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
byte *pbVar1;
uint uVar2;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (this[0x18] ==
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1) {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (*(int *)(this + 0x14) != -1) {
local_9 = (char)*(int *)(this + 0x14);
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
}
if (*(int *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
}
return;
}
| |
35,235 | google::protobuf::Reflection::RemoveLast(google::protobuf::Message*, google::protobuf::FieldDescriptor const*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_message_reflection.cc | void Reflection::RemoveLast(Message* message,
const FieldDescriptor* field) const {
USAGE_CHECK_MESSAGE_TYPE(RemoveLast);
USAGE_CHECK_REPEATED(RemoveLast);
CheckInvalidAccess(schema_, field);
if (field->is_extension()) {
MutableExtensionSet(message)->RemoveLast(field->number());
} else {
switch (field->cpp_type()) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \
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:
MutableRaw<RepeatedPtrField<std::string> >(message, field)
->RemoveLast();
break;
}
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
MutableRaw<MapFieldBase>(message, field)
->MutableRepeatedField()
->RemoveLast<GenericTypeHandler<Message> >();
} else {
MutableRaw<RepeatedPtrFieldBase>(message, field)
->RemoveLast<GenericTypeHandler<Message> >();
}
break;
}
}
} | O3 | cpp | google::protobuf::Reflection::RemoveLast(google::protobuf::Message*, google::protobuf::FieldDescriptor const*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
cmpq %rdi, 0x20(%rdx)
je 0x65d3e
leaq 0x540a1(%rip), %rdx # 0xb9dd0
leaq 0x53f93(%rip), %rcx # 0xb9cc9
movq %r14, %rsi
callq 0x65a82
movb 0x1(%r14), %al
movl %eax, %ecx
notb %cl
testb $0x60, %cl
je 0x65d68
movq (%r15), %rdi
leaq 0x5407b(%rip), %rdx # 0xb9dd0
leaq 0x54030(%rip), %rcx # 0xb9d8c
movq %r14, %rsi
callq 0x65a82
movb 0x1(%r14), %al
testb $0x8, %al
jne 0x65dd6
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x65d91
leaq -0x2b15c(%rip), %rax # 0x3ac20
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
callq 0x3fc96
movzbl 0x2(%r14), %eax
leaq 0x4fe83(%rip), %rcx # 0xb5c20
movl (%rcx,%rax,4), %eax
decl %eax
cmpl $0x9, %eax
ja 0x65dcb
leaq 0x53bba(%rip), %rcx # 0xb9968
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ea6a
movl %eax, %eax
decl (%rbx,%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%r15), %eax
addq %rax, %rbx
movl 0x4(%r14), %esi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x965d0
movq %r14, %rdi
callq 0x6454a
movl %eax, %ebp
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ea6a
movl %eax, %eax
addq %rax, %rbx
testb %bpl, %bpl
je 0x65e6d
movq %rbx, %rdi
callq 0x726b2
movq 0x10(%rax), %rcx
movslq 0x8(%rax), %rdx
leaq -0x1(%rdx), %rsi
movl %esi, 0x8(%rax)
movq (%rcx,%rdx,8), %rdi
jmp 0x65e80
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ea6a
movl %eax, %eax
movq 0x10(%rbx,%rax), %rcx
movslq 0x8(%rbx,%rax), %rdx
leaq -0x1(%rdx), %rsi
movl %esi, 0x8(%rbx,%rax)
movq (%rcx,%rdx,8), %rax
movq $0x0, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
jmp 0x65dcb
movq 0x10(%rbx), %rax
movslq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x8(%rbx)
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x65dcb
nop
| _ZNK6google8protobuf10Reflection10RemoveLastEPNS0_7MessageEPKNS0_15FieldDescriptorE:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rdi, [rdi]; this
cmp [rdx+20h], rdi
jz short loc_65D3E
lea rdx, aRemovelast; "RemoveLast"
lea rcx, aFieldDoesNotMa; "Field does not match message type."
mov rsi, r14; google::protobuf::Descriptor *
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
loc_65D3E:
mov al, [r14+1]
mov ecx, eax
not cl
test cl, 60h
jz short loc_65D68
mov rdi, [r15]; this
lea rdx, aRemovelast; "RemoveLast"
lea rcx, aFieldIsSingula; "Field is singular; the method requires "...
mov rsi, r14; google::protobuf::Descriptor *
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
mov al, [r14+1]
loc_65D68:
test al, 8
jnz short loc_65DD6
mov rdi, [r14+18h]
test rdi, rdi
jz short loc_65D91
lea rax, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
lea rsi, [rsp+38h+var_28]; google::protobuf::FieldDescriptor *
mov [rsi], rax
lea rdx, [rsp+38h+var_30]
mov [rdx], r14
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
loc_65D91:
movzx eax, byte ptr [r14+2]
lea rcx, _ZN6google8protobuf15FieldDescriptor17kTypeToCppTypeMapE; google::protobuf::FieldDescriptor::kTypeToCppTypeMap
mov eax, [rcx+rax*4]
dec eax; switch 10 cases
cmp eax, 9
ja short def_65DB5; jumptable 0000000000065DB5 default case
lea rcx, jpt_65DB5
movsxd rax, ds:(jpt_65DB5 - 0B9968h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_65DB7:
add r15, 8; jumptable 0000000000065DB5 cases 1-8
mov rdi, r15; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*)
mov eax, eax
dec dword ptr [rbx+rax]
def_65DB5:
add rsp, 18h; jumptable 0000000000065DB5 default case
pop rbx
pop r14
pop r15
pop rbp
retn
loc_65DD6:
mov eax, [r15+28h]
add rbx, rax
mov esi, [r14+4]; int
mov rdi, rbx; this
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN6google8protobuf8internal12ExtensionSet10RemoveLastEi; google::protobuf::internal::ExtensionSet::RemoveLast(int)
loc_65DF3:
mov rdi, r14; jumptable 0000000000065DB5 case 10
call _ZN6google8protobuf12_GLOBAL__N_115IsMapFieldInApiEPKNS0_15FieldDescriptorE_0; google::protobuf::`anonymous namespace'::IsMapFieldInApi(google::protobuf::FieldDescriptor const*)
mov ebp, eax
add r15, 8
mov rdi, r15; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*)
mov eax, eax
add rbx, rax
test bpl, bpl
jz short loc_65E6D
mov rdi, rbx; this
call _ZN6google8protobuf8internal12MapFieldBase20MutableRepeatedFieldEv; google::protobuf::internal::MapFieldBase::MutableRepeatedField(void)
mov rcx, [rax+10h]
movsxd rdx, dword ptr [rax+8]
lea rsi, [rdx-1]
mov [rax+8], esi
mov rdi, [rcx+rdx*8]
jmp short loc_65E80
loc_65E33:
add r15, 8; jumptable 0000000000065DB5 case 9
mov rdi, r15; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*)
mov eax, eax
mov rcx, [rbx+rax+10h]
movsxd rdx, dword ptr [rbx+rax+8]
lea rsi, [rdx-1]
mov [rbx+rax+8], esi
mov rax, [rcx+rdx*8]
mov qword ptr [rax+8], 0
mov rax, [rax]
mov byte ptr [rax], 0
jmp def_65DB5; jumptable 0000000000065DB5 default case
loc_65E6D:
mov rax, [rbx+10h]
movsxd rcx, dword ptr [rbx+8]
lea rdx, [rcx-1]
mov [rbx+8], edx
mov rdi, [rax+rcx*8]
loc_65E80:
mov rax, [rdi]
call qword ptr [rax+20h]
jmp def_65DB5; jumptable 0000000000065DB5 default case
| long long google::protobuf::Reflection::RemoveLast(
google::protobuf::_anonymous_namespace_ **this,
google::protobuf::Message *a2,
const google::protobuf::FieldDescriptor *a3,
long long a4,
const char *a5,
long long a6)
{
unsigned int v6; // eax
google::protobuf::Message *v8; // rbx
google::protobuf::_anonymous_namespace_ *v10; // rdi
long long v11; // rcx
long long v12; // rdi
long long result; // rax
char IsMapFieldInApi; // bp
google::protobuf::internal::MapFieldBase *v15; // rbx
long long v16; // rax
long long v17; // rcx
long long v18; // rdx
long long v19; // rdi
unsigned int FieldOffset; // eax
long long v21; // rcx
long long v22; // rdx
long long *v23; // rax
long long v24; // rax
long long v25; // rcx
const google::protobuf::FieldDescriptor *v26; // [rsp+8h] [rbp-30h] BYREF
_QWORD v27[5]; // [rsp+10h] [rbp-28h] BYREF
v8 = a2;
v10 = *this;
if ( *((google::protobuf::_anonymous_namespace_ **)a3 + 4) != v10 )
{
a2 = a3;
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
v10,
a3,
(const google::protobuf::FieldDescriptor *)"RemoveLast",
"Field does not match message type.",
a5);
}
LOBYTE(v6) = *((_BYTE *)a3 + 1);
v11 = v6;
LOBYTE(v11) = ~(_BYTE)v6;
if ( (~(_BYTE)v6 & 0x60) != 0 )
{
a2 = a3;
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
*this,
a3,
(const google::protobuf::FieldDescriptor *)"RemoveLast",
"Field is singular; the method requires a repeated field.",
a5);
LOBYTE(v6) = *((_BYTE *)a3 + 1);
}
if ( (v6 & 8) != 0 )
return google::protobuf::internal::ExtensionSet::RemoveLast(
(google::protobuf::Message *)((char *)v8 + *((unsigned int *)this + 10)),
*((_DWORD *)a3 + 1));
v12 = *((_QWORD *)a3 + 3);
if ( v12 )
{
a2 = (google::protobuf::Message *)v27;
v27[0] = google::protobuf::FieldDescriptor::TypeOnceInit;
v26 = a3;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v12,
(long long)v27,
(long long)&v26,
v11,
(long long)a5,
a6);
}
result = (unsigned int)(google::protobuf::FieldDescriptor::kTypeToCppTypeMap[*((unsigned __int8 *)a3 + 2)] - 1);
switch ( *((_BYTE *)a3 + 2) )
{
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 0xD:
case 0xE:
case 0xF:
case 0x10:
case 0x11:
case 0x12:
result = (unsigned int)google::protobuf::internal::ReflectionSchema::GetFieldOffset(
(google::protobuf::internal::ReflectionSchema *)(this + 1),
a3);
--*(_DWORD *)((char *)v8 + (unsigned int)result);
break;
case 9:
case 0xC:
FieldOffset = google::protobuf::internal::ReflectionSchema::GetFieldOffset(
(google::protobuf::internal::ReflectionSchema *)(this + 1),
a3);
v21 = *(_QWORD *)((char *)v8 + FieldOffset + 16);
v22 = *(int *)((char *)v8 + FieldOffset + 8);
*(_DWORD *)((char *)v8 + FieldOffset + 8) = v22 - 1;
v23 = *(long long **)(v21 + 8 * v22);
v23[1] = 0LL;
result = *v23;
*(_BYTE *)result = 0;
break;
case 0xA:
case 0xB:
IsMapFieldInApi = google::protobuf::`anonymous namespace'::IsMapFieldInApi(
a3,
a2,
(long long)a3,
(long long)google::protobuf::FieldDescriptor::kTypeToCppTypeMap,
(long long)a5,
a6);
v15 = (google::protobuf::Message *)((char *)v8
+ (unsigned int)google::protobuf::internal::ReflectionSchema::GetFieldOffset(
(google::protobuf::internal::ReflectionSchema *)(this + 1),
a3));
if ( IsMapFieldInApi )
{
v16 = google::protobuf::internal::MapFieldBase::MutableRepeatedField(v15);
v17 = *(_QWORD *)(v16 + 16);
v18 = *(int *)(v16 + 8);
*(_DWORD *)(v16 + 8) = v18 - 1;
v19 = *(_QWORD *)(v17 + 8 * v18);
}
else
{
v24 = *((_QWORD *)v15 + 2);
v25 = *((int *)v15 + 2);
*((_DWORD *)v15 + 2) = v25 - 1;
v19 = *(_QWORD *)(v24 + 8 * v25);
}
result = (*(long long ( **)(long long))(*(_QWORD *)v19 + 32LL))(v19);
break;
default:
return result;
}
return result;
}
| RemoveLast:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDX + 0x20],RDI
JZ 0x00165d3e
LEA RDX,[0x1b9dd0]
LEA RCX,[0x1b9cc9]
MOV RSI,R14
CALL 0x00165a82
LAB_00165d3e:
MOV AL,byte ptr [R14 + 0x1]
MOV ECX,EAX
NOT CL
TEST CL,0x60
JZ 0x00165d68
MOV RDI,qword ptr [R15]
LEA RDX,[0x1b9dd0]
LEA RCX,[0x1b9d8c]
MOV RSI,R14
CALL 0x00165a82
MOV AL,byte ptr [R14 + 0x1]
LAB_00165d68:
TEST AL,0x8
JNZ 0x00165dd6
MOV RDI,qword ptr [R14 + 0x18]
TEST RDI,RDI
JZ 0x00165d91
LEA RAX,[0x13ac20]
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],R14
CALL 0x0013fc96
LAB_00165d91:
MOVZX EAX,byte ptr [R14 + 0x2]
LEA RCX,[0x1b5c20]
MOV EAX,dword ptr [RCX + RAX*0x4]
DEC EAX
CMP EAX,0x9
JA 0x00165dcb
LEA RCX,[0x1b9968]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
ADD R15,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x0016ea6a
MOV EAX,EAX
DEC dword ptr [RBX + RAX*0x1]
default:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00165dd6:
MOV EAX,dword ptr [R15 + 0x28]
ADD RBX,RAX
MOV ESI,dword ptr [R14 + 0x4]
MOV RDI,RBX
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001965d0
caseD_a:
MOV RDI,R14
CALL 0x0016454a
MOV EBP,EAX
ADD R15,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x0016ea6a
MOV EAX,EAX
ADD RBX,RAX
TEST BPL,BPL
JZ 0x00165e6d
MOV RDI,RBX
CALL 0x001726b2
MOV RCX,qword ptr [RAX + 0x10]
MOVSXD RDX,dword ptr [RAX + 0x8]
LEA RSI,[RDX + -0x1]
MOV dword ptr [RAX + 0x8],ESI
MOV RDI,qword ptr [RCX + RDX*0x8]
JMP 0x00165e80
caseD_9:
ADD R15,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x0016ea6a
MOV EAX,EAX
MOV RCX,qword ptr [RBX + RAX*0x1 + 0x10]
MOVSXD RDX,dword ptr [RBX + RAX*0x1 + 0x8]
LEA RSI,[RDX + -0x1]
MOV dword ptr [RBX + RAX*0x1 + 0x8],ESI
MOV RAX,qword ptr [RCX + RDX*0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX],0x0
JMP 0x00165dcb
LAB_00165e6d:
MOV RAX,qword ptr [RBX + 0x10]
MOVSXD RCX,dword ptr [RBX + 0x8]
LEA RDX,[RCX + -0x1]
MOV dword ptr [RBX + 0x8],EDX
MOV RDI,qword ptr [RAX + RCX*0x8]
LAB_00165e80:
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x20]
JMP 0x00165dcb
|
/* google::protobuf::Reflection::RemoveLast(google::protobuf::Message*,
google::protobuf::FieldDescriptor const*) const */
void __thiscall
google::protobuf::Reflection::RemoveLast(Reflection *this,Message *param_1,FieldDescriptor *param_2)
{
int iVar1;
int8 *puVar2;
FieldDescriptor FVar3;
char cVar4;
uint uVar5;
long lVar6;
ulong uVar7;
MapFieldBase *this_00;
long *plVar8;
FieldDescriptor *local_30;
code *local_28;
if (*(Descriptor **)(param_2 + 0x20) != *(Descriptor **)this) {
(anonymous_namespace)::ReportReflectionUsageError
(*(Descriptor **)this,param_2,"RemoveLast","Field does not match message type.");
}
FVar3 = param_2[1];
if ((~(byte)FVar3 & 0x60) != 0) {
(anonymous_namespace)::ReportReflectionUsageError
(*(Descriptor **)this,param_2,"RemoveLast",
"Field is singular; the method requires a repeated field.");
FVar3 = param_2[1];
}
if (((byte)FVar3 & 8) != 0) {
internal::ExtensionSet::RemoveLast
((ExtensionSet *)(param_1 + *(uint *)(this + 0x28)),*(int *)(param_2 + 4));
return;
}
if (*(once_flag **)(param_2 + 0x18) != (once_flag *)0x0) {
local_28 = FieldDescriptor::TypeOnceInit;
local_30 = param_2;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(param_2 + 0x18),(_func_void_FieldDescriptor_ptr *)&local_28,&local_30
);
}
switch(*(int4 *)(FieldDescriptor::kTypeToCppTypeMap + (ulong)(byte)param_2[2] * 4)) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
uVar5 = internal::ReflectionSchema::GetFieldOffset((ReflectionSchema *)(this + 8),param_2);
*(int *)(param_1 + uVar5) = *(int *)(param_1 + uVar5) + -1;
break;
case 9:
uVar5 = internal::ReflectionSchema::GetFieldOffset((ReflectionSchema *)(this + 8),param_2);
uVar7 = (ulong)uVar5;
iVar1 = *(int *)(param_1 + uVar7 + 8);
*(int *)(param_1 + uVar7 + 8) = iVar1 + -1;
puVar2 = *(int8 **)(*(long *)(param_1 + uVar7 + 0x10) + (long)iVar1 * 8);
puVar2[1] = 0;
*(int1 *)*puVar2 = 0;
break;
case 10:
cVar4 = (anonymous_namespace)::IsMapFieldInApi(param_2);
uVar5 = internal::ReflectionSchema::GetFieldOffset((ReflectionSchema *)(this + 8),param_2);
this_00 = (MapFieldBase *)(param_1 + uVar5);
if (cVar4 == '\0') {
iVar1 = *(int *)(this_00 + 8);
*(int *)(this_00 + 8) = iVar1 + -1;
plVar8 = *(long **)(*(long *)(this_00 + 0x10) + (long)iVar1 * 8);
}
else {
lVar6 = internal::MapFieldBase::MutableRepeatedField(this_00);
iVar1 = *(int *)(lVar6 + 8);
*(int *)(lVar6 + 8) = iVar1 + -1;
plVar8 = *(long **)(*(long *)(lVar6 + 0x10) + (long)iVar1 * 8);
}
(**(code **)(*plVar8 + 0x20))();
}
return;
}
| |
35,236 | JS_FlattenIntoArray | bluesky950520[P]quickjs/quickjs.c | static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValue target,
JSValue source, int64_t sourceLen,
int64_t targetIndex, int depth,
JSValue mapperFunction,
JSValue thisArg)
{
JSValue element;
int64_t sourceIndex, elementLen;
int present, is_array;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
for (sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
present = JS_TryGetPropertyInt64(ctx, source, sourceIndex, &element);
if (present < 0)
return -1;
if (!present)
continue;
if (!JS_IsUndefined(mapperFunction)) {
JSValue args[3] = { element, js_int64(sourceIndex), source };
element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
if (JS_IsException(element))
return -1;
}
if (depth > 0) {
is_array = JS_IsArray(ctx, element);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length64(ctx, &elementLen, element) < 0)
goto fail;
targetIndex = JS_FlattenIntoArray(ctx, target, element,
elementLen, targetIndex,
depth - 1,
JS_UNDEFINED, JS_UNDEFINED);
if (targetIndex < 0)
goto fail;
JS_FreeValue(ctx, element);
continue;
}
}
if (targetIndex >= MAX_SAFE_INTEGER) {
JS_ThrowTypeError(ctx, "Array too long");
goto fail;
}
if (JS_DefinePropertyValueInt64(ctx, target, targetIndex, element,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
return -1;
targetIndex++;
}
return targetIndex;
fail:
JS_FreeValue(ctx, element);
return -1;
} | O1 | c | JS_FlattenIntoArray:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdi, %r12
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x77878
leaq 0x2606c(%rip), %rsi # 0x9d8ce
movq %r12, %rdi
xorl %eax, %eax
callq 0x1fec9
movq $-0x1, %r13
jmp 0x77b9c
movq %r9, %r15
movq 0x10(%rbp), %rbx
testq %r9, %r9
jle 0x77b70
leaq 0x30(%rbp), %rax
leaq 0x20(%rbp), %rcx
movl 0x18(%rbp), %edx
movq (%rcx), %rsi
movq %rsi, -0xd0(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0xc8(%rbp)
movl %ecx, %ecx
movq %rcx, -0xd8(%rbp)
movq (%rax), %rcx
movq %rcx, -0xc0(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xb8(%rbp)
leal -0x1(%rdx), %eax
movl %eax, -0x54(%rbp)
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
movq %r15, -0x60(%rbp)
movq %r12, %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %r14, %rcx
leaq -0x50(%rbp), %r8
callq 0x4cabd
movq $-0x1, %r13
testl %eax, %eax
js 0x77b9c
je 0x77b5f
movq %rbx, -0x38(%rbp)
cmpl $0x3, -0xd8(%rbp)
je 0x77a09
movaps -0x50(%rbp), %xmm0
movaps %xmm0, -0xb0(%rbp)
movq %r14, %rax
shrq $0x1f, %rax
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movl %r14d, %ecx
movq %xmm0, %rdx
cmoveq %rcx, %rdx
movl $0x7, %ecx
cmovneq %rcx, %rax
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x110(%rbp)
movq $0x3, -0x108(%rbp)
movups -0x110(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0xb0(%rbp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %r12, %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %r8
movl $0x3, %r9d
callq 0x278b6
movq %rdx, %rbx
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq 0x18(%r12), %rdi
callq 0x1ccb2
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq 0x18(%r12), %rdi
callq 0x1ccb2
cmpl $0x6, %ebx
je 0x77b9c
movl 0x18(%rbp), %eax
testl %eax, %eax
jle 0x77ae9
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %rbx
movq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x276be
testl %eax, %eax
js 0x77b8a
je 0x77ae9
movq -0x30(%rbp), %r12
movq %r12, %rdi
leaq -0xe0(%rbp), %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x21ec8
testl %eax, %eax
js 0x77b8a
movq -0xe0(%rbp), %r9
xorl %eax, %eax
movl %eax, -0x100(%rbp)
movl $0x3, %ecx
movq %rcx, -0xf8(%rbp)
movl %eax, -0xf0(%rbp)
movq %rcx, -0xe8(%rbp)
movups -0xf0(%rbp), %xmm0
movups %xmm0, 0x20(%rsp)
movups -0x100(%rbp), %xmm0
movups %xmm0, 0x10(%rsp)
movl -0x54(%rbp), %eax
movl %eax, 0x8(%rsp)
movq -0x38(%rbp), %rax
movq %rax, (%rsp)
movq %r12, %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x77827
movq %rax, -0x38(%rbp)
testq %rax, %rax
js 0x77b8a
movq 0x18(%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movq -0x60(%rbp), %r15
movq -0x38(%rbp), %rbx
jmp 0x77b5f
movq -0x38(%rbp), %rbx
movabsq $0x1fffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFF
cmpq %rax, %rbx
jge 0x77b75
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
movq %xmm0, %rcx
movaps -0x50(%rbp), %xmm0
movslq %ebx, %rax
cmpq %rbx, %rax
movl %eax, %eax
cmoveq %rax, %rcx
movaps %xmm0, -0xb0(%rbp)
movl $0x7, %r8d
movl $0x0, %eax
cmoveq %rax, %r8
movaps -0xb0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq -0x30(%rbp), %r12
movq %r12, %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
movl $0x4007, %r9d # imm = 0x4007
callq 0x25f19
testl %eax, %eax
movq -0x60(%rbp), %r15
js 0x77b9c
incq %rbx
incq %r14
movq %rbx, %r13
cmpq %r14, %r15
jne 0x778d7
jmp 0x77b9c
movq %rbx, %r13
jmp 0x77b9c
leaq 0x28b44(%rip), %rsi # 0xa06c0
movq -0x30(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x21953
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x18(%r12), %rdi
callq 0x1ccb2
movq %r13, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_FlattenIntoArray:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
mov [rbp+var_80], r8
mov [rbp+var_78], rcx
mov [rbp+var_70], rdx
mov [rbp+var_68], rsi
mov r12, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_77878
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
mov rdi, r12
xor eax, eax
call JS_ThrowRangeError
mov r13, 0FFFFFFFFFFFFFFFFh
jmp loc_77B9C
loc_77878:
mov r15, r9
mov rbx, [rbp+arg_0]
test r9, r9
jle loc_77B70
lea rax, [rbp+arg_20]
lea rcx, [rbp+arg_10]
mov edx, [rbp+arg_8]
mov rsi, [rcx]
mov [rbp+var_D0], rsi
mov rcx, [rcx+8]
mov [rbp+var_C8], rcx
mov ecx, ecx
mov [rbp+var_D8], rcx
mov rcx, [rax]
mov [rbp+var_C0], rcx
mov rax, [rax+8]
mov [rbp+var_B8], rax
lea eax, [rdx-1]
mov [rbp+var_54], eax
xor r14d, r14d
mov [rbp+var_30], r12
mov [rbp+var_60], r15
loc_778D7:
mov rdi, r12
mov rsi, [rbp+var_78]
mov rdx, [rbp+var_80]
mov rcx, r14
lea r8, [rbp+var_50]
call JS_TryGetPropertyInt64
mov r13, 0FFFFFFFFFFFFFFFFh
test eax, eax
js loc_77B9C
jz loc_77B5F
mov [rbp+var_38], rbx
cmp dword ptr [rbp+var_D8], 3
jz loc_77A09
movaps xmm0, [rbp+var_50]
movaps [rbp+var_B0], xmm0
mov rax, r14
shr rax, 1Fh
xorps xmm0, xmm0
cvtsi2sd xmm0, r14
mov ecx, r14d
movq rdx, xmm0
cmovz rdx, rcx
mov ecx, 7
cmovnz rax, rcx
mov [rbp+var_A0], rdx
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
mov [rbp+var_90], rax
mov rax, [rbp+var_80]
mov [rbp+var_88], rax
mov dword ptr [rbp+var_110], 0
mov qword ptr [rbp+var_110+8], 3
movups xmm0, [rbp+var_110]
movups [rsp+140h+var_140], xmm0
lea rax, [rbp+var_B0]
mov qword ptr [rsp+140h+var_130], rax
mov dword ptr [rsp+140h+var_130+8], 2
mov rdi, r12
mov rsi, [rbp+var_D0]
mov rdx, [rbp+var_C8]
mov rcx, [rbp+var_C0]
mov r8, [rbp+var_B8]
mov r9d, 3
call JS_CallInternal
mov rbx, rdx
mov qword ptr [rbp+var_50], rax
mov qword ptr [rbp+var_50+8], rdx
mov rsi, qword ptr [rbp+var_B0]
mov rdx, qword ptr [rbp+var_B0+8]
mov rdi, [r12+18h]
call JS_FreeValueRT
mov rsi, [rbp+var_A0]
mov rdx, [rbp+var_98]
mov rdi, [r12+18h]
call JS_FreeValueRT
cmp ebx, 6
jz loc_77B9C
loc_77A09:
mov eax, [rbp+arg_8]
test eax, eax
jle loc_77AE9
mov r15, qword ptr [rbp+var_50]
mov rbx, qword ptr [rbp+var_50+8]
mov r12, [rbp+var_30]
mov rdi, r12
mov rsi, r15
mov rdx, rbx
call JS_IsArray
test eax, eax
js loc_77B8A
jz loc_77AE9
mov r12, [rbp+var_30]
mov rdi, r12
lea rsi, [rbp+var_E0]
mov rdx, r15
mov rcx, rbx
call js_get_length64
test eax, eax
js loc_77B8A
mov r9, [rbp+var_E0]
xor eax, eax
mov dword ptr [rbp+var_100], eax
mov ecx, 3
mov qword ptr [rbp+var_100+8], rcx
mov dword ptr [rbp+var_F0], eax
mov qword ptr [rbp+var_F0+8], rcx
movups xmm0, [rbp+var_F0]
movups [rsp+140h+var_120], xmm0
movups xmm0, [rbp+var_100]
movups [rsp+140h+var_130], xmm0
mov eax, [rbp+var_54]
mov dword ptr [rsp+140h+var_140+8], eax
mov rax, [rbp+var_38]
mov qword ptr [rsp+140h+var_140], rax
mov rdi, r12
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
mov rcx, r15
mov r8, rbx
call JS_FlattenIntoArray
mov [rbp+var_38], rax
test rax, rax
js loc_77B8A
mov rdi, [r12+18h]
mov rsi, r15
mov rdx, rbx
call JS_FreeValueRT
mov r15, [rbp+var_60]
mov rbx, [rbp+var_38]
jmp short loc_77B5F
loc_77AE9:
mov rbx, [rbp+var_38]
mov rax, 1FFFFFFFFFFFFFh
cmp rbx, rax
jge short loc_77B75
xorps xmm0, xmm0
cvtsi2sd xmm0, rbx
movq rcx, xmm0
movaps xmm0, [rbp+var_50]
movsxd rax, ebx
cmp rax, rbx
mov eax, eax
cmovz rcx, rax
movaps [rbp+var_B0], xmm0
mov r8d, 7
mov eax, 0
cmovz r8, rax
movaps xmm0, [rbp+var_B0]
movups [rsp+140h+var_140], xmm0
mov r12, [rbp+var_30]
mov rdi, r12
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
mov r9d, 4007h
call JS_DefinePropertyValueValue
test eax, eax
mov r15, [rbp+var_60]
js short loc_77B9C
inc rbx
loc_77B5F:
inc r14
mov r13, rbx
cmp r15, r14
jnz loc_778D7
jmp short loc_77B9C
loc_77B70:
mov r13, rbx
jmp short loc_77B9C
loc_77B75:
lea rsi, aArrayTooLong; "Array too long"
mov r12, [rbp+var_30]
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
loc_77B8A:
mov rsi, qword ptr [rbp+var_50]
mov rdx, qword ptr [rbp+var_50+8]
mov rdi, [r12+18h]
call JS_FreeValueRT
loc_77B9C:
mov rax, r13
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_FlattenIntoArray(
long long a1,
unsigned long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
int a16,
long long a17,
long long a18,
long long a19,
long long a20)
{
long long v20; // r12
long long v21; // r13
long long v22; // r15
long long v23; // rbx
unsigned long long v24; // r14
int PropertyInt64; // eax
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
long long v29; // r9
__m128 v30; // xmm4
__m128 v31; // xmm5
long long v32; // rax
double v33; // rdx
__int128 v34; // rax
int v35; // ebx
__int128 v36; // kr00_16
int IsArray; // eax
long long v38; // rbx
double v39; // rcx
long long v40; // r8
int v41; // eax
char v43; // [rsp+0h] [rbp-140h]
__m128 v44; // [rsp+30h] [rbp-110h]
__m128 v45; // [rsp+40h] [rbp-100h]
long long v46; // [rsp+60h] [rbp-E0h] BYREF
long long v47; // [rsp+68h] [rbp-D8h]
long long v48; // [rsp+70h] [rbp-D0h]
long long v49; // [rsp+78h] [rbp-C8h]
long long v50; // [rsp+80h] [rbp-C0h]
long long v51; // [rsp+88h] [rbp-B8h]
__m128 v52; // [rsp+90h] [rbp-B0h] BYREF
double v53; // [rsp+A0h] [rbp-A0h]
long long v54; // [rsp+A8h] [rbp-98h]
long long v55; // [rsp+B0h] [rbp-90h]
long long v56; // [rsp+B8h] [rbp-88h]
long long v57; // [rsp+C0h] [rbp-80h]
long long v58; // [rsp+C8h] [rbp-78h]
long long v59; // [rsp+D0h] [rbp-70h]
unsigned long long v60; // [rsp+D8h] [rbp-68h]
long long v61; // [rsp+E0h] [rbp-60h]
int v62; // [rsp+ECh] [rbp-54h]
__int128 v63; // [rsp+F0h] [rbp-50h] BYREF
long long v64; // [rsp+108h] [rbp-38h]
long long v65; // [rsp+110h] [rbp-30h]
long long savedregs; // [rsp+140h] [rbp+0h] BYREF
v57 = a5;
v58 = a4;
v59 = a3;
v60 = a2;
v20 = a1;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
v22 = a6;
v23 = a15;
if ( a6 <= 0 )
{
return a15;
}
else
{
v48 = a17;
v49 = a18;
v47 = (unsigned int)a18;
v50 = a19;
v51 = a20;
v62 = a16 - 1;
v24 = 0LL;
v65 = a1;
v61 = a6;
do
{
PropertyInt64 = JS_TryGetPropertyInt64(v20, v58, v57, v24, (long long)&v63);
v21 = -1LL;
if ( PropertyInt64 < 0 )
break;
if ( PropertyInt64 )
{
v64 = v23;
if ( (_DWORD)v47 != 3 )
{
v52 = (__m128)v63;
v32 = v24 >> 31;
v33 = (double)(int)v24;
if ( v24 >> 31 )
v32 = 7LL;
else
*(_QWORD *)&v33 = (unsigned int)v24;
v53 = v33;
v54 = v32;
v55 = v58;
v56 = v57;
v44.m128_i32[0] = 0;
v44.m128_u64[1] = 3LL;
a7 = v44;
*(_QWORD *)&v34 = JS_CallInternal(
v20,
v48,
v49,
v50,
v51,
3LL,
v44,
a8,
a9,
a10,
v30,
v31,
a13,
a14,
v44.m128_i8[0],
3,
(long long)&v52,
2u);
v35 = DWORD2(v34);
v63 = v34;
JS_FreeValueRT(*(_QWORD *)(v20 + 24), v52.m128_u64[0], v52.m128_i64[1]);
JS_FreeValueRT(*(_QWORD *)(v20 + 24), *(_DWORD **)&v53, v54);
if ( v35 == 6 )
return v21;
}
if ( a16 <= 0 )
goto LABEL_18;
v36 = v63;
v20 = v65;
IsArray = JS_IsArray(v65, v63, SDWORD2(v63));
if ( IsArray < 0 )
goto LABEL_29;
if ( IsArray )
{
v20 = v65;
if ( (int)js_get_length64(v65, &v46, v36, SDWORD2(v36)) < 0 )
goto LABEL_29;
v45.m128_i32[0] = 0;
v45.m128_u64[1] = 3LL;
a7 = v45;
v64 = JS_FlattenIntoArray(v20, v60, v59, v36, DWORD2(v36), v46, v64, v62, 0, 3);
if ( v64 < 0 )
goto LABEL_29;
JS_FreeValueRT(*(_QWORD *)(v20 + 24), (_DWORD *)v36, *((long long *)&v36 + 1));
v22 = v61;
v23 = v64;
}
else
{
LABEL_18:
v38 = v64;
if ( v64 >= 0x1FFFFFFFFFFFFFLL )
{
v20 = v65;
JS_ThrowTypeError(
v65,
(long long)"Array too long",
v26,
v27,
v28,
v29,
a7,
a8,
a9,
a10,
v30,
v31,
a13,
a14,
v43);
LABEL_29:
JS_FreeValueRT(*(_QWORD *)(v20 + 24), (_DWORD *)v63, *((long long *)&v63 + 1));
return v21;
}
v39 = (double)(int)v64;
if ( (int)v64 == v64 )
*(_QWORD *)&v39 = (unsigned int)v64;
v52 = (__m128)v63;
v40 = 7LL;
if ( (int)v64 == v64 )
v40 = 0LL;
a7 = v52;
v20 = v65;
v41 = JS_DefinePropertyValueValue(
v65,
v60,
v59,
*(_DWORD **)&v39,
v40,
16391,
*(double *)v52.m128_u64,
a8,
a9,
a10,
*(double *)v30.m128_u64,
*(double *)v31.m128_u64,
a13,
a14,
v52.m128_u64[0],
v52.m128_i64[1]);
v22 = v61;
if ( v41 < 0 )
return v21;
v23 = v38 + 1;
}
}
++v24;
v21 = v23;
}
while ( v22 != v24 );
}
}
else
{
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v43);
return -1LL;
}
return v21;
}
| JS_FlattenIntoArray:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
MOV qword ptr [RBP + -0x80],R8
MOV qword ptr [RBP + -0x78],RCX
MOV qword ptr [RBP + -0x70],RDX
MOV qword ptr [RBP + -0x68],RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00177878
LEA RSI,[0x19d8ce]
MOV RDI,R12
XOR EAX,EAX
CALL 0x0011fec9
MOV R13,-0x1
JMP 0x00177b9c
LAB_00177878:
MOV R15,R9
MOV RBX,qword ptr [RBP + 0x10]
TEST R9,R9
JLE 0x00177b70
LEA RAX,[RBP + 0x30]
LEA RCX,[RBP + 0x20]
MOV EDX,dword ptr [RBP + 0x18]
MOV RSI,qword ptr [RCX]
MOV qword ptr [RBP + -0xd0],RSI
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RBP + -0xc8],RCX
MOV ECX,ECX
MOV qword ptr [RBP + -0xd8],RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xb8],RAX
LEA EAX,[RDX + -0x1]
MOV dword ptr [RBP + -0x54],EAX
XOR R14D,R14D
MOV qword ptr [RBP + -0x30],R12
MOV qword ptr [RBP + -0x60],R15
LAB_001778d7:
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x80]
MOV RCX,R14
LEA R8,[RBP + -0x50]
CALL 0x0014cabd
MOV R13,-0x1
TEST EAX,EAX
JS 0x00177b9c
JZ 0x00177b5f
MOV qword ptr [RBP + -0x38],RBX
CMP dword ptr [RBP + -0xd8],0x3
JZ 0x00177a09
MOVAPS XMM0,xmmword ptr [RBP + -0x50]
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOV RAX,R14
SHR RAX,0x1f
XORPS XMM0,XMM0
CVTSI2SD XMM0,R14
MOV ECX,R14D
MOVQ RDX,XMM0
CMOVZ RDX,RCX
MOV ECX,0x7
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0xa0],RDX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x88],RAX
MOV dword ptr [RBP + -0x110],0x0
MOV qword ptr [RBP + -0x108],0x3
MOVUPS XMM0,xmmword ptr [RBP + -0x110]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RBP + -0xb0]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0xd0]
MOV RDX,qword ptr [RBP + -0xc8]
MOV RCX,qword ptr [RBP + -0xc0]
MOV R8,qword ptr [RBP + -0xb8]
MOV R9D,0x3
CALL 0x001278b6
MOV RBX,RDX
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x48],RDX
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDX,qword ptr [RBP + -0xa8]
MOV RDI,qword ptr [R12 + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBP + -0xa0]
MOV RDX,qword ptr [RBP + -0x98]
MOV RDI,qword ptr [R12 + 0x18]
CALL 0x0011ccb2
CMP EBX,0x6
JZ 0x00177b9c
LAB_00177a09:
MOV EAX,dword ptr [RBP + 0x18]
TEST EAX,EAX
JLE 0x00177ae9
MOV R15,qword ptr [RBP + -0x50]
MOV RBX,qword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x30]
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
CALL 0x001276be
TEST EAX,EAX
JS 0x00177b8a
JZ 0x00177ae9
MOV R12,qword ptr [RBP + -0x30]
MOV RDI,R12
LEA RSI,[RBP + -0xe0]
MOV RDX,R15
MOV RCX,RBX
CALL 0x00121ec8
TEST EAX,EAX
JS 0x00177b8a
MOV R9,qword ptr [RBP + -0xe0]
XOR EAX,EAX
MOV dword ptr [RBP + -0x100],EAX
MOV ECX,0x3
MOV qword ptr [RBP + -0xf8],RCX
MOV dword ptr [RBP + -0xf0],EAX
MOV qword ptr [RBP + -0xe8],RCX
MOVUPS XMM0,xmmword ptr [RBP + -0xf0]
MOVUPS xmmword ptr [RSP + 0x20],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0x100]
MOVUPS xmmword ptr [RSP + 0x10],XMM0
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RSP + 0x8],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RSP],RAX
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,R15
MOV R8,RBX
CALL 0x00177827
MOV qword ptr [RBP + -0x38],RAX
TEST RAX,RAX
JS 0x00177b8a
MOV RDI,qword ptr [R12 + 0x18]
MOV RSI,R15
MOV RDX,RBX
CALL 0x0011ccb2
MOV R15,qword ptr [RBP + -0x60]
MOV RBX,qword ptr [RBP + -0x38]
JMP 0x00177b5f
LAB_00177ae9:
MOV RBX,qword ptr [RBP + -0x38]
MOV RAX,0x1fffffffffffff
CMP RBX,RAX
JGE 0x00177b75
XORPS XMM0,XMM0
CVTSI2SD XMM0,RBX
MOVQ RCX,XMM0
MOVAPS XMM0,xmmword ptr [RBP + -0x50]
MOVSXD RAX,EBX
CMP RAX,RBX
MOV EAX,EAX
CMOVZ RCX,RAX
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOV R8D,0x7
MOV EAX,0x0
CMOVZ R8,RAX
MOVAPS XMM0,xmmword ptr [RBP + -0xb0]
MOVUPS xmmword ptr [RSP],XMM0
MOV R12,qword ptr [RBP + -0x30]
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
MOV R9D,0x4007
CALL 0x00125f19
TEST EAX,EAX
MOV R15,qword ptr [RBP + -0x60]
JS 0x00177b9c
INC RBX
LAB_00177b5f:
INC R14
MOV R13,RBX
CMP R15,R14
JNZ 0x001778d7
JMP 0x00177b9c
LAB_00177b70:
MOV R13,RBX
JMP 0x00177b9c
LAB_00177b75:
LEA RSI,[0x1a06c0]
MOV R12,qword ptr [RBP + -0x30]
MOV RDI,R12
XOR EAX,EAX
CALL 0x00121953
LAB_00177b8a:
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R12 + 0x18]
CALL 0x0011ccb2
LAB_00177b9c:
MOV RAX,R13
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong JS_FlattenIntoArray(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,ulong param_6,ulong param_7,int param_8,
int8 param_9,ulong param_10,int8 param_11,int8 param_12)
{
int8 uVar1;
int iVar2;
double dVar3;
int8 uVar4;
long lVar5;
ulong uVar6;
bool bVar7;
int1 auVar8 [16];
uint uStack_114;
uint uStack_104;
uint uStack_f4;
int8 local_e8;
ulong local_e0;
int8 local_d8;
ulong local_d0;
int8 local_c8;
int8 local_c0;
int1 local_b8 [16];
double local_a8;
int8 local_a0;
int8 local_98;
int8 local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
ulong local_68;
int local_5c;
int1 local_58 [16];
ulong local_40;
long local_38;
local_88 = param_5;
local_80 = param_4;
local_78 = param_3;
local_70 = param_2;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
param_7 = 0xffffffffffffffff;
}
else if (0 < (long)param_6) {
local_d8 = param_9;
local_d0 = param_10;
local_e0 = param_10 & 0xffffffff;
local_c8 = param_11;
local_c0 = param_12;
local_5c = param_8 + -1;
uVar6 = 0;
local_68 = param_6;
local_38 = param_1;
do {
iVar2 = JS_TryGetPropertyInt64(param_1,local_80,local_88,uVar6,local_58);
if (iVar2 < 0) {
return 0xffffffffffffffff;
}
if (iVar2 != 0) {
local_40 = param_7;
if ((int)local_e0 != 3) {
local_a8 = (double)(long)uVar6;
if (uVar6 >> 0x1f == 0) {
local_a0 = 0;
local_a8 = (double)(uVar6 & 0xffffffff);
}
else {
local_a0 = 7;
}
local_98 = local_80;
local_90 = local_88;
local_b8 = local_58;
auVar8 = JS_CallInternal(param_1,local_d8,local_d0,local_c8,local_c0,3,
(ulong)uStack_114 << 0x20,3,local_b8,2);
local_58 = auVar8;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_b8._0_8_,local_b8._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_a8,local_a0);
if (auVar8._8_4_ == 6) {
return 0xffffffffffffffff;
}
}
lVar5 = local_38;
uVar1 = local_58._8_8_;
uVar4 = local_58._0_8_;
if (0 < param_8) {
iVar2 = JS_IsArray(local_38,local_58._0_8_,local_58._8_8_);
param_1 = local_38;
if (iVar2 < 0) goto LAB_00177b8a;
if (iVar2 != 0) {
iVar2 = js_get_length64(local_38,&local_e8,uVar4,uVar1);
lVar5 = param_1;
if (iVar2 < 0) goto LAB_00177b8a;
local_40 = JS_FlattenIntoArray(param_1,local_70,local_78,uVar4,uVar1,local_e8,local_40,
local_5c,(ulong)uStack_104 << 0x20,3,
(ulong)uStack_f4 << 0x20,3);
if ((long)local_40 < 0) goto LAB_00177b8a;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4,uVar1);
param_7 = local_40;
param_6 = local_68;
goto LAB_00177b5f;
}
}
param_1 = local_38;
param_7 = local_40;
if (0x1ffffffffffffe < (long)local_40) {
JS_ThrowTypeError(local_38,"Array too long");
lVar5 = param_1;
LAB_00177b8a:
JS_FreeValueRT(*(int8 *)(lVar5 + 0x18),local_58._0_8_,local_58._8_8_);
return 0xffffffffffffffff;
}
bVar7 = (long)(int)local_40 == local_40;
dVar3 = (double)(long)local_40;
if (bVar7) {
dVar3 = (double)(local_40 & 0xffffffff);
}
uVar4 = 7;
if (bVar7) {
uVar4 = 0;
}
local_b8._8_4_ = local_58._8_4_;
auVar8 = local_58;
iVar2 = JS_DefinePropertyValueValue
(local_38,local_70,local_78,dVar3,uVar4,0x4007,local_58._0_8_,
local_b8._8_4_);
local_b8 = auVar8;
if (iVar2 < 0) {
return 0xffffffffffffffff;
}
param_7 = param_7 + 1;
param_6 = local_68;
}
LAB_00177b5f:
uVar6 = uVar6 + 1;
} while (param_6 != uVar6);
}
return param_7;
}
| |
35,237 | JS_FlattenIntoArray | bluesky950520[P]quickjs/quickjs.c | static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValue target,
JSValue source, int64_t sourceLen,
int64_t targetIndex, int depth,
JSValue mapperFunction,
JSValue thisArg)
{
JSValue element;
int64_t sourceIndex, elementLen;
int present, is_array;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
for (sourceIndex = 0; sourceIndex < sourceLen; sourceIndex++) {
present = JS_TryGetPropertyInt64(ctx, source, sourceIndex, &element);
if (present < 0)
return -1;
if (!present)
continue;
if (!JS_IsUndefined(mapperFunction)) {
JSValue args[3] = { element, js_int64(sourceIndex), source };
element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
if (JS_IsException(element))
return -1;
}
if (depth > 0) {
is_array = JS_IsArray(ctx, element);
if (is_array < 0)
goto fail;
if (is_array) {
if (js_get_length64(ctx, &elementLen, element) < 0)
goto fail;
targetIndex = JS_FlattenIntoArray(ctx, target, element,
elementLen, targetIndex,
depth - 1,
JS_UNDEFINED, JS_UNDEFINED);
if (targetIndex < 0)
goto fail;
JS_FreeValue(ctx, element);
continue;
}
}
if (targetIndex >= MAX_SAFE_INTEGER) {
JS_ThrowTypeError(ctx, "Array too long");
goto fail;
}
if (JS_DefinePropertyValueInt64(ctx, target, targetIndex, element,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
return -1;
targetIndex++;
}
return targetIndex;
fail:
JS_FreeValue(ctx, element);
return -1;
} | O3 | c | JS_FlattenIntoArray:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x7a1b7
leaq 0x266fd(%rip), %rsi # 0xa089e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x205f0
movq $-0x1, %r13
jmp 0x7a4aa
movq %r9, %r12
movq 0x10(%rbp), %r14
testq %r9, %r9
jle 0x7a4a7
movq 0x28(%rbp), %rax
movl 0x18(%rbp), %ecx
movl %eax, %eax
movq %rax, -0xb0(%rbp)
leal -0x1(%rcx), %eax
movq %rax, -0xa8(%rbp)
xorl %r15d, %r15d
movq %r12, -0x48(%rbp)
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %r15, %rcx
leaq -0x40(%rbp), %r8
callq 0x4e98a
movq $-0x1, %r13
testl %eax, %eax
js 0x7a4aa
je 0x7a474
cmpl $0x3, -0xb0(%rbp)
je 0x7a32e
movaps -0x40(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq %r15, %rax
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
shrq $0x1f, %rax
movq %xmm0, %rcx
cmoveq %r15, %rcx
movl $0x7, %edx
cmovneq %rdx, %rax
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0xc8(%rbp)
movq $0x3, -0xc0(%rbp)
subq $0x20, %rsp
movups -0xc8(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %rbx, %rdi
movq 0x20(%rbp), %rsi
movq 0x28(%rbp), %rdx
movq 0x30(%rbp), %rcx
movq 0x38(%rbp), %r8
movl $0x3, %r9d
callq 0x27eca
addq $0x20, %rsp
movq %rdx, %r12
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x98(%rbp), %rdx
movq 0x18(%rbx), %rdi
cmpl $-0x9, %edx
jb 0x7a300
movq -0xa0(%rbp), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x7a300
callq 0x20d90
movq 0x18(%rbx), %rdi
movq -0x88(%rbp), %rdx
cmpl $-0x9, %edx
jb 0x7a324
movq -0x90(%rbp), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x7a324
callq 0x20d90
cmpl $0x6, %r12d
je 0x7a4aa
movl 0x18(%rbp), %eax
testl %eax, %eax
jle 0x7a3fa
movq -0x38(%rbp), %rcx
cmpl $-0x1, %ecx
jne 0x7a3fa
movq -0x40(%rbp), %r12
movzwl 0x6(%r12), %edx
cmpw $0x30, %dx
je 0x7a485
xorl %eax, %eax
cmpw $0x2, %dx
sete %al
testl %eax, %eax
je 0x7a3fa
movq %rbx, %rdi
leaq -0xb8(%rbp), %rsi
movq %r12, %rdx
movq %rcx, %rbx
callq 0x226df
testl %eax, %eax
js 0x7a4da
movq -0xb8(%rbp), %r9
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r12, %rcx
movq %rbx, -0x50(%rbp)
movq %rbx, %r8
movl $0x3, %r10d
pushq %r10
xorl %eax, %eax
pushq %rax
pushq %r10
pushq %rax
pushq -0xa8(%rbp)
pushq %r14
callq 0x7a166
addq $0x30, %rsp
testq %rax, %rax
js 0x7a4df
movq %rax, %r14
movq -0x30(%rbp), %rbx
movq 0x18(%rbx), %rdi
movl (%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r12)
cmpl $0x1, %eax
jg 0x7a3f4
movq %r12, %rsi
movq -0x50(%rbp), %rdx
callq 0x20d90
movq -0x48(%rbp), %r12
jmp 0x7a474
movabsq $0x1fffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFF
cmpq %rax, %r14
jge 0x7a4bf
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movq %xmm0, %rcx
movaps -0x40(%rbp), %xmm0
movslq %r14d, %rax
cmpq %r14, %rax
movl %eax, %eax
cmoveq %rax, %rcx
movaps %xmm0, -0xa0(%rbp)
movl $0x7, %r8d
movl $0x0, %eax
cmoveq %rax, %r8
subq $0x10, %rsp
movaps -0xa0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movl $0x4007, %r9d # imm = 0x4007
callq 0x265c6
addq $0x10, %rsp
testl %eax, %eax
movq -0x48(%rbp), %r12
js 0x7a4aa
incq %r14
incq %r15
movq %r14, %r13
cmpq %r15, %r12
jne 0x7a1ec
jmp 0x7a4aa
movq %rbx, %rdi
movq %r12, %rsi
movq %rcx, %rdx
movq %rcx, %rbx
callq 0x27d0d
movq %rbx, %rcx
movq -0x30(%rbp), %rbx
testl %eax, %eax
jns 0x7a363
jmp 0x7a4e7
movq %r14, %r13
movq %r13, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x291b4(%rip), %rsi # 0xa367a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2214f
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rcx
jmp 0x7a4e7
movq %rbx, %rcx
jmp 0x7a4e3
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rbx
cmpl $-0x9, %ecx
jb 0x7a4aa
movq 0x18(%rbx), %rdi
movl (%r12), %eax
leal -0x1(%rax), %edx
movl %edx, (%r12)
cmpl $0x1, %eax
jg 0x7a4aa
movq %r12, %rsi
movq %rcx, %rdx
callq 0x20d90
jmp 0x7a4aa
| JS_FlattenIntoArray:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov [rbp+var_70], r8
mov [rbp+var_68], rcx
mov [rbp+var_60], rdx
mov [rbp+var_58], rsi
mov rbx, rdi
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_7A1B7
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
mov r13, 0FFFFFFFFFFFFFFFFh
jmp loc_7A4AA
loc_7A1B7:
mov r12, r9
mov r14, [rbp+arg_0]
test r9, r9
jle loc_7A4A7
mov rax, [rbp+arg_18]
mov ecx, [rbp+arg_8]
mov eax, eax
mov [rbp+var_B0], rax
lea eax, [rcx-1]
mov [rbp+var_A8], rax
xor r15d, r15d
mov [rbp+var_48], r12
mov [rbp+var_30], rbx
loc_7A1EC:
mov rdi, rbx
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
mov rcx, r15
lea r8, [rbp+var_40]
call JS_TryGetPropertyInt64
mov r13, 0FFFFFFFFFFFFFFFFh
test eax, eax
js loc_7A4AA
jz loc_7A474
cmp dword ptr [rbp+var_B0], 3
jz loc_7A32E
movaps xmm0, [rbp+var_40]
movaps [rbp+var_A0], xmm0
mov rax, r15
xorps xmm0, xmm0
cvtsi2sd xmm0, r15
shr rax, 1Fh
movq rcx, xmm0
cmovz rcx, r15
mov edx, 7
cmovnz rax, rdx
mov [rbp+var_90], rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_68]
mov [rbp+var_80], rax
mov rax, [rbp+var_70]
mov [rbp+var_78], rax
mov dword ptr [rbp+var_C8], 0
mov qword ptr [rbp+var_C8+8], 3
sub rsp, 20h
movups xmm0, [rbp+var_C8]
movups [rsp+0F0h+var_F0], xmm0
lea rax, [rbp+var_A0]
mov qword ptr [rsp+0F0h+var_E0], rax
mov dword ptr [rsp+0F0h+var_E0+8], 2
mov rdi, rbx
mov rsi, [rbp+arg_10]
mov rdx, [rbp+arg_18]
mov rcx, [rbp+arg_20]
mov r8, [rbp+arg_28]
mov r9d, 3
call JS_CallInternal
add rsp, 20h
mov r12, rdx
mov qword ptr [rbp+var_40], rax
mov qword ptr [rbp+var_40+8], rdx
mov rdx, qword ptr [rbp+var_A0+8]
mov rdi, [rbx+18h]
cmp edx, 0FFFFFFF7h
jb short loc_7A300
mov rsi, qword ptr [rbp+var_A0]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_7A300
call js_free_value_rt
mov rdi, [rbx+18h]
loc_7A300:
mov rdx, [rbp+var_88]
cmp edx, 0FFFFFFF7h
jb short loc_7A324
mov rsi, [rbp+var_90]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_7A324
call js_free_value_rt
loc_7A324:
cmp r12d, 6
jz loc_7A4AA
loc_7A32E:
mov eax, [rbp+arg_8]
test eax, eax
jle loc_7A3FA
mov rcx, qword ptr [rbp+var_40+8]
cmp ecx, 0FFFFFFFFh
jnz loc_7A3FA
mov r12, qword ptr [rbp+var_40]
movzx edx, word ptr [r12+6]
cmp dx, 30h ; '0'
jz loc_7A485
xor eax, eax
cmp dx, 2
setz al
loc_7A363:
test eax, eax
jz loc_7A3FA
mov rdi, rbx
lea rsi, [rbp+var_B8]
mov rdx, r12
mov rbx, rcx
call js_get_length64
test eax, eax
js loc_7A4DA
mov r9, [rbp+var_B8]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_60]
mov rcx, r12
mov [rbp+var_50], rbx
mov r8, rbx
mov r10d, 3
push r10
xor eax, eax
push rax
push r10
push rax
push [rbp+var_A8]
push r14
call JS_FlattenIntoArray
add rsp, 30h
test rax, rax
js loc_7A4DF
mov r14, rax
mov rbx, [rbp+var_30]
mov rdi, [rbx+18h]
mov eax, [r12]
lea ecx, [rax-1]
mov [r12], ecx
cmp eax, 1
jg short loc_7A3F4
mov rsi, r12
mov rdx, [rbp+var_50]
call js_free_value_rt
loc_7A3F4:
mov r12, [rbp+var_48]
jmp short loc_7A474
loc_7A3FA:
mov rax, 1FFFFFFFFFFFFFh
cmp r14, rax
jge loc_7A4BF
xorps xmm0, xmm0
cvtsi2sd xmm0, r14
movq rcx, xmm0
movaps xmm0, [rbp+var_40]
movsxd rax, r14d
cmp rax, r14
mov eax, eax
cmovz rcx, rax
movaps [rbp+var_A0], xmm0
mov r8d, 7
mov eax, 0
cmovz r8, rax
sub rsp, 10h
movaps xmm0, [rbp+var_A0]
movups [rsp+0E0h+var_E0], xmm0
mov rdi, rbx
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_60]
mov r9d, 4007h
call JS_DefinePropertyValueValue
add rsp, 10h
test eax, eax
mov r12, [rbp+var_48]
js short loc_7A4AA
inc r14
loc_7A474:
inc r15
mov r13, r14
cmp r12, r15
jnz loc_7A1EC
jmp short loc_7A4AA
loc_7A485:
mov rdi, rbx
mov rsi, r12
mov rdx, rcx
mov rbx, rcx
call js_proxy_isArray
mov rcx, rbx
mov rbx, [rbp+var_30]
test eax, eax
jns loc_7A363
jmp short loc_7A4E7
loc_7A4A7:
mov r13, r14
loc_7A4AA:
mov rax, r13
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7A4BF:
lea rsi, aArrayTooLong; "Array too long"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r12, qword ptr [rbp+var_40]
mov rcx, qword ptr [rbp+var_40+8]
jmp short loc_7A4E7
loc_7A4DA:
mov rcx, rbx
jmp short loc_7A4E3
loc_7A4DF:
mov rcx, [rbp+var_50]
loc_7A4E3:
mov rbx, [rbp+var_30]
loc_7A4E7:
cmp ecx, 0FFFFFFF7h
jb short loc_7A4AA
mov rdi, [rbx+18h]
mov eax, [r12]
lea edx, [rax-1]
mov [r12], edx
cmp eax, 1
jg short loc_7A4AA
mov rsi, r12
mov rdx, rcx
call js_free_value_rt
jmp short loc_7A4AA
| long long JS_FlattenIntoArray(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
long long a15,
int a16,
long long a17,
long long a18,
long long a19,
long long a20)
{
long long v20; // rbx
long long v21; // r13
long long v22; // r12
long long v23; // r14
unsigned long long v24; // r15
int PropertyInt64; // eax
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
long long v29; // r9
__m128 v30; // xmm4
__m128 v31; // xmm5
long long v32; // rax
double v33; // rcx
__int128 v34; // rax
int v35; // r12d
long long v36; // rdx
long long v37; // rdi
_QWORD *v38; // rsi
int v39; // eax
double v40; // rsi
int v41; // eax
_QWORD *v42; // r12
int isArray; // eax
long long v44; // rdi
long long v45; // rbx
long long v46; // rax
long long v47; // rdi
int v48; // eax
long long v49; // rcx
double v50; // rcx
long long v51; // r8
int v52; // eax
long long v53; // rdi
long long v54; // rbx
long long v56; // rdi
int v57; // eax
char v58; // [rsp+20h] [rbp-D0h]
__m128i v59; // [rsp+28h] [rbp-C8h]
long long v60; // [rsp+38h] [rbp-B8h] BYREF
long long v61; // [rsp+40h] [rbp-B0h]
long long v62; // [rsp+48h] [rbp-A8h]
__m128 v63; // [rsp+50h] [rbp-A0h] BYREF
double v64; // [rsp+60h] [rbp-90h]
long long v65; // [rsp+68h] [rbp-88h]
long long v66; // [rsp+70h] [rbp-80h]
long long v67; // [rsp+78h] [rbp-78h]
long long v68; // [rsp+80h] [rbp-70h]
long long v69; // [rsp+88h] [rbp-68h]
long long v70; // [rsp+90h] [rbp-60h]
long long v71; // [rsp+98h] [rbp-58h]
long long v72; // [rsp+A0h] [rbp-50h]
long long v73; // [rsp+A8h] [rbp-48h]
__int128 v74; // [rsp+B0h] [rbp-40h] BYREF
long long v75; // [rsp+C0h] [rbp-30h]
long long savedregs; // [rsp+F0h] [rbp+0h] BYREF
v68 = a5;
v69 = a4;
v70 = a3;
v71 = a2;
v20 = a1;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
v22 = a6;
v23 = a15;
if ( a6 > 0 )
{
v61 = (unsigned int)a18;
v62 = (unsigned int)(a16 - 1);
*(double *)&v24 = 0.0;
v73 = a6;
v75 = a1;
while ( 1 )
{
PropertyInt64 = JS_TryGetPropertyInt64(v20, v69, v68, v24, (long long)&v74);
v21 = -1LL;
if ( PropertyInt64 < 0 )
return v21;
if ( PropertyInt64 )
{
if ( (_DWORD)v61 != 3 )
{
v63 = (__m128)v74;
v32 = v24 >> 31;
v33 = (double)(int)v24;
if ( v24 >> 31 )
v32 = 7LL;
else
v33 = *(double *)&v24;
v64 = v33;
v65 = v32;
v66 = v69;
v67 = v68;
v59.m128i_i32[0] = 0;
v59.m128i_i64[1] = 3LL;
a7 = (__m128)v59;
*(_QWORD *)&v34 = JS_CallInternal(
v20,
a17,
a18,
a19,
a20,
3LL,
v59,
a8,
a9,
a10,
v30,
v31,
a13,
a14,
0,
3,
(long long)&v63,
2u);
v35 = DWORD2(v34);
v74 = v34;
v36 = v63.m128_i64[1];
v37 = *(_QWORD *)(v20 + 24);
if ( v63.m128_i32[2] >= 0xFFFFFFF7 )
{
v38 = (_QWORD *)v63.m128_u64[0];
v39 = *(_DWORD *)v63.m128_u64[0];
v27 = (unsigned int)(*(_DWORD *)v63.m128_u64[0] - 1);
*(_DWORD *)v63.m128_u64[0] = v27;
if ( v39 <= 1 )
{
js_free_value_rt(v37, v38, v36, v27, v28, v29);
v37 = *(_QWORD *)(v20 + 24);
}
}
v26 = v65;
if ( (unsigned int)v65 >= 0xFFFFFFF7 )
{
v40 = v64;
v41 = **(_DWORD **)&v64;
v27 = (unsigned int)(**(_DWORD **)&v64 - 1);
**(_DWORD **)&v64 = v27;
if ( v41 <= 1 )
js_free_value_rt(v37, *(_QWORD **)&v40, v26, v27, v28, v29);
}
if ( v35 == 6 )
return v21;
}
if ( a16 <= 0 )
goto LABEL_28;
v27 = *((_QWORD *)&v74 + 1);
if ( DWORD2(v74) != -1 )
goto LABEL_28;
v42 = (_QWORD *)v74;
v26 = *(unsigned __int16 *)(v74 + 6);
if ( (_WORD)v26 == 48 )
{
v53 = v20;
v54 = *((_QWORD *)&v74 + 1);
isArray = js_proxy_isArray(
v53,
v74,
*((long long *)&v74 + 1),
a7,
a8,
a9,
a10,
v30,
v31,
a13,
a14,
*((long long *)&v74 + 1),
v28,
v29);
v27 = v54;
v20 = v75;
if ( isArray < 0 )
goto LABEL_45;
}
else
{
isArray = (_WORD)v26 == 2;
}
if ( isArray )
{
v44 = v20;
v45 = v27;
if ( (int)js_get_length64(v44, &v60, (int)v42, v27) < 0 )
{
v27 = v45;
LABEL_44:
v20 = v75;
goto LABEL_45;
}
v72 = v45;
v46 = JS_FlattenIntoArray(v75, v71, v70, (_DWORD)v42, v45, v60, v23, v62, 0LL, 3LL, 0LL, 3LL);
if ( v46 < 0 )
{
v27 = v72;
goto LABEL_44;
}
v23 = v46;
v20 = v75;
v47 = *(_QWORD *)(v75 + 24);
v48 = *(_DWORD *)v42;
v49 = (unsigned int)(*(_DWORD *)v42 - 1);
*(_DWORD *)v42 = v49;
if ( v48 <= 1 )
js_free_value_rt(v47, v42, v72, v49, v28, v29);
v22 = v73;
}
else
{
LABEL_28:
if ( v23 >= 0x1FFFFFFFFFFFFFLL )
{
JS_ThrowTypeError(
v20,
(long long)"Array too long",
v26,
v27,
v28,
v29,
a7,
a8,
a9,
a10,
v30,
v31,
a13,
a14,
v58);
v27 = *((_QWORD *)&v74 + 1);
v42 = (_QWORD *)v74;
LABEL_45:
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
{
v56 = *(_QWORD *)(v20 + 24);
v57 = (*(_DWORD *)v42)--;
if ( v57 <= 1 )
js_free_value_rt(v56, v42, v27, v27, v28, v29);
}
return v21;
}
v50 = (double)(int)v23;
if ( (int)v23 == v23 )
*(_QWORD *)&v50 = (unsigned int)v23;
v63 = (__m128)v74;
v51 = 7LL;
if ( (int)v23 == v23 )
v51 = 0LL;
a7 = v63;
v52 = JS_DefinePropertyValueValue(
v20,
v71,
v70,
*(_QWORD **)&v50,
v51,
16391,
*(double *)v63.m128_u64,
a8,
a9,
a10,
*(double *)v30.m128_u64,
*(double *)v31.m128_u64,
a13,
a14,
(int *)v63.m128_u64[0],
v63.m128_i64[1]);
v22 = v73;
if ( v52 < 0 )
return v21;
++v23;
}
}
++v24;
v21 = v23;
if ( v22 == v24 )
return v21;
}
}
return a15;
}
else
{
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v58);
return -1LL;
}
}
| JS_FlattenIntoArray:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0x70],R8
MOV qword ptr [RBP + -0x68],RCX
MOV qword ptr [RBP + -0x60],RDX
MOV qword ptr [RBP + -0x58],RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x0017a1b7
LEA RSI,[0x1a089e]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001205f0
MOV R13,-0x1
JMP 0x0017a4aa
LAB_0017a1b7:
MOV R12,R9
MOV R14,qword ptr [RBP + 0x10]
TEST R9,R9
JLE 0x0017a4a7
MOV RAX,qword ptr [RBP + 0x28]
MOV ECX,dword ptr [RBP + 0x18]
MOV EAX,EAX
MOV qword ptr [RBP + -0xb0],RAX
LEA EAX,[RCX + -0x1]
MOV qword ptr [RBP + -0xa8],RAX
XOR R15D,R15D
MOV qword ptr [RBP + -0x48],R12
MOV qword ptr [RBP + -0x30],RBX
LAB_0017a1ec:
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,R15
LEA R8,[RBP + -0x40]
CALL 0x0014e98a
MOV R13,-0x1
TEST EAX,EAX
JS 0x0017a4aa
JZ 0x0017a474
CMP dword ptr [RBP + -0xb0],0x3
JZ 0x0017a32e
MOVAPS XMM0,xmmword ptr [RBP + -0x40]
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOV RAX,R15
XORPS XMM0,XMM0
CVTSI2SD XMM0,R15
SHR RAX,0x1f
MOVQ RCX,XMM0
CMOVZ RCX,R15
MOV EDX,0x7
CMOVNZ RAX,RDX
MOV qword ptr [RBP + -0x90],RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0xc8],0x0
MOV qword ptr [RBP + -0xc0],0x3
SUB RSP,0x20
MOVUPS XMM0,xmmword ptr [RBP + -0xc8]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RBP + -0xa0]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,RBX
MOV RSI,qword ptr [RBP + 0x20]
MOV RDX,qword ptr [RBP + 0x28]
MOV RCX,qword ptr [RBP + 0x30]
MOV R8,qword ptr [RBP + 0x38]
MOV R9D,0x3
CALL 0x00127eca
ADD RSP,0x20
MOV R12,RDX
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],RDX
MOV RDX,qword ptr [RBP + -0x98]
MOV RDI,qword ptr [RBX + 0x18]
CMP EDX,-0x9
JC 0x0017a300
MOV RSI,qword ptr [RBP + -0xa0]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0017a300
CALL 0x00120d90
MOV RDI,qword ptr [RBX + 0x18]
LAB_0017a300:
MOV RDX,qword ptr [RBP + -0x88]
CMP EDX,-0x9
JC 0x0017a324
MOV RSI,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0017a324
CALL 0x00120d90
LAB_0017a324:
CMP R12D,0x6
JZ 0x0017a4aa
LAB_0017a32e:
MOV EAX,dword ptr [RBP + 0x18]
TEST EAX,EAX
JLE 0x0017a3fa
MOV RCX,qword ptr [RBP + -0x38]
CMP ECX,-0x1
JNZ 0x0017a3fa
MOV R12,qword ptr [RBP + -0x40]
MOVZX EDX,word ptr [R12 + 0x6]
CMP DX,0x30
JZ 0x0017a485
XOR EAX,EAX
CMP DX,0x2
SETZ AL
LAB_0017a363:
TEST EAX,EAX
JZ 0x0017a3fa
MOV RDI,RBX
LEA RSI,[RBP + -0xb8]
MOV RDX,R12
MOV RBX,RCX
CALL 0x001226df
TEST EAX,EAX
JS 0x0017a4da
MOV R9,qword ptr [RBP + -0xb8]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,R12
MOV qword ptr [RBP + -0x50],RBX
MOV R8,RBX
MOV R10D,0x3
PUSH R10
XOR EAX,EAX
PUSH RAX
PUSH R10
PUSH RAX
PUSH qword ptr [RBP + -0xa8]
PUSH R14
CALL 0x0017a166
ADD RSP,0x30
TEST RAX,RAX
JS 0x0017a4df
MOV R14,RAX
MOV RBX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R12]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R12],ECX
CMP EAX,0x1
JG 0x0017a3f4
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00120d90
LAB_0017a3f4:
MOV R12,qword ptr [RBP + -0x48]
JMP 0x0017a474
LAB_0017a3fa:
MOV RAX,0x1fffffffffffff
CMP R14,RAX
JGE 0x0017a4bf
XORPS XMM0,XMM0
CVTSI2SD XMM0,R14
MOVQ RCX,XMM0
MOVAPS XMM0,xmmword ptr [RBP + -0x40]
MOVSXD RAX,R14D
CMP RAX,R14
MOV EAX,EAX
CMOVZ RCX,RAX
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOV R8D,0x7
MOV EAX,0x0
CMOVZ R8,RAX
SUB RSP,0x10
MOVAPS XMM0,xmmword ptr [RBP + -0xa0]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x60]
MOV R9D,0x4007
CALL 0x001265c6
ADD RSP,0x10
TEST EAX,EAX
MOV R12,qword ptr [RBP + -0x48]
JS 0x0017a4aa
INC R14
LAB_0017a474:
INC R15
MOV R13,R14
CMP R12,R15
JNZ 0x0017a1ec
JMP 0x0017a4aa
LAB_0017a485:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RCX
MOV RBX,RCX
CALL 0x00127d0d
MOV RCX,RBX
MOV RBX,qword ptr [RBP + -0x30]
TEST EAX,EAX
JNS 0x0017a363
JMP 0x0017a4e7
LAB_0017a4a7:
MOV R13,R14
LAB_0017a4aa:
MOV RAX,R13
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017a4bf:
LEA RSI,[0x1a367a]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012214f
MOV R12,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x38]
JMP 0x0017a4e7
LAB_0017a4da:
MOV RCX,RBX
JMP 0x0017a4e3
LAB_0017a4df:
MOV RCX,qword ptr [RBP + -0x50]
LAB_0017a4e3:
MOV RBX,qword ptr [RBP + -0x30]
LAB_0017a4e7:
CMP ECX,-0x9
JC 0x0017a4aa
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R12]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12],EDX
CMP EAX,0x1
JG 0x0017a4aa
MOV RSI,R12
MOV RDX,RCX
CALL 0x00120d90
JMP 0x0017a4aa
|
ulong JS_FlattenIntoArray(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int *param_6,ulong param_7,int param_8,
int8 param_9,ulong param_10,int8 param_11,int8 param_12)
{
int8 uVar1;
int1 auVar2 [16];
int iVar3;
uint uVar4;
ulong uVar5;
double dVar6;
int8 uVar7;
int *piVar8;
bool bVar9;
int1 auVar10 [16];
int4 uVar11;
uint uStack_cc;
int8 local_c0;
ulong local_b8;
ulong local_b0;
int1 local_a8 [16];
int *local_98;
int8 local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int *local_50;
int1 local_48 [16];
long local_38;
local_78 = param_5;
local_70 = param_4;
local_68 = param_3;
local_60 = param_2;
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
param_7 = 0xffffffffffffffff;
}
else if (0 < (long)param_6) {
local_b8 = param_10 & 0xffffffff;
local_b0 = (ulong)(param_8 - 1);
piVar8 = (int *)0x0;
uVar5 = param_7;
local_50 = param_6;
local_38 = param_1;
while( true ) {
uVar11 = 0;
iVar3 = JS_TryGetPropertyInt64(param_1,local_70,local_78,piVar8,local_48);
param_7 = 0xffffffffffffffff;
if (iVar3 < 0) break;
if (iVar3 != 0) {
auVar2 = local_48;
if ((int)local_b8 != 3) {
local_98 = (int *)(double)(long)piVar8;
if ((ulong)piVar8 >> 0x1f == 0) {
local_90 = 0;
local_98 = piVar8;
}
else {
local_90 = 7;
}
local_88 = local_70;
local_80 = local_78;
local_a8 = local_48;
auVar10 = JS_CallInternal(param_1,param_9,param_10,param_11,param_12,3,
(ulong)uStack_cc << 0x20,3,local_a8,CONCAT44(uVar11,2));
uVar7 = *(int8 *)(param_1 + 0x18);
local_48 = auVar10;
if ((0xfffffff6 < local_a8._8_4_) &&
(iVar3 = *(int *)local_a8._0_8_, *(int *)local_a8._0_8_ = iVar3 + -1, iVar3 < 2)) {
js_free_value_rt(uVar7);
uVar7 = *(int8 *)(param_1 + 0x18);
}
if ((0xfffffff6 < (uint)local_90) &&
(iVar3 = *local_98, *local_98 = iVar3 + -1, iVar3 < 2)) {
js_free_value_rt(uVar7);
}
auVar2 = local_48;
if (auVar10._8_4_ == 6) {
return 0xffffffffffffffff;
}
}
local_48._8_8_ = auVar2._8_8_;
uVar1 = local_48._8_8_;
local_48._0_8_ = auVar2._0_8_;
uVar7 = local_48._0_8_;
auVar10 = auVar2;
if ((0 < param_8) && (auVar2._8_4_ == -1)) {
if (*(short *)(local_48._0_8_ + 6) == 0x30) {
uVar4 = js_proxy_isArray(param_1,local_48._0_8_,local_48._8_8_);
local_48 = auVar10;
param_1 = local_38;
auVar10 = local_48;
if ((int)uVar4 < 0) goto LAB_0017a4e7;
}
else {
uVar4 = (uint)(*(short *)(local_48._0_8_ + 6) == 2);
}
if (uVar4 != 0) {
local_48 = auVar10;
iVar3 = js_get_length64(param_1,&local_c0,uVar7);
param_1 = local_38;
if (iVar3 < 0) goto LAB_0017a4e7;
local_58 = uVar1;
uVar5 = JS_FlattenIntoArray(local_38,local_60,local_68,uVar7,uVar1,local_c0,uVar5,
local_b0,0,3,0,3);
param_1 = local_38;
auVar2._8_8_ = local_58;
auVar2._0_8_ = uVar7;
if ((long)uVar5 < 0) goto LAB_0017a4e7;
uVar1 = *(int8 *)(local_38 + 0x18);
iVar3 = *(int *)uVar7;
*(int *)uVar7 = iVar3 + -1;
param_6 = local_50;
if (iVar3 < 2) {
js_free_value_rt(uVar1,uVar7,local_58);
param_6 = local_50;
}
goto LAB_0017a474;
}
}
local_48 = auVar10;
if (0x1ffffffffffffe < (long)uVar5) {
JS_ThrowTypeError(param_1,"Array too long");
auVar2 = local_48;
LAB_0017a4e7:
piVar8 = auVar2._0_8_;
if (auVar2._8_4_ < 0xfffffff7) {
return 0xffffffffffffffff;
}
uVar7 = *(int8 *)(param_1 + 0x18);
iVar3 = *piVar8;
*piVar8 = iVar3 + -1;
if (1 < iVar3) {
return 0xffffffffffffffff;
}
js_free_value_rt(uVar7,piVar8,auVar2._8_8_);
return 0xffffffffffffffff;
}
bVar9 = (long)(int)uVar5 == uVar5;
dVar6 = (double)(long)uVar5;
if (bVar9) {
dVar6 = (double)(uVar5 & 0xffffffff);
}
uVar7 = 7;
if (bVar9) {
uVar7 = 0;
}
local_a8 = auVar10;
iVar3 = JS_DefinePropertyValueValue(param_1,local_60,local_68,dVar6,uVar7,0x4007,auVar10);
if (iVar3 < 0) {
return 0xffffffffffffffff;
}
uVar5 = uVar5 + 1;
param_6 = local_50;
}
LAB_0017a474:
piVar8 = (int *)((long)piVar8 + 1);
if (param_6 == piVar8) {
return uVar5;
}
}
}
return param_7;
}
| |
35,238 | common_embd_similarity_cos(float const*, float const*, int) | llama.cpp/common/common.cpp | float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
} | O3 | cpp | common_embd_similarity_cos(float const*, float const*, int):
subq $0x28, %rsp
testl %edx, %edx
jle 0xfa73f
movl %edx, %eax
xorpd %xmm0, %xmm0
xorpd %xmm4, %xmm4
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm3
movss (%rdi,%rcx,4), %xmm1
movaps %xmm1, %xmm2
shufps $0x0, %xmm1, %xmm2 # xmm2 = xmm2[0,0],xmm1[0,0]
unpcklps %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
mulps %xmm2, %xmm1
cvtps2pd %xmm1, %xmm1
addpd %xmm1, %xmm0
mulss %xmm3, %xmm3
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
addsd %xmm1, %xmm4
incq %rcx
cmpq %rcx, %rax
jne 0xfa6bc
xorps %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpeqsd %xmm2, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
movapd %xmm4, %xmm1
cmpeqsd %xmm2, %xmm1
movq %xmm1, %rcx
andl $0x1, %ecx
ucomisd %xmm2, %xmm0
jne 0xfa71e
jnp 0xfa743
ucomisd %xmm2, %xmm4
jne 0xfa726
jnp 0xfa743
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
jb 0xfa757
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0xfa770
movb $0x1, %cl
movb $0x1, %al
testb %cl, %al
jne 0xfa74d
xorpd %xmm0, %xmm0
jmp 0xfa7ad
movss 0x179bb(%rip), %xmm0 # 0x112110
jmp 0xfa7ad
movsd %xmm4, 0x8(%rsp)
callq 0x20810
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm2
ucomisd %xmm1, %xmm4
jb 0xfa77f
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
jmp 0xfa794
movapd %xmm4, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x20810
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
unpckhpd %xmm1, %xmm1 # xmm1 = xmm1[1,1]
divsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x28, %rsp
retq
| _Z26common_embd_similarity_cosPKfS0_i:
sub rsp, 28h
test edx, edx
jle loc_FA73F
mov eax, edx
xorpd xmm0, xmm0
xorpd xmm4, xmm4
xor ecx, ecx
loc_FA6BC:
movss xmm3, dword ptr [rsi+rcx*4]
movss xmm1, dword ptr [rdi+rcx*4]
movaps xmm2, xmm1
shufps xmm2, xmm1, 0
unpcklps xmm1, xmm3
mulps xmm1, xmm2
cvtps2pd xmm1, xmm1
addpd xmm0, xmm1
mulss xmm3, xmm3
xorps xmm1, xmm1
cvtss2sd xmm1, xmm3
addsd xmm4, xmm1
inc rcx
cmp rax, rcx
jnz short loc_FA6BC
xorps xmm2, xmm2
movapd xmm1, xmm0
cmpeqsd xmm1, xmm2
movq rax, xmm1
and eax, 1
movapd xmm1, xmm4
cmpeqsd xmm1, xmm2
movq rcx, xmm1
and ecx, 1
ucomisd xmm0, xmm2
jnz short loc_FA71E
jnp short loc_FA743
loc_FA71E:
ucomisd xmm4, xmm2
jnz short loc_FA726
jnp short loc_FA743
loc_FA726:
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
movapd [rsp+28h+var_18], xmm0
jb short loc_FA757
xorps xmm2, xmm2
sqrtsd xmm2, xmm0
jmp short loc_FA770
loc_FA73F:
mov cl, 1
mov al, 1
loc_FA743:
test al, cl
jnz short loc_FA74D
xorpd xmm0, xmm0
jmp short loc_FA7AD
loc_FA74D:
movss xmm0, cs:dword_112110
jmp short loc_FA7AD
loc_FA757:
movsd [rsp+28h+var_20], xmm4
call _sqrt
xorpd xmm1, xmm1
movsd xmm4, [rsp+28h+var_20]
movapd xmm2, xmm0
loc_FA770:
ucomisd xmm4, xmm1
jb short loc_FA77F
xorps xmm0, xmm0
sqrtsd xmm0, xmm4
jmp short loc_FA794
loc_FA77F:
movapd xmm0, xmm4
movsd [rsp+28h+var_20], xmm2
call _sqrt
movsd xmm2, [rsp+28h+var_20]
loc_FA794:
movapd xmm1, [rsp+28h+var_18]
mulsd xmm2, xmm0
unpckhpd xmm1, xmm1
divsd xmm1, xmm2
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm1
loc_FA7AD:
add rsp, 28h
retn
| float common_embd_similarity_cos(const float *a1, const float *a2, int a3)
{
__m128d v3; // xmm0
__m128d v4; // xmm4
long long i; // rcx
__m128 v6; // xmm3
char v7; // al
char v8; // cl
double v9; // xmm2_8
double v11; // xmm0_8
double v12; // xmm0_8
double v13; // [rsp+8h] [rbp-20h]
__m128d v14; // [rsp+10h] [rbp-18h]
if ( a3 <= 0 )
{
v8 = 1;
v7 = 1;
LABEL_9:
if ( ((unsigned __int8)v8 & (unsigned __int8)v7) != 0 )
return 1.0;
else
return 0.0;
}
v3 = 0LL;
v4 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v6 = (__m128)LODWORD(a2[i]);
v3 = _mm_add_pd(
v3,
_mm_cvtps_pd(
_mm_mul_ps(
_mm_unpacklo_ps((__m128)LODWORD(a1[i]), v6),
_mm_shuffle_ps((__m128)LODWORD(a1[i]), (__m128)LODWORD(a1[i]), 0))));
v4.m128d_f64[0] = v4.m128d_f64[0] + (float)(v6.m128_f32[0] * v6.m128_f32[0]);
}
v7 = *(_OWORD *)&_mm_cmpeq_sd(v3, (__m128d)0LL) & 1;
v8 = *(_OWORD *)&_mm_cmpeq_sd(v4, (__m128d)0LL) & 1;
if ( v3.m128d_f64[0] == 0.0 || v4.m128d_f64[0] == 0.0 )
goto LABEL_9;
v14 = v3;
if ( v3.m128d_f64[0] < 0.0 )
{
v13 = v4.m128d_f64[0];
v11 = sqrt(v3.m128d_f64[0]);
v4.m128d_f64[0] = v13;
v9 = v11;
}
else
{
v9 = sqrt(v3.m128d_f64[0]);
}
if ( v4.m128d_f64[0] < 0.0 )
v12 = sqrt(v4.m128d_f64[0]);
else
v12 = sqrt(v4.m128d_f64[0]);
return _mm_unpackhi_pd(v14, v14).m128d_f64[0] / (v9 * v12);
}
| common_embd_similarity_cos:
SUB RSP,0x28
TEST EDX,EDX
JLE 0x001fa73f
MOV EAX,EDX
XORPD XMM0,XMM0
XORPD XMM4,XMM4
XOR ECX,ECX
LAB_001fa6bc:
MOVSS XMM3,dword ptr [RSI + RCX*0x4]
MOVSS XMM1,dword ptr [RDI + RCX*0x4]
MOVAPS XMM2,XMM1
SHUFPS XMM2,XMM1,0x0
UNPCKLPS XMM1,XMM3
MULPS XMM1,XMM2
CVTPS2PD XMM1,XMM1
ADDPD XMM0,XMM1
MULSS XMM3,XMM3
XORPS XMM1,XMM1
CVTSS2SD XMM1,XMM3
ADDSD XMM4,XMM1
INC RCX
CMP RAX,RCX
JNZ 0x001fa6bc
XORPS XMM2,XMM2
MOVAPD XMM1,XMM0
CMPEQSD XMM1,XMM2
MOVQ RAX,XMM1
AND EAX,0x1
MOVAPD XMM1,XMM4
CMPEQSD XMM1,XMM2
MOVQ RCX,XMM1
AND ECX,0x1
UCOMISD XMM0,XMM2
JNZ 0x001fa71e
JNP 0x001fa743
LAB_001fa71e:
UCOMISD XMM4,XMM2
JNZ 0x001fa726
JNP 0x001fa743
LAB_001fa726:
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
MOVAPD xmmword ptr [RSP + 0x10],XMM0
JC 0x001fa757
XORPS XMM2,XMM2
SQRTSD XMM2,XMM0
JMP 0x001fa770
LAB_001fa73f:
MOV CL,0x1
MOV AL,0x1
LAB_001fa743:
TEST AL,CL
JNZ 0x001fa74d
XORPD XMM0,XMM0
JMP 0x001fa7ad
LAB_001fa74d:
MOVSS XMM0,dword ptr [0x00212110]
JMP 0x001fa7ad
LAB_001fa757:
MOVSD qword ptr [RSP + 0x8],XMM4
CALL 0x00120810
XORPD XMM1,XMM1
MOVSD XMM4,qword ptr [RSP + 0x8]
MOVAPD XMM2,XMM0
LAB_001fa770:
UCOMISD XMM4,XMM1
JC 0x001fa77f
XORPS XMM0,XMM0
SQRTSD XMM0,XMM4
JMP 0x001fa794
LAB_001fa77f:
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x8],XMM2
CALL 0x00120810
MOVSD XMM2,qword ptr [RSP + 0x8]
LAB_001fa794:
MOVAPD XMM1,xmmword ptr [RSP + 0x10]
MULSD XMM2,XMM0
UNPCKHPD XMM1,XMM1
DIVSD XMM1,XMM2
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM1
LAB_001fa7ad:
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
float fVar1;
int1 auVar2 [16];
double dVar3;
bool bVar4;
bool bVar5;
ulong uVar6;
float fVar7;
double dVar8;
double dVar9;
double dStack_10;
if (param_3 < 1) {
bVar5 = true;
bVar4 = true;
}
else {
dVar8 = 0.0;
dVar3 = 0.0;
dVar9 = 0.0;
uVar6 = 0;
do {
fVar7 = param_2[uVar6];
fVar1 = param_1[uVar6];
dVar8 = dVar8 + (double)(fVar1 * fVar1);
dVar3 = dVar3 + (double)(fVar7 * fVar1);
dVar9 = dVar9 + (double)(fVar7 * fVar7);
uVar6 = uVar6 + 1;
} while ((uint)param_3 != uVar6);
bVar4 = dVar8 == 0.0;
bVar5 = dVar9 == 0.0;
if (((dVar8 != 0.0) || (NAN(dVar8))) && ((dVar9 != 0.0 || (NAN(dVar9))))) {
auVar2._8_4_ = SUB84(dVar3,0);
auVar2._0_8_ = dVar8;
auVar2._12_4_ = (int)((ulong)dVar3 >> 0x20);
dStack_10 = auVar2._8_8_;
if (dVar8 < 0.0) {
dVar8 = sqrt(dVar8);
}
else {
dVar8 = SQRT(dVar8);
}
if (dVar9 < 0.0) {
dVar9 = sqrt(dVar9);
}
else {
dVar9 = SQRT(dVar9);
}
return (float)(dStack_10 / (dVar8 * dVar9));
}
}
fVar7 = _DAT_00212110;
if (!(bool)(bVar4 & bVar5)) {
fVar7 = 0.0;
}
return fVar7;
}
| |
35,239 | ma_randominit | eloqsql/libmariadb/libmariadb/ma_password.c | void ma_randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
{ /* For mysql 3.21.# */
#ifdef HAVE_purify
memset((char*) rand_st, 0m sizeof(*rand_st)); /* Avoid UMC warnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O0 | c | ma_randominit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x3fffffff, 0x10(%rax) # imm = 0x3FFFFFFF
movq -0x8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0x7f64(%rip), %xmm1 # 0x53e80
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7f68(%rip), %xmm1 # 0x53e90
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
| ma_randominit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 3FFFFFFFh
mov rax, [rbp+var_8]
movq xmm0, qword ptr [rax+10h]
movaps xmm1, cs:xmmword_53E80
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_53E90
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
mov rax, [rbp+var_8]
movsd qword ptr [rax+18h], xmm0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax], rdx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax+8], rdx
pop rbp
retn
| long long ma_randominit(long long a1, unsigned long long a2, unsigned long long a3)
{
__m128d v3; // xmm1
long long result; // rax
*(_QWORD *)(a1 + 16) = 0x3FFFFFFFLL;
v3 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)(a1 + 16)), (__m128i)xmmword_53E80),
(__m128d)xmmword_53E90);
*(double *)(a1 + 24) = _mm_unpackhi_pd(v3, v3).m128d_f64[0] + v3.m128d_f64[0];
*(_QWORD *)a1 = a2 % *(_QWORD *)(a1 + 16);
result = a1;
*(_QWORD *)(a1 + 8) = a3 % *(_QWORD *)(a1 + 16);
return result;
}
| ma_randominit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x3fffffff
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,qword ptr [RAX + 0x10]
MOVAPS XMM1,xmmword ptr [0x00153e80]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x00153e90]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x18],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RDX
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ma_randominit(ulong *param_1,ulong param_2,ulong param_3)
{
ulong uVar1;
int1 auVar2 [16];
param_1[2] = 0x3fffffff;
uVar1 = param_1[2];
auVar2._8_4_ = (int)(uVar1 >> 0x20);
auVar2._0_8_ = uVar1;
auVar2._12_4_ = _UNK_00153e84;
param_1[3] = (ulong)((auVar2._8_8_ - _UNK_00153e98) +
((double)CONCAT44(_DAT_00153e80,(int)uVar1) - _DAT_00153e90));
*param_1 = param_2 % param_1[2];
param_1[1] = param_3 % param_1[2];
return;
}
| |
35,240 | ma_randominit | eloqsql/libmariadb/libmariadb/ma_password.c | void ma_randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
{ /* For mysql 3.21.# */
#ifdef HAVE_purify
memset((char*) rand_st, 0m sizeof(*rand_st)); /* Avoid UMC warnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O3 | c | ma_randominit:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
movq $0x3fffffff, 0x10(%rdi) # imm = 0x3FFFFFFF
movabsq $0x41cfffffff800000, %rax # imm = 0x41CFFFFFFF800000
movq %rax, 0x18(%rdi)
movabsq $0x400000011, %r8 # imm = 0x400000011
movq %rsi, %rax
mulq %r8
movq %rsi, %r9
subq %rdx, %r9
shrq %r9
addq %rdx, %r9
shrq $0x1d, %r9
movq %r9, %rax
shlq $0x1e, %rax
subq %rax, %r9
addq %rsi, %r9
movq %rcx, %rax
mulq %r8
movq %r9, (%rdi)
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1d, %rax
movq %rax, %rdx
shlq $0x1e, %rdx
subq %rdx, %rax
addq %rcx, %rax
movq %rax, 0x8(%rdi)
popq %rbp
retq
| ma_randominit:
push rbp
mov rbp, rsp
mov rcx, rdx
mov qword ptr [rdi+10h], 3FFFFFFFh
mov rax, 41CFFFFFFF800000h
mov [rdi+18h], rax
mov r8, 400000011h
mov rax, rsi
mul r8
mov r9, rsi
sub r9, rdx
shr r9, 1
add r9, rdx
shr r9, 1Dh
mov rax, r9
shl rax, 1Eh
sub r9, rax
add r9, rsi
mov rax, rcx
mul r8
mov [rdi], r9
mov rax, rcx
sub rax, rdx
shr rax, 1
add rax, rdx
shr rax, 1Dh
mov rdx, rax
shl rdx, 1Eh
sub rax, rdx
add rax, rcx
mov [rdi+8], rax
pop rbp
retn
| unsigned long long ma_randominit(unsigned long long *a1, unsigned long long a2, unsigned long long a3)
{
unsigned long long result; // rax
a1[2] = 0x3FFFFFFFLL;
a1[3] = 0x41CFFFFFFF800000LL;
*a1 = a2 % 0x3FFFFFFF;
result = a3 % 0x3FFFFFFF;
a1[1] = a3 % 0x3FFFFFFF;
return result;
}
| ma_randominit:
PUSH RBP
MOV RBP,RSP
MOV RCX,RDX
MOV qword ptr [RDI + 0x10],0x3fffffff
MOV RAX,0x41cfffffff800000
MOV qword ptr [RDI + 0x18],RAX
MOV R8,0x400000011
MOV RAX,RSI
MUL R8
MOV R9,RSI
SUB R9,RDX
SHR R9,0x1
ADD R9,RDX
SHR R9,0x1d
MOV RAX,R9
SHL RAX,0x1e
SUB R9,RAX
ADD R9,RSI
MOV RAX,RCX
MUL R8
MOV qword ptr [RDI],R9
MOV RAX,RCX
SUB RAX,RDX
SHR RAX,0x1
ADD RAX,RDX
SHR RAX,0x1d
MOV RDX,RAX
SHL RDX,0x1e
SUB RAX,RDX
ADD RAX,RCX
MOV qword ptr [RDI + 0x8],RAX
POP RBP
RET
|
void ma_randominit(ulong *param_1,ulong param_2,ulong param_3)
{
param_1[2] = 0x3fffffff;
param_1[3] = 0x41cfffffff800000;
*param_1 = param_2 % 0x3fffffff;
param_1[1] = param_3 % 0x3fffffff;
return;
}
| |
35,241 | atoi_octal | eloqsql/mysys/my_init.c | static ulong atoi_octal(const char *str)
{
long int tmp;
while (*str && my_isspace(&my_charset_latin1, *str))
str++;
str2int(str,
(*str == '0' ? 8 : 10), /* Octalt or decimalt */
0, INT_MAX, &tmp);
return (ulong) tmp;
} | O0 | c | atoi_octal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xf28d0
leaq 0x27389c(%rip), %rax # 0x366150
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xf28d9
jmp 0xf28e7
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xf289c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movl $0xa, %esi
movl $0x8, %eax
cmpl $0x30, %ecx
cmovel %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
leaq -0x10(%rbp), %r8
callq 0x14d960
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| atoi_octal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
loc_F289C:
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_F28D0
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_11], al
loc_F28D0:
mov al, [rbp+var_11]
test al, 1
jnz short loc_F28D9
jmp short loc_F28E7
loc_F28D9:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_F289C
loc_F28E7:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
mov esi, 0Ah
mov eax, 8
cmp ecx, 30h ; '0'
cmovz esi, eax
xor eax, eax
mov edx, eax
mov ecx, 7FFFFFFFh
lea r8, [rbp+var_10]
call str2int
mov rax, [rbp+var_10]
add rsp, 20h
pop rbp
retn
| long long atoi_octal(_BYTE *a1)
{
long long v1; // rsi
bool v3; // [rsp+Fh] [rbp-11h]
long long v4; // [rsp+10h] [rbp-10h] BYREF
_BYTE *i; // [rsp+18h] [rbp-8h]
for ( i = a1; ; ++i )
{
v3 = 0;
if ( *i )
v3 = (*(_BYTE *)(*((_QWORD *)&my_charset_latin1 + 8) + (unsigned __int8)*i + 1LL) & 8) != 0;
if ( !v3 )
break;
}
v1 = 10LL;
if ( *i == 48 )
v1 = 8LL;
str2int(i, v1, 0LL, 0x7FFFFFFFLL, &v4);
return v4;
}
| atoi_octal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
LAB_001f289c:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x001f28d0
LEA RAX,[0x466150]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x11],AL
LAB_001f28d0:
MOV AL,byte ptr [RBP + -0x11]
TEST AL,0x1
JNZ 0x001f28d9
JMP 0x001f28e7
LAB_001f28d9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f289c
LAB_001f28e7:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
MOV ESI,0xa
MOV EAX,0x8
CMP ECX,0x30
CMOVZ ESI,EAX
XOR EAX,EAX
MOV EDX,EAX
MOV ECX,0x7fffffff
LEA R8,[RBP + -0x10]
CALL 0x0024d960
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x20
POP RBP
RET
|
int8 atoi_octal(byte *param_1)
{
int8 uVar1;
bool bVar2;
int8 local_18;
byte *local_10;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (*local_10 != 0) {
bVar2 = (PTR_ctype_latin1_00466190[(ulong)*local_10 + 1] & 8) != 0;
}
if (!bVar2) break;
local_10 = local_10 + 1;
}
uVar1 = 10;
if (*local_10 == 0x30) {
uVar1 = 8;
}
str2int(local_10,uVar1,0,0x7fffffff,&local_18);
return local_18;
}
| |
35,242 | getopt_ull | eloqsql/mysys/my_getopt.c | static ulonglong getopt_ull(char *arg, const struct my_option *optp, int *err)
{
ulonglong num= eval_num_suffix_ull(arg, err, (char*) optp->name);
return getopt_ull_limit_value(num, optp, NULL);
} | O3 | c | getopt_ull:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rcx
cmpb $0x2d, (%rdi)
jne 0x9bae3
leaq 0x34976e(%rip), %r8 # 0x3e5240
leaq 0x775da(%rip), %rsi # 0x1130b3
xorl %r13d, %r13d
xorl %edi, %edi
movq %r15, %rdx
jmp 0x9bb2b
movq %rcx, -0x30(%rbp)
xorl %r14d, %r14d
movl %r14d, (%r12)
callq 0x5fc00
movq %rax, %r13
movl %r14d, (%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
movl $0xa, %edx
callq 0x5f0d0
cmpl $0x22, (%r13)
jne 0x9bb54
leaq 0x349728(%rip), %r8 # 0x3e5240
leaq 0x775ba(%rip), %rsi # 0x1130d9
xorl %r13d, %r13d
xorl %edi, %edi
movq %r15, %rdx
movq -0x30(%rbp), %rcx
xorl %eax, %eax
callq *(%r8)
movl $0x1, (%r12)
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x9adf4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rdx
movb (%rdx), %cl
movzbl %cl, %esi
cmpl $0x53, %esi
jle 0x9bb7a
leal -0x65(%rsi), %edi
cmpl $0xb, %edi
ja 0x9bb9e
leaq 0x7b25b(%rip), %rsi # 0x116dcc
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
leal -0x45(%rsi), %edi
cmpl $0xb, %edi
ja 0x9bbd8
leaq 0x7b213(%rip), %rsi # 0x116d9c
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
movabsq $0x1000000000000000, %r13 # imm = 0x1000000000000000
jmp 0x9bbe2
cmpl $0x54, %esi
je 0x9bba8
cmpl $0x74, %esi
jne 0x9bc15
movabsq $0x10000000000, %r13 # imm = 0x10000000000
jmp 0x9bbe2
movabsq $0x4000000000000, %r13 # imm = 0x4000000000000
jmp 0x9bbe2
movl $0x400, %r13d # imm = 0x400
jmp 0x9bbe2
movl $0x40000000, %r13d # imm = 0x40000000
jmp 0x9bbe2
movl $0x100000, %r13d # imm = 0x100000
jmp 0x9bbe2
movl $0x1, %r13d
testl %esi, %esi
jne 0x9bc15
imulq %rax, %r13
cmpl $0x0, (%r12)
je 0x9bb38
leaq 0x349648(%rip), %r9 # 0x3e5240
movsbl %cl, %edx
leaq 0x774fc(%rip), %rsi # 0x1130fe
xorl %edi, %edi
movq -0x30(%rbp), %rcx
movq %r15, %r8
xorl %eax, %eax
callq *(%r9)
jmp 0x9bb38
movl $0x1, (%r12)
movb (%rdx), %cl
xorl %r13d, %r13d
jmp 0x9bbf1
| getopt_ull:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov rbx, rsi
mov r15, rdi
mov rcx, [rsi]
cmp byte ptr [rdi], 2Dh ; '-'
jnz short loc_9BAE3
lea r8, my_getopt_error_reporter
lea rsi, aIncorrectUnsig; "Incorrect unsigned value: '%s' for %s"
xor r13d, r13d
xor edi, edi
mov rdx, r15
jmp short loc_9BB2B
loc_9BAE3:
mov [rbp+var_30], rcx
xor r14d, r14d
mov [r12], r14d
call ___errno_location
mov r13, rax
mov [rax], r14d
lea rsi, [rbp+var_38]
mov rdi, r15
mov edx, 0Ah
call ___isoc23_strtoul
cmp dword ptr [r13+0], 22h ; '"'
jnz short loc_9BB54
lea r8, my_getopt_error_reporter
lea rsi, aIncorrectInteg_0; "Incorrect integer value: '%s' for %s"
xor r13d, r13d
xor edi, edi
mov rdx, r15
mov rcx, [rbp+var_30]
loc_9BB2B:
xor eax, eax
call qword ptr [r8]
mov dword ptr [r12], 1
loc_9BB38:
mov rdi, r13
mov rsi, rbx
xor edx, edx
call getopt_ull_limit_value
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9BB54:
mov rdx, [rbp+var_38]
mov cl, [rdx]
movzx esi, cl
cmp esi, 53h ; 'S'
jle short loc_9BB7A
lea edi, [rsi-65h]; switch 12 cases
cmp edi, 0Bh
ja short def_9BB78; jumptable 000000000009BB78 default case
lea rsi, jpt_9BB78
movsxd rdi, ds:(jpt_9BB78 - 116DCCh)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_9BB7A:
lea edi, [rsi-45h]; switch 12 cases
cmp edi, 0Bh
ja short def_9BB90; jumptable 000000000009BB90 default case
lea rsi, jpt_9BB90
movsxd rdi, ds:(jpt_9BB90 - 116D9Ch)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_9BB92:
mov r13, 1000000000000000h; jumptable 000000000009BB78 case 101
jmp short loc_9BBE2
def_9BB78:
cmp esi, 54h ; 'T'; jumptable 000000000009BB78 default case
jz short loc_9BBA8
cmp esi, 74h ; 't'
jnz short loc_9BC15; jumptable 000000000009BB78 cases 102,104-106,108,110,111
loc_9BBA8:
mov r13, 10000000000h
jmp short loc_9BBE2
loc_9BBB4:
mov r13, 4000000000000h; jumptable 000000000009BB78 case 112
jmp short loc_9BBE2
loc_9BBC0:
mov r13d, 400h; jumptable 000000000009BB78 case 107
jmp short loc_9BBE2
loc_9BBC8:
mov r13d, 40000000h; jumptable 000000000009BB78 case 103
jmp short loc_9BBE2
loc_9BBD0:
mov r13d, (offset aTheStatementIs_1+4Bh); jumptable 000000000009BB78 case 109
jmp short loc_9BBE2
def_9BB90:
mov r13d, 1; jumptable 000000000009BB90 default case
test esi, esi
jnz short loc_9BC15; jumptable 000000000009BB78 cases 102,104-106,108,110,111
loc_9BBE2:
imul r13, rax
cmp dword ptr [r12], 0
jz loc_9BB38
loc_9BBF1:
lea r9, my_getopt_error_reporter
movsx edx, cl
lea rsi, aUnknownSuffixC_0; "Unknown suffix '%c' used for variable '"...
xor edi, edi
mov rcx, [rbp+var_30]
mov r8, r15
xor eax, eax
call qword ptr [r9]
jmp loc_9BB38
loc_9BC15:
mov dword ptr [r12], 1; jumptable 000000000009BB78 cases 102,104-106,108,110,111
mov cl, [rdx]
xor r13d, r13d
jmp short loc_9BBF1
| unsigned long long getopt_ull(const char *a1, _QWORD *a2, _DWORD *a3)
{
unsigned long long v5; // r13
_DWORD *v6; // r13
long long v7; // rax
char *v9; // rdx
char v10; // cl
unsigned int v11; // esi
long long v12; // r13
char *v13; // [rsp+8h] [rbp-38h] BYREF
const char *v14; // [rsp+10h] [rbp-30h]
if ( *a1 == 45 )
{
v5 = 0LL;
my_getopt_error_reporter(0, "Incorrect unsigned value: '%s' for %s", a1, *a2);
LABEL_5:
*a3 = 1;
return getopt_ull_limit_value(v5, (long long)a2, 0LL);
}
v14 = (const char *)*a2;
*a3 = 0;
v6 = (_DWORD *)__errno_location(a1);
*v6 = 0;
v7 = __isoc23_strtoul(a1, &v13, 10LL);
if ( *v6 == 34 )
{
v5 = 0LL;
my_getopt_error_reporter(0, "Incorrect integer value: '%s' for %s", a1, v14);
goto LABEL_5;
}
v9 = v13;
v10 = *v13;
v11 = (unsigned __int8)*v13;
if ( v11 <= 0x53 )
{
switch ( *v13 )
{
case 'E':
LABEL_10:
v12 = 0x1000000000000000LL;
goto LABEL_19;
case 'F':
case 'H':
case 'I':
case 'J':
case 'L':
case 'N':
case 'O':
break;
case 'G':
LABEL_16:
v12 = 0x40000000LL;
goto LABEL_19;
case 'K':
LABEL_15:
v12 = 1024LL;
goto LABEL_19;
case 'M':
LABEL_17:
v12 = (long long)" performance_schema table(s). This is unsafe because system tables may differ on slaves";
goto LABEL_19;
case 'P':
LABEL_14:
v12 = 0x4000000000000LL;
goto LABEL_19;
default:
v12 = 1LL;
if ( !*v13 )
goto LABEL_19;
break;
}
LABEL_21:
*a3 = 1;
v10 = *v9;
v5 = 0LL;
goto LABEL_20;
}
switch ( *v13 )
{
case 'e':
goto LABEL_10;
case 'f':
case 'h':
case 'i':
case 'j':
case 'l':
case 'n':
case 'o':
goto LABEL_21;
case 'g':
goto LABEL_16;
case 'k':
goto LABEL_15;
case 'm':
goto LABEL_17;
case 'p':
goto LABEL_14;
default:
if ( v11 != 84 && v11 != 116 )
goto LABEL_21;
v12 = 0x10000000000LL;
break;
}
LABEL_19:
v5 = v7 * v12;
if ( *a3 )
LABEL_20:
my_getopt_error_reporter(0, "Unknown suffix '%c' used for variable '%s' (value '%s')", (unsigned int)v10, v14, a1);
return getopt_ull_limit_value(v5, (long long)a2, 0LL);
}
| getopt_ull:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RCX,qword ptr [RSI]
CMP byte ptr [RDI],0x2d
JNZ 0x0019bae3
LEA R8,[0x4e5240]
LEA RSI,[0x2130b3]
XOR R13D,R13D
XOR EDI,EDI
MOV RDX,R15
JMP 0x0019bb2b
LAB_0019bae3:
MOV qword ptr [RBP + -0x30],RCX
XOR R14D,R14D
MOV dword ptr [R12],R14D
CALL 0x0015fc00
MOV R13,RAX
MOV dword ptr [RAX],R14D
LEA RSI,[RBP + -0x38]
MOV RDI,R15
MOV EDX,0xa
CALL 0x0015f0d0
CMP dword ptr [R13],0x22
JNZ 0x0019bb54
LEA R8,[0x4e5240]
LEA RSI,[0x2130d9]
XOR R13D,R13D
XOR EDI,EDI
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x30]
LAB_0019bb2b:
XOR EAX,EAX
CALL qword ptr [R8]
MOV dword ptr [R12],0x1
LAB_0019bb38:
MOV RDI,R13
MOV RSI,RBX
XOR EDX,EDX
CALL 0x0019adf4
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019bb54:
MOV RDX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RDX]
MOVZX ESI,CL
CMP ESI,0x53
JLE 0x0019bb7a
LEA EDI,[RSI + -0x65]
CMP EDI,0xb
JA 0x0019bb9e
LEA RSI,[0x216dcc]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
LAB_0019bb7a:
LEA EDI,[RSI + -0x45]
CMP EDI,0xb
JA 0x0019bbd8
LEA RSI,[0x216d9c]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
caseD_65:
MOV R13,0x1000000000000000
JMP 0x0019bbe2
default:
CMP ESI,0x54
JZ 0x0019bba8
CMP ESI,0x74
JNZ 0x0019bc15
LAB_0019bba8:
MOV R13,0x10000000000
JMP 0x0019bbe2
caseD_70:
MOV R13,0x4000000000000
JMP 0x0019bbe2
caseD_6b:
MOV R13D,0x400
JMP 0x0019bbe2
caseD_67:
MOV R13D,0x40000000
JMP 0x0019bbe2
caseD_6d:
MOV R13D,0x100000
JMP 0x0019bbe2
default:
MOV R13D,0x1
TEST ESI,ESI
JNZ 0x0019bc15
LAB_0019bbe2:
IMUL R13,RAX
CMP dword ptr [R12],0x0
JZ 0x0019bb38
LAB_0019bbf1:
LEA R9,[0x4e5240]
MOVSX EDX,CL
LEA RSI,[0x2130fe]
XOR EDI,EDI
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,R15
XOR EAX,EAX
CALL qword ptr [R9]
JMP 0x0019bb38
caseD_66:
MOV dword ptr [R12],0x1
MOV CL,byte ptr [RDX]
XOR R13D,R13D
JMP 0x0019bbf1
|
void getopt_ull(char *param_1,int8 *param_2,int *param_3)
{
int *piVar1;
long lVar2;
byte bVar3;
int8 uVar4;
char *pcVar5;
long lVar6;
byte *local_40;
int8 local_38;
uVar4 = *param_2;
if (*param_1 == '-') {
pcVar5 = "Incorrect unsigned value: \'%s\' for %s";
}
else {
*param_3 = 0;
local_38 = uVar4;
piVar1 = __errno_location();
*piVar1 = 0;
lVar2 = __isoc23_strtoul(param_1,&local_40,10);
if (*piVar1 != 0x22) {
bVar3 = *local_40;
if (bVar3 < 0x54) {
switch(bVar3) {
case 0x45:
goto switchD_0019bb78_caseD_65;
case 0x46:
case 0x48:
case 0x49:
case 0x4a:
case 0x4c:
case 0x4e:
case 0x4f:
break;
case 0x47:
goto switchD_0019bb78_caseD_67;
case 0x4b:
goto switchD_0019bb78_caseD_6b;
case 0x4d:
goto switchD_0019bb78_caseD_6d;
case 0x50:
goto switchD_0019bb78_caseD_70;
default:
lVar6 = 1;
if (bVar3 == 0) goto LAB_0019bbe2;
}
switchD_0019bb78_caseD_66:
*param_3 = 1;
bVar3 = *local_40;
lVar6 = 0;
}
else {
switch(bVar3) {
case 0x65:
switchD_0019bb78_caseD_65:
lVar6 = 0x1000000000000000;
break;
case 0x66:
case 0x68:
case 0x69:
case 0x6a:
case 0x6c:
case 0x6e:
case 0x6f:
goto switchD_0019bb78_caseD_66;
case 0x67:
switchD_0019bb78_caseD_67:
lVar6 = 0x40000000;
break;
case 0x6b:
switchD_0019bb78_caseD_6b:
lVar6 = 0x400;
break;
case 0x6d:
switchD_0019bb78_caseD_6d:
lVar6 = 0x100000;
break;
case 0x70:
switchD_0019bb78_caseD_70:
lVar6 = 0x4000000000000;
break;
default:
if ((bVar3 != 0x54) && (bVar3 != 0x74)) goto switchD_0019bb78_caseD_66;
lVar6 = 0x10000000000;
}
LAB_0019bbe2:
lVar6 = lVar6 * lVar2;
if (*param_3 == 0) goto LAB_0019bb38;
}
(*(code *)my_getopt_error_reporter)
(0,"Unknown suffix \'%c\' used for variable \'%s\' (value \'%s\')",(int)(char)bVar3,
local_38,param_1);
goto LAB_0019bb38;
}
pcVar5 = "Incorrect integer value: \'%s\' for %s";
uVar4 = local_38;
}
lVar6 = 0;
(*(code *)my_getopt_error_reporter)(0,pcVar5,param_1,uVar4);
*param_3 = 1;
LAB_0019bb38:
getopt_ull_limit_value(lVar6,param_2,0);
return;
}
| |
35,243 | my_strntoull_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static ulonglong
my_strntoull_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr + l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) res) : (longlong) res);
} | O3 | c | my_strntoull_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xcc7c6
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0xcc796
cmpq $0x9, %rcx
je 0xcc7ae
cmpq $0x20, %rcx
je 0xcc7ae
jmp 0xcc7f8
cmpq $0x2b, %rcx
je 0xcc7ae
cmpq $0x2d, %rcx
jne 0xcc7f8
xorl %ecx, %ecx
cmpl $0x0, -0x34(%rbp)
sete %cl
movl %ecx, -0x34(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0xcc77e
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0xcc7d2
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq -0x44(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
movq %rcx, -0x60(%rbp)
divq %rcx
movq %rdx, %rbx
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xcc8d2
movq %r12, -0x70(%rbp)
movl %ebx, %ecx
movq %rcx, -0x68(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %edi, %edi
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0xcc858
movq %rax, -0x30(%rbp)
jmp 0xcc87d
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0xcc868
addq $-0x37, %rsi
jmp 0xcc876
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0xcc8e3
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0xcc8e3
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0xcc892
movq %rcx, %r12
jmp 0xcc8ab
jne 0xcc89e
movq -0x58(%rbp), %r12
cmpq -0x68(%rbp), %rax
ja 0xcc8ab
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movl %edi, %esi
movq %rax, %r12
movq %rsi, -0x78(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *-0x70(%rbp)
movq -0x78(%rbp), %rsi
movq %r12, %rcx
movl %esi, %edi
testl %eax, %eax
jg 0xcc83c
jmp 0xcc8da
xorl %r12d, %r12d
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0xcc91d
movl %esi, %edi
movq %r12, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xcc8ef
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0xcc90e
testl %edi, %edi
je 0xcc938
movq -0x50(%rbp), %rax
movl $0x22, (%rax)
movq $-0x1, %rax
jmp 0xcc7e9
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0xcc7e7
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xcc929
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0xcc7e7
movq %rcx, %rax
negq %rax
cmpl $0x0, -0x34(%rbp)
cmoveq %rcx, %rax
jmp 0xcc7e9
| my_strntoull_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_40], r8
mov [rbp+var_44], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_CC7C6
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_CC77E:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_CC796
cmp rcx, 9
jz short loc_CC7AE
cmp rcx, 20h ; ' '
jz short loc_CC7AE
jmp short loc_CC7F8
loc_CC796:
cmp rcx, 2Bh ; '+'
jz short loc_CC7AE
cmp rcx, 2Dh ; '-'
jnz short loc_CC7F8
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_CC7AE:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_CC77E
loc_CC7C6:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_CC7D2
mov [rcx], r15
loc_CC7D2:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_CC7E7:
xor eax, eax
loc_CC7E9:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CC7F8:
movsxd rcx, [rbp+var_44]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_60], rcx
div rcx
mov rbx, rdx
mov [rbp+var_58], rax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_CC8D2
mov [rbp+var_70], r12
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor edi, edi
loc_CC83C:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_CC858
mov [rbp+var_30], rax
jmp short loc_CC87D
loc_CC858:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_CC868
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_CC876
loc_CC868:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_CC8E3
add rsi, 0FFFFFFFFFFFFFFA9h
loc_CC876:
mov [rbp+var_30], rsi
mov rax, rsi
loc_CC87D:
cmp eax, [rbp+var_44]
jge short loc_CC8E3
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_CC892
mov r12, rcx
jmp short loc_CC8AB
loc_CC892:
jnz short loc_CC89E
mov r12, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_CC8AB
loc_CC89E:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, edi
mov r12, rax
loc_CC8AB:
mov [rbp+var_78], rsi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call [rbp+var_70]
mov rsi, [rbp+var_78]
mov rcx, r12
mov edi, esi
test eax, eax
jg loc_CC83C
jmp short loc_CC8DA
loc_CC8D2:
xor r12d, r12d
mov rbx, r15
xor esi, esi
loc_CC8DA:
test eax, eax
jz short loc_CC91D
mov edi, esi
mov rcx, r12
loc_CC8E3:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_CC8EF
mov [rax], rbx
loc_CC8EF:
cmp rbx, r15
jz short loc_CC90E
test edi, edi
jz short loc_CC938
mov rax, [rbp+var_50]
mov dword ptr [rax], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
jmp loc_CC7E9
loc_CC90E:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_CC7E7
loc_CC91D:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_CC929
mov [rax], rbx
loc_CC929:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_CC7E7
loc_CC938:
mov rax, rcx
neg rax
cmp [rbp+var_34], 0
cmovz rax, rcx
jmp loc_CC7E9
| long long my_strntoull_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
long long result; // rax
int v13; // eax
unsigned long long v14; // rcx
long long v15; // rbx
int v16; // edi
unsigned long long v17; // rax
long long v18; // rsi
int v19; // esi
unsigned long long v20; // r12
long long ( *v21)(long long, _QWORD *, long long, long long); // [rsp+10h] [rbp-70h]
unsigned long long v22; // [rsp+28h] [rbp-58h]
BOOL v26; // [rsp+4Ch] [rbp-34h]
_QWORD v27[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v27, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v26 = 0;
while ( v27[0] > 42LL )
{
if ( v27[0] != 43LL )
{
if ( v27[0] != 45LL )
goto LABEL_17;
v26 = !v26;
}
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v27, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
if ( v27[0] == 9LL || v27[0] == 32LL )
goto LABEL_10;
LABEL_17:
v22 = 0xFFFFFFFFFFFFFFFFLL / a4;
v13 = v8(a1, v27, v6, v9);
if ( v13 <= 0 )
{
v20 = 0LL;
v15 = v6;
v19 = 0;
LABEL_35:
if ( v13 )
{
v16 = v19;
v14 = v20;
goto LABEL_37;
}
if ( a5 )
*a5 = v15;
*a6 = 84;
return 0LL;
}
v21 = v8;
v14 = 0LL;
v15 = v6;
v16 = 0;
while ( 1 )
{
v15 += (unsigned int)v13;
v17 = v27[0] - 48LL;
if ( (unsigned long long)(v27[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v27[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v27[0] - 97LL) > 0x19 )
break;
v18 = v27[0] - 87LL;
}
else
{
v18 = v27[0] - 55LL;
}
v27[0] = v18;
v17 = v18;
}
else
{
v27[0] -= 48LL;
}
if ( (int)v17 >= a4 )
break;
v19 = 1;
if ( v14 <= v22 )
{
if ( v14 != v22 || (v20 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v19 = v16;
v20 = a4 * v14 + v17;
}
}
else
{
v20 = v14;
}
v13 = v21(a1, v27, v15, v9);
v14 = v20;
v16 = v19;
if ( v13 <= 0 )
goto LABEL_35;
}
LABEL_37:
if ( a5 )
*a5 = v15;
if ( v15 == v6 )
{
*a6 = 33;
return 0LL;
}
if ( v16 )
{
*a6 = 34;
return -1LL;
}
else
{
result = -(long long)v14;
if ( !v26 )
return v14;
}
return result;
}
| my_strntoull_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001cc7c6
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_001cc77e:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x001cc796
CMP RCX,0x9
JZ 0x001cc7ae
CMP RCX,0x20
JZ 0x001cc7ae
JMP 0x001cc7f8
LAB_001cc796:
CMP RCX,0x2b
JZ 0x001cc7ae
CMP RCX,0x2d
JNZ 0x001cc7f8
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_001cc7ae:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x001cc77e
LAB_001cc7c6:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x001cc7d2
MOV qword ptr [RCX],R15
LAB_001cc7d2:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_001cc7e7:
XOR EAX,EAX
LAB_001cc7e9:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cc7f8:
MOVSXD RCX,dword ptr [RBP + -0x44]
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x60],RCX
DIV RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x58],RAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001cc8d2
MOV qword ptr [RBP + -0x70],R12
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR EDI,EDI
LAB_001cc83c:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x001cc858
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001cc87d
LAB_001cc858:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x001cc868
ADD RSI,-0x37
JMP 0x001cc876
LAB_001cc868:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x001cc8e3
ADD RSI,-0x57
LAB_001cc876:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_001cc87d:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x001cc8e3
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x001cc892
MOV R12,RCX
JMP 0x001cc8ab
LAB_001cc892:
JNZ 0x001cc89e
MOV R12,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x001cc8ab
LAB_001cc89e:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,EDI
MOV R12,RAX
LAB_001cc8ab:
MOV qword ptr [RBP + -0x78],RSI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RCX,R12
MOV EDI,ESI
TEST EAX,EAX
JG 0x001cc83c
JMP 0x001cc8da
LAB_001cc8d2:
XOR R12D,R12D
MOV RBX,R15
XOR ESI,ESI
LAB_001cc8da:
TEST EAX,EAX
JZ 0x001cc91d
MOV EDI,ESI
MOV RCX,R12
LAB_001cc8e3:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001cc8ef
MOV qword ptr [RAX],RBX
LAB_001cc8ef:
CMP RBX,R15
JZ 0x001cc90e
TEST EDI,EDI
JZ 0x001cc938
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x22
MOV RAX,-0x1
JMP 0x001cc7e9
LAB_001cc90e:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x001cc7e7
LAB_001cc91d:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001cc929
MOV qword ptr [RAX],RBX
LAB_001cc929:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x001cc7e7
LAB_001cc938:
MOV RAX,RCX
NEG RAX
CMP dword ptr [RBP + -0x34],0x0
CMOVZ RAX,RCX
JMP 0x001cc7e9
|
ulong my_strntoull_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
bool bVar4;
bool bVar5;
ulong uVar6;
bool bVar7;
uint uVar8;
ulong uVar9;
int4 uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar8) {
bVar4 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_001cc7f8:
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
auVar3 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar9 = SUB168(auVar3 / auVar2,0);
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar12 = param_2;
if ((int)uVar8 < 1) {
uVar11 = 0;
bVar5 = false;
goto LAB_001cc8da;
}
uVar11 = 0;
bVar5 = false;
goto LAB_001cc83c;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_001cc7f8;
bVar4 = !bVar4;
}
param_2 = param_2 + (ulong)uVar8;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar8);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar10 = 0x21;
if (uVar8 == 0) {
uVar10 = 0x54;
}
*param_6 = uVar10;
return 0;
while( true ) {
if (param_4 <= (int)uVar13) goto LAB_001cc8e3;
uVar6 = uVar11;
bVar7 = true;
if ((uVar11 <= uVar9) &&
((uVar11 != uVar9 || (uVar6 = uVar9, uVar13 <= (SUB168(auVar3 % auVar2,0) & 0xffffffff))))) {
uVar6 = uVar13 + uVar11 * (long)param_4;
bVar7 = bVar5;
}
bVar5 = bVar7;
uVar11 = uVar6;
local_38 = uVar13;
uVar8 = (*pcVar1)(param_1,&local_38,lVar12,param_3);
if ((int)uVar8 < 1) break;
LAB_001cc83c:
lVar12 = (ulong)uVar8 + lVar12;
uVar13 = local_38 - 0x30;
if (9 < uVar13) {
if (local_38 - 0x41 < 0x1a) {
uVar13 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_001cc8e3;
uVar13 = local_38 - 0x57;
}
}
}
LAB_001cc8da:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_001cc8e3:
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
if (lVar12 != param_2) {
if (bVar5) {
*param_6 = 0x22;
return 0xffffffffffffffff;
}
if (!bVar4) {
return uVar11;
}
return -uVar11;
}
*param_6 = 0x21;
}
return 0;
}
| |
35,244 | ps_fetch_datetime | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
unsigned char **row)
{
MYSQL_TIME *t= (MYSQL_TIME *)r_param->buffer;
unsigned int len= net_field_length(row);
switch (r_param->buffer_type) {
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_DATE:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_TIME:
convert_to_datetime(t, row, len, field->type);
t->year= t->day= t->month= 0;
break;
case MYSQL_TYPE_YEAR:
{
MYSQL_TIME tm;
convert_to_datetime(&tm, row, len, field->type);
shortstore(r_param->buffer, tm.year);
break;
}
default:
{
char dtbuffer[60];
MYSQL_TIME tm;
size_t length;
convert_to_datetime(&tm, row, len, field->type);
switch(field->type) {
case MYSQL_TYPE_DATE:
length= sprintf(dtbuffer, "%04u-%02u-%02u", tm.year, tm.month, tm.day);
break;
case MYSQL_TYPE_TIME:
length= sprintf(dtbuffer, "%s%02u:%02u:%02u", (tm.neg ? "-" : ""), tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
length= sprintf(dtbuffer, "%04u-%02u-%02u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
default:
dtbuffer[0]= 0;
length= 0;
break;
}
convert_froma_string(r_param, dtbuffer, length);
break;
}
}
(*row) += len;
} | O3 | c | ps_fetch_datetime:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %r13
movq %rdx, %rdi
callq 0x26fc9
movq %rax, %r14
movl 0x60(%r15), %eax
addl $-0x7, %eax
cmpl $0x6, %eax
ja 0x357d4
leaq 0x19d55(%rip), %rcx # 0x4f508
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x363a9
jmp 0x359d3
movl 0x70(%r12), %r13d
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x363a9
addl $-0x7, %r13d
cmpl $0x5, %r13d
ja 0x359bd
leaq 0x19d21(%rip), %rax # 0x4f524
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl -0x94(%rbp), %r11d
movl -0x90(%rbp), %r13d
movl -0x8c(%rbp), %r10d
leaq 0x1657a(%rip), %rcx # 0x4bdbd
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r11
pushq -0xa8(%rbp)
callq 0x142b0
addq $0x20, %rsp
jmp 0x35911
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x363a9
movl $0x0, 0x8(%r13)
movq $0x0, (%r13)
jmp 0x359d3
movl 0x70(%r12), %ecx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x363a9
movl (%r12), %eax
movq 0x10(%r15), %rcx
movb %al, (%rcx)
movq 0x10(%r15), %rcx
movb %ah, 0x1(%rcx)
jmp 0x359d3
cmpb $0x0, -0x80(%rbp)
leaq 0x116f3(%rip), %rax # 0x46fc0
leaq 0x10de8(%rip), %r8 # 0x466bc
cmoveq %rax, %r8
movl -0x94(%rbp), %r9d
movl -0x90(%rbp), %r10d
movl -0x8c(%rbp), %r11d
leaq 0x164b1(%rip), %rcx # 0x4bda5
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x142b0
addq $0x10, %rsp
movslq %eax, %r13
movl 0x68(%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x359c4
movq -0x88(%rbp), %r8
leaq 0x16484(%rip), %rcx # 0x4bdb6
leaq -0x78(%rbp), %rdi
movl $0x8, %edx
movl $0x1, %esi
xorl %eax, %eax
callq 0x142b0
movl 0x68(%r12), %eax
cmpq $0x5, %rax
ja 0x3595b
leaq -0x78(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x141c0
addq %rax, %r13
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movq %r12, %rsi
callq 0x14470
jmp 0x359c4
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %r10d
subq $0x8, %rsp
leaq 0x163f9(%rip), %rcx # 0x4bd96
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
callq 0x142b0
addq $0x10, %rsp
movslq %eax, %r13
jmp 0x359c4
movb $0x0, -0x70(%rbp)
xorl %r13d, %r13d
leaq -0x70(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x35ed9
movl %r14d, %eax
addq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x359fa
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14520
| ps_fetch_datetime:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdx
mov r12, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi+10h]
mov rdi, rdx
call net_field_length
mov r14, rax
mov eax, [r15+60h]
add eax, 0FFFFFFF9h; switch 7 cases
cmp eax, 6
ja short def_357BA; jumptable 00000000000357BA default case, cases 8,9
lea rcx, jpt_357BA
movsxd rax, ds:(jpt_357BA - 4F508h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_357BC:
mov ecx, [r12+70h]; jumptable 00000000000357BA cases 7,10,12
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
jmp loc_359D3
def_357BA:
mov r13d, [r12+70h]; jumptable 00000000000357BA default case, cases 8,9
lea rdi, [rbp+var_A0]
mov rsi, rbx
mov edx, r14d
mov ecx, r13d
call convert_to_datetime
add r13d, 0FFFFFFF9h; switch 6 cases
cmp r13d, 5
ja def_3580A; jumptable 000000000003580A default case, cases 8,9
lea rax, jpt_3580A
movsxd rcx, ds:(jpt_3580A - 4F524h)[rax+r13*4]
add rcx, rax
jmp rcx; switch jump
loc_3580C:
mov r8d, [rbp+var_A0]; jumptable 000000000003580A cases 7,12
mov r9d, [rbp+var_9C]
mov eax, [rbp+var_98]
mov [rbp+var_A8], rax
mov r11d, [rbp+var_94]
mov r13d, [rbp+var_90]
mov r10d, [rbp+var_8C]
lea rcx, a04u02u02u02u02; "%04u-%02u-%02u %02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
push r13
push r11
push [rbp+var_A8]
call ___sprintf_chk
add rsp, 20h
jmp loc_35911
loc_3586D:
mov ecx, [r12+70h]; jumptable 00000000000357BA case 11
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov dword ptr [r13+8], 0
mov qword ptr [r13+0], 0
jmp loc_359D3
loc_35895:
mov ecx, [r12+70h]; jumptable 00000000000357BA case 13
lea r12, [rbp+var_70]
mov rdi, r12
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov eax, [r12]
mov rcx, [r15+10h]
mov [rcx], al
mov rcx, [r15+10h]
mov [rcx+1], ah
jmp loc_359D3
loc_358C2:
cmp [rbp+var_80], 0; jumptable 000000000003580A case 11
lea rax, a12+4; ""
lea r8, asc_466A9+13h; "-"
cmovz r8, rax
mov r9d, [rbp+var_94]
mov r10d, [rbp+var_90]
mov r11d, [rbp+var_8C]
lea rcx, aS02u02u02u; "%s%02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r11
push r10
call ___sprintf_chk
add rsp, 10h
loc_35911:
movsxd r13, eax
mov eax, [r12+68h]
dec eax
cmp eax, 5
ja loc_359C4
mov r8, [rbp+var_88]
lea rcx, a06lu; ".%06lu"
lea rdi, [rbp+var_78]
mov edx, 8
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov eax, [r12+68h]
cmp rax, 5
ja short loc_3595B
lea rcx, [rbp+var_78]
mov byte ptr [rax+rcx+1], 0
loc_3595B:
lea r12, [rbp+var_78]
mov rdi, r12
call _strlen
add r13, rax
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov rsi, r12
call ___strcat_chk
jmp short loc_359C4
loc_3597D:
mov r8d, [rbp+var_A0]; jumptable 000000000003580A case 10
mov r9d, [rbp+var_9C]
mov r10d, [rbp+var_98]
sub rsp, 8
lea rcx, a04u02u02u; "%04u-%02u-%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
call ___sprintf_chk
add rsp, 10h
movsxd r13, eax
jmp short loc_359C4
def_3580A:
mov [rbp+var_70], 0; jumptable 000000000003580A default case, cases 8,9
xor r13d, r13d
loc_359C4:
lea rsi, [rbp+var_70]
mov rdi, r15
mov rdx, r13
call convert_froma_string
loc_359D3:
mov eax, r14d
add [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_359FA
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_359FA:
call ___stack_chk_fail
| unsigned long long ps_fetch_datetime(long long a1, long long a2, unsigned __int8 **a3)
{
long long v4; // r13
unsigned int v5; // r14d
unsigned int v6; // r13d
int v7; // eax
char v8; // ah
const char *v9; // r8
long long v10; // r13
unsigned long long v11; // rax
int v13; // [rsp+10h] [rbp-A0h] BYREF
int v14; // [rsp+14h] [rbp-9Ch]
int v15; // [rsp+18h] [rbp-98h]
int v16; // [rsp+1Ch] [rbp-94h]
int v17; // [rsp+20h] [rbp-90h]
int v18; // [rsp+24h] [rbp-8Ch]
long long v19; // [rsp+28h] [rbp-88h]
char v20; // [rsp+30h] [rbp-80h]
_BYTE v21[8]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v22[64]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v23; // [rsp+80h] [rbp-30h]
v23 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 16);
v5 = net_field_length(a3);
switch ( *(_DWORD *)(a1 + 96) )
{
case 7:
case 0xA:
case 0xC:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
break;
case 0xB:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
*(_DWORD *)(v4 + 8) = 0;
*(_QWORD *)v4 = 0LL;
break;
case 0xD:
convert_to_datetime(v22, a3, v5, *(unsigned int *)(a2 + 112));
v8 = v22[1];
**(_BYTE **)(a1 + 16) = v22[0];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
break;
default:
v6 = *(_DWORD *)(a2 + 112);
convert_to_datetime(&v13, a3, v5, v6);
switch ( v6 )
{
case 7u:
case 0xCu:
v7 = __sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u %02u:%02u:%02u", v13, v14, v15, v16, v17, v18);
goto LABEL_10;
case 0xAu:
v10 = (int)__sprintf_chk(v22, 1LL, 60LL, "%04u-%02u-%02u", v13, v14, v15);
break;
case 0xBu:
v9 = "-";
if ( !v20 )
v9 = "";
v7 = __sprintf_chk(v22, 1LL, 60LL, "%s%02u:%02u:%02u", v9, v16, v17, v18);
LABEL_10:
v10 = v7;
if ( (unsigned int)(*(_DWORD *)(a2 + 104) - 1) <= 5 )
{
__sprintf_chk(v21, 1LL, 8LL, ".%06lu", v19);
v11 = *(unsigned int *)(a2 + 104);
if ( v11 <= 5 )
v21[v11 + 1] = 0;
v10 += strlen(v21);
__strcat_chk(v22, v21, 60LL);
}
break;
default:
v22[0] = 0;
v10 = 0LL;
break;
}
convert_froma_string(a1, v22, v10);
break;
}
*a3 += v5;
return __readfsqword(0x28u);
}
| ps_fetch_datetime:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI + 0x10]
MOV RDI,RDX
CALL 0x00126fc9
MOV R14,RAX
MOV EAX,dword ptr [R15 + 0x60]
ADD EAX,-0x7
CMP EAX,0x6
JA 0x001357d4
LEA RCX,[0x14f508]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001363a9
JMP 0x001359d3
caseD_8:
MOV R13D,dword ptr [R12 + 0x70]
LEA RDI,[RBP + -0xa0]
MOV RSI,RBX
MOV EDX,R14D
MOV ECX,R13D
CALL 0x001363a9
ADD R13D,-0x7
CMP R13D,0x5
JA 0x001359bd
LEA RAX,[0x14f524]
MOVSXD RCX,dword ptr [RAX + R13*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_7:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV EAX,dword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0xa8],RAX
MOV R11D,dword ptr [RBP + -0x94]
MOV R13D,dword ptr [RBP + -0x90]
MOV R10D,dword ptr [RBP + -0x8c]
LEA RCX,[0x14bdbd]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RBP + -0xa8]
CALL 0x001142b0
ADD RSP,0x20
JMP 0x00135911
caseD_b:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001363a9
MOV dword ptr [R13 + 0x8],0x0
MOV qword ptr [R13],0x0
JMP 0x001359d3
caseD_d:
MOV ECX,dword ptr [R12 + 0x70]
LEA R12,[RBP + -0x70]
MOV RDI,R12
MOV RSI,RBX
MOV EDX,R14D
CALL 0x001363a9
MOV EAX,dword ptr [R12]
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX + 0x1],AH
JMP 0x001359d3
caseD_b:
CMP byte ptr [RBP + -0x80],0x0
LEA RAX,[0x146fc0]
LEA R8,[0x1466bc]
CMOVZ R8,RAX
MOV R9D,dword ptr [RBP + -0x94]
MOV R10D,dword ptr [RBP + -0x90]
MOV R11D,dword ptr [RBP + -0x8c]
LEA RCX,[0x14bda5]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R11
PUSH R10
CALL 0x001142b0
ADD RSP,0x10
LAB_00135911:
MOVSXD R13,EAX
MOV EAX,dword ptr [R12 + 0x68]
DEC EAX
CMP EAX,0x5
JA 0x001359c4
MOV R8,qword ptr [RBP + -0x88]
LEA RCX,[0x14bdb6]
LEA RDI,[RBP + -0x78]
MOV EDX,0x8
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001142b0
MOV EAX,dword ptr [R12 + 0x68]
CMP RAX,0x5
JA 0x0013595b
LEA RCX,[RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_0013595b:
LEA R12,[RBP + -0x78]
MOV RDI,R12
CALL 0x001141c0
ADD R13,RAX
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV RSI,R12
CALL 0x00114470
JMP 0x001359c4
caseD_a:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV R10D,dword ptr [RBP + -0x98]
SUB RSP,0x8
LEA RCX,[0x14bd96]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
CALL 0x001142b0
ADD RSP,0x10
MOVSXD R13,EAX
JMP 0x001359c4
caseD_8:
MOV byte ptr [RBP + -0x70],0x0
XOR R13D,R13D
LAB_001359c4:
LEA RSI,[RBP + -0x70]
MOV RDI,R15
MOV RDX,R13
CALL 0x00135ed9
LAB_001359d3:
MOV EAX,R14D
ADD qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001359fa
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001359fa:
CALL 0x00114520
|
void ps_fetch_datetime(long param_1,long param_2,long *param_3)
{
int4 uVar1;
int8 *puVar2;
uint uVar3;
int iVar4;
size_t sVar5;
char *pcVar6;
long lVar7;
long in_FS_OFFSET;
int4 local_a8;
int4 local_a4;
int4 local_a0;
int4 local_9c;
int4 local_98;
int4 local_94;
int8 local_90;
char local_88;
char local_80;
int1 auStack_7f [7];
uint local_78 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = *(int8 **)(param_1 + 0x10);
uVar3 = net_field_length(param_3);
switch(*(int4 *)(param_1 + 0x60)) {
case 7:
case 10:
case 0xc:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
break;
default:
uVar1 = *(int4 *)(param_2 + 0x70);
convert_to_datetime(&local_a8,param_3,uVar3,uVar1);
switch(uVar1) {
case 7:
case 0xc:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u %02u:%02u:%02u",local_a8,local_a4,
local_a0,local_9c,local_98,local_94);
goto LAB_00135911;
default:
local_78[0] = local_78[0] & 0xffffff00;
lVar7 = 0;
break;
case 10:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u",local_a8,local_a4,local_a0);
lVar7 = (long)iVar4;
break;
case 0xb:
pcVar6 = "-";
if (local_88 == '\0') {
pcVar6 = "";
}
iVar4 = __sprintf_chk(local_78,1,0x3c,"%s%02u:%02u:%02u",pcVar6,local_9c,local_98,local_94);
LAB_00135911:
lVar7 = (long)iVar4;
if (*(int *)(param_2 + 0x68) - 1U < 6) {
__sprintf_chk(&local_80,1,8,".%06lu",local_90);
if ((ulong)*(uint *)(param_2 + 0x68) < 6) {
auStack_7f[*(uint *)(param_2 + 0x68)] = 0;
}
sVar5 = strlen(&local_80);
lVar7 = lVar7 + sVar5;
__strcat_chk(local_78,&local_80,0x3c);
}
}
convert_froma_string(param_1,local_78,lVar7);
break;
case 0xb:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
*(int4 *)(puVar2 + 1) = 0;
*puVar2 = 0;
break;
case 0xd:
convert_to_datetime(local_78,param_3,uVar3,*(int4 *)(param_2 + 0x70));
**(int1 **)(param_1 + 0x10) = (char)local_78[0];
*(char *)(*(long *)(param_1 + 0x10) + 1) = (char)(local_78[0] >> 8);
}
*param_3 = *param_3 + (ulong)uVar3;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
35,245 | Overworld::~Overworld() | untodesu[P]voxelius/game/server/overworld.hh | virtual ~Overworld(void) = default; | O3 | cpp | Overworld::~Overworld():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x548, %r14d # imm = 0x548
movq -0x10(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x201e3
movq (%rbx,%r14), %rsi
subq %rdi, %rsi
callq 0x166c0
addq $-0x20, %r14
cmpq $0x4c8, %r14 # imm = 0x4C8
jne 0x201cd
leaq 0x370(%rbx), %rdi
callq 0x20066
leaq 0xe1865(%rip), %r14 # 0x101a68
movq %r14, 0x338(%rbx)
movq 0x350(%rbx), %rdi
leaq 0x360(%rbx), %rax
cmpq %rax, %rdi
je 0x20228
movq (%rax), %rsi
incq %rsi
callq 0x166c0
movq %r14, 0x300(%rbx)
movq 0x318(%rbx), %rdi
leaq 0x328(%rbx), %rax
cmpq %rax, %rdi
je 0x2024d
movq (%rax), %rsi
incq %rsi
callq 0x166c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3accc
| _ZN9OverworldD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, 548h
loc_201CD:
mov rdi, [rbx+r14-10h]; void *
test rdi, rdi
jz short loc_201E3
mov rsi, [rbx+r14]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_201E3:
add r14, 0FFFFFFFFFFFFFFE0h
cmp r14, 4C8h
jnz short loc_201CD
lea rdi, [rbx+370h]
call _ZN7emhash87HashMapIN3glm3vecILi2EiLNS1_9qualifierE0EEE18Overworld_MetadataSt4hashIS4_ESt8equal_toIS4_EED2Ev; emhash8::HashMap<glm::vec<2,int,(glm::qualifier)0>,Overworld_Metadata,std::hash<glm::vec<2,int,(glm::qualifier)0>>,std::equal_to<glm::vec<2,int,(glm::qualifier)0>>>::~HashMap()
lea r14, off_101A68
mov [rbx+338h], r14
mov rdi, [rbx+350h]; void *
lea rax, [rbx+360h]
cmp rdi, rax
jz short loc_20228
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_20228:
mov [rbx+300h], r14
mov rdi, [rbx+318h]; void *
lea rax, [rbx+328h]
cmp rdi, rax
jz short loc_2024D
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2024D:
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN9DimensionD2Ev; Dimension::~Dimension()
| void Overworld::~Overworld(Overworld *this)
{
long long i; // r14
void *v3; // rdi
char *v4; // rdi
char *v5; // rdi
for ( i = 1352LL; i != 1224; i -= 32LL )
{
v3 = *(void **)((char *)this + i - 16);
if ( v3 )
operator delete(v3, *(_QWORD *)((char *)this + i) - (_QWORD)v3);
}
emhash8::HashMap<glm::vec<2,int,(glm::qualifier)0>,Overworld_Metadata,std::hash<glm::vec<2,int,(glm::qualifier)0>>,std::equal_to<glm::vec<2,int,(glm::qualifier)0>>>::~HashMap((_QWORD *)this + 110);
*((_QWORD *)this + 103) = &off_101A68;
v4 = (char *)*((_QWORD *)this + 106);
if ( v4 != (char *)this + 864 )
operator delete(v4, *((_QWORD *)this + 108) + 1LL);
*((_QWORD *)this + 96) = &off_101A68;
v5 = (char *)*((_QWORD *)this + 99);
if ( v5 != (char *)this + 808 )
operator delete(v5, *((_QWORD *)this + 101) + 1LL);
Dimension::~Dimension(this);
}
| ~Overworld:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,0x548
LAB_001201cd:
MOV RDI,qword ptr [RBX + R14*0x1 + -0x10]
TEST RDI,RDI
JZ 0x001201e3
MOV RSI,qword ptr [RBX + R14*0x1]
SUB RSI,RDI
CALL 0x001166c0
LAB_001201e3:
ADD R14,-0x20
CMP R14,0x4c8
JNZ 0x001201cd
LEA RDI,[RBX + 0x370]
CALL 0x00120066
LEA R14,[0x201a68]
MOV qword ptr [RBX + 0x338],R14
MOV RDI,qword ptr [RBX + 0x350]
LEA RAX,[RBX + 0x360]
CMP RDI,RAX
JZ 0x00120228
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001166c0
LAB_00120228:
MOV qword ptr [RBX + 0x300],R14
MOV RDI,qword ptr [RBX + 0x318]
LEA RAX,[RBX + 0x328]
CMP RDI,RAX
JZ 0x0012024d
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001166c0
LAB_0012024d:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013accc
|
/* Overworld::~Overworld() */
void __thiscall Overworld::~Overworld(Overworld *this)
{
void *pvVar1;
long lVar2;
lVar2 = 0x548;
do {
pvVar1 = *(void **)(this + lVar2 + -0x10);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + lVar2) - (long)pvVar1);
}
lVar2 = lVar2 + -0x20;
} while (lVar2 != 0x4c8);
emhash8::
HashMap<glm::vec<2,int,(glm::qualifier)0>,Overworld_Metadata,std::hash<glm::vec<2,int,(glm::qualifier)0>>,std::equal_to<glm::vec<2,int,(glm::qualifier)0>>>
::~HashMap((HashMap<glm::vec<2,int,(glm::qualifier)0>,Overworld_Metadata,std::hash<glm::vec<2,int,(glm::qualifier)0>>,std::equal_to<glm::vec<2,int,(glm::qualifier)0>>>
*)(this + 0x370));
*(int ***)(this + 0x338) = &PTR__ConfigNumber_00201a68;
if (*(Overworld **)(this + 0x350) != this + 0x360) {
operator_delete(*(Overworld **)(this + 0x350),*(long *)(this + 0x360) + 1);
}
*(int ***)(this + 0x300) = &PTR__ConfigNumber_00201a68;
if (*(Overworld **)(this + 0x318) != this + 0x328) {
operator_delete(*(Overworld **)(this + 0x318),*(long *)(this + 0x328) + 1);
}
Dimension::~Dimension((Dimension *)this);
return;
}
| |
35,246 | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, int)) | monkey531[P]llama/common/arg.h | common_arg(
const std::initializer_list<const char *> & args,
const char * value_hint,
const std::string & help,
void (*handler)(common_params & params, int)
) : args(args), value_hint(value_hint), help(help), handler_int(handler) {} | O0 | c | common_arg::common_arg(std::initializer_list<char const*> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&, int)):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movl $0x0, 0x6c(%rsp)
leaq 0x6c(%rsp), %rax
movq %rax, 0x70(%rsp)
movq $0x1, 0x78(%rsp)
leaq 0x6a(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9d770
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %r8
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x6b(%rsp), %rcx
callq 0x9d780
jmp 0x8d68b
leaq 0x6a(%rsp), %rdi
callq 0x9d860
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
callq 0x9d870
movq 0x20(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9d880
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x9d890
jmp 0x8d702
leaq 0x3f(%rsp), %rdi
callq 0x9d920
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x78(%rdi)
movq $0x0, 0x80(%rdi)
movq $0x0, 0x88(%rdi)
addq $0x90, %rdi
movq 0x88(%rsp), %rsi
callq 0x5d1f0
jmp 0x8d749
movq 0x20(%rsp), %rax
movb $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0xd0(%rax)
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6a(%rsp), %rdi
callq 0x9d860
jmp 0x8d7ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x9d920
jmp 0x8d7d9
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x9d930
movq 0x8(%rsp), %rdi
callq 0x9d990
movq 0x28(%rsp), %rdi
callq 0x9d990
movq 0x60(%rsp), %rdi
callq 0x5dbc0
nopw (%rax,%rax)
| _ZN10common_argC2ERKSt16initializer_listIPKcES2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsiE:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_20], rcx
mov [rsp+0A8h+var_28], r8
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_80], rax
mov [rsp+0A8h+var_88], rax
mov [rsp+0A8h+var_3C], 0
lea rax, [rsp+0A8h+var_3C]
mov [rsp+0A8h+var_38], rax
mov [rsp+0A8h+var_30], 1
lea rdi, [rsp+0A8h+var_3E]
mov [rsp+0A8h+var_78], rdi
call _ZNSaI13llama_exampleEC2Ev; std::allocator<llama_example>::allocator(void)
mov rdi, [rsp+0A8h+var_80]
mov r8, [rsp+0A8h+var_78]
mov rsi, [rsp+0A8h+var_38]
mov rdx, [rsp+0A8h+var_30]
lea rcx, [rsp+0A8h+var_3D]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
jmp short $+2
loc_8D68B:
lea rdi, [rsp+0A8h+var_3E]
call _ZNSaI13llama_exampleED2Ev; std::allocator<llama_example>::~allocator()
mov rax, [rsp+0A8h+var_88]
mov rdi, rax
add rdi, 30h ; '0'
mov [rsp+0A8h+var_A0], rdi
xorps xmm0, xmm0
movups xmmword ptr [rax+50h], xmm0
movups xmmword ptr [rax+40h], xmm0
movups xmmword ptr [rax+30h], xmm0
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2Ev; std::set<llama_example>::set(void)
mov rax, [rsp+0A8h+var_88]
add rax, 60h ; '`'
mov [rsp+0A8h+var_98], rax
mov rax, [rsp+0A8h+var_10]
movups xmm0, xmmword ptr [rax]
movaps [rsp+0A8h+var_68], xmm0
lea rdi, [rsp+0A8h+var_69]
mov [rsp+0A8h+var_90], rdi
call _ZNSaIPKcEC2Ev; std::allocator<char const*>::allocator(void)
mov rdi, [rsp+0A8h+var_98]
mov rcx, [rsp+0A8h+var_90]
mov rsi, qword ptr [rsp+0A8h+var_68]
mov rdx, qword ptr [rsp+0A8h+var_68+8]
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
jmp short $+2
loc_8D702:
lea rdi, [rsp+0A8h+var_69]
call _ZNSaIPKcED2Ev; std::allocator<char const*>::~allocator()
mov rdi, [rsp+0A8h+var_88]
mov rax, [rsp+0A8h+var_18]
mov [rdi+78h], rax
mov qword ptr [rdi+80h], 0
mov qword ptr [rdi+88h], 0
add rdi, 90h
mov rsi, [rsp+0A8h+var_20]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_8D749:
mov rax, [rsp+0A8h+var_88]
mov byte ptr [rax+0B0h], 0
mov qword ptr [rax+0B8h], 0
mov qword ptr [rax+0C0h], 0
mov qword ptr [rax+0C8h], 0
mov rcx, [rsp+0A8h+var_28]
mov [rax+0D0h], rcx
add rsp, 0A8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_62]
call _ZNSaI13llama_exampleED2Ev; std::allocator<llama_example>::~allocator()
jmp short loc_8D7ED
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_37]
call _ZNSaIPKcED2Ev; std::allocator<char const*>::~allocator()
jmp short loc_8D7D9
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
call _ZNSt6vectorIPKcSaIS1_EED2Ev; std::vector<char const*>::~vector()
loc_8D7D9:
mov rdi, [rsp+arg_0]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EED2Ev; std::set<llama_example>::~set()
mov rdi, [rsp+arg_20]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EED2Ev; std::set<llama_example>::~set()
loc_8D7ED:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| long long common_arg::common_arg(long long a1, __int128 *a2, long long a3, long long a4, long long a5)
{
int v5; // r9d
int v6; // r8d
int v7; // r9d
long long result; // rax
int v9; // [rsp+0h] [rbp-A8h]
char v10; // [rsp+3Fh] [rbp-69h] BYREF
__int128 v11; // [rsp+40h] [rbp-68h]
char v12; // [rsp+6Ah] [rbp-3Eh] BYREF
char v13; // [rsp+6Bh] [rbp-3Dh] BYREF
int v14; // [rsp+6Ch] [rbp-3Ch] BYREF
int *v15; // [rsp+70h] [rbp-38h]
long long v16; // [rsp+78h] [rbp-30h]
long long v17; // [rsp+80h] [rbp-28h]
long long v18; // [rsp+88h] [rbp-20h]
long long v19; // [rsp+90h] [rbp-18h]
__int128 *v20; // [rsp+98h] [rbp-10h]
long long v21; // [rsp+A0h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v14 = 0;
v15 = &v14;
v16 = 1LL;
std::allocator<llama_example>::allocator();
std::set<llama_example>::set(a1, (_DWORD)v15, v16, (unsigned int)&v13, (unsigned int)&v12, v5);
std::allocator<llama_example>::~allocator(&v12);
*(_OWORD *)(a1 + 80) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
std::set<llama_example>::set();
v11 = *v20;
std::allocator<char const*>::allocator();
std::vector<char const*>::vector(a1 + 96, v11, DWORD2(v11), (unsigned int)&v10, v6, v7, v9);
std::allocator<char const*>::~allocator(&v10);
*(_QWORD *)(a1 + 120) = v19;
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
std::string::basic_string(a1 + 144, v18);
result = a1;
*(_BYTE *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 184) = 0LL;
*(_QWORD *)(a1 + 192) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
*(_QWORD *)(a1 + 208) = v17;
return result;
}
| common_arg:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x80],R8
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x6c],0x0
LEA RAX,[RSP + 0x6c]
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],0x1
LEA RDI,[RSP + 0x6a]
MOV qword ptr [RSP + 0x30],RDI
CALL 0x0019d770
MOV RDI,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
LAB_0018d67f:
LEA RCX,[RSP + 0x6b]
CALL 0x0019d780
JMP 0x0018d68b
LAB_0018d68b:
LEA RDI,[RSP + 0x6a]
CALL 0x0019d860
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,RAX
ADD RDI,0x30
MOV qword ptr [RSP + 0x8],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x50],XMM0
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
CALL 0x0019d870
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x60
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x98]
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0019d880
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
LAB_0018d6fb:
CALL 0x0019d890
JMP 0x0018d702
LAB_0018d702:
LEA RDI,[RSP + 0x3f]
CALL 0x0019d920
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RDI + 0x78],RAX
MOV qword ptr [RDI + 0x80],0x0
MOV qword ptr [RDI + 0x88],0x0
ADD RDI,0x90
MOV RSI,qword ptr [RSP + 0x88]
LAB_0018d742:
CALL 0x0015d1f0
LAB_0018d747:
JMP 0x0018d749
LAB_0018d749:
MOV RAX,qword ptr [RSP + 0x20]
MOV byte ptr [RAX + 0xb0],0x0
MOV qword ptr [RAX + 0xb8],0x0
MOV qword ptr [RAX + 0xc0],0x0
MOV qword ptr [RAX + 0xc8],0x0
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RAX + 0xd0],RCX
ADD RSP,0xa8
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, char const*,
std::__cxx11::string const&, void (*)(common_params&, int)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,char *param_2,string *param_3,
_func_void_common_params_ptr_int *param_4)
{
allocator<char_const*> local_69;
int8 local_68;
int8 uStack_60;
allocator<llama_example> local_3e;
int1 local_3d;
int4 local_3c;
int4 *local_38;
int8 local_30;
_func_void_common_params_ptr_int *local_28;
string *local_20;
char *local_18;
int8 *local_10;
common_arg *local_8;
local_3c = 0;
local_38 = &local_3c;
local_30 = 1;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = (int8 *)param_1;
local_8 = this;
std::allocator<llama_example>::allocator(&local_3e);
/* try { // try from 0018d67f to 0018d688 has its CatchHandler @ 0018d78d */
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,local_38,local_30,&local_3d,&local_3e);
std::allocator<llama_example>::~allocator(&local_3e);
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
((set<llama_example,std::less<llama_example>,std::allocator<llama_example>> *)
(this + 0x30));
local_68 = *local_10;
uStack_60 = local_10[1];
std::allocator<char_const*>::allocator(&local_69);
/* try { // try from 0018d6fb to 0018d6ff has its CatchHandler @ 0018d7a7 */
std::vector<char_const*,std::allocator<char_const*>>::vector
(this + 0x60,local_68,uStack_60,&local_69);
std::allocator<char_const*>::~allocator(&local_69);
*(char **)(this + 0x78) = local_18;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
/* try { // try from 0018d742 to 0018d746 has its CatchHandler @ 0018d7c1 */
std::__cxx11::string::string((string *)(this + 0x90),local_20);
this[0xb0] = (common_arg)0x0;
*(int8 *)(this + 0xb8) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 200) = 0;
*(_func_void_common_params_ptr_int **)(this + 0xd0) = local_28;
return;
}
| |
35,247 | js_typed_array_sort | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_sort(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSObject *p;
int len;
size_t elt_size;
struct TA_sort_context tsc;
int (*cmpfun)(const void *a, const void *b, void *opaque);
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return JS_ThrowTypeErrorArrayBufferOOB(ctx);
tsc.ctx = ctx;
tsc.exception = 0;
tsc.arr = this_val;
tsc.cmp = argv[0];
if (!JS_IsUndefined(tsc.cmp) && check_function(ctx, tsc.cmp))
return JS_EXCEPTION;
len = p->u.array.count;
if (len > 1) {
switch (p->class_id) {
case JS_CLASS_INT8_ARRAY:
tsc.getfun = js_TA_get_int8;
cmpfun = js_TA_cmp_int8;
break;
case JS_CLASS_UINT8C_ARRAY:
case JS_CLASS_UINT8_ARRAY:
tsc.getfun = js_TA_get_uint8;
cmpfun = js_TA_cmp_uint8;
break;
case JS_CLASS_INT16_ARRAY:
tsc.getfun = js_TA_get_int16;
cmpfun = js_TA_cmp_int16;
break;
case JS_CLASS_UINT16_ARRAY:
tsc.getfun = js_TA_get_uint16;
cmpfun = js_TA_cmp_uint16;
break;
case JS_CLASS_INT32_ARRAY:
tsc.getfun = js_TA_get_int32;
cmpfun = js_TA_cmp_int32;
break;
case JS_CLASS_UINT32_ARRAY:
tsc.getfun = js_TA_get_uint32;
cmpfun = js_TA_cmp_uint32;
break;
case JS_CLASS_BIG_INT64_ARRAY:
tsc.getfun = js_TA_get_int64;
cmpfun = js_TA_cmp_int64;
break;
case JS_CLASS_BIG_UINT64_ARRAY:
tsc.getfun = js_TA_get_uint64;
cmpfun = js_TA_cmp_uint64;
break;
case JS_CLASS_FLOAT16_ARRAY:
tsc.getfun = js_TA_get_float16;
cmpfun = js_TA_cmp_float16;
break;
case JS_CLASS_FLOAT32_ARRAY:
tsc.getfun = js_TA_get_float32;
cmpfun = js_TA_cmp_float32;
break;
case JS_CLASS_FLOAT64_ARRAY:
tsc.getfun = js_TA_get_float64;
cmpfun = js_TA_cmp_float64;
break;
default:
abort();
}
elt_size = 1 << typed_array_size_log2(p->class_id);
if (!JS_IsUndefined(tsc.cmp)) {
uint32_t *array_idx;
void *array_tmp;
size_t i, j;
/* XXX: a stable sort would use less memory */
array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
if (!array_idx)
return JS_EXCEPTION;
for(i = 0; i < len; i++)
array_idx[i] = i;
tsc.elt_size = elt_size;
rqsort(array_idx, len, sizeof(array_idx[0]),
js_TA_cmp_generic, &tsc);
if (tsc.exception)
goto fail;
// per spec: typed array can be detached mid-iteration
if (typed_array_is_oob(p))
goto done;
len = min_int(len, p->u.array.count);
if (len == 0)
goto done;
array_tmp = js_malloc(ctx, len * elt_size);
if (!array_tmp) {
fail:
js_free(ctx, array_idx);
return JS_EXCEPTION;
}
memcpy(array_tmp, p->u.array.u.ptr, len * elt_size);
switch(elt_size) {
case 1:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint8_ptr[i] = ((uint8_t *)array_tmp)[j];
}
break;
case 2:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint16_ptr[i] = ((uint16_t *)array_tmp)[j];
}
break;
case 4:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint32_ptr[i] = ((uint32_t *)array_tmp)[j];
}
break;
case 8:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint64_ptr[i] = ((uint64_t *)array_tmp)[j];
}
break;
default:
abort();
}
js_free(ctx, array_tmp);
done:
js_free(ctx, array_idx);
} else {
rqsort(p->u.array.u.ptr, len, elt_size, cmpfun, &tsc);
if (tsc.exception)
return JS_EXCEPTION;
}
}
return js_dup(this_val);
} | O1 | c | js_typed_array_sort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, 0x28(%rsp)
cmpl $-0x1, %ebx
jne 0x81cd2
movq 0x28(%rsp), %r12
movzwl 0x6(%r12), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x81ce6
leaq 0x20738(%rip), %rsi # 0xa2411
xorl %r12d, %r12d
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %r13d
testq %r12, %r12
je 0x81de0
movq %r12, %rdi
callq 0x396c4
testl %eax, %eax
je 0x81d1a
leaq 0x2071a(%rip), %rsi # 0xa2422
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x81de3
movq %r15, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movdqu (%rbp), %xmm0
movdqu %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rdx
cmpl $0x3, %edx
je 0x81d5b
movq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x415b1
testl %eax, %eax
jne 0x81de0
movslq 0x40(%r12), %rbp
cmpq $0x2, %rbp
jl 0x81f58
movzwl 0x6(%r12), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jae 0x820d0
movzwl %ax, %eax
shll $0x3, %eax
leaq 0x4ada6(%rip), %rcx # 0xccb30
movq (%rax,%rcx), %rcx
movq %rcx, 0x58(%rsp)
movzwl 0x6(%r12), %ecx
leaq 0x1bb3f(%rip), %rdx # 0x9d8df
movb -0x15(%rcx,%rdx), %cl
leaq 0x4ade5(%rip), %rdx # 0xccb90
movl $0x1, %esi
shll %cl, %esi
movq (%rax,%rdx), %rcx
movslq %esi, %rdx
cmpl $0x3, 0x50(%rsp)
jne 0x81dfd
movq 0x38(%r12), %rdi
leaq 0x28(%rsp), %r15
movq %rbp, %rsi
movq %r15, %r8
callq 0x1c031
cmpl $0x0, 0x8(%r15)
je 0x81f58
xorl %r14d, %r14d
xorl %eax, %eax
orq %rax, %r14
movq %r14, %rax
movq %r13, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq (,%rbp,4), %rsi
movq %r15, %rdi
callq 0xede6
testq %rax, %rax
je 0x81de0
cmpq $0x1, %rbp
movq %rbp, %rcx
adcq $0x0, %rcx
leal 0x1(%rcx), %esi
andl $-0x2, %esi
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x19a5e(%rip), %xmm1 # 0x9b8a0
xorl %ecx, %ecx
movdqa 0x19a64(%rip), %xmm2 # 0x9b8b0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x19a74(%rip), %xmm4 # 0x9b8d0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x81e90
movl %ecx, (%rax,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x81ea5
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rax,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rsi
jne 0x81e5c
leaq 0x28(%rsp), %r8
movq 0x18(%rsp), %rcx
movl %ecx, 0x38(%r8)
leaq 0x1113(%rip), %rcx # 0x82fda
movl $0x4, %edx
movq %rax, %rdi
movq %rax, (%rsp)
movq %rbp, %rsi
callq 0x1c031
leaq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x81f16
movq 0x18(%r15), %rbx
decq 0x28(%rbx)
movq (%rsp), %r14
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
jmp 0x81de0
movq %r12, %rdi
callq 0x396c4
testl %eax, %eax
jne 0x81f2b
movl 0x40(%r12), %eax
testl %eax, %eax
jne 0x81f81
movq 0x18(%r15), %r15
decq 0x28(%r15)
movq (%rsp), %r12
movq %r12, %rdi
callq *0x20(%r15)
movq 0x30(%r15), %rcx
movq 0x40(%r15), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r15)
movq %r12, %rsi
callq *0x10(%r15)
movq %r14, 0x20(%rsp)
cmpl $-0x9, %ebx
jb 0x81f69
movq 0x20(%rsp), %rax
incl (%rax)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r14, %rax
movl %r14d, %r14d
movq %rbx, %r13
jmp 0x81de5
cmpl %eax, %ebp
cmovll %ebp, %eax
movslq %eax, %rbp
movq 0x10(%rsp), %rsi
imulq %rbp, %rsi
movq %r15, %rdi
movq %rsi, 0x10(%rsp)
callq 0xede6
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x81ee6
movq 0x38(%r12), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xe5b0
movq 0x18(%rsp), %rax
decl %eax
cmpl $0x7, %eax
ja 0x820d0
movq %rax, %rcx
leaq 0x1b7d1(%rip), %rax # 0x9d7ac
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %eax, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %r13
movl (%rsi,%rax,4), %ecx
movb (%r13,%rcx), %cl
movq 0x38(%r12), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %rbp
jne 0x81ff7
jmp 0x8209c
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %eax, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %r13
movl (%rsi,%rax,4), %ecx
movl (%r13,%rcx,4), %ecx
movq 0x38(%r12), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x82027
jmp 0x8209c
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %eax, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %r13
movl (%rsi,%rax,4), %ecx
movq (%r13,%rcx,8), %rcx
movq 0x38(%r12), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %rbp
jne 0x82054
jmp 0x8209c
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %eax, %eax
movq (%rsp), %rsi
movq 0x8(%rsp), %r13
movl (%rsi,%rax,4), %ecx
movzwl (%r13,%rcx,2), %ecx
movq 0x38(%r12), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
cmpq %rax, %rbp
jne 0x82082
movq 0x18(%r15), %r12
decq 0x28(%r12)
movq %r13, %rdi
callq *0x20(%r12)
movq 0x30(%r12), %rcx
movq 0x40(%r12), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r12)
movq %r13, %rsi
callq *0x10(%r12)
jmp 0x81f2b
callq 0xe090
| js_typed_array_sort:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbp, r8
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov [rsp+98h+var_70], rsi
cmp ebx, 0FFFFFFFFh
jnz short loc_81CD2
mov r12, [rsp+98h+var_70]
movzx eax, word ptr [r12+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_81CE6
loc_81CD2:
lea rsi, aNotATypedarray; "not a TypedArray"
xor r12d, r12d
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
loc_81CE6:
mov r13d, 6
test r12, r12
jz loc_81DE0
mov rdi, r12
call typed_array_is_oob
test eax, eax
jz short loc_81D1A
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
jmp loc_81DE3
loc_81D1A:
mov [rsp+98h+var_70], r15
mov [rsp+98h+var_68], 0
mov [rsp+98h+var_60], r14
mov [rsp+98h+var_58], rbx
movdqu xmm0, xmmword ptr [rbp+0]
movdqu [rsp+98h+var_50], xmm0
mov rdx, qword ptr [rsp+98h+var_50+8]
cmp edx, 3
jz short loc_81D5B
mov rsi, qword ptr [rsp+98h+var_50]
mov rdi, r15
call check_function
test eax, eax
jnz loc_81DE0
loc_81D5B:
movsxd rbp, dword ptr [r12+40h]
cmp rbp, 2
jl loc_81F58
movzx eax, word ptr [r12+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jnb def_81FE2; jumptable 0000000000081FE2 default case, cases 3,5-7
movzx eax, ax
shl eax, 3
lea rcx, off_CCB30
mov rcx, [rax+rcx]
mov [rsp+98h+var_40], rcx
movzx ecx, word ptr [r12+6]
lea rdx, typed_array_size_log2
mov cl, [rcx+rdx-15h]
lea rdx, off_CCB90
mov esi, 1
shl esi, cl
mov rcx, [rax+rdx]
movsxd rdx, esi
cmp dword ptr [rsp+98h+var_50+8], 3
jnz short loc_81DFD
mov rdi, [r12+38h]
lea r15, [rsp+98h+var_70]
mov rsi, rbp
mov r8, r15
call rqsort
cmp dword ptr [r15+8], 0
jz loc_81F58
loc_81DE0:
xor r14d, r14d
loc_81DE3:
xor eax, eax
loc_81DE5:
or r14, rax
mov rax, r14
mov rdx, r13
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_81DFD:
mov [rsp+98h+var_88], rdx
mov [rsp+98h+var_80], rsi
lea rsi, ds:0[rbp*4]
mov rdi, r15
call js_malloc
test rax, rax
jz short loc_81DE0
cmp rbp, 1
mov rcx, rbp
adc rcx, 0
lea esi, [rcx+1]
and esi, 0FFFFFFFEh
dec rcx
movq xmm0, rcx
pshufd xmm0, xmm0, 44h ; 'D'
movdqa xmm1, cs:xmmword_9B8A0
xor ecx, ecx
movdqa xmm2, cs:xmmword_9B8B0
pxor xmm0, xmm2
pcmpeqd xmm3, xmm3
movdqa xmm4, cs:xmmword_9B8D0
loc_81E5C:
movdqa xmm5, xmm1
pxor xmm5, xmm2
movdqa xmm6, xmm5
pcmpgtd xmm6, xmm0
pcmpeqd xmm5, xmm0
pshufd xmm7, xmm5, 0F5h
pand xmm7, xmm6
pshufd xmm5, xmm6, 0F5h
por xmm5, xmm7
movd edx, xmm5
not edx
test dl, 1
jz short loc_81E90
mov [rax+rcx*4], ecx
loc_81E90:
pxor xmm5, xmm3
pextrw edx, xmm5, 4
test dl, 1
jz short loc_81EA5
lea edx, [rcx+1]
mov [rax+rcx*4+4], edx
loc_81EA5:
add rcx, 2
paddq xmm1, xmm4
cmp rsi, rcx
jnz short loc_81E5C
lea r8, [rsp+98h+var_70]
mov rcx, [rsp+98h+var_80]
mov [r8+38h], ecx
lea rcx, js_TA_cmp_generic
mov edx, 4
mov rdi, rax
mov [rsp+98h+var_98], rax
mov rsi, rbp
call rqsort
lea rax, [rsp+98h+var_70]
cmp dword ptr [rax+8], 0
jz short loc_81F16
loc_81EE6:
mov rbx, [r15+18h]
dec qword ptr [rbx+28h]
mov r14, [rsp+98h+var_98]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
jmp loc_81DE0
loc_81F16:
mov rdi, r12
call typed_array_is_oob
test eax, eax
jnz short loc_81F2B
mov eax, [r12+40h]
test eax, eax
jnz short loc_81F81
loc_81F2B:
mov r15, [r15+18h]
dec qword ptr [r15+28h]
mov r12, [rsp+98h+var_98]
mov rdi, r12
call qword ptr [r15+20h]
mov rcx, [r15+30h]
mov rdi, [r15+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r15+30h], rcx
mov rsi, r12
call qword ptr [r15+10h]
loc_81F58:
mov [rsp+98h+var_78], r14
cmp ebx, 0FFFFFFF7h
jb short loc_81F69
mov rax, [rsp+98h+var_78]
inc dword ptr [rax]
loc_81F69:
mov rax, 0FFFFFFFF00000000h
and rax, r14
mov r14d, r14d
mov r13, rbx
jmp loc_81DE5
loc_81F81:
cmp ebp, eax
cmovl eax, ebp
movsxd rbp, eax
mov rsi, [rsp+98h+var_88]
imul rsi, rbp
mov rdi, r15
mov [rsp+98h+var_88], rsi
call js_malloc
mov [rsp+98h+var_90], rax
test rax, rax
jz loc_81EE6
mov rsi, [r12+38h]
mov rdi, [rsp+98h+var_90]
mov rdx, [rsp+98h+var_88]
call _memcpy
mov rax, [rsp+98h+var_80]
dec eax; switch 8 cases
cmp eax, 7
ja def_81FE2; jumptable 0000000000081FE2 default case, cases 3,5-7
mov rcx, rax
lea rax, jpt_81FE2
movsxd rcx, ds:(jpt_81FE2 - 9D7ACh)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_81FE4:
cmp rbp, 1; jumptable 0000000000081FE2 case 1
adc rbp, 0
xor eax, eax
mov rsi, [rsp+98h+var_98]
mov r13, [rsp+98h+var_90]
loc_81FF7:
mov ecx, [rsi+rax*4]
mov cl, [r13+rcx+0]
mov rdx, [r12+38h]
mov [rdx+rax], cl
inc rax
cmp rbp, rax
jnz short loc_81FF7
jmp loc_8209C
loc_82014:
cmp rbp, 1; jumptable 0000000000081FE2 case 4
adc rbp, 0
xor eax, eax
mov rsi, [rsp+98h+var_98]
mov r13, [rsp+98h+var_90]
loc_82027:
mov ecx, [rsi+rax*4]
mov ecx, [r13+rcx*4+0]
mov rdx, [r12+38h]
mov [rdx+rax*4], ecx
inc rax
cmp rbp, rax
jnz short loc_82027
jmp short loc_8209C
loc_82041:
cmp rbp, 1; jumptable 0000000000081FE2 case 8
adc rbp, 0
xor eax, eax
mov rsi, [rsp+98h+var_98]
mov r13, [rsp+98h+var_90]
loc_82054:
mov ecx, [rsi+rax*4]
mov rcx, [r13+rcx*8+0]
mov rdx, [r12+38h]
mov [rdx+rax*8], rcx
inc rax
cmp rbp, rax
jnz short loc_82054
jmp short loc_8209C
loc_8206F:
cmp rbp, 1; jumptable 0000000000081FE2 case 2
adc rbp, 0
xor eax, eax
mov rsi, [rsp+98h+var_98]
mov r13, [rsp+98h+var_90]
loc_82082:
mov ecx, [rsi+rax*4]
movzx ecx, word ptr [r13+rcx*2+0]
mov rdx, [r12+38h]
mov [rdx+rax*2], cx
inc rax
cmp rbp, rax
jnz short loc_82082
loc_8209C:
mov r12, [r15+18h]
dec qword ptr [r12+28h]
mov rdi, r13
call qword ptr [r12+20h]
mov rcx, [r12+30h]
mov rdi, [r12+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r12+30h], rcx
mov rsi, r13
call qword ptr [r12+10h]
jmp loc_81F2B
def_81FE2:
call _abort; jumptable 0000000000081FE2 default case, cases 3,5-7
| unsigned long long js_typed_array_sort(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
const __m128i *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned long long v16; // r14
long long v18; // r12
const char *v19; // rdi
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
__m128 v26; // xmm0
signed long long v27; // rbp
long long v28; // rax
int v29; // esi
unsigned long long v30; // rax
long long v32; // rax
signed long long v33; // rcx
long long v34; // rsi
__m128i v35; // xmm0
__m128i si128; // xmm1
long long v37; // rcx
__m128i v38; // xmm2
__m128i v39; // xmm0
__m128i v40; // xmm4
__m128i v41; // xmm5
__m128i v42; // xmm6
__m128i v43; // xmm5
long long v44; // rbx
long long v45; // rax
long long v46; // rdi
int v47; // eax
long long v48; // r15
long long v49; // rax
long long v50; // rdi
long long v51; // rbp
long long v52; // rbp
long long v53; // rax
long long v54; // r13
long long v55; // rbp
long long v56; // rax
long long v57; // rbp
long long v58; // rax
long long v59; // rbp
long long v60; // rax
long long v61; // r12
long long v62; // rax
long long v63; // rdi
char v64; // [rsp+0h] [rbp-98h]
long long v65; // [rsp+0h] [rbp-98h]
long long v66; // [rsp+8h] [rbp-90h]
long long v67; // [rsp+10h] [rbp-88h]
long long v68; // [rsp+10h] [rbp-88h]
int v69; // [rsp+18h] [rbp-80h]
long long v70; // [rsp+28h] [rbp-70h] BYREF
int v71; // [rsp+30h] [rbp-68h]
_DWORD *v72; // [rsp+38h] [rbp-60h]
long long v73; // [rsp+40h] [rbp-58h]
__m128 v74; // [rsp+48h] [rbp-50h]
long long ( *v75)(); // [rsp+58h] [rbp-40h]
int v76; // [rsp+60h] [rbp-38h]
v16 = (unsigned long long)a2;
v70 = (long long)a2;
if ( (_DWORD)a3 != -1 || (v18 = v70, (unsigned __int16)(*(_WORD *)(v70 + 6) - 21) >= 0xCu) )
{
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a TypedArray",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v64);
}
if ( !v18 )
goto LABEL_13;
v19 = (const char *)v18;
if ( typed_array_is_oob(v18) )
{
v16 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached or resized",
v20,
v21,
v22,
v23,
a7,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v64);
LABEL_14:
v30 = 0LL;
return v30 | v16;
}
v70 = a1;
v71 = 0;
v72 = a2;
v73 = a3;
v26 = (__m128)_mm_loadu_si128(a5);
v74 = v26;
if ( v26.m128_i32[2] != 3 )
{
v19 = (const char *)a1;
if ( (unsigned int)check_function(
a1,
v74.m128_i64[0],
v26.m128_i32[2],
v26,
a8,
a9,
a10,
*(double *)v24.m128_u64,
*(double *)v25.m128_u64,
a13,
a14) )
{
LABEL_13:
v16 = 0LL;
goto LABEL_14;
}
}
v27 = *(int *)(v18 + 64);
if ( v27 >= 2 )
{
if ( (unsigned __int16)(*(_WORD *)(v18 + 6) - 21) >= 0xCu )
LABEL_47:
abort(v19);
v28 = (unsigned __int16)(*(_WORD *)(v18 + 6) - 21);
v75 = off_CCB30[v28];
v29 = 1 << typed_array_size_log2[*(unsigned __int16 *)(v18 + 6) - 21];
if ( v74.m128_i32[2] != 3 )
{
v67 = v29;
v69 = 1 << typed_array_size_log2[*(unsigned __int16 *)(v18 + 6) - 21];
v32 = js_malloc(a1, 4 * v27);
if ( !v32 )
goto LABEL_13;
v33 = (v27 == 0) + v27;
v34 = ((_DWORD)v33 + 1) & 0xFFFFFFFE;
v35 = _mm_shuffle_epi32((__m128i)(unsigned long long)(v33 - 1), 68);
si128 = _mm_load_si128((const __m128i *)&xmmword_9B8A0);
v37 = 0LL;
v38 = _mm_load_si128((const __m128i *)&xmmword_9B8B0);
v39 = _mm_xor_si128(v35, v38);
v40 = _mm_load_si128((const __m128i *)&xmmword_9B8D0);
do
{
v41 = _mm_xor_si128(si128, v38);
v42 = _mm_cmpgt_epi32(v41, v39);
v43 = _mm_or_si128(
_mm_shuffle_epi32(v42, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v41, v39), 245), v42));
if ( (~_mm_cvtsi128_si32(v43) & 1) != 0 )
*(_DWORD *)(v32 + 4 * v37) = v37;
if ( (_mm_extract_epi16(_mm_xor_si128(v43, (__m128i)-1LL), 4) & 1) != 0 )
*(_DWORD *)(v32 + 4 * v37 + 4) = v37 + 1;
v37 += 2LL;
si128 = _mm_add_epi64(si128, v40);
}
while ( v34 != v37 );
v76 = v69;
v65 = v32;
rqsort(
v32,
v27,
4LL,
(long long ( *)(unsigned long long, unsigned long long, long long))js_TA_cmp_generic,
(long long)&v70);
if ( !v71 )
{
if ( typed_array_is_oob(v18) || (v47 = *(_DWORD *)(v18 + 64)) == 0 )
{
LABEL_27:
v48 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v48 + 40);
v49 = (*(long long ( **)(long long, double, double, double, double))(v48 + 32))(
v65,
*(double *)v39.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v38.m128i_i64,
NAN);
v50 = *(_QWORD *)(v48 + 64);
*(_QWORD *)(v48 + 48) = *(_QWORD *)(v48 + 48) - v49 - 8;
(*(void ( **)(long long, long long))(v48 + 16))(v50, v65);
goto LABEL_28;
}
if ( (int)v27 < v47 )
v47 = v27;
v51 = v47;
v68 = v47 * v67;
v66 = js_malloc(a1, v68);
if ( v66 )
{
v19 = (const char *)v66;
memcpy(v66, *(_QWORD *)(v18 + 56), v68);
switch ( v69 )
{
case 1:
v52 = (v51 == 0) + v51;
v53 = 0LL;
v54 = v66;
do
{
*(_BYTE *)(*(_QWORD *)(v18 + 56) + v53) = *(_BYTE *)(v66 + *(unsigned int *)(v65 + 4 * v53));
++v53;
}
while ( v52 != v53 );
goto LABEL_46;
case 2:
v59 = (v51 == 0) + v51;
v60 = 0LL;
v54 = v66;
do
{
*(_WORD *)(*(_QWORD *)(v18 + 56) + 2 * v60) = *(_WORD *)(v66 + 2LL * *(unsigned int *)(v65 + 4 * v60));
++v60;
}
while ( v59 != v60 );
goto LABEL_46;
case 4:
v55 = (v51 == 0) + v51;
v56 = 0LL;
v54 = v66;
do
{
*(_DWORD *)(*(_QWORD *)(v18 + 56) + 4 * v56) = *(_DWORD *)(v66 + 4LL * *(unsigned int *)(v65 + 4 * v56));
++v56;
}
while ( v55 != v56 );
goto LABEL_46;
case 8:
v57 = (v51 == 0) + v51;
v58 = 0LL;
v54 = v66;
do
{
*(_QWORD *)(*(_QWORD *)(v18 + 56) + 8 * v58) = *(_QWORD *)(v66 + 8LL * *(unsigned int *)(v65 + 4 * v58));
++v58;
}
while ( v57 != v58 );
LABEL_46:
v61 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v61 + 40);
v62 = (*(long long ( **)(long long, double, double, double, double))(v61 + 32))(
v54,
*(double *)v39.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v38.m128i_i64,
NAN);
v63 = *(_QWORD *)(v61 + 64);
*(_QWORD *)(v61 + 48) = *(_QWORD *)(v61 + 48) - v62 - 8;
(*(void ( **)(long long, long long))(v61 + 16))(v63, v54);
goto LABEL_27;
default:
goto LABEL_47;
}
}
}
v44 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v44 + 40);
v45 = (*(long long ( **)(long long, double, double, double, double))(v44 + 32))(
v65,
*(double *)v39.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v38.m128i_i64,
NAN);
v46 = *(_QWORD *)(v44 + 64);
*(_QWORD *)(v44 + 48) = *(_QWORD *)(v44 + 48) - v45 - 8;
(*(void ( **)(long long, long long))(v44 + 16))(v46, v65);
goto LABEL_13;
}
rqsort(
*(_QWORD *)(v18 + 56),
v27,
v29,
(long long ( *)(unsigned long long, unsigned long long, long long))off_CCB90[v28],
(long long)&v70);
if ( v71 )
goto LABEL_13;
}
LABEL_28:
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*(_DWORD *)v16;
v30 = v16 & 0xFFFFFFFF00000000LL;
v16 = (unsigned int)v16;
return v30 | v16;
}
| |||
35,248 | js_typed_array_sort | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_sort(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSObject *p;
int len;
size_t elt_size;
struct TA_sort_context tsc;
int (*cmpfun)(const void *a, const void *b, void *opaque);
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return JS_ThrowTypeErrorArrayBufferOOB(ctx);
tsc.ctx = ctx;
tsc.exception = 0;
tsc.arr = this_val;
tsc.cmp = argv[0];
if (!JS_IsUndefined(tsc.cmp) && check_function(ctx, tsc.cmp))
return JS_EXCEPTION;
len = p->u.array.count;
if (len > 1) {
switch (p->class_id) {
case JS_CLASS_INT8_ARRAY:
tsc.getfun = js_TA_get_int8;
cmpfun = js_TA_cmp_int8;
break;
case JS_CLASS_UINT8C_ARRAY:
case JS_CLASS_UINT8_ARRAY:
tsc.getfun = js_TA_get_uint8;
cmpfun = js_TA_cmp_uint8;
break;
case JS_CLASS_INT16_ARRAY:
tsc.getfun = js_TA_get_int16;
cmpfun = js_TA_cmp_int16;
break;
case JS_CLASS_UINT16_ARRAY:
tsc.getfun = js_TA_get_uint16;
cmpfun = js_TA_cmp_uint16;
break;
case JS_CLASS_INT32_ARRAY:
tsc.getfun = js_TA_get_int32;
cmpfun = js_TA_cmp_int32;
break;
case JS_CLASS_UINT32_ARRAY:
tsc.getfun = js_TA_get_uint32;
cmpfun = js_TA_cmp_uint32;
break;
case JS_CLASS_BIG_INT64_ARRAY:
tsc.getfun = js_TA_get_int64;
cmpfun = js_TA_cmp_int64;
break;
case JS_CLASS_BIG_UINT64_ARRAY:
tsc.getfun = js_TA_get_uint64;
cmpfun = js_TA_cmp_uint64;
break;
case JS_CLASS_FLOAT16_ARRAY:
tsc.getfun = js_TA_get_float16;
cmpfun = js_TA_cmp_float16;
break;
case JS_CLASS_FLOAT32_ARRAY:
tsc.getfun = js_TA_get_float32;
cmpfun = js_TA_cmp_float32;
break;
case JS_CLASS_FLOAT64_ARRAY:
tsc.getfun = js_TA_get_float64;
cmpfun = js_TA_cmp_float64;
break;
default:
abort();
}
elt_size = 1 << typed_array_size_log2(p->class_id);
if (!JS_IsUndefined(tsc.cmp)) {
uint32_t *array_idx;
void *array_tmp;
size_t i, j;
/* XXX: a stable sort would use less memory */
array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
if (!array_idx)
return JS_EXCEPTION;
for(i = 0; i < len; i++)
array_idx[i] = i;
tsc.elt_size = elt_size;
rqsort(array_idx, len, sizeof(array_idx[0]),
js_TA_cmp_generic, &tsc);
if (tsc.exception)
goto fail;
// per spec: typed array can be detached mid-iteration
if (typed_array_is_oob(p))
goto done;
len = min_int(len, p->u.array.count);
if (len == 0)
goto done;
array_tmp = js_malloc(ctx, len * elt_size);
if (!array_tmp) {
fail:
js_free(ctx, array_idx);
return JS_EXCEPTION;
}
memcpy(array_tmp, p->u.array.u.ptr, len * elt_size);
switch(elt_size) {
case 1:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint8_ptr[i] = ((uint8_t *)array_tmp)[j];
}
break;
case 2:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint16_ptr[i] = ((uint16_t *)array_tmp)[j];
}
break;
case 4:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint32_ptr[i] = ((uint32_t *)array_tmp)[j];
}
break;
case 8:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint64_ptr[i] = ((uint64_t *)array_tmp)[j];
}
break;
default:
abort();
}
js_free(ctx, array_tmp);
done:
js_free(ctx, array_idx);
} else {
rqsort(p->u.array.u.ptr, len, elt_size, cmpfun, &tsc);
if (tsc.exception)
return JS_EXCEPTION;
}
}
return js_dup(this_val);
} | O2 | c | js_typed_array_sort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3280b
pushq $0x6
popq %r13
testq %rax, %rax
je 0x6d208
movq %rax, %r12
movq %rax, %rdi
callq 0x32836
testl %eax, %eax
je 0x6d221
movq %r15, %rdi
callq 0x3289b
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r13, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x28(%rsp)
andl $0x0, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movups (%rbp), %xmm0
movups %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rdx
movl %edx, %edi
cmpq $0x3, %rdi
je 0x6d262
movq 0x48(%rsp), %rsi
movq %rdi, %rbp
movq %r15, %rdi
callq 0x3949a
movq %rbp, %rdi
testl %eax, %eax
jne 0x6d208
movslq 0x40(%r12), %rbp
cmpq $0x2, %rbp
jl 0x6d372
movzwl 0x6(%r12), %eax
leal -0x15(%rax), %ecx
cmpw $0xc, %cx
jae 0x6d4a4
movzwl %cx, %edx
leaq 0x175f1(%rip), %rcx # 0x8487f
movb -0x15(%rax,%rcx), %cl
pushq $0x1
popq %rsi
shll %cl, %esi
shll $0x3, %edx
leaq 0x4d88f(%rip), %rax # 0xbab30
movq (%rdx,%rax), %rax
leaq 0x4d8e4(%rip), %rcx # 0xbab90
movq (%rdx,%rcx), %rcx
movq %rax, 0x58(%rsp)
movslq %esi, %rdx
cmpl $0x3, %edi
jne 0x6d2e2
movq 0x38(%r12), %rdi
leaq 0x28(%rsp), %r15
movq %rbp, %rsi
movq %r15, %r8
callq 0x1683c
cmpl $0x0, 0x8(%r15)
jne 0x6d208
jmp 0x6d372
movq %rdx, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
leaq (,%rbp,4), %rsi
movq %r15, %rdi
callq 0x17214
testq %rax, %rax
je 0x6d208
movq %rax, %rdi
xorl %eax, %eax
movq 0x20(%rsp), %rcx
cmpq %rax, %rbp
je 0x6d31c
movl %eax, (%rdi,%rax,4)
incq %rax
jmp 0x6d30f
leaq 0x28(%rsp), %r8
movl %ecx, 0x38(%r8)
leaq 0xc0c(%rip), %rcx # 0x6df38
pushq $0x4
popq %rdx
movq %rdi, 0x8(%rsp)
movq %rbp, %rsi
callq 0x1683c
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6d359
movq %r15, %rdi
callq 0x1726e
jmp 0x6d208
movq %r12, %rdi
callq 0x32836
testl %eax, %eax
je 0x6d392
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1726e
cmpl $-0x9, %ebx
jb 0x6d37a
incl (%r14)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r14, %rcx
movl %r14d, %eax
movq %rbx, %r13
jmp 0x6d20c
movl 0x40(%r12), %eax
testl %eax, %eax
je 0x6d365
cmpl %eax, %ebp
cmovll %ebp, %eax
movslq %eax, %rbp
movq 0x18(%rsp), %rsi
imulq %rbp, %rsi
movq %r15, %rdi
movq %rsi, 0x18(%rsp)
callq 0x17214
testq %rax, %rax
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
je 0x6d34c
movq 0x38(%r12), %rsi
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movq 0x18(%rsp), %rdx
movq %rcx, %r13
callq 0xe5c0
decl %r13d
cmpl $0x7, %r13d
ja 0x6d4a4
leaq 0x1734e(%rip), %rax # 0x84744
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %eax, %eax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
cmpq %rax, %rbp
je 0x6d497
movl (%rdi,%rax,4), %ecx
movb (%rsi,%rcx), %cl
movq 0x38(%r12), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x6d40b
xorl %eax, %eax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
cmpq %rax, %rbp
je 0x6d497
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rcx,4), %ecx
movq 0x38(%r12), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
jmp 0x6d433
xorl %eax, %eax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
cmpq %rax, %rbp
je 0x6d497
movl (%rdi,%rax,4), %ecx
movq (%rsi,%rcx,8), %rcx
movq 0x38(%r12), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x6d457
xorl %eax, %eax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
cmpq %rax, %rbp
je 0x6d497
movl (%rdi,%rax,4), %ecx
movzwl (%rsi,%rcx,2), %ecx
movq 0x38(%r12), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
jmp 0x6d47d
movq %r15, %rdi
callq 0x1726e
jmp 0x6d365
callq 0xe090
| js_typed_array_sort:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbp, r8
mov rbx, rdx
mov r14, rsi
mov r15, rdi
call get_typed_array
push 6
pop r13
test rax, rax
jz short loc_6D208
mov r12, rax
mov rdi, rax
call typed_array_is_oob
test eax, eax
jz short loc_6D221
mov rdi, r15
call JS_ThrowTypeErrorArrayBufferOOB
loc_6D208:
xor eax, eax
xor ecx, ecx
loc_6D20C:
or rax, rcx
mov rdx, r13
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6D221:
mov [rsp+98h+var_70], r15
and [rsp+98h+var_68], 0
mov [rsp+98h+var_60], r14
mov [rsp+98h+var_58], rbx
movups xmm0, xmmword ptr [rbp+0]
movups [rsp+98h+var_50], xmm0
mov rdx, qword ptr [rsp+98h+var_50+8]
mov edi, edx
cmp rdi, 3
jz short loc_6D262
mov rsi, qword ptr [rsp+98h+var_50]
mov rbp, rdi
mov rdi, r15
call check_function
mov rdi, rbp
test eax, eax
jnz short loc_6D208
loc_6D262:
movsxd rbp, dword ptr [r12+40h]
cmp rbp, 2
jl loc_6D372
movzx eax, word ptr [r12+6]
lea ecx, [rax-15h]
cmp cx, 0Ch
jnb def_6D3FD; jumptable 000000000006D3FD default case, cases 3,5-7
movzx edx, cx
lea rcx, typed_array_size_log2
mov cl, [rax+rcx-15h]
push 1
pop rsi
shl esi, cl
shl edx, 3
lea rax, off_BAB30
mov rax, [rdx+rax]
lea rcx, off_BAB90
mov rcx, [rdx+rcx]
mov [rsp+98h+var_40], rax
movsxd rdx, esi
cmp edi, 3
jnz short loc_6D2E2
mov rdi, [r12+38h]
lea r15, [rsp+98h+var_70]
mov rsi, rbp
mov r8, r15
call rqsort
cmp dword ptr [r15+8], 0
jnz loc_6D208
jmp loc_6D372
loc_6D2E2:
mov [rsp+98h+var_80], rdx
mov [rsp+98h+var_78], rsi
lea rsi, ds:0[rbp*4]
mov rdi, r15
call js_malloc
test rax, rax
jz loc_6D208
mov rdi, rax
xor eax, eax
mov rcx, [rsp+98h+var_78]
loc_6D30F:
cmp rbp, rax
jz short loc_6D31C
mov [rdi+rax*4], eax
inc rax
jmp short loc_6D30F
loc_6D31C:
lea r8, [rsp+98h+var_70]
mov [r8+38h], ecx
lea rcx, js_TA_cmp_generic
push 4
pop rdx
mov [rsp+98h+var_90], rdi
mov rsi, rbp
call rqsort
mov rsi, [rsp+98h+var_90]
lea rax, [rsp+98h+var_70]
cmp dword ptr [rax+8], 0
jz short loc_6D359
loc_6D34C:
mov rdi, r15
call js_free
jmp loc_6D208
loc_6D359:
mov rdi, r12
call typed_array_is_oob
test eax, eax
jz short loc_6D392
loc_6D365:
mov rdi, r15
mov rsi, [rsp+98h+var_90]
call js_free
loc_6D372:
cmp ebx, 0FFFFFFF7h
jb short loc_6D37A
inc dword ptr [r14]
loc_6D37A:
mov rcx, 0FFFFFFFF00000000h
and rcx, r14
mov eax, r14d
mov r13, rbx
jmp loc_6D20C
loc_6D392:
mov eax, [r12+40h]
test eax, eax
jz short loc_6D365
cmp ebp, eax
cmovl eax, ebp
movsxd rbp, eax
mov rsi, [rsp+98h+var_80]
imul rsi, rbp
mov rdi, r15
mov [rsp+98h+var_80], rsi
call js_malloc
test rax, rax
mov rsi, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_78]
jz short loc_6D34C
mov rsi, [r12+38h]
mov [rsp+98h+var_88], rax
mov rdi, rax
mov rdx, [rsp+98h+var_80]
mov r13, rcx
call _memcpy
dec r13d; switch 8 cases
cmp r13d, 7
ja def_6D3FD; jumptable 000000000006D3FD default case, cases 3,5-7
lea rax, jpt_6D3FD
movsxd rcx, ds:(jpt_6D3FD - 84744h)[rax+r13*4]
add rcx, rax
jmp rcx; switch jump
loc_6D3FF:
xor eax, eax; jumptable 000000000006D3FD case 1
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_88]
loc_6D40B:
cmp rbp, rax
jz loc_6D497
mov ecx, [rdi+rax*4]
mov cl, [rsi+rcx]
mov rdx, [r12+38h]
mov [rdx+rax], cl
inc rax
jmp short loc_6D40B
loc_6D427:
xor eax, eax; jumptable 000000000006D3FD case 4
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_88]
loc_6D433:
cmp rbp, rax
jz short loc_6D497
mov ecx, [rdi+rax*4]
mov ecx, [rsi+rcx*4]
mov rdx, [r12+38h]
mov [rdx+rax*4], ecx
inc rax
jmp short loc_6D433
loc_6D44B:
xor eax, eax; jumptable 000000000006D3FD case 8
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_88]
loc_6D457:
cmp rbp, rax
jz short loc_6D497
mov ecx, [rdi+rax*4]
mov rcx, [rsi+rcx*8]
mov rdx, [r12+38h]
mov [rdx+rax*8], rcx
inc rax
jmp short loc_6D457
loc_6D471:
xor eax, eax; jumptable 000000000006D3FD case 2
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_88]
loc_6D47D:
cmp rbp, rax
jz short loc_6D497
mov ecx, [rdi+rax*4]
movzx ecx, word ptr [rsi+rcx*2]
mov rdx, [r12+38h]
mov [rdx+rax*2], cx
inc rax
jmp short loc_6D47D
loc_6D497:
mov rdi, r15
call js_free
jmp loc_6D365
def_6D3FD:
call _abort; jumptable 000000000006D3FD default case, cases 3,5-7
| unsigned long long js_typed_array_sort(
long long a1,
long long a2,
long long a3,
long long a4,
__m128 *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long typed_array; // rax
long long v19; // r12
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // rax
unsigned long long v27; // rcx
__m128 v29; // xmm0
const char *v30; // rdi
signed long long v31; // rbp
long long v32; // rax
int v33; // esi
long long v34; // rdx
long long ( *v35)(unsigned long long, unsigned long long, long long); // rcx
long long v36; // rax
long long v37; // rdi
long long i; // rax
long long v39; // rsi
int v40; // eax
long long v41; // rbp
long long v42; // rax
long long v43; // rax
long long v44; // rsi
long long v45; // rax
long long v46; // rax
long long v47; // rax
char v48; // [rsp+0h] [rbp-98h]
long long v49; // [rsp+8h] [rbp-90h]
long long v50; // [rsp+10h] [rbp-88h]
long long v51; // [rsp+18h] [rbp-80h]
long long v52; // [rsp+18h] [rbp-80h]
int v53; // [rsp+20h] [rbp-78h]
long long v54; // [rsp+28h] [rbp-70h] BYREF
int v55; // [rsp+30h] [rbp-68h]
long long v56; // [rsp+38h] [rbp-60h]
long long v57; // [rsp+40h] [rbp-58h]
__m128 v58; // [rsp+48h] [rbp-50h]
long long ( *v59)(); // [rsp+58h] [rbp-40h]
int v60; // [rsp+60h] [rbp-38h]
typed_array = get_typed_array(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( !typed_array )
goto LABEL_4;
v19 = typed_array;
if ( typed_array_is_oob(typed_array) )
{
JS_ThrowTypeErrorArrayBufferOOB(a1, a7, a8, a9, a10, v24, v25, a13, a14, a2, v20, v21, v22, v23, v48);
LABEL_4:
v26 = 0LL;
v27 = 0LL;
return v27 | v26;
}
v54 = a1;
v55 = 0;
v56 = a2;
v57 = a3;
v29 = *a5;
v58 = *a5;
v30 = (const char *)v58.m128_u32[2];
if ( v58.m128_u32[2] != 3LL )
{
v30 = (const char *)v58.m128_u32[2];
if ( (unsigned int)check_function(
a1,
v58.m128_i64[0],
v58.m128_i32[2],
v29,
a8,
a9,
a10,
*(double *)v24.m128_u64,
*(double *)v25.m128_u64,
a13,
a14) )
goto LABEL_4;
}
v31 = *(int *)(v19 + 64);
if ( v31 >= 2 )
{
v32 = *(unsigned __int16 *)(v19 + 6);
if ( (unsigned __int16)(v32 - 21) >= 0xCu )
LABEL_42:
abort(v30);
v33 = 1 << typed_array_size_log2[v32 - 21];
v34 = (unsigned __int16)(v32 - 21);
v35 = (long long ( *)(unsigned long long, unsigned long long, long long))off_BAB90[v34];
v59 = off_BAB30[v34];
if ( (_DWORD)v30 != 3 )
{
v51 = v33;
v53 = v33;
v36 = js_malloc(a1, 4 * v31);
if ( !v36 )
goto LABEL_4;
v37 = v36;
for ( i = 0LL; v31 != i; ++i )
*(_DWORD *)(v37 + 4 * i) = i;
v60 = v33;
v49 = v37;
rqsort(
v37,
v31,
4LL,
(long long ( *)(unsigned long long, unsigned long long, long long))js_TA_cmp_generic,
(long long)&v54);
v39 = v37;
if ( !v55 )
{
if ( typed_array_is_oob(v19) || (v40 = *(_DWORD *)(v19 + 64)) == 0 )
{
LABEL_20:
js_free(a1, v49);
goto LABEL_21;
}
if ( (int)v31 < v40 )
v40 = v31;
v41 = v40;
v52 = v40 * v51;
v42 = js_malloc(a1, v52);
v39 = v37;
if ( v42 )
{
v50 = v42;
v30 = (const char *)v42;
memcpy(v42, *(_QWORD *)(v19 + 56), v52);
switch ( v53 )
{
case 1:
v43 = 0LL;
v44 = v50;
while ( v41 != v43 )
{
*(_BYTE *)(*(_QWORD *)(v19 + 56) + v43) = *(_BYTE *)(v50 + *(unsigned int *)(v49 + 4 * v43));
++v43;
}
goto LABEL_41;
case 2:
v47 = 0LL;
v44 = v50;
while ( v41 != v47 )
{
*(_WORD *)(*(_QWORD *)(v19 + 56) + 2 * v47) = *(_WORD *)(v50 + 2LL * *(unsigned int *)(v49 + 4 * v47));
++v47;
}
goto LABEL_41;
case 4:
v45 = 0LL;
v44 = v50;
while ( v41 != v45 )
{
*(_DWORD *)(*(_QWORD *)(v19 + 56) + 4 * v45) = *(_DWORD *)(v50 + 4LL * *(unsigned int *)(v49 + 4 * v45));
++v45;
}
goto LABEL_41;
case 8:
v46 = 0LL;
v44 = v50;
while ( v41 != v46 )
{
*(_QWORD *)(*(_QWORD *)(v19 + 56) + 8 * v46) = *(_QWORD *)(v50 + 8LL * *(unsigned int *)(v49 + 4 * v46));
++v46;
}
LABEL_41:
js_free(a1, v44);
goto LABEL_20;
default:
goto LABEL_42;
}
}
}
js_free(a1, v39);
goto LABEL_4;
}
rqsort(*(_QWORD *)(v19 + 56), v31, v33, v35, (long long)&v54);
if ( v55 )
goto LABEL_4;
}
LABEL_21:
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*(_DWORD *)a2;
v27 = a2 & 0xFFFFFFFF00000000LL;
v26 = (unsigned int)a2;
return v27 | v26;
}
| js_typed_array_sort:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBP,R8
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CALL 0x0013280b
PUSH 0x6
POP R13
TEST RAX,RAX
JZ 0x0016d208
MOV R12,RAX
MOV RDI,RAX
CALL 0x00132836
TEST EAX,EAX
JZ 0x0016d221
MOV RDI,R15
CALL 0x0013289b
LAB_0016d208:
XOR EAX,EAX
XOR ECX,ECX
LAB_0016d20c:
OR RAX,RCX
MOV RDX,R13
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016d221:
MOV qword ptr [RSP + 0x28],R15
AND dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],R14
MOV qword ptr [RSP + 0x40],RBX
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS xmmword ptr [RSP + 0x48],XMM0
MOV RDX,qword ptr [RSP + 0x50]
MOV EDI,EDX
CMP RDI,0x3
JZ 0x0016d262
MOV RSI,qword ptr [RSP + 0x48]
MOV RBP,RDI
MOV RDI,R15
CALL 0x0013949a
MOV RDI,RBP
TEST EAX,EAX
JNZ 0x0016d208
LAB_0016d262:
MOVSXD RBP,dword ptr [R12 + 0x40]
CMP RBP,0x2
JL 0x0016d372
MOVZX EAX,word ptr [R12 + 0x6]
LEA ECX,[RAX + -0x15]
CMP CX,0xc
JNC 0x0016d4a4
MOVZX EDX,CX
LEA RCX,[0x18487f]
MOV CL,byte ptr [RAX + RCX*0x1 + -0x15]
PUSH 0x1
POP RSI
SHL ESI,CL
SHL EDX,0x3
LEA RAX,[0x1bab30]
MOV RAX,qword ptr [RDX + RAX*0x1]
LEA RCX,[0x1bab90]
MOV RCX,qword ptr [RDX + RCX*0x1]
MOV qword ptr [RSP + 0x58],RAX
MOVSXD RDX,ESI
CMP EDI,0x3
JNZ 0x0016d2e2
MOV RDI,qword ptr [R12 + 0x38]
LEA R15,[RSP + 0x28]
MOV RSI,RBP
MOV R8,R15
CALL 0x0011683c
CMP dword ptr [R15 + 0x8],0x0
JNZ 0x0016d208
JMP 0x0016d372
LAB_0016d2e2:
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x20],RSI
LEA RSI,[RBP*0x4]
MOV RDI,R15
CALL 0x00117214
TEST RAX,RAX
JZ 0x0016d208
MOV RDI,RAX
XOR EAX,EAX
MOV RCX,qword ptr [RSP + 0x20]
LAB_0016d30f:
CMP RBP,RAX
JZ 0x0016d31c
MOV dword ptr [RDI + RAX*0x4],EAX
INC RAX
JMP 0x0016d30f
LAB_0016d31c:
LEA R8,[RSP + 0x28]
MOV dword ptr [R8 + 0x38],ECX
LEA RCX,[0x16df38]
PUSH 0x4
POP RDX
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,RBP
CALL 0x0011683c
MOV RSI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x28]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x0016d359
LAB_0016d34c:
MOV RDI,R15
CALL 0x0011726e
JMP 0x0016d208
LAB_0016d359:
MOV RDI,R12
CALL 0x00132836
TEST EAX,EAX
JZ 0x0016d392
LAB_0016d365:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0011726e
LAB_0016d372:
CMP EBX,-0x9
JC 0x0016d37a
INC dword ptr [R14]
LAB_0016d37a:
MOV RCX,-0x100000000
AND RCX,R14
MOV EAX,R14D
MOV R13,RBX
JMP 0x0016d20c
LAB_0016d392:
MOV EAX,dword ptr [R12 + 0x40]
TEST EAX,EAX
JZ 0x0016d365
CMP EBP,EAX
CMOVL EAX,EBP
MOVSXD RBP,EAX
MOV RSI,qword ptr [RSP + 0x18]
IMUL RSI,RBP
MOV RDI,R15
MOV qword ptr [RSP + 0x18],RSI
CALL 0x00117214
TEST RAX,RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
JZ 0x0016d34c
MOV RSI,qword ptr [R12 + 0x38]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,RAX
MOV RDX,qword ptr [RSP + 0x18]
MOV R13,RCX
CALL 0x0010e5c0
DEC R13D
CMP R13D,0x7
JA 0x0016d4a4
LEA RAX,[0x184744]
MOVSXD RCX,dword ptr [RAX + R13*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
XOR EAX,EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0016d40b:
CMP RBP,RAX
JZ 0x0016d497
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV CL,byte ptr [RSI + RCX*0x1]
MOV RDX,qword ptr [R12 + 0x38]
MOV byte ptr [RDX + RAX*0x1],CL
INC RAX
JMP 0x0016d40b
caseD_4:
XOR EAX,EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0016d433:
CMP RBP,RAX
JZ 0x0016d497
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV ECX,dword ptr [RSI + RCX*0x4]
MOV RDX,qword ptr [R12 + 0x38]
MOV dword ptr [RDX + RAX*0x4],ECX
INC RAX
JMP 0x0016d433
caseD_8:
XOR EAX,EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0016d457:
CMP RBP,RAX
JZ 0x0016d497
MOV ECX,dword ptr [RDI + RAX*0x4]
MOV RCX,qword ptr [RSI + RCX*0x8]
MOV RDX,qword ptr [R12 + 0x38]
MOV qword ptr [RDX + RAX*0x8],RCX
INC RAX
JMP 0x0016d457
caseD_2:
XOR EAX,EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_0016d47d:
CMP RBP,RAX
JZ 0x0016d497
MOV ECX,dword ptr [RDI + RAX*0x4]
MOVZX ECX,word ptr [RSI + RCX*0x2]
MOV RDX,qword ptr [R12 + 0x38]
MOV word ptr [RDX + RAX*0x2],CX
INC RAX
JMP 0x0016d47d
LAB_0016d497:
MOV RDI,R15
CALL 0x0011726e
JMP 0x0016d365
caseD_3:
CALL 0x0010e090
|
int1 [16]
js_typed_array_sort(int8 param_1,int *param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
long lVar5;
long lVar6;
void *__dest;
ushort uVar7;
ulong uVar8;
long lVar9;
long lVar10;
int iVar11;
int1 auVar12 [16];
int8 local_70;
int local_68;
int *local_60;
int8 local_58;
int4 local_50;
int4 uStack_4c;
int iStack_48;
int4 uStack_44;
int *local_40;
int local_38;
lVar3 = get_typed_array();
if (lVar3 != 0) {
iVar1 = typed_array_is_oob(lVar3);
if (iVar1 == 0) {
local_68 = 0;
local_50 = *(int4 *)param_5;
uStack_4c = *(int4 *)((long)param_5 + 4);
iVar1 = *(int *)(param_5 + 1);
uStack_44 = *(int4 *)((long)param_5 + 0xc);
local_70 = param_1;
local_60 = param_2;
local_58 = param_3;
iStack_48 = iVar1;
if ((iVar1 == 3) || (iVar2 = check_function(param_1,*param_5), iVar2 == 0)) {
iVar2 = *(int *)(lVar3 + 0x40);
lVar10 = (long)iVar2;
if (lVar10 < 2) {
LAB_0016d372:
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
uVar8 = (ulong)param_2 & 0xffffffff00000000;
uVar4 = (ulong)param_2 & 0xffffffff;
goto LAB_0016d20c;
}
uVar7 = *(ushort *)(lVar3 + 6) - 0x15;
if (0xb < uVar7) {
switchD_0016d3fd_caseD_3:
/* WARNING: Subroutine does not return */
abort();
}
iVar11 = 1 << ("toSorted"[(ulong)*(ushort *)(lVar3 + 6) + 6] & 0x1fU);
local_40 = (&PTR_js_TA_get_uint8_001bab30)[uVar7];
lVar9 = (long)iVar11;
if (iVar1 == 3) {
rqsort(*(int8 *)(lVar3 + 0x38),lVar10,lVar9,(&PTR_js_TA_cmp_uint8_001bab90)[uVar7],
&local_70);
if (local_68 == 0) goto LAB_0016d372;
}
else {
lVar5 = js_malloc(param_1,lVar10 * 4,lVar9,(&PTR_js_TA_cmp_uint8_001bab90)[uVar7]);
if (lVar5 != 0) {
for (lVar6 = 0; lVar10 != lVar6; lVar6 = lVar6 + 1) {
*(int *)(lVar5 + lVar6 * 4) = (int)lVar6;
}
local_38 = iVar11;
rqsort(lVar5,lVar10,4,js_TA_cmp_generic);
if (local_68 == 0) {
iVar1 = typed_array_is_oob(lVar3,lVar5);
if ((iVar1 == 0) && (iVar1 = *(int *)(lVar3 + 0x40), iVar1 != 0)) {
if (iVar2 < iVar1) {
iVar1 = iVar2;
}
lVar10 = (long)iVar1;
__dest = (void *)js_malloc(param_1);
if (__dest == (void *)0x0) goto LAB_0016d34c;
memcpy(__dest,*(void **)(lVar3 + 0x38),lVar9 * lVar10);
switch(iVar11) {
case 1:
for (lVar9 = 0; lVar10 != lVar9; lVar9 = lVar9 + 1) {
*(int1 *)(*(long *)(lVar3 + 0x38) + lVar9) =
*(int1 *)((long)__dest + (ulong)*(uint *)(lVar5 + lVar9 * 4));
}
break;
case 2:
for (lVar9 = 0; lVar10 != lVar9; lVar9 = lVar9 + 1) {
*(int2 *)(*(long *)(lVar3 + 0x38) + lVar9 * 2) =
*(int2 *)((long)__dest + (ulong)*(uint *)(lVar5 + lVar9 * 4) * 2);
}
break;
default:
goto switchD_0016d3fd_caseD_3;
case 4:
for (lVar9 = 0; lVar10 != lVar9; lVar9 = lVar9 + 1) {
*(int4 *)(*(long *)(lVar3 + 0x38) + lVar9 * 4) =
*(int4 *)((long)__dest + (ulong)*(uint *)(lVar5 + lVar9 * 4) * 4);
}
break;
case 8:
for (lVar9 = 0; lVar10 != lVar9; lVar9 = lVar9 + 1) {
*(int8 *)(*(long *)(lVar3 + 0x38) + lVar9 * 8) =
*(int8 *)((long)__dest + (ulong)*(uint *)(lVar5 + lVar9 * 4) * 8);
}
}
js_free(param_1);
}
js_free(param_1,lVar5);
goto LAB_0016d372;
}
LAB_0016d34c:
js_free(param_1,lVar5);
}
}
}
}
else {
JS_ThrowTypeErrorArrayBufferOOB(param_1);
}
}
uVar4 = 0;
uVar8 = 0;
param_3 = 6;
LAB_0016d20c:
auVar12._0_8_ = uVar4 | uVar8;
auVar12._8_8_ = param_3;
return auVar12;
}
| |
35,249 | js_typed_array_sort | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_sort(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSObject *p;
int len;
size_t elt_size;
struct TA_sort_context tsc;
int (*cmpfun)(const void *a, const void *b, void *opaque);
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return JS_ThrowTypeErrorArrayBufferOOB(ctx);
tsc.ctx = ctx;
tsc.exception = 0;
tsc.arr = this_val;
tsc.cmp = argv[0];
if (!JS_IsUndefined(tsc.cmp) && check_function(ctx, tsc.cmp))
return JS_EXCEPTION;
len = p->u.array.count;
if (len > 1) {
switch (p->class_id) {
case JS_CLASS_INT8_ARRAY:
tsc.getfun = js_TA_get_int8;
cmpfun = js_TA_cmp_int8;
break;
case JS_CLASS_UINT8C_ARRAY:
case JS_CLASS_UINT8_ARRAY:
tsc.getfun = js_TA_get_uint8;
cmpfun = js_TA_cmp_uint8;
break;
case JS_CLASS_INT16_ARRAY:
tsc.getfun = js_TA_get_int16;
cmpfun = js_TA_cmp_int16;
break;
case JS_CLASS_UINT16_ARRAY:
tsc.getfun = js_TA_get_uint16;
cmpfun = js_TA_cmp_uint16;
break;
case JS_CLASS_INT32_ARRAY:
tsc.getfun = js_TA_get_int32;
cmpfun = js_TA_cmp_int32;
break;
case JS_CLASS_UINT32_ARRAY:
tsc.getfun = js_TA_get_uint32;
cmpfun = js_TA_cmp_uint32;
break;
case JS_CLASS_BIG_INT64_ARRAY:
tsc.getfun = js_TA_get_int64;
cmpfun = js_TA_cmp_int64;
break;
case JS_CLASS_BIG_UINT64_ARRAY:
tsc.getfun = js_TA_get_uint64;
cmpfun = js_TA_cmp_uint64;
break;
case JS_CLASS_FLOAT16_ARRAY:
tsc.getfun = js_TA_get_float16;
cmpfun = js_TA_cmp_float16;
break;
case JS_CLASS_FLOAT32_ARRAY:
tsc.getfun = js_TA_get_float32;
cmpfun = js_TA_cmp_float32;
break;
case JS_CLASS_FLOAT64_ARRAY:
tsc.getfun = js_TA_get_float64;
cmpfun = js_TA_cmp_float64;
break;
default:
abort();
}
elt_size = 1 << typed_array_size_log2(p->class_id);
if (!JS_IsUndefined(tsc.cmp)) {
uint32_t *array_idx;
void *array_tmp;
size_t i, j;
/* XXX: a stable sort would use less memory */
array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
if (!array_idx)
return JS_EXCEPTION;
for(i = 0; i < len; i++)
array_idx[i] = i;
tsc.elt_size = elt_size;
rqsort(array_idx, len, sizeof(array_idx[0]),
js_TA_cmp_generic, &tsc);
if (tsc.exception)
goto fail;
// per spec: typed array can be detached mid-iteration
if (typed_array_is_oob(p))
goto done;
len = min_int(len, p->u.array.count);
if (len == 0)
goto done;
array_tmp = js_malloc(ctx, len * elt_size);
if (!array_tmp) {
fail:
js_free(ctx, array_idx);
return JS_EXCEPTION;
}
memcpy(array_tmp, p->u.array.u.ptr, len * elt_size);
switch(elt_size) {
case 1:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint8_ptr[i] = ((uint8_t *)array_tmp)[j];
}
break;
case 2:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint16_ptr[i] = ((uint16_t *)array_tmp)[j];
}
break;
case 4:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint32_ptr[i] = ((uint32_t *)array_tmp)[j];
}
break;
case 8:
for(i = 0; i < len; i++) {
j = array_idx[i];
p->u.array.u.uint64_ptr[i] = ((uint64_t *)array_tmp)[j];
}
break;
default:
abort();
}
js_free(ctx, array_tmp);
done:
js_free(ctx, array_idx);
} else {
rqsort(p->u.array.u.ptr, len, elt_size, cmpfun, &tsc);
if (tsc.exception)
return JS_EXCEPTION;
}
}
return js_dup(this_val);
} | O3 | c | js_typed_array_sort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r15
cmpl $-0x1, %ebx
jne 0x847fb
movq %rsi, %r14
movzwl 0x6(%rsi), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jae 0x847fb
movq %r8, %r12
movq %r14, %rdi
callq 0x3aa19
testl %eax, %eax
je 0x8482e
leaq 0x20bd3(%rip), %rsi # 0xa53cc
jmp 0x84802
leaq 0x20bb9(%rip), %rsi # 0xa53bb
xorl %r14d, %r14d
movq %r15, %rdi
xorl %eax, %eax
callq 0x22d8b
movl $0x6, %ebx
xorl %eax, %eax
orq %rax, %r14
movq %r14, %rax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movdqu (%r12), %xmm0
movdqu %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rdx
movl %edx, %ebp
cmpq $0x3, %rbp
je 0x8486f
movq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x42f63
testl %eax, %eax
jne 0x848eb
movslq 0x40(%r14), %r13
cmpq $0x2, %r13
jl 0x84a47
movzwl 0x6(%r14), %eax
leal -0x15(%rax), %ecx
cmpw $0xc, %cx
jae 0x84b92
movzwl %cx, %edx
leaq 0x1bfc6(%rip), %rcx # 0xa085f
movb -0x15(%rax,%rcx), %cl
movl $0x1, %r12d
shll %cl, %r12d
shll $0x3, %edx
leaq 0x4b280(%rip), %rax # 0xcfb30
movq (%rdx,%rax), %rax
leaq 0x4b2d5(%rip), %rcx # 0xcfb90
movq (%rdx,%rcx), %rcx
movq %rax, 0x48(%rsp)
movslq %r12d, %rdx
cmpl $0x3, %ebp
jne 0x848f8
movq 0x38(%r14), %rdi
leaq 0x18(%rsp), %r15
movq %r13, %rsi
movq %r15, %r8
callq 0x1c934
cmpl $0x0, 0x8(%r15)
je 0x84a47
movl $0x6, %ebx
xorl %r14d, %r14d
jmp 0x84814
movq %rdx, 0x10(%rsp)
leaq (,%r13,4), %rsi
movq %r15, %rdi
callq 0xee12
testq %rax, %rax
je 0x849fb
movq %rax, %rbp
leal 0x1(%r13), %eax
andl $-0x2, %eax
movq %r13, %rcx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x1cdf8(%rip), %xmm1 # 0xa1730
xorl %ecx, %ecx
movdqa 0x1cdfe(%rip), %xmm2 # 0xa1740
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x1ce0e(%rip), %xmm4 # 0xa1760
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x84987
movl %ecx, (%rbp,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x8499c
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rbp,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x84952
leaq 0x18(%rsp), %r8
movl %r12d, 0x38(%r8)
leaq 0x1128(%rip), %rcx # 0x85ae1
movl $0x4, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1c934
leaq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x84a0a
movq 0x18(%r15), %rbx
decq 0x28(%rbx)
movq %rbp, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %rbp, %rsi
callq *0x10(%rbx)
xorl %r14d, %r14d
xorl %eax, %eax
movl $0x6, %ebx
jmp 0x84816
movq %r14, %rdi
callq 0x3aa19
testl %eax, %eax
jne 0x84a1e
movl 0x40(%r14), %eax
testl %eax, %eax
jne 0x84a5f
movq 0x18(%r15), %r15
decq 0x28(%r15)
movq %rbp, %rdi
callq *0x20(%r15)
movq 0x30(%r15), %rcx
movq 0x40(%r15), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r15)
movq %rbp, %rsi
callq *0x10(%r15)
incl (%r14)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %r14, %rax
movl %r14d, %r14d
jmp 0x84816
cmpl %eax, %r13d
cmovll %r13d, %eax
movslq %eax, %r13
movq 0x10(%rsp), %rsi
imulq %r13, %rsi
movq %r15, %rdi
movq %rsi, 0x10(%rsp)
callq 0xee12
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x849d4
movq 0x38(%r14), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0xe5b0
decl %r12d
cmpl $0x7, %r12d
ja 0x84b92
leaq 0x1bc74(%rip), %rax # 0xa0728
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %eax, %eax
movq 0x8(%rsp), %rsi
movl (%rbp,%rax,4), %ecx
movb (%rsi,%rcx), %cl
movq 0x38(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r13
jne 0x84acc
jmp 0x84b5b
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %eax, %eax
movq 0x8(%rsp), %rsi
movl (%rbp,%rax,4), %ecx
movl (%rsi,%rcx,4), %ecx
movq 0x38(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0x84af3
jmp 0x84b5b
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %eax, %eax
movq 0x8(%rsp), %rsi
movl (%rbp,%rax,4), %ecx
movq (%rsi,%rcx,8), %rcx
movq 0x38(%r14), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x84b1a
jmp 0x84b5b
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %eax, %eax
movq 0x8(%rsp), %rsi
movl (%rbp,%rax,4), %ecx
movzwl (%rsi,%rcx,2), %ecx
movq 0x38(%r14), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
cmpq %rax, %r13
jne 0x84b43
movq 0x18(%r15), %r12
decq 0x28(%r12)
movq %rsi, %r13
movq %rsi, %rdi
callq *0x20(%r12)
movq 0x30(%r12), %rcx
movq 0x40(%r12), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r12)
movq %r13, %rsi
callq *0x10(%r12)
jmp 0x84a1e
callq 0xe090
| js_typed_array_sort:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdx
mov r15, rdi
cmp ebx, 0FFFFFFFFh
jnz short loc_847FB
mov r14, rsi
movzx eax, word ptr [rsi+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jnb short loc_847FB
mov r12, r8
mov rdi, r14
call typed_array_is_oob
test eax, eax
jz short loc_8482E
lea rsi, aArraybufferIsD_0; "ArrayBuffer is detached or resized"
jmp short loc_84802
loc_847FB:
lea rsi, aNotATypedarray; "not a TypedArray"
loc_84802:
xor r14d, r14d
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov ebx, 6
loc_84814:
xor eax, eax
loc_84816:
or r14, rax
mov rax, r14
mov rdx, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8482E:
mov [rsp+88h+var_70], r15
mov [rsp+88h+var_68], 0
mov [rsp+88h+var_60], r14
mov [rsp+88h+var_58], rbx
movdqu xmm0, xmmword ptr [r12]
movdqu [rsp+88h+var_50], xmm0
mov rdx, qword ptr [rsp+88h+var_50+8]
mov ebp, edx
cmp rbp, 3
jz short loc_8486F
mov rsi, qword ptr [rsp+88h+var_50]
mov rdi, r15
call check_function
test eax, eax
jnz short loc_848EB
loc_8486F:
movsxd r13, dword ptr [r14+40h]
cmp r13, 2
jl loc_84A47
movzx eax, word ptr [r14+6]
lea ecx, [rax-15h]
cmp cx, 0Ch
jnb def_84ABB; jumptable 0000000000084ABB default case, cases 3,5-7
movzx edx, cx
lea rcx, typed_array_size_log2
mov cl, [rax+rcx-15h]
mov r12d, 1
shl r12d, cl
shl edx, 3
lea rax, off_CFB30
mov rax, [rdx+rax]
lea rcx, off_CFB90
mov rcx, [rdx+rcx]
mov [rsp+88h+var_40], rax
movsxd rdx, r12d
cmp ebp, 3
jnz short loc_848F8
mov rdi, [r14+38h]
lea r15, [rsp+88h+var_70]
mov rsi, r13
mov r8, r15
call rqsort
cmp dword ptr [r15+8], 0
jz loc_84A47
loc_848EB:
mov ebx, 6
xor r14d, r14d
jmp loc_84814
loc_848F8:
mov [rsp+88h+var_78], rdx
lea rsi, ds:0[r13*4]
mov rdi, r15
call js_malloc
test rax, rax
jz loc_849FB
mov rbp, rax
lea eax, [r13+1]
and eax, 0FFFFFFFEh
mov rcx, r13
dec rcx
movq xmm0, rcx
pshufd xmm0, xmm0, 44h ; 'D'
movdqa xmm1, cs:xmmword_A1730
xor ecx, ecx
movdqa xmm2, cs:xmmword_A1740
pxor xmm0, xmm2
pcmpeqd xmm3, xmm3
movdqa xmm4, cs:xmmword_A1760
loc_84952:
movdqa xmm5, xmm1
pxor xmm5, xmm2
movdqa xmm6, xmm5
pcmpgtd xmm6, xmm0
pcmpeqd xmm5, xmm0
pshufd xmm7, xmm5, 0F5h
pand xmm7, xmm6
pshufd xmm5, xmm6, 0F5h
por xmm5, xmm7
movd edx, xmm5
not edx
test dl, 1
jz short loc_84987
mov [rbp+rcx*4+0], ecx
loc_84987:
pxor xmm5, xmm3
pextrw edx, xmm5, 4
test dl, 1
jz short loc_8499C
lea edx, [rcx+1]
mov [rbp+rcx*4+4], edx
loc_8499C:
add rcx, 2
paddq xmm1, xmm4
cmp rax, rcx
jnz short loc_84952
lea r8, [rsp+88h+var_70]
mov [r8+38h], r12d
lea rcx, js_TA_cmp_generic
mov edx, 4
mov rdi, rbp
mov rsi, r13
call rqsort
lea rax, [rsp+88h+var_70]
cmp dword ptr [rax+8], 0
jz short loc_84A0A
loc_849D4:
mov rbx, [r15+18h]
dec qword ptr [rbx+28h]
mov rdi, rbp
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, rbp
call qword ptr [rbx+10h]
loc_849FB:
xor r14d, r14d
xor eax, eax
mov ebx, 6
jmp loc_84816
loc_84A0A:
mov rdi, r14
call typed_array_is_oob
test eax, eax
jnz short loc_84A1E
mov eax, [r14+40h]
test eax, eax
jnz short loc_84A5F
loc_84A1E:
mov r15, [r15+18h]
dec qword ptr [r15+28h]
mov rdi, rbp
call qword ptr [r15+20h]
mov rcx, [r15+30h]
mov rdi, [r15+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r15+30h], rcx
mov rsi, rbp
call qword ptr [r15+10h]
loc_84A47:
inc dword ptr [r14]
mov rax, 0FFFFFFFF00000000h
and rax, r14
mov r14d, r14d
jmp loc_84816
loc_84A5F:
cmp r13d, eax
cmovl eax, r13d
movsxd r13, eax
mov rsi, [rsp+88h+var_78]
imul rsi, r13
mov rdi, r15
mov [rsp+88h+var_78], rsi
call js_malloc
mov [rsp+88h+var_80], rax
test rax, rax
jz loc_849D4
mov rsi, [r14+38h]
mov rdi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
call _memcpy
dec r12d; switch 8 cases
cmp r12d, 7
ja def_84ABB; jumptable 0000000000084ABB default case, cases 3,5-7
lea rax, jpt_84ABB
movsxd rcx, ds:(jpt_84ABB - 0A0728h)[rax+r12*4]
add rcx, rax
jmp rcx; switch jump
loc_84ABD:
cmp r13, 1; jumptable 0000000000084ABB case 1
adc r13, 0
xor eax, eax
mov rsi, [rsp+88h+var_80]
loc_84ACC:
mov ecx, [rbp+rax*4+0]
mov cl, [rsi+rcx]
mov rdx, [r14+38h]
mov [rdx+rax], cl
inc rax
cmp r13, rax
jnz short loc_84ACC
jmp short loc_84B5B
loc_84AE4:
cmp r13, 1; jumptable 0000000000084ABB case 4
adc r13, 0
xor eax, eax
mov rsi, [rsp+88h+var_80]
loc_84AF3:
mov ecx, [rbp+rax*4+0]
mov ecx, [rsi+rcx*4]
mov rdx, [r14+38h]
mov [rdx+rax*4], ecx
inc rax
cmp r13, rax
jnz short loc_84AF3
jmp short loc_84B5B
loc_84B0B:
cmp r13, 1; jumptable 0000000000084ABB case 8
adc r13, 0
xor eax, eax
mov rsi, [rsp+88h+var_80]
loc_84B1A:
mov ecx, [rbp+rax*4+0]
mov rcx, [rsi+rcx*8]
mov rdx, [r14+38h]
mov [rdx+rax*8], rcx
inc rax
cmp r13, rax
jnz short loc_84B1A
jmp short loc_84B5B
loc_84B34:
cmp r13, 1; jumptable 0000000000084ABB case 2
adc r13, 0
xor eax, eax
mov rsi, [rsp+88h+var_80]
loc_84B43:
mov ecx, [rbp+rax*4+0]
movzx ecx, word ptr [rsi+rcx*2]
mov rdx, [r14+38h]
mov [rdx+rax*2], cx
inc rax
cmp r13, rax
jnz short loc_84B43
loc_84B5B:
mov r12, [r15+18h]
dec qword ptr [r12+28h]
mov r13, rsi
mov rdi, rsi
call qword ptr [r12+20h]
mov rcx, [r12+30h]
mov rdi, [r12+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r12+30h], rcx
mov rsi, r13
call qword ptr [r12+10h]
jmp loc_84A1E
def_84ABB:
call _abort; jumptable 0000000000084ABB default case, cases 3,5-7
| unsigned long long js_typed_array_sort(
long long a1,
long long a2,
long long a3,
long long a4,
const __m128i *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v16; // r14
const char *v18; // rdi
const char *v19; // rsi
unsigned long long v20; // rax
__m128 v22; // xmm0
signed long long v23; // r13
long long v24; // rax
int v25; // r12d
long long v26; // rdx
long long ( *v27)(unsigned long long, unsigned long long, long long); // rcx
long long v28; // rax
long long v29; // rbp
__m128i si128; // xmm1
long long v31; // rcx
__m128i v32; // xmm2
__m128i v33; // xmm0
__m128i v34; // xmm4
__m128i v35; // xmm5
__m128i v36; // xmm6
__m128i v37; // xmm5
long long v38; // rbx
long long v39; // rax
long long v40; // rdi
int v41; // eax
long long v42; // r15
long long v43; // rax
long long v44; // rdi
long long v45; // r13
long long v46; // r13
long long v47; // rax
long long v48; // rsi
long long v49; // r13
long long v50; // rax
long long v51; // r13
long long v52; // rax
long long v53; // r13
long long v54; // rax
long long v55; // r12
long long v56; // rax
long long v57; // rdi
char v58; // [rsp+0h] [rbp-88h]
long long v59; // [rsp+8h] [rbp-80h]
long long v60; // [rsp+10h] [rbp-78h]
long long v61; // [rsp+18h] [rbp-70h] BYREF
int v62; // [rsp+20h] [rbp-68h]
long long v63; // [rsp+28h] [rbp-60h]
long long v64; // [rsp+30h] [rbp-58h]
__m128 v65; // [rsp+38h] [rbp-50h]
long long ( *v66)(); // [rsp+48h] [rbp-40h]
int v67; // [rsp+50h] [rbp-38h]
if ( (_DWORD)a3 != -1 || (v16 = a2, (unsigned __int16)(*(_WORD *)(a2 + 6) - 21) >= 0xCu) )
{
v19 = "not a TypedArray";
goto LABEL_6;
}
v18 = (const char *)a2;
if ( !typed_array_is_oob(a2) )
{
v61 = a1;
v62 = 0;
v63 = a2;
v64 = a3;
v22 = (__m128)_mm_loadu_si128(a5);
v65 = v22;
if ( v22.m128_u32[2] != 3LL )
{
v18 = (const char *)a1;
if ( (unsigned int)check_function(
a1,
v65.m128_i64[0],
v22.m128_i64[1],
a4,
(long long)a5,
a6,
v22,
a8,
a9,
a10,
a11,
a12,
a13,
a14) )
goto LABEL_15;
}
v23 = *(int *)(a2 + 64);
if ( v23 >= 2 )
{
v24 = *(unsigned __int16 *)(a2 + 6);
if ( (unsigned __int16)(v24 - 21) >= 0xCu )
LABEL_46:
abort(v18);
v25 = 1 << typed_array_size_log2[v24 - 21];
v26 = (unsigned __int16)(v24 - 21);
v27 = (long long ( *)(unsigned long long, unsigned long long, long long))off_CFB90[v26];
v66 = off_CFB30[v26];
if ( v22.m128_i32[2] != 3 )
{
v28 = js_malloc(a1, 4 * v23);
if ( v28 )
{
v29 = v28;
si128 = _mm_load_si128((const __m128i *)&xmmword_A1730);
v31 = 0LL;
v32 = _mm_load_si128((const __m128i *)&xmmword_A1740);
v33 = _mm_xor_si128(_mm_shuffle_epi32((__m128i)(unsigned long long)(v23 - 1), 68), v32);
v34 = _mm_load_si128((const __m128i *)&xmmword_A1760);
do
{
v35 = _mm_xor_si128(si128, v32);
v36 = _mm_cmpgt_epi32(v35, v33);
v37 = _mm_or_si128(
_mm_shuffle_epi32(v36, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v35, v33), 245), v36));
if ( (~_mm_cvtsi128_si32(v37) & 1) != 0 )
*(_DWORD *)(v28 + 4 * v31) = v31;
if ( (_mm_extract_epi16(_mm_xor_si128(v37, (__m128i)-1LL), 4) & 1) != 0 )
*(_DWORD *)(v28 + 4 * v31 + 4) = v31 + 1;
v31 += 2LL;
si128 = _mm_add_epi64(si128, v34);
}
while ( (((_DWORD)v23 + 1) & 0xFFFFFFFE) != v31 );
v67 = v25;
rqsort(
v28,
v23,
4LL,
(long long ( *)(unsigned long long, unsigned long long, long long))js_TA_cmp_generic,
(long long)&v61);
if ( !v62 )
{
if ( typed_array_is_oob(a2) || (v41 = *(_DWORD *)(a2 + 64)) == 0 )
{
LABEL_28:
v42 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v42 + 40);
v43 = (*(long long ( **)(long long, double, double, double, double))(v42 + 32))(
v29,
*(double *)v33.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v32.m128i_i64,
NAN);
v44 = *(_QWORD *)(v42 + 64);
*(_QWORD *)(v42 + 48) = *(_QWORD *)(v42 + 48) - v43 - 8;
(*(void ( **)(long long, long long))(v42 + 16))(v44, v29);
goto LABEL_29;
}
if ( (int)v23 < v41 )
v41 = v23;
v45 = v41;
v60 = v41 * (long long)v25;
v59 = js_malloc(a1, v60);
if ( v59 )
{
v18 = (const char *)v59;
memcpy(v59, *(_QWORD *)(a2 + 56), v60);
switch ( v25 )
{
case 1:
v46 = (v45 == 0) + v45;
v47 = 0LL;
v48 = v59;
do
{
*(_BYTE *)(*(_QWORD *)(v16 + 56) + v47) = *(_BYTE *)(v59 + *(unsigned int *)(v29 + 4 * v47));
++v47;
}
while ( v46 != v47 );
goto LABEL_45;
case 2:
v53 = (v45 == 0) + v45;
v54 = 0LL;
v48 = v59;
do
{
*(_WORD *)(*(_QWORD *)(v16 + 56) + 2 * v54) = *(_WORD *)(v59 + 2LL
* *(unsigned int *)(v29 + 4 * v54));
++v54;
}
while ( v53 != v54 );
goto LABEL_45;
case 4:
v49 = (v45 == 0) + v45;
v50 = 0LL;
v48 = v59;
do
{
*(_DWORD *)(*(_QWORD *)(v16 + 56) + 4 * v50) = *(_DWORD *)(v59
+ 4LL * *(unsigned int *)(v29 + 4 * v50));
++v50;
}
while ( v49 != v50 );
goto LABEL_45;
case 8:
v51 = (v45 == 0) + v45;
v52 = 0LL;
v48 = v59;
do
{
*(_QWORD *)(*(_QWORD *)(v16 + 56) + 8 * v52) = *(_QWORD *)(v59
+ 8LL * *(unsigned int *)(v29 + 4 * v52));
++v52;
}
while ( v51 != v52 );
LABEL_45:
v55 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v55 + 40);
v56 = (*(long long ( **)(long long, double, double, double, double))(v55 + 32))(
v48,
*(double *)v33.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v32.m128i_i64,
NAN);
v57 = *(_QWORD *)(v55 + 64);
*(_QWORD *)(v55 + 48) = *(_QWORD *)(v55 + 48) - v56 - 8;
(*(void ( **)(long long, long long))(v55 + 16))(v57, v48);
goto LABEL_28;
default:
goto LABEL_46;
}
}
}
v38 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v38 + 40);
v39 = (*(long long ( **)(long long, double, double, double, double))(v38 + 32))(
v29,
*(double *)v33.m128i_i64,
*(double *)si128.m128i_i64,
*(double *)v32.m128i_i64,
NAN);
v40 = *(_QWORD *)(v38 + 64);
*(_QWORD *)(v38 + 48) = *(_QWORD *)(v38 + 48) - v39 - 8;
(*(void ( **)(long long, long long))(v38 + 16))(v40, v29);
}
v16 = 0LL;
v20 = 0LL;
return v20 | v16;
}
rqsort(*(_QWORD *)(a2 + 56), v23, v25, v27, (long long)&v61);
if ( v62 )
{
LABEL_15:
v16 = 0LL;
goto LABEL_7;
}
}
LABEL_29:
++*(_DWORD *)v16;
v20 = v16 & 0xFFFFFFFF00000000LL;
v16 = (unsigned int)v16;
return v20 | v16;
}
v19 = "ArrayBuffer is detached or resized";
LABEL_6:
v16 = 0LL;
JS_ThrowTypeError(a1, (long long)v19, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v58);
LABEL_7:
v20 = 0LL;
return v20 | v16;
}
| js_math_clz32:
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
CMP ECX,-0x9
JC 0x001847c8
INC dword ptr [RDX]
LAB_001847c8:
PUSH RBX
SUB RSP,0x10
LEA RBX,[RSP + 0xc]
MOV RSI,RBX
CALL 0x0012bac4
MOV ECX,EAX
MOV EAX,dword ptr [RBX]
TEST EAX,EAX
LEA RSP,[RSP + 0x10]
POP RBX
JZ 0x001847f0
BSR EAX,EAX
XOR EAX,0x1f
JMP 0x001847f5
LAB_001847f0:
MOV EAX,0x20
LAB_001847f5:
XOR ESI,ESI
TEST ECX,ECX
CMOVNZ EAX,ESI
MOV EDX,0x6
CMOVZ RDX,RSI
RET
|
int1 [16] js_math_clz32(int8 param_1)
{
int iVar1;
uint uVar2;
ulong uVar3;
int8 *in_R8;
int1 auVar5 [16];
uint local_c;
ulong uVar4;
if (0xfffffff6 < (uint)in_R8[1]) {
*(int *)*in_R8 = *(int *)*in_R8 + 1;
}
iVar1 = JS_ToInt32Free(param_1,&local_c);
if (local_c == 0) {
uVar2 = 0x20;
}
else {
uVar2 = 0x1f;
if (local_c != 0) {
for (; local_c >> uVar2 == 0; uVar2 = uVar2 - 1) {
}
}
uVar2 = uVar2 ^ 0x1f;
}
uVar3 = (ulong)uVar2;
if (iVar1 != 0) {
uVar3 = 0;
}
uVar4 = 6;
if (iVar1 == 0) {
uVar4 = 0;
}
auVar5._8_8_ = uVar4;
auVar5._0_8_ = uVar3;
return auVar5;
}
| |
35,250 | my_strnncollsp_8bit_bin | eloqsql/strings/ctype-bin.c | static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *end;
size_t length;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
return a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
} | O0 | c | my_strnncollsp_8bit_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x45d78
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x45d80
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x45dde
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x45ddc
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x45e35
jmp 0x45d93
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x45def
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x45e2f
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x45e15
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
subq -0x40(%rbp), %rsi
callq 0x455a0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x58(%rbp)
jmp 0x45e29
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq -0x40(%rbp), %rsi
callq 0x455a0
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| my_strnncollsp_8bit_bin:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_45D78
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
jmp short loc_45D80
loc_45D78:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_45D80:
mov rax, [rbp+var_48]
mov rcx, [rbp+var_50]
mov [rbp+var_40], rcx
add rax, rcx
mov [rbp+var_38], rax
loc_45D93:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_38]
jnb short loc_45DDE
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jz short loc_45DDC
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax-1]
mov rcx, [rbp+var_28]
movzx ecx, byte ptr [rcx-1]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_45E35
loc_45DDC:
jmp short loc_45D93
loc_45DDE:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnz short loc_45DEF
xor eax, eax
mov [rbp+var_54], eax
jmp short loc_45E2F
loc_45DEF:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_45E15
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
sub rsi, [rbp+var_40]
call my_strnncollsp_padspace_bin
mov ecx, eax
xor eax, eax
sub eax, ecx
mov [rbp+var_58], eax
jmp short loc_45E29
loc_45E15:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
sub rsi, [rbp+var_40]
call my_strnncollsp_padspace_bin
mov [rbp+var_58], eax
loc_45E29:
mov eax, [rbp+var_58]
mov [rbp+var_54], eax
loc_45E2F:
mov eax, [rbp+var_54]
mov [rbp+var_4], eax
loc_45E35:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long my_strnncollsp_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rcx
unsigned long long v10; // [rsp+10h] [rbp-50h]
unsigned __int8 *v12; // [rsp+48h] [rbp-18h]
v12 = a2;
if ( a3 >= a5 )
v10 = a5;
else
v10 = a3;
while ( v12 < &a2[v10] )
{
v5 = v12++;
v6 = a4++;
if ( *v5 != *v6 )
return (unsigned int)(*(v12 - 1) - *(a4 - 1));
}
if ( a3 == a5 )
{
return 0;
}
else if ( a3 >= a5 )
{
return (unsigned int)my_strnncollsp_padspace_bin(v12, a3 - v10);
}
else
{
return (unsigned int)-(int)my_strnncollsp_padspace_bin(a4, a5 - v10);
}
}
| my_strnncollsp_8bit_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00145d78
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00145d80
LAB_00145d78:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_00145d80:
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x40],RCX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
LAB_00145d93:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00145dde
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
JZ 0x00145ddc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + -0x1]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + -0x1]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00145e35
LAB_00145ddc:
JMP 0x00145d93
LAB_00145dde:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00145def
XOR EAX,EAX
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00145e2f
LAB_00145def:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00145e15
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
SUB RSI,qword ptr [RBP + -0x40]
CALL 0x001455a0
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOV dword ptr [RBP + -0x58],EAX
JMP 0x00145e29
LAB_00145e15:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
SUB RSI,qword ptr [RBP + -0x40]
CALL 0x001455a0
MOV dword ptr [RBP + -0x58],EAX
LAB_00145e29:
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x54],EAX
LAB_00145e2f:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x4],EAX
LAB_00145e35:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int my_strnncollsp_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte *pbVar2;
int local_60;
int local_5c;
ulong local_58;
byte *local_30;
byte *local_20;
local_58 = param_5;
if (param_3 < param_5) {
local_58 = param_3;
}
pbVar1 = param_4;
pbVar2 = param_2;
do {
local_20 = pbVar2;
local_30 = pbVar1;
if (param_2 + local_58 <= local_20) {
if (param_3 == param_5) {
local_5c = 0;
}
else {
if (param_3 < param_5) {
local_60 = my_strnncollsp_padspace_bin(local_30,param_5 - local_58);
local_60 = -local_60;
}
else {
local_60 = my_strnncollsp_padspace_bin(local_20,param_3 - local_58);
}
local_5c = local_60;
}
return local_5c;
}
pbVar1 = local_30 + 1;
pbVar2 = local_20 + 1;
} while (*local_20 == *local_30);
return (uint)*local_20 - (uint)*local_30;
}
| |
35,251 | init_myisam_psi_keys | eloqsql/storage/myisam/mi_static.c | void init_myisam_psi_keys()
{
const char* category= "myisam";
int count;
count= array_elements(all_myisam_mutexes);
mysql_mutex_register(category, all_myisam_mutexes, count);
count= array_elements(all_myisam_rwlocks);
mysql_rwlock_register(category, all_myisam_rwlocks, count);
count= array_elements(all_myisam_conds);
mysql_cond_register(category, all_myisam_conds, count);
count= array_elements(all_myisam_files);
mysql_file_register(category, all_myisam_files, count);
count= array_elements(all_myisam_threads);
mysql_thread_register(category, all_myisam_threads, count);
count= array_elements(all_myisam_memory);
mysql_memory_register(category, all_myisam_memory, count);
} | O3 | c | init_myisam_psi_keys:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x2f66f6(%rip), %r14 # 0x3368c8
movq (%r14), %rax
leaq 0x57428(%rip), %rbx # 0x97604
leaq 0x2f48fd(%rip), %rsi # 0x334ae0
movq %rbx, %rdi
movl $0x3, %edx
callq *(%rax)
movq (%r14), %rax
leaq 0x2f4939(%rip), %rsi # 0x334b30
movq %rbx, %rdi
movl $0x2, %edx
callq *0x8(%rax)
movq (%r14), %rax
leaq 0x2f4954(%rip), %rsi # 0x334b60
movq %rbx, %rdi
movl $0x1, %edx
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x2f495f(%rip), %rsi # 0x334b80
movq %rbx, %rdi
movl $0x4, %edx
callq *0x20(%rax)
movq (%r14), %rax
leaq 0x2f49aa(%rip), %rsi # 0x334be0
movq %rbx, %rdi
movl $0x1, %edx
callq *0x18(%rax)
movq (%r14), %rax
movq 0x3d8(%rax), %rax
leaq 0x2f49ae(%rip), %rsi # 0x334c00
movq %rbx, %rdi
movl $0x15, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
| init_myisam_psi_keys:
push rbp
mov rbp, rsp
push r14
push rbx
lea r14, PSI_server
mov rax, [r14]
lea rbx, aThrLockMyisam+9; "myisam"
lea rsi, all_myisam_mutexes
mov rdi, rbx
mov edx, 3
call qword ptr [rax]
mov rax, [r14]
lea rsi, all_myisam_rwlocks
mov rdi, rbx
mov edx, 2
call qword ptr [rax+8]
mov rax, [r14]
lea rsi, all_myisam_conds
mov rdi, rbx
mov edx, 1
call qword ptr [rax+10h]
mov rax, [r14]
lea rsi, all_myisam_files
mov rdi, rbx
mov edx, 4
call qword ptr [rax+20h]
mov rax, [r14]
lea rsi, all_myisam_threads
mov rdi, rbx
mov edx, 1
call qword ptr [rax+18h]
mov rax, [r14]
mov rax, [rax+3D8h]
lea rsi, all_myisam_memory
mov rdi, rbx
mov edx, 15h
pop rbx
pop r14
pop rbp
jmp rax
| long long init_myisam_psi_keys()
{
(*(void ( **)(char *, _UNKNOWN **, long long))PSI_server)("myisam", &all_myisam_mutexes, 3LL);
(*((void ( **)(char *, _UNKNOWN **, long long))PSI_server + 1))("myisam", &all_myisam_rwlocks, 2LL);
(*((void ( **)(char *, _UNKNOWN **, long long))PSI_server + 2))("myisam", &all_myisam_conds, 1LL);
(*((void ( **)(char *, _UNKNOWN **, long long))PSI_server + 4))("myisam", &all_myisam_files, 4LL);
(*((void ( **)(char *, _UNKNOWN **, long long))PSI_server + 3))("myisam", &all_myisam_threads, 1LL);
return (*((long long ( **)(char *, _UNKNOWN **, long long))PSI_server + 123))(
"myisam",
&all_myisam_memory,
21LL);
}
| init_myisam_psi_keys:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA R14,[0x4368c8]
MOV RAX,qword ptr [R14]
LEA RBX,[0x197604]
LEA RSI,[0x434ae0]
MOV RDI,RBX
MOV EDX,0x3
CALL qword ptr [RAX]
MOV RAX,qword ptr [R14]
LEA RSI,[0x434b30]
MOV RDI,RBX
MOV EDX,0x2
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14]
LEA RSI,[0x434b60]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
LEA RSI,[0x434b80]
MOV RDI,RBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x20]
MOV RAX,qword ptr [R14]
LEA RSI,[0x434be0]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x18]
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x3d8]
LEA RSI,[0x434c00]
MOV RDI,RBX
MOV EDX,0x15
POP RBX
POP R14
POP RBP
JMP RAX
|
void init_myisam_psi_keys(void)
{
(**(code **)PSI_server)("myisam",all_myisam_mutexes,3);
(**(code **)(PSI_server + 8))("myisam",all_myisam_rwlocks,2);
(**(code **)(PSI_server + 0x10))("myisam",all_myisam_conds,1);
(**(code **)(PSI_server + 0x20))("myisam",all_myisam_files,4);
(**(code **)(PSI_server + 0x18))("myisam",all_myisam_threads,1);
/* WARNING: Could not recover jumptable at 0x0014025e. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(PSI_server + 0x3d8))("myisam",all_myisam_memory,0x15);
return;
}
| |
35,252 | compare_columns | eloqsql/storage/maria/ma_create.c | static int compare_columns(MARIA_COLUMNDEF **a_ptr, MARIA_COLUMNDEF **b_ptr)
{
MARIA_COLUMNDEF *a= *a_ptr, *b= *b_ptr;
enum en_fieldtype a_type, b_type;
a_type= (a->type == FIELD_CHECK) ? FIELD_NORMAL : a->type;
b_type= (b->type == FIELD_CHECK) ? FIELD_NORMAL : b->type;
if (a_type == FIELD_NORMAL && !a->null_bit)
{
if (b_type != FIELD_NORMAL || b->null_bit)
return -1;
return sign((long) a->offset - (long) b->offset);
}
if (b_type == FIELD_NORMAL && !b->null_bit)
return 1;
if (a_type == b_type)
return sign((long) a->offset - (long) b->offset);
if (a_type == FIELD_NORMAL)
return -1;
if (b_type == FIELD_NORMAL)
return 1;
if (a_type == FIELD_SKIP_ZERO)
return -1;
if (b_type == FIELD_SKIP_ZERO)
return 1;
if (a->type != FIELD_BLOB && b->type != FIELD_BLOB)
if (a->length != b->length)
return sign((long) a->length - (long) b->length);
if (a_type == FIELD_BLOB)
return 1;
if (b_type == FIELD_BLOB)
return -1;
return sign((long) a->offset - (long) b->offset);
} | O3 | c | compare_columns:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq (%rsi), %rcx
movl (%rdx), %r8d
xorl %esi, %esi
cmpl $0x9, %r8d
movl %r8d, %edi
cmovel %esi, %edi
movl (%rcx), %r9d
cmpl $0x9, %r9d
cmovnel %r9d, %esi
testl %edi, %edi
jne 0x4590c
cmpb $0x0, 0x12(%rdx)
je 0x4599d
testl %esi, %esi
jne 0x4591a
cmpb $0x0, 0x12(%rcx)
je 0x459b1
cmpl %esi, %edi
jne 0x45936
movl 0x4(%rdx), %eax
xorl %edx, %edx
cmpl 0x4(%rcx), %eax
setne %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %edx, %eax
jmp 0x459b6
testl %esi, %esi
sete %r11b
xorl %eax, %eax
testl %edi, %edi
sete %r10b
orb %r10b, %r11b
je 0x45953
movb %r10b, %al
negl %eax
orl $0x1, %eax
jmp 0x459b6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x3, %edi
je 0x459b6
movl $0x1, %eax
cmpl $0x3, %esi
je 0x459b6
cmpl $0x4, %r8d
sete %r8b
cmpl $0x4, %r9d
sete %r9b
orb %r8b, %r9b
jne 0x4598c
movzwl 0x8(%rdx), %r8d
movzwl 0x8(%rcx), %r9d
cmpw %r9w, %r8w
jne 0x459b8
cmpl $0x4, %edi
je 0x459b6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x4, %esi
jne 0x4591e
jmp 0x459b6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
jne 0x459b6
cmpb $0x0, 0x12(%rcx)
jne 0x459b6
jmp 0x4591e
movl $0x1, %eax
popq %rbp
retq
xorl %eax, %eax
cmpw %r9w, %r8w
sbbl %eax, %eax
jmp 0x4594e
| compare_columns:
push rbp
mov rbp, rsp
mov rdx, [rdi]
mov rcx, [rsi]
mov r8d, [rdx]
xor esi, esi
cmp r8d, 9
mov edi, r8d
cmovz edi, esi
mov r9d, [rcx]
cmp r9d, 9
cmovnz esi, r9d
test edi, edi
jnz short loc_4590C
cmp byte ptr [rdx+12h], 0
jz loc_4599D
loc_4590C:
test esi, esi
jnz short loc_4591A
cmp byte ptr [rcx+12h], 0
jz loc_459B1
loc_4591A:
cmp edi, esi
jnz short loc_45936
loc_4591E:
mov eax, [rdx+4]
xor edx, edx
cmp eax, [rcx+4]
setnz dl
mov eax, 0FFFFFFFFh
cmovnb eax, edx
jmp loc_459B6
loc_45936:
test esi, esi
setz r11b
xor eax, eax
test edi, edi
setz r10b
or r11b, r10b
jz short loc_45953
mov al, r10b
neg eax
loc_4594E:
or eax, 1
jmp short loc_459B6
loc_45953:
mov eax, 0FFFFFFFFh
cmp edi, 3
jz short loc_459B6
mov eax, 1
cmp esi, 3
jz short loc_459B6
cmp r8d, 4
setz r8b
cmp r9d, 4
setz r9b
or r9b, r8b
jnz short loc_4598C
movzx r8d, word ptr [rdx+8]
movzx r9d, word ptr [rcx+8]
cmp r8w, r9w
jnz short loc_459B8
loc_4598C:
cmp edi, 4
jz short loc_459B6
mov eax, 0FFFFFFFFh
cmp esi, 4
jnz short loc_4591E
jmp short loc_459B6
loc_4599D:
mov eax, 0FFFFFFFFh
test esi, esi
jnz short loc_459B6
cmp byte ptr [rcx+12h], 0
jnz short loc_459B6
jmp loc_4591E
loc_459B1:
mov eax, 1
loc_459B6:
pop rbp
retn
loc_459B8:
xor eax, eax
cmp r8w, r9w
sbb eax, eax
jmp short loc_4594E
| long long compare_columns(int **a1, int **a2)
{
int *v2; // rdx
int *v3; // rcx
int v4; // r8d
int v5; // esi
int v6; // edi
unsigned int v7; // eax
bool v8; // cf
BOOL v9; // edx
long long result; // rax
int v11; // eax
int v12; // eax
unsigned __int16 v13; // r8
unsigned __int16 v14; // r9
v2 = *a1;
v3 = *a2;
v5 = 0;
v6 = **a1;
v4 = v6;
if ( v6 == 9 )
v6 = 0;
if ( *v3 != 9 )
v5 = *v3;
if ( !v6 && !*((_BYTE *)v2 + 18) )
{
result = 0xFFFFFFFFLL;
if ( v5 || *((_BYTE *)v3 + 18) )
return result;
LABEL_10:
v7 = v2[1];
v8 = v7 < v3[1];
v9 = v7 != v3[1];
result = 0xFFFFFFFFLL;
if ( !v8 )
return v9;
return result;
}
if ( !v5 && !*((_BYTE *)v3 + 18) )
return 1LL;
if ( v6 == v5 )
goto LABEL_10;
v11 = 0;
if ( v6 == 0 || v5 == 0 )
{
LOBYTE(v11) = v6 == 0;
v12 = -v11;
return v12 | 1u;
}
result = 0xFFFFFFFFLL;
if ( v6 != 3 )
{
result = 1LL;
if ( v5 != 3 )
{
if ( v4 != 4 && *v3 != 4 )
{
v13 = *((_WORD *)v2 + 4);
v14 = *((_WORD *)v3 + 4);
if ( v13 != v14 )
{
v12 = -(v13 < v14);
return v12 | 1u;
}
}
if ( v6 != 4 )
{
result = 0xFFFFFFFFLL;
if ( v5 != 4 )
goto LABEL_10;
}
}
}
return result;
}
| compare_columns:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI]
MOV RCX,qword ptr [RSI]
MOV R8D,dword ptr [RDX]
XOR ESI,ESI
CMP R8D,0x9
MOV EDI,R8D
CMOVZ EDI,ESI
MOV R9D,dword ptr [RCX]
CMP R9D,0x9
CMOVNZ ESI,R9D
TEST EDI,EDI
JNZ 0x0014590c
CMP byte ptr [RDX + 0x12],0x0
JZ 0x0014599d
LAB_0014590c:
TEST ESI,ESI
JNZ 0x0014591a
CMP byte ptr [RCX + 0x12],0x0
JZ 0x001459b1
LAB_0014591a:
CMP EDI,ESI
JNZ 0x00145936
LAB_0014591e:
MOV EAX,dword ptr [RDX + 0x4]
XOR EDX,EDX
CMP EAX,dword ptr [RCX + 0x4]
SETNZ DL
MOV EAX,0xffffffff
CMOVNC EAX,EDX
JMP 0x001459b6
LAB_00145936:
TEST ESI,ESI
SETZ R11B
XOR EAX,EAX
TEST EDI,EDI
SETZ R10B
OR R11B,R10B
JZ 0x00145953
MOV AL,R10B
NEG EAX
LAB_0014594e:
OR EAX,0x1
JMP 0x001459b6
LAB_00145953:
MOV EAX,0xffffffff
CMP EDI,0x3
JZ 0x001459b6
MOV EAX,0x1
CMP ESI,0x3
JZ 0x001459b6
CMP R8D,0x4
SETZ R8B
CMP R9D,0x4
SETZ R9B
OR R9B,R8B
JNZ 0x0014598c
MOVZX R8D,word ptr [RDX + 0x8]
MOVZX R9D,word ptr [RCX + 0x8]
CMP R8W,R9W
JNZ 0x001459b8
LAB_0014598c:
CMP EDI,0x4
JZ 0x001459b6
MOV EAX,0xffffffff
CMP ESI,0x4
JNZ 0x0014591e
JMP 0x001459b6
LAB_0014599d:
MOV EAX,0xffffffff
TEST ESI,ESI
JNZ 0x001459b6
CMP byte ptr [RCX + 0x12],0x0
JNZ 0x001459b6
JMP 0x0014591e
LAB_001459b1:
MOV EAX,0x1
LAB_001459b6:
POP RBP
RET
LAB_001459b8:
XOR EAX,EAX
CMP R8W,R9W
SBB EAX,EAX
JMP 0x0014594e
|
uint compare_columns(int8 *param_1,int8 *param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int iVar6;
int iVar7;
bool bVar8;
piVar3 = (int *)*param_1;
piVar4 = (int *)*param_2;
iVar1 = *piVar3;
iVar7 = iVar1;
if (iVar1 == 9) {
iVar7 = 0;
}
iVar2 = *piVar4;
iVar6 = 0;
if (iVar2 != 9) {
iVar6 = iVar2;
}
if ((iVar7 == 0) && (*(char *)((long)piVar3 + 0x12) == '\0')) {
if (iVar6 != 0) {
return 0xffffffff;
}
if (*(char *)((long)piVar4 + 0x12) != '\0') {
return 0xffffffff;
}
}
else {
if ((iVar6 == 0) && (*(char *)((long)piVar4 + 0x12) == '\0')) {
return 1;
}
if (iVar7 != iVar6) {
bVar8 = iVar7 == 0;
if (iVar6 == 0 || bVar8) {
LAB_0014594e:
return -(uint)bVar8 | 1;
}
if (iVar7 == 3) {
return 0xffffffff;
}
if (iVar6 == 3) {
return 1;
}
if (iVar2 != 4 && iVar1 != 4) {
if (*(ushort *)(piVar3 + 2) != *(ushort *)(piVar4 + 2)) {
bVar8 = *(ushort *)(piVar3 + 2) < *(ushort *)(piVar4 + 2);
goto LAB_0014594e;
}
}
if (iVar7 == 4) {
return 1;
}
if (iVar6 == 4) {
return 0xffffffff;
}
}
}
uVar5 = 0xffffffff;
if ((uint)piVar4[1] <= (uint)piVar3[1]) {
uVar5 = (uint)(piVar3[1] != piVar4[1]);
}
return uVar5;
}
| |
35,253 | 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 0x5c166
leaq 0x27e442(%rip), %rbx # 0x2da590
movzbl (%rax), %edx
testb $0x8, (%rdx,%rbx)
je 0x5c18c
incq %rax
movq %rax, 0x130(%r14)
cmpq %rcx, %rax
jne 0x5c14e
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 0x5c1b4
cmpl $0x2d2d213c, (%r13) # imm = 0x2D2D213C
je 0x5c21d
leaq 0x9(%r13), %rax
cmpq %r12, %rax
ja 0x5c1dd
movabsq $0x41544144435b213c, %rcx # imm = 0x41544144435B213C
xorq (%r13), %rcx
movzbl 0x8(%r13), %edx
xorq $0x5b, %rdx
orq %rcx, %rdx
je 0x5c2ca
movq %rsi, -0x30(%rbp)
movsbl (%r13), %r15d
leaq 0x5bef(%rip), %rdi # 0x61ddc
movl $0x7, %edx
movl %r15d, %esi
callq 0x243a0
testq %rax, %rax
je 0x5c259
incq %r13
movq %r13, 0x130(%r14)
movq -0x30(%rbp), %rax
movq %r13, 0x8(%rax)
movq (%rax), %rax
movsbl (%rax), %r15d
jmp 0x5c17a
leaq 0x3(%r13), %rax
cmpq %r12, %rax
ja 0x5c242
movzwl (%r13), %ecx
xorl $0x2d2d, %ecx # imm = 0x2D2D
movzbl 0x2(%r13), %edx
xorl $0x3e, %edx
orw %cx, %dx
je 0x5c360
incq %r13
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jne 0x5c21d
movq %r12, %rax
jmp 0x5c367
movzbl %r15b, %eax
cmpq $0x27, %rax
movq -0x30(%rbp), %rdi
je 0x5c270
cmpl $0x22, %eax
jne 0x5c31d
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5c28f
movb (%rax), %cl
movq (%rdi), %rdx
leaq 0x1(%rax), %r13
cmpb (%rdx), %cl
jne 0x5c273
movq %rax, 0x8(%rdi)
movq 0x130(%r14), %rax
cmpq 0x138(%r14), %rax
jae 0x5c2ad
incq %rax
movq %rax, 0x130(%r14)
incq (%rdi)
movl $0x53, %r15d
testb $0x2, (%r14)
jne 0x5c17a
callq 0x5c75b
jmp 0x5c17a
leaq -0x2(%r12), %rcx
movq %rax, 0x130(%r14)
movl $0x44, %r15d
cmpq %rcx, %rax
jae 0x5c17a
subq %r13, %r12
addq $0xc, %r13
addq $-0xb, %r12
cmpb $0x5d, -0x3(%r13)
jne 0x5c305
cmpb $0x5d, -0x2(%r13)
jne 0x5c305
cmpb $0x3e, -0x1(%r13)
je 0x5c376
leaq -0x2(%r13), %rax
movq %rax, 0x130(%r14)
incq %r13
decq %r12
jne 0x5c2f0
jmp 0x5c17a
movl $0x55, %r15d
testb $0x1, (%rax,%rbx)
je 0x5c17a
incq %r13
movq %r13, %rax
movq %r13, 0x130(%r14)
cmpq %r12, %r13
jae 0x5c34c
movzbl (%rax), %ecx
leaq 0x1(%rax), %r13
testb $0x2, (%rcx,%rbx)
jne 0x5c330
movq %rax, 0x8(%rdi)
callq 0x5c75b
movl $0x49, %r15d
jmp 0x5c17a
movq %rax, 0x130(%r14)
movq %rax, 0x8(%rsi)
movl $0x43, %r15d
jmp 0x5c17a
movq %r13, 0x130(%r14)
movq %r13, 0x8(%rsi)
jmp 0x5c17a
| 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_5C166
lea rbx, my_xml_ctype
loc_5C14E:
movzx edx, byte ptr [rax]
test byte ptr [rdx+rbx], 8
jz short loc_5C18C
inc rax
mov [r14+130h], rax
cmp rax, rcx
jnz short loc_5C14E
loc_5C166:
mov [rsi], rcx
mov rax, [r14+138h]
mov [rsi+8], rax
mov r15d, 45h ; 'E'
loc_5C17A:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5C18C:
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_5C1B4
cmp dword ptr [r13+0], 2D2D213Ch
jz short loc_5C21D
loc_5C1B4:
lea rax, [r13+9]
cmp rax, r12
ja short loc_5C1DD
mov rcx, 41544144435B213Ch
xor rcx, [r13+0]
movzx edx, byte ptr [r13+8]
xor rdx, 5Bh
or rdx, rcx
jz loc_5C2CA
loc_5C1DD:
mov [rbp+var_30], rsi
movsx r15d, byte ptr [r13+0]
lea rdi, asc_61DDC; "?=/<>!"
mov edx, 7
mov esi, r15d
call _memchr
test rax, rax
jz short loc_5C259
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_5C17A
loc_5C21D:
lea rax, [r13+3]
cmp rax, r12
ja short loc_5C242
movzx ecx, word ptr [r13+0]
xor ecx, 2D2Dh
movzx edx, byte ptr [r13+2]
xor edx, 3Eh
or dx, cx
jz loc_5C360
loc_5C242:
inc r13
mov [r14+130h], r13
cmp r13, r12
jnz short loc_5C21D
mov rax, r12
jmp loc_5C367
loc_5C259:
movzx eax, r15b
cmp rax, 27h ; '''
mov rdi, [rbp+var_30]
jz short loc_5C270
cmp eax, 22h ; '"'
jnz loc_5C31D
loc_5C270:
inc r13
loc_5C273:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5C28F
mov cl, [rax]
mov rdx, [rdi]
lea r13, [rax+1]
cmp cl, [rdx]
jnz short loc_5C273
loc_5C28F:
mov [rdi+8], rax
mov rax, [r14+130h]
cmp rax, [r14+138h]
jnb short loc_5C2AD
inc rax
mov [r14+130h], rax
loc_5C2AD:
inc qword ptr [rdi]
mov r15d, 53h ; 'S'
test byte ptr [r14], 2
jnz loc_5C17A
call my_xml_norm_text
jmp loc_5C17A
loc_5C2CA:
lea rcx, [r12-2]
mov [r14+130h], rax
mov r15d, 44h ; 'D'
cmp rax, rcx
jnb loc_5C17A
sub r12, r13
add r13, 0Ch
add r12, 0FFFFFFFFFFFFFFF5h
loc_5C2F0:
cmp byte ptr [r13-3], 5Dh ; ']'
jnz short loc_5C305
cmp byte ptr [r13-2], 5Dh ; ']'
jnz short loc_5C305
cmp byte ptr [r13-1], 3Eh ; '>'
jz short loc_5C376
loc_5C305:
lea rax, [r13-2]
mov [r14+130h], rax
inc r13
dec r12
jnz short loc_5C2F0
jmp loc_5C17A
loc_5C31D:
mov r15d, 55h ; 'U'
test byte ptr [rax+rbx], 1
jz loc_5C17A
inc r13
loc_5C330:
mov rax, r13
mov [r14+130h], r13
cmp r13, r12
jnb short loc_5C34C
movzx ecx, byte ptr [rax]
lea r13, [rax+1]
test byte ptr [rcx+rbx], 2
jnz short loc_5C330
loc_5C34C:
mov [rdi+8], rax
call my_xml_norm_text
mov r15d, 49h ; 'I'
jmp loc_5C17A
loc_5C360:
mov [r14+130h], rax
loc_5C367:
mov [rsi+8], rax
mov r15d, 43h ; 'C'
jmp loc_5C17A
loc_5C376:
mov [r14+130h], r13
mov [rsi+8], r13
jmp loc_5C17A
| 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 0x0015c166
LEA RBX,[0x3da590]
LAB_0015c14e:
MOVZX EDX,byte ptr [RAX]
TEST byte ptr [RDX + RBX*0x1],0x8
JZ 0x0015c18c
INC RAX
MOV qword ptr [R14 + 0x130],RAX
CMP RAX,RCX
JNZ 0x0015c14e
LAB_0015c166:
MOV qword ptr [RSI],RCX
MOV RAX,qword ptr [R14 + 0x138]
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x45
LAB_0015c17a:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015c18c:
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 0x0015c1b4
CMP dword ptr [R13],0x2d2d213c
JZ 0x0015c21d
LAB_0015c1b4:
LEA RAX,[R13 + 0x9]
CMP RAX,R12
JA 0x0015c1dd
MOV RCX,0x41544144435b213c
XOR RCX,qword ptr [R13]
MOVZX EDX,byte ptr [R13 + 0x8]
XOR RDX,0x5b
OR RDX,RCX
JZ 0x0015c2ca
LAB_0015c1dd:
MOV qword ptr [RBP + -0x30],RSI
MOVSX R15D,byte ptr [R13]
LEA RDI,[0x161ddc]
MOV EDX,0x7
MOV ESI,R15D
CALL 0x001243a0
TEST RAX,RAX
JZ 0x0015c259
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 0x0015c17a
LAB_0015c21d:
LEA RAX,[R13 + 0x3]
CMP RAX,R12
JA 0x0015c242
MOVZX ECX,word ptr [R13]
XOR ECX,0x2d2d
MOVZX EDX,byte ptr [R13 + 0x2]
XOR EDX,0x3e
OR DX,CX
JZ 0x0015c360
LAB_0015c242:
INC R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNZ 0x0015c21d
MOV RAX,R12
JMP 0x0015c367
LAB_0015c259:
MOVZX EAX,R15B
CMP RAX,0x27
MOV RDI,qword ptr [RBP + -0x30]
JZ 0x0015c270
CMP EAX,0x22
JNZ 0x0015c31d
LAB_0015c270:
INC R13
LAB_0015c273:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015c28f
MOV CL,byte ptr [RAX]
MOV RDX,qword ptr [RDI]
LEA R13,[RAX + 0x1]
CMP CL,byte ptr [RDX]
JNZ 0x0015c273
LAB_0015c28f:
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [R14 + 0x130]
CMP RAX,qword ptr [R14 + 0x138]
JNC 0x0015c2ad
INC RAX
MOV qword ptr [R14 + 0x130],RAX
LAB_0015c2ad:
INC qword ptr [RDI]
MOV R15D,0x53
TEST byte ptr [R14],0x2
JNZ 0x0015c17a
CALL 0x0015c75b
JMP 0x0015c17a
LAB_0015c2ca:
LEA RCX,[R12 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
MOV R15D,0x44
CMP RAX,RCX
JNC 0x0015c17a
SUB R12,R13
ADD R13,0xc
ADD R12,-0xb
LAB_0015c2f0:
CMP byte ptr [R13 + -0x3],0x5d
JNZ 0x0015c305
CMP byte ptr [R13 + -0x2],0x5d
JNZ 0x0015c305
CMP byte ptr [R13 + -0x1],0x3e
JZ 0x0015c376
LAB_0015c305:
LEA RAX,[R13 + -0x2]
MOV qword ptr [R14 + 0x130],RAX
INC R13
DEC R12
JNZ 0x0015c2f0
JMP 0x0015c17a
LAB_0015c31d:
MOV R15D,0x55
TEST byte ptr [RAX + RBX*0x1],0x1
JZ 0x0015c17a
INC R13
LAB_0015c330:
MOV RAX,R13
MOV qword ptr [R14 + 0x130],R13
CMP R13,R12
JNC 0x0015c34c
MOVZX ECX,byte ptr [RAX]
LEA R13,[RAX + 0x1]
TEST byte ptr [RCX + RBX*0x1],0x2
JNZ 0x0015c330
LAB_0015c34c:
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015c75b
MOV R15D,0x49
JMP 0x0015c17a
LAB_0015c360:
MOV qword ptr [R14 + 0x130],RAX
LAB_0015c367:
MOV qword ptr [RSI + 0x8],RAX
MOV R15D,0x43
JMP 0x0015c17a
LAB_0015c376:
MOV qword ptr [R14 + 0x130],R13
MOV qword ptr [RSI + 0x8],R13
JMP 0x0015c17a
|
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_0015c21d;
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_0015c273;
if ((my_xml_ctype[uVar2] & 1) == 0) {
return 0x55;
}
goto LAB_0015c330;
}
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_0015c21d:
pbVar6 = pbVar3 + 3;
if ((pbVar6 <= pbVar5) && (pbVar3[2] == 0x3e && *(short *)pbVar3 == 0x2d2d)) {
*(byte **)(param_1 + 0x130) = pbVar6;
pbVar5 = pbVar6;
goto LAB_0015c367;
}
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar3 == pbVar5) {
LAB_0015c367:
param_2[1] = (long)pbVar5;
return 0x43;
}
goto LAB_0015c21d;
while (*pbVar3 != *(byte *)*param_2) {
LAB_0015c273:
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_0015c330:
pbVar3 = pbVar3 + 1;
*(byte **)(param_1 + 0x130) = pbVar3;
if (pbVar5 <= pbVar3) break;
}
param_2[1] = (long)pbVar3;
my_xml_norm_text();
return 0x49;
}
| |
35,254 | ggml_vec_dot_q4_1_q8_1 | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void ggml_vec_dot_q4_1_q8_1(const int n, float * restrict s, const void * restrict vx, const void * restrict vy) {
const int qk = QK8_1;
const int nb = n / qk;
assert(n % qk == 0);
const block_q4_1 * restrict x = vx;
const block_q8_1 * restrict y = vy;
// TODO: add WASM SIMD
#if defined(__ARM_NEON)
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t sumv1 = vdupq_n_f32(0.0f);
float summs = 0;
assert(nb % 2 == 0); // TODO: handle odd nb
for (int i = 0; i < nb; i += 2) {
const block_q4_1 * restrict x0 = &x[i + 0];
const block_q4_1 * restrict x1 = &x[i + 1];
const block_q8_1 * restrict y0 = &y[i + 0];
const block_q8_1 * restrict y1 = &y[i + 1];
summs += GGML_FP16_TO_FP32(x0->m) * y0->s + GGML_FP16_TO_FP32(x1->m) * y1->s;
const uint8x16_t m4b = vdupq_n_u8(0x0F);
const uint8x16_t v0_0 = vld1q_u8(x0->qs);
const uint8x16_t v0_1 = vld1q_u8(x1->qs);
// 4-bit -> 8-bit
const int8x16_t v0_0l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t v0_0h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t v0_1l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t v0_1h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// load y
const int8x16_t v1_0l = vld1q_s8(y0->qs);
const int8x16_t v1_0h = vld1q_s8(y0->qs + 16);
const int8x16_t v1_1l = vld1q_s8(y1->qs);
const int8x16_t v1_1h = vld1q_s8(y1->qs + 16);
// dot product into int32x4_t
const int32x4_t p_0 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_0l, v1_0l), v0_0h, v1_0h);
const int32x4_t p_1 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_1l, v1_1l), v0_1h, v1_1h);
sumv0 = vmlaq_n_f32(sumv0, vcvtq_f32_s32(p_0), GGML_FP16_TO_FP32(x0->d)*y0->d);
sumv1 = vmlaq_n_f32(sumv1, vcvtq_f32_s32(p_1), GGML_FP16_TO_FP32(x1->d)*y1->d);
}
*s = vaddvq_f32(sumv0) + vaddvq_f32(sumv1) + summs;
#elif defined(__AVX2__) || defined(__AVX__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
float summs = 0;
// Main loop
for (int i = 0; i < nb; ++i) {
const float d0 = GGML_FP16_TO_FP32(x[i].d);
const float d1 = y[i].d;
summs += GGML_FP16_TO_FP32(x[i].m) * y[i].s;
const __m256 d0v = _mm256_set1_ps( d0 );
const __m256 d1v = _mm256_set1_ps( d1 );
// Compute combined scales
const __m256 d0d1 = _mm256_mul_ps( d0v, d1v );
// Load 16 bytes, and unpack 4 bit fields into bytes, making 32 bytes
const __m256i bx = bytes_from_nibbles_32(x[i].qs);
const __m256i by = _mm256_loadu_si256( (const __m256i *)y[i].qs );
const __m256 xy = mul_sum_us8_pairs_float(bx, by);
// Accumulate d0*d1*x*y
#if defined(__AVX2__)
acc = _mm256_fmadd_ps( d0d1, xy, acc );
#else
acc = _mm256_add_ps( _mm256_mul_ps( d0d1, xy ), acc );
#endif
}
*s = hsum_float_8(acc) + summs;
#elif defined(__riscv_v_intrinsic)
float sumf = 0.0;
size_t vl = __riscv_vsetvl_e8m1(qk/2);
for (int i = 0; i < nb; i++) {
// load elements
vuint8mf2_t tx = __riscv_vle8_v_u8mf2(x[i].qs, vl);
vint8mf2_t y0 = __riscv_vle8_v_i8mf2(y[i].qs, vl);
vint8mf2_t y1 = __riscv_vle8_v_i8mf2(y[i].qs+16, vl);
// mask and store lower part of x, and then upper part
vuint8mf2_t x_a = __riscv_vand_vx_u8mf2(tx, 0x0F, vl);
vuint8mf2_t x_l = __riscv_vsrl_vx_u8mf2(tx, 0x04, vl);
vint8mf2_t v0 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_a);
vint8mf2_t v1 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_l);
vint16m1_t vec_mul1 = __riscv_vwmul_vv_i16m1(v0, y0, vl);
vint16m1_t vec_mul2 = __riscv_vwmul_vv_i16m1(v1, y1, vl);
vint32m1_t vec_zero = __riscv_vmv_v_x_i32m1(0, vl);
vint32m1_t vs1 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul1, vec_zero, vl);
vint32m1_t vs2 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul2, vs1, vl);
int sumi = __riscv_vmv_x_s_i32m1_i32(vs2);
sumf += (GGML_FP16_TO_FP32(x[i].d)*y[i].d)*sumi + GGML_FP16_TO_FP32(x[i].m)*y[i].s;
}
*s = sumf;
#else
// scalar
float sumf = 0.0;
for (int i = 0; i < nb; i++) {
int sumi = 0;
for (int j = 0; j < qk/2; ++j) {
const int v0 = (x[i].qs[j] & 0x0F);
const int v1 = (x[i].qs[j] >> 4);
sumi += (v0 * y[i].qs[j]) + (v1 * y[i].qs[j + qk/2]);
}
sumf += (GGML_FP16_TO_FP32(x[i].d)*y[i].d)*sumi + GGML_FP16_TO_FP32(x[i].m)*y[i].s;
}
*s = sumf;
#endif
} | O1 | c | ggml_vec_dot_q4_1_q8_1:
cmpl $0x20, %edi
jl 0xb97ed
shrl $0x3, %edi
andl $-0x4, %edi
leaq (%rdi,%rdi,4), %rax
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
xorl %edi, %edi
leaq 0xc4b01(%rip), %r8 # 0x17e280
vpbroadcastb 0xf8a8(%rip), %ymm2 # 0xc9030
vpbroadcastw 0xf8a1(%rip), %ymm3 # 0xc9032
movzwl (%rdx,%rdi), %r9d
vmovss (%r8,%r9,4), %xmm4
movzwl 0x2(%rdx,%rdi), %r9d
vmovss (%r8,%r9,4), %xmm5
vfmadd231ss 0x4(%rcx,%rdi,2), %xmm5, %xmm0 # xmm0 = (xmm5 * mem) + xmm0
vmulss (%rcx,%rdi,2), %xmm4, %xmm4
vbroadcastss %xmm4, %ymm4
vmovdqu 0x4(%rdx,%rdi), %xmm5
vpsrlw $0x4, %xmm5, %xmm6
vinserti128 $0x1, %xmm6, %ymm5, %ymm5
vpand %ymm2, %ymm5, %ymm5
vpmaddubsw 0x8(%rcx,%rdi,2), %ymm5, %ymm5
vpmaddwd %ymm5, %ymm3, %ymm5
vcvtdq2ps %ymm5, %ymm5
vfmadd231ps %ymm5, %ymm4, %ymm1 # ymm1 = (ymm4 * ymm5) + ymm1
addq $0x14, %rdi
cmpq %rdi, %rax
jne 0xb9791
jmp 0xb97f5
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm1, %xmm2, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
vzeroupper
retq
| ggml_vec_dot_q4_1_q8_1:
cmp edi, 20h ; ' '
jl loc_B97ED
shr edi, 3
and edi, 0FFFFFFFCh
lea rax, [rdi+rdi*4]
vxorps xmm0, xmm0, xmm0
vxorps xmm1, xmm1, xmm1
xor edi, edi
lea r8, ggml_table_f32_f16
vpbroadcastb ymm2, cs:byte_C9030
vpbroadcastw ymm3, cs:word_C9032
loc_B9791:
movzx r9d, word ptr [rdx+rdi]
vmovss xmm4, dword ptr [r8+r9*4]
movzx r9d, word ptr [rdx+rdi+2]
vmovss xmm5, dword ptr [r8+r9*4]
vfmadd231ss xmm0, xmm5, dword ptr [rcx+rdi*2+4]
vmulss xmm4, xmm4, dword ptr [rcx+rdi*2]
vbroadcastss ymm4, xmm4
vmovdqu xmm5, xmmword ptr [rdx+rdi+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [rcx+rdi*2+8]
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
add rdi, 14h
cmp rax, rdi
jnz short loc_B9791
jmp short loc_B97F5
loc_B97ED:
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
loc_B97F5:
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
retn
| void ggml_vec_dot_q4_1_q8_1(int a1, long long _RSI, long long _RDX, __m128 _XMM0, __m128 _XMM1)
{
long long v7; // rax
if ( a1 < 32 )
{
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
}
else
{
v7 = 5LL * (((unsigned int)a1 >> 3) & 0xFFFFFFFC);
__asm
{
vxorps xmm0, xmm0, xmm0
vxorps xmm1, xmm1, xmm1
}
_RDI = 0LL;
_R8 = &ggml_table_f32_f16;
__asm
{
vpbroadcastb ymm2, cs:byte_C9030
vpbroadcastw ymm3, cs:word_C9032
}
do
{
_R9 = *(unsigned __int16 *)(_RDX + _RDI);
__asm { vmovss xmm4, dword ptr [r8+r9*4] }
_R9 = *(unsigned __int16 *)(_RDX + _RDI + 2);
__asm
{
vmovss xmm5, dword ptr [r8+r9*4]
vfmadd231ss xmm0, xmm5, dword ptr [rcx+rdi*2+4]
vmulss xmm4, xmm4, dword ptr [rcx+rdi*2]
vbroadcastss ymm4, xmm4
vmovdqu xmm5, xmmword ptr [rdx+rdi+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [rcx+rdi*2+8]
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
}
_RDI += 20LL;
}
while ( v7 != _RDI );
}
__asm
{
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
}
}
| |||
35,255 | ggml_vec_dot_q4_1_q8_1 | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | void ggml_vec_dot_q4_1_q8_1(const int n, float * restrict s, const void * restrict vx, const void * restrict vy) {
const int qk = QK8_1;
const int nb = n / qk;
assert(n % qk == 0);
const block_q4_1 * restrict x = vx;
const block_q8_1 * restrict y = vy;
// TODO: add WASM SIMD
#if defined(__ARM_NEON)
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t sumv1 = vdupq_n_f32(0.0f);
float summs = 0;
assert(nb % 2 == 0); // TODO: handle odd nb
for (int i = 0; i < nb; i += 2) {
const block_q4_1 * restrict x0 = &x[i + 0];
const block_q4_1 * restrict x1 = &x[i + 1];
const block_q8_1 * restrict y0 = &y[i + 0];
const block_q8_1 * restrict y1 = &y[i + 1];
summs += GGML_FP16_TO_FP32(x0->m) * y0->s + GGML_FP16_TO_FP32(x1->m) * y1->s;
const uint8x16_t m4b = vdupq_n_u8(0x0F);
const uint8x16_t v0_0 = vld1q_u8(x0->qs);
const uint8x16_t v0_1 = vld1q_u8(x1->qs);
// 4-bit -> 8-bit
const int8x16_t v0_0l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t v0_0h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t v0_1l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t v0_1h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// load y
const int8x16_t v1_0l = vld1q_s8(y0->qs);
const int8x16_t v1_0h = vld1q_s8(y0->qs + 16);
const int8x16_t v1_1l = vld1q_s8(y1->qs);
const int8x16_t v1_1h = vld1q_s8(y1->qs + 16);
// dot product into int32x4_t
const int32x4_t p_0 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_0l, v1_0l), v0_0h, v1_0h);
const int32x4_t p_1 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_1l, v1_1l), v0_1h, v1_1h);
sumv0 = vmlaq_n_f32(sumv0, vcvtq_f32_s32(p_0), GGML_FP16_TO_FP32(x0->d)*y0->d);
sumv1 = vmlaq_n_f32(sumv1, vcvtq_f32_s32(p_1), GGML_FP16_TO_FP32(x1->d)*y1->d);
}
*s = vaddvq_f32(sumv0) + vaddvq_f32(sumv1) + summs;
#elif defined(__AVX2__) || defined(__AVX__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
float summs = 0;
// Main loop
for (int i = 0; i < nb; ++i) {
const float d0 = GGML_FP16_TO_FP32(x[i].d);
const float d1 = y[i].d;
summs += GGML_FP16_TO_FP32(x[i].m) * y[i].s;
const __m256 d0v = _mm256_set1_ps( d0 );
const __m256 d1v = _mm256_set1_ps( d1 );
// Compute combined scales
const __m256 d0d1 = _mm256_mul_ps( d0v, d1v );
// Load 16 bytes, and unpack 4 bit fields into bytes, making 32 bytes
const __m256i bx = bytes_from_nibbles_32(x[i].qs);
const __m256i by = _mm256_loadu_si256( (const __m256i *)y[i].qs );
const __m256 xy = mul_sum_us8_pairs_float(bx, by);
// Accumulate d0*d1*x*y
#if defined(__AVX2__)
acc = _mm256_fmadd_ps( d0d1, xy, acc );
#else
acc = _mm256_add_ps( _mm256_mul_ps( d0d1, xy ), acc );
#endif
}
*s = hsum_float_8(acc) + summs;
#elif defined(__riscv_v_intrinsic)
float sumf = 0.0;
size_t vl = __riscv_vsetvl_e8m1(qk/2);
for (int i = 0; i < nb; i++) {
// load elements
vuint8mf2_t tx = __riscv_vle8_v_u8mf2(x[i].qs, vl);
vint8mf2_t y0 = __riscv_vle8_v_i8mf2(y[i].qs, vl);
vint8mf2_t y1 = __riscv_vle8_v_i8mf2(y[i].qs+16, vl);
// mask and store lower part of x, and then upper part
vuint8mf2_t x_a = __riscv_vand_vx_u8mf2(tx, 0x0F, vl);
vuint8mf2_t x_l = __riscv_vsrl_vx_u8mf2(tx, 0x04, vl);
vint8mf2_t v0 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_a);
vint8mf2_t v1 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_l);
vint16m1_t vec_mul1 = __riscv_vwmul_vv_i16m1(v0, y0, vl);
vint16m1_t vec_mul2 = __riscv_vwmul_vv_i16m1(v1, y1, vl);
vint32m1_t vec_zero = __riscv_vmv_v_x_i32m1(0, vl);
vint32m1_t vs1 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul1, vec_zero, vl);
vint32m1_t vs2 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul2, vs1, vl);
int sumi = __riscv_vmv_x_s_i32m1_i32(vs2);
sumf += (GGML_FP16_TO_FP32(x[i].d)*y[i].d)*sumi + GGML_FP16_TO_FP32(x[i].m)*y[i].s;
}
*s = sumf;
#else
// scalar
float sumf = 0.0;
for (int i = 0; i < nb; i++) {
int sumi = 0;
for (int j = 0; j < qk/2; ++j) {
const int v0 = (x[i].qs[j] & 0x0F);
const int v1 = (x[i].qs[j] >> 4);
sumi += (v0 * y[i].qs[j]) + (v1 * y[i].qs[j + qk/2]);
}
sumf += (GGML_FP16_TO_FP32(x[i].d)*y[i].d)*sumi + GGML_FP16_TO_FP32(x[i].m)*y[i].s;
}
*s = sumf;
#endif
} | O2 | c | ggml_vec_dot_q4_1_q8_1:
movq %rdx, %r8
movl %edi, %eax
pushq $0x20
popq %rdi
cltd
idivl %edi
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x14, %rax, %rax
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
leaq 0xc7e7a(%rip), %rdi # 0x15d290
vpbroadcastb 0xfb05(%rip), %ymm2 # 0xa4f24
vpbroadcastw 0xfafe(%rip), %ymm3 # 0xa4f26
cmpq %rdx, %rax
je 0x95485
movzwl (%r8,%rdx), %r9d
vmovss (%rdi,%r9,4), %xmm4
movzwl 0x2(%r8,%rdx), %r9d
vmovss (%rdi,%r9,4), %xmm5
vfmadd231ss 0x4(%rcx,%rdx,2), %xmm5, %xmm0 # xmm0 = (xmm5 * mem) + xmm0
vmulss (%rcx,%rdx,2), %xmm4, %xmm4
vbroadcastss %xmm4, %ymm4
vmovdqu 0x4(%r8,%rdx), %xmm5
vpsrlw $0x4, %xmm5, %xmm6
vinserti128 $0x1, %xmm6, %ymm5, %ymm5
vpand %ymm2, %ymm5, %ymm5
vpmaddubsw 0x8(%rcx,%rdx,2), %ymm5, %ymm5
vpmaddwd %ymm5, %ymm3, %ymm5
vcvtdq2ps %ymm5, %ymm5
vfmadd231ps %ymm5, %ymm4, %ymm1 # ymm1 = (ymm4 * ymm5) + ymm1
addq $0x14, %rdx
jmp 0x95428
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm1, %xmm2, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
vzeroupper
retq
| ggml_vec_dot_q4_1_q8_1:
mov r8, rdx
mov eax, edi
push 20h ; ' '
pop rdi
cdq
idiv edi
xor edx, edx
test eax, eax
cmovle eax, edx
imul rax, 14h
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
lea rdi, ggml_table_f32_f16
vpbroadcastb ymm2, cs:byte_A4F24
vpbroadcastw ymm3, cs:word_A4F26
loc_95428:
cmp rax, rdx
jz short loc_95485
movzx r9d, word ptr [r8+rdx]
vmovss xmm4, dword ptr [rdi+r9*4]
movzx r9d, word ptr [r8+rdx+2]
vmovss xmm5, dword ptr [rdi+r9*4]
vfmadd231ss xmm0, xmm5, dword ptr [rcx+rdx*2+4]
vmulss xmm4, xmm4, dword ptr [rcx+rdx*2]
vbroadcastss ymm4, xmm4
vmovdqu xmm5, xmmword ptr [r8+rdx+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [rcx+rdx*2+8]
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
add rdx, 14h
jmp short loc_95428
loc_95485:
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
retn
| long long ggml_vec_dot_q4_1_q8_1(int a1, long long _RSI, long long a3, __m128 _XMM0, __m128 _XMM1)
{
long long v8; // rax
long long result; // rax
_R8 = a3;
v8 = (unsigned int)(a1 / 32);
_RDX = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
result = 20 * v8;
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
_RDI = &ggml_table_f32_f16;
__asm
{
vpbroadcastb ymm2, cs:byte_A4F24
vpbroadcastw ymm3, cs:word_A4F26
}
while ( result != _RDX )
{
_R9 = *(unsigned __int16 *)(_R8 + _RDX);
__asm { vmovss xmm4, dword ptr [rdi+r9*4] }
_R9 = *(unsigned __int16 *)(_R8 + _RDX + 2);
__asm
{
vmovss xmm5, dword ptr [rdi+r9*4]
vfmadd231ss xmm0, xmm5, dword ptr [rcx+rdx*2+4]
vmulss xmm4, xmm4, dword ptr [rcx+rdx*2]
vbroadcastss ymm4, xmm4
vmovdqu xmm5, xmmword ptr [r8+rdx+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [rcx+rdx*2+8]
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
}
_RDX += 20LL;
}
__asm
{
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q4_1_q8_1:
MOV R8,RDX
MOV EAX,EDI
PUSH 0x20
POP RDI
CDQ
IDIV EDI
XOR EDX,EDX
TEST EAX,EAX
CMOVLE EAX,EDX
IMUL RAX,RAX,0x14
VXORPS XMM1,XMM1,XMM1
VXORPS XMM0,XMM0,XMM0
LEA RDI,[0x25d290]
VPBROADCASTB YMM2,byte ptr [0x001a4f24]
VPBROADCASTW YMM3,word ptr [0x001a4f26]
LAB_00195428:
CMP RAX,RDX
JZ 0x00195485
MOVZX R9D,word ptr [R8 + RDX*0x1]
VMOVSS XMM4,dword ptr [RDI + R9*0x4]
MOVZX R9D,word ptr [R8 + RDX*0x1 + 0x2]
VMOVSS XMM5,dword ptr [RDI + R9*0x4]
VFMADD231SS XMM0,XMM5,dword ptr [RCX + RDX*0x2 + 0x4]
VMULSS XMM4,XMM4,dword ptr [RCX + RDX*0x2]
VBROADCASTSS YMM4,XMM4
VMOVDQU XMM5,xmmword ptr [R8 + RDX*0x1 + 0x4]
VPSRLW XMM6,XMM5,0x4
VINSERTI128 YMM5,YMM5,XMM6,0x1
VPAND YMM5,YMM5,YMM2
VPMADDUBSW YMM5,YMM5,ymmword ptr [RCX + RDX*0x2 + 0x8]
VPMADDWD YMM5,YMM3,YMM5
VCVTDQ2PS YMM5,YMM5
VFMADD231PS YMM1,YMM4,YMM5
ADD RDX,0x14
JMP 0x00195428
LAB_00195485:
VEXTRACTF128 XMM2,YMM1,0x1
VADDPS XMM1,XMM2,XMM1
VSHUFPD XMM2,XMM1,XMM1,0x1
VADDPS XMM1,XMM1,XMM2
VHADDPS XMM1,XMM1,XMM1
VADDSS XMM0,XMM0,XMM1
VMOVSS dword ptr [RSI],XMM0
VZEROUPPER
RET
|
void ggml_vec_dot_q4_1_q8_1(int param_1,float *param_2,long param_3,long param_4)
{
float fVar1;
ulong uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [32];
int1 auVar8 [32];
int1 auVar9 [32];
int1 auVar10 [32];
int1 auVar11 [16];
uVar3 = 0;
uVar2 = (long)param_1 / 0x20 & 0xffffffff;
if ((int)((long)param_1 / 0x20) < 1) {
uVar2 = uVar3;
}
auVar5 = ZEXT816(0) << 0x40;
auVar4 = ZEXT816(0) << 0x40;
auVar7[1] = DAT_001a4f24;
auVar7[0] = DAT_001a4f24;
auVar7[2] = DAT_001a4f24;
auVar7[3] = DAT_001a4f24;
auVar7[4] = DAT_001a4f24;
auVar7[5] = DAT_001a4f24;
auVar7[6] = DAT_001a4f24;
auVar7[7] = DAT_001a4f24;
auVar7[8] = DAT_001a4f24;
auVar7[9] = DAT_001a4f24;
auVar7[10] = DAT_001a4f24;
auVar7[0xb] = DAT_001a4f24;
auVar7[0xc] = DAT_001a4f24;
auVar7[0xd] = DAT_001a4f24;
auVar7[0xe] = DAT_001a4f24;
auVar7[0xf] = DAT_001a4f24;
auVar7[0x10] = DAT_001a4f24;
auVar7[0x11] = DAT_001a4f24;
auVar7[0x12] = DAT_001a4f24;
auVar7[0x13] = DAT_001a4f24;
auVar7[0x14] = DAT_001a4f24;
auVar7[0x15] = DAT_001a4f24;
auVar7[0x16] = DAT_001a4f24;
auVar7[0x17] = DAT_001a4f24;
auVar7[0x18] = DAT_001a4f24;
auVar7[0x19] = DAT_001a4f24;
auVar7[0x1a] = DAT_001a4f24;
auVar7[0x1b] = DAT_001a4f24;
auVar7[0x1c] = DAT_001a4f24;
auVar7[0x1d] = DAT_001a4f24;
auVar7[0x1e] = DAT_001a4f24;
auVar7[0x1f] = DAT_001a4f24;
auVar8._2_2_ = DAT_001a4f26;
auVar8._0_2_ = DAT_001a4f26;
auVar8._4_2_ = DAT_001a4f26;
auVar8._6_2_ = DAT_001a4f26;
auVar8._8_2_ = DAT_001a4f26;
auVar8._10_2_ = DAT_001a4f26;
auVar8._12_2_ = DAT_001a4f26;
auVar8._14_2_ = DAT_001a4f26;
auVar8._16_2_ = DAT_001a4f26;
auVar8._18_2_ = DAT_001a4f26;
auVar8._20_2_ = DAT_001a4f26;
auVar8._22_2_ = DAT_001a4f26;
auVar8._24_2_ = DAT_001a4f26;
auVar8._26_2_ = DAT_001a4f26;
auVar8._28_2_ = DAT_001a4f26;
auVar8._30_2_ = DAT_001a4f26;
for (; uVar2 * 0x14 - uVar3 != 0; uVar3 = uVar3 + 0x14) {
auVar4 = vfmadd231ss_fma(auVar4,ZEXT416((uint)(&ggml_table_f32_f16)
[*(ushort *)(param_3 + 2 + uVar3)]),
ZEXT416(*(uint *)(param_4 + 4 + uVar3 * 2)));
fVar1 = (float)(&ggml_table_f32_f16)[*(ushort *)(param_3 + uVar3)] *
*(float *)(param_4 + uVar3 * 2);
auVar9._4_4_ = fVar1;
auVar9._0_4_ = fVar1;
auVar9._8_4_ = fVar1;
auVar9._12_4_ = fVar1;
auVar9._16_4_ = fVar1;
auVar9._20_4_ = fVar1;
auVar9._24_4_ = fVar1;
auVar9._28_4_ = fVar1;
auVar6 = *(int1 (*) [16])(param_3 + 4 + uVar3);
auVar11 = vpsrlw_avx(auVar6,4);
auVar10._0_16_ = ZEXT116(0) * auVar11 + ZEXT116(1) * auVar6;
auVar10._16_16_ = ZEXT116(0) * SUB4816((int1 [48])0x0,0) + ZEXT116(1) * auVar11;
auVar10 = vpand_avx2(auVar10,auVar7);
auVar10 = vpmaddubsw_avx2(auVar10,*(int1 (*) [32])(param_4 + 8 + uVar3 * 2));
auVar10 = vpmaddwd_avx2(auVar8,auVar10);
auVar10 = vcvtdq2ps_avx(auVar10);
auVar5 = vfmadd231ps_fma(ZEXT1632(auVar5),auVar9,auVar10);
}
auVar6._0_4_ = auVar5._0_4_ + 0.0;
auVar6._4_4_ = auVar5._4_4_ + 0.0;
auVar6._8_4_ = auVar5._8_4_ + 0.0;
auVar6._12_4_ = auVar5._12_4_ + 0.0;
auVar5 = vshufpd_avx(auVar6,auVar6,1);
auVar11._0_4_ = auVar6._0_4_ + auVar5._0_4_;
auVar11._4_4_ = auVar6._4_4_ + auVar5._4_4_;
auVar11._8_4_ = auVar6._8_4_ + auVar5._8_4_;
auVar11._12_4_ = auVar6._12_4_ + auVar5._12_4_;
auVar5 = vhaddps_avx(auVar11,auVar11);
*param_2 = auVar4._0_4_ + auVar5._0_4_;
return;
}
| |
35,256 | c4_update_from_sync_data | corpus-core[P]colibri-stateless/src/chains/eth/verifier/sync_committee.c | INTERNAL bool c4_update_from_sync_data(verify_ctx_t* ctx) {
if (ssz_is_error(ctx->sync_data)) RETURN_VERIFY_ERROR(ctx, "invalid sync_data!");
if (ctx->sync_data.def->type == SSZ_TYPE_NONE) return true;
if (ctx->sync_data.def == eth_ssz_verification_type(ETH_SSZ_VERIFY_LIGHT_CLIENT_UPDATE_LIST)) {
uint32_t updates_len = ssz_len(ctx->sync_data);
for (uint32_t i = 0; i < updates_len; i++) {
ssz_ob_t update = ssz_at(ctx->sync_data, i);
if (ssz_is_error(update)) RETURN_VERIFY_ERROR(ctx, "invalid sync_data!");
if (!update_light_client_update(ctx, &update, NULL)) return false;
}
return true;
}
else
RETURN_VERIFY_ERROR(ctx, "unknown sync_data type!");
} | O2 | c | c4_update_from_sync_data:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0x29dff
cmpq $0x0, 0x58(%rbx)
je 0x29dff
movb $0x1, %bpl
cmpl $0x8, 0x8(%r14)
je 0x29e15
pushq $0xa
popq %rdi
callq 0x258a4
cmpq %rax, %r14
je 0x29d8d
leaq 0x70(%rbx), %rdi
leaq 0x4bb60(%rip), %rsi # 0x758eb
jmp 0x29e0a
leaq 0x50(%rbx), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
xorl %r14d, %r14d
callq 0x4c626
movl %eax, %r15d
leaq 0x20(%rsp), %r12
cmpl %r14d, %r15d
sete %bpl
je 0x29e15
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movl %r14d, %esi
callq 0x4c4b1
cmpq $0x0, 0x30(%rsp)
je 0x29dff
cmpq $0x0, 0x28(%rsp)
je 0x29dff
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x29e26
incl %r14d
testb %al, %al
jne 0x29db3
jmp 0x29e15
leaq 0x70(%rbx), %rdi
leaq 0x4bace(%rip), %rsi # 0x758d8
callq 0x50675
movb $0x0, 0x68(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| c4_update_from_sync_data:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, [rdi+60h]
test r14, r14
jz loc_29DFF
cmp qword ptr [rbx+58h], 0
jz loc_29DFF
mov bpl, 1
cmp dword ptr [r14+8], 8
jz loc_29E15
push 0Ah
pop rdi
call eth_ssz_verification_type
cmp r14, rax
jz short loc_29D8D
lea rdi, [rbx+70h]
lea rsi, aUnknownSyncDat; "unknown sync_data type!"
jmp short loc_29E0A
loc_29D8D:
lea r13, [rbx+50h]
mov rax, [r13+10h]
mov [rsp+68h+var_58], rax
movups xmm0, xmmword ptr [r13+0]
movups [rsp+68h+var_68], xmm0
xor r14d, r14d
call ssz_len
mov r15d, eax
lea r12, [rsp+68h+var_48]
loc_29DB3:
cmp r15d, r14d
setz bpl
jz short loc_29E15
mov rax, [r13+10h]
mov [rsp+68h+var_58], rax
movups xmm0, xmmword ptr [r13+0]
movups [rsp+68h+var_68], xmm0
mov rdi, r12
mov esi, r14d
call ssz_at
cmp [rsp+68h+var_38], 0
jz short loc_29DFF
cmp [rsp+68h+var_40], 0
jz short loc_29DFF
mov rdi, rbx
mov rsi, r12
xor edx, edx
call update_light_client_update
inc r14d
test al, al
jnz short loc_29DB3
jmp short loc_29E15
loc_29DFF:
lea rdi, [rbx+70h]
lea rsi, aInvalidSyncDat; "invalid sync_data!"
loc_29E0A:
call c4_state_add_error
mov byte ptr [rbx+68h], 0
xor ebp, ebp
loc_29E15:
mov eax, ebp
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long c4_update_from_sync_data(long long a1, int a2)
{
unsigned int v2; // ebp
long long v4; // r14
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long v9; // rdi
const char *v10; // rsi
int v11; // r14d
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
int v16; // r15d
_BYTE v18[8]; // [rsp+20h] [rbp-48h] BYREF
long long v19; // [rsp+28h] [rbp-40h]
long long v20; // [rsp+30h] [rbp-38h]
v4 = *(_QWORD *)(a1 + 96);
if ( !v4 || !*(_QWORD *)(a1 + 88) )
{
LABEL_12:
v9 = a1 + 112;
v10 = "invalid sync_data!";
goto LABEL_13;
}
LOBYTE(v2) = 1;
if ( *(_DWORD *)(v4 + 8) != 8 )
{
if ( (char **)v4 != eth_ssz_verification_type(10) )
{
v9 = a1 + 112;
v10 = "unknown sync_data type!";
LABEL_13:
c4_state_add_error(v9, v10);
*(_BYTE *)(a1 + 104) = 0;
return 0;
}
v11 = 0;
v16 = ssz_len(10, a2, v5, v6, v7, v8, *(_OWORD *)(a1 + 80), *(_QWORD *)(a1 + 88), *(_QWORD *)(a1 + 96));
do
{
LOBYTE(v2) = v16 == v11;
if ( v16 == v11 )
break;
ssz_at(
(unsigned int)v18,
v11,
v12,
v13,
v14,
v15,
*(_OWORD *)(a1 + 80),
*(_QWORD *)(a1 + 88),
*(_QWORD *)(a1 + 96));
if ( !v20 || !v19 )
goto LABEL_12;
++v11;
}
while ( (unsigned __int8)update_light_client_update(a1, v18, 0LL) );
}
return v2;
}
| c4_update_from_sync_data:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x60]
TEST R14,R14
JZ 0x00129dff
CMP qword ptr [RBX + 0x58],0x0
JZ 0x00129dff
MOV BPL,0x1
CMP dword ptr [R14 + 0x8],0x8
JZ 0x00129e15
PUSH 0xa
POP RDI
CALL 0x001258a4
CMP R14,RAX
JZ 0x00129d8d
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1758eb]
JMP 0x00129e0a
LAB_00129d8d:
LEA R13,[RBX + 0x50]
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS xmmword ptr [RSP],XMM0
XOR R14D,R14D
CALL 0x0014c626
MOV R15D,EAX
LEA R12,[RSP + 0x20]
LAB_00129db3:
CMP R15D,R14D
SETZ BPL
JZ 0x00129e15
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R12
MOV ESI,R14D
CALL 0x0014c4b1
CMP qword ptr [RSP + 0x30],0x0
JZ 0x00129dff
CMP qword ptr [RSP + 0x28],0x0
JZ 0x00129dff
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL 0x00129e26
INC R14D
TEST AL,AL
JNZ 0x00129db3
JMP 0x00129e15
LAB_00129dff:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1758d8]
LAB_00129e0a:
CALL 0x00150675
MOV byte ptr [RBX + 0x68],0x0
XOR EBP,EBP
LAB_00129e15:
MOV EAX,EBP
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong c4_update_from_sync_data(long param_1)
{
long lVar1;
char cVar2;
int iVar3;
long lVar4;
int8 unaff_RBP;
ulong uVar5;
char *pcVar6;
int iVar7;
int1 local_48 [8];
long local_40;
long local_38;
lVar1 = *(long *)(param_1 + 0x60);
if ((lVar1 == 0) || (*(long *)(param_1 + 0x58) == 0)) {
LAB_00129dff:
pcVar6 = "invalid sync_data!";
}
else {
uVar5 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
if (*(int *)(lVar1 + 8) == 8) goto LAB_00129e15;
lVar4 = eth_ssz_verification_type(10);
if (lVar1 == lVar4) {
iVar7 = 0;
iVar3 = ssz_len();
do {
uVar5 = CONCAT71((int7)(uVar5 >> 8),iVar3 == iVar7);
if (iVar3 == iVar7) break;
ssz_at(local_48,iVar7);
if ((local_38 == 0) || (local_40 == 0)) goto LAB_00129dff;
cVar2 = update_light_client_update(param_1,local_48,0);
iVar7 = iVar7 + 1;
} while (cVar2 != '\0');
goto LAB_00129e15;
}
pcVar6 = "unknown sync_data type!";
}
c4_state_add_error(param_1 + 0x70,pcVar6);
*(int1 *)(param_1 + 0x68) = 0;
uVar5 = 0;
LAB_00129e15:
return uVar5 & 0xffffffff;
}
| |
35,257 | GetSplinePointBezierCubic | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | Vector2 GetSplinePointBezierCubic(Vector2 startPos, Vector2 startControlPos, Vector2 endControlPos, Vector2 endPos, float t)
{
Vector2 point = { 0 };
float a = powf(1.0f - t, 3);
float b = 3.0f*powf(1.0f - t, 2)*t;
float c = 3.0f*(1.0f - t)*powf(t, 2);
float d = powf(t, 3);
point.y = a*startPos.y + b*startControlPos.y + c*endControlPos.y + d*endPos.y;
point.x = a*startPos.x + b*startControlPos.x + c*endControlPos.x + d*endPos.x;
return point;
} | O1 | c | GetSplinePointBezierCubic:
subq $0x58, %rsp
movss %xmm4, 0x4(%rsp)
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movss 0x563e9(%rip), %xmm0 # 0xd9944
subss %xmm4, %xmm0
movss %xmm0, (%rsp)
movss 0x51bd0(%rip), %xmm1 # 0xd513c
callq 0x98a0
movss %xmm0, 0xc(%rsp)
movss (%rsp), %xmm3
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
movss 0x51bb1(%rip), %xmm1 # 0xd513c
mulss %xmm1, %xmm0
movss 0x4(%rsp), %xmm2
mulss %xmm2, %xmm0
movss %xmm0, 0x8(%rsp)
mulss %xmm1, %xmm3
movaps %xmm2, %xmm0
mulss %xmm2, %xmm0
mulss %xmm3, %xmm0
movss %xmm0, (%rsp)
movaps %xmm2, %xmm0
callq 0x98a0
movaps 0x10(%rsp), %xmm5
movaps %xmm5, %xmm1
shufps $0x55, %xmm5, %xmm1 # xmm1 = xmm1[1,1],xmm5[1,1]
movaps 0x20(%rsp), %xmm6
movaps %xmm6, %xmm2
shufps $0x55, %xmm6, %xmm2 # xmm2 = xmm2[1,1],xmm6[1,1]
movss 0x8(%rsp), %xmm9
mulss %xmm9, %xmm2
movss 0xc(%rsp), %xmm7
mulss %xmm7, %xmm1
addss %xmm2, %xmm1
movaps 0x30(%rsp), %xmm4
movaps %xmm4, %xmm2
shufps $0x55, %xmm4, %xmm2 # xmm2 = xmm2[1,1],xmm4[1,1]
movss (%rsp), %xmm8
mulss %xmm8, %xmm2
addss %xmm1, %xmm2
movaps 0x40(%rsp), %xmm3
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1 # xmm1 = xmm1[1,1],xmm3[1,1]
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
mulss %xmm6, %xmm9
movaps %xmm7, %xmm2
mulss %xmm5, %xmm2
addss %xmm9, %xmm2
mulss %xmm4, %xmm8
addss %xmm2, %xmm8
mulss %xmm3, %xmm0
addss %xmm8, %xmm0
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addq $0x58, %rsp
retq
| GetSplinePointBezierCubic:
sub rsp, 58h
movss [rsp+58h+var_54], xmm4
movaps [rsp+58h+var_18], xmm3
movaps [rsp+58h+var_28], xmm2
movaps [rsp+58h+var_38], xmm1
movaps [rsp+58h+var_48], xmm0
movss xmm0, cs:dword_D9944
subss xmm0, xmm4
movss [rsp+58h+var_58], xmm0
movss xmm1, cs:dword_D513C
call _powf
movss [rsp+58h+var_4C], xmm0
movss xmm3, [rsp+58h+var_58]
movaps xmm0, xmm3
mulss xmm0, xmm3
movss xmm1, cs:dword_D513C
mulss xmm0, xmm1
movss xmm2, [rsp+58h+var_54]
mulss xmm0, xmm2
movss [rsp+58h+var_50], xmm0
mulss xmm3, xmm1
movaps xmm0, xmm2
mulss xmm0, xmm2
mulss xmm0, xmm3
movss [rsp+58h+var_58], xmm0
movaps xmm0, xmm2
call _powf
movaps xmm5, [rsp+58h+var_48]
movaps xmm1, xmm5
shufps xmm1, xmm5, 55h ; 'U'
movaps xmm6, [rsp+58h+var_38]
movaps xmm2, xmm6
shufps xmm2, xmm6, 55h ; 'U'
movss xmm9, [rsp+58h+var_50]
mulss xmm2, xmm9
movss xmm7, [rsp+58h+var_4C]
mulss xmm1, xmm7
addss xmm1, xmm2
movaps xmm4, [rsp+58h+var_28]
movaps xmm2, xmm4
shufps xmm2, xmm4, 55h ; 'U'
movss xmm8, [rsp+58h+var_58]
mulss xmm2, xmm8
addss xmm2, xmm1
movaps xmm3, [rsp+58h+var_18]
movaps xmm1, xmm3
shufps xmm1, xmm3, 55h ; 'U'
mulss xmm1, xmm0
addss xmm1, xmm2
mulss xmm9, xmm6
movaps xmm2, xmm7
mulss xmm2, xmm5
addss xmm2, xmm9
mulss xmm8, xmm4
addss xmm8, xmm2
mulss xmm0, xmm3
addss xmm0, xmm8
unpcklps xmm0, xmm1
add rsp, 58h
retn
| __m128 GetSplinePointBezierCubic(__m128 a1, __m128 a2, __m128 a3, __m128 a4, float a5)
{
__m128 v5; // xmm0
__m128 v7; // xmm1
float v9; // [rsp+0h] [rbp-58h]
float v10; // [rsp+0h] [rbp-58h]
float v12; // [rsp+8h] [rbp-50h]
float v13; // [rsp+Ch] [rbp-4Ch]
v9 = 1.0 - a5;
v13 = powf(1.0 - a5, 3.0);
v12 = (float)((float)(v9 * v9) * 3.0) * a5;
v10 = (float)(a5 * a5) * (float)(v9 * 3.0);
v5 = (__m128)LODWORD(a5);
v5.m128_f32[0] = powf(a5, 3.0);
v7 = _mm_shuffle_ps(a4, a4, 85);
v7.m128_f32[0] = (float)(v7.m128_f32[0] * v5.m128_f32[0])
+ (float)((float)(_mm_shuffle_ps(a3, a3, 85).m128_f32[0] * v10)
+ (float)((float)(_mm_shuffle_ps(a1, a1, 85).m128_f32[0] * v13)
+ (float)(_mm_shuffle_ps(a2, a2, 85).m128_f32[0] * v12)));
v5.m128_f32[0] = (float)(v5.m128_f32[0] * a4.m128_f32[0])
+ (float)((float)(v10 * a3.m128_f32[0])
+ (float)((float)(v13 * a1.m128_f32[0]) + (float)(v12 * a2.m128_f32[0])));
return _mm_unpacklo_ps(v5, v7);
}
| GetSplinePointBezierCubic:
SUB RSP,0x58
MOVSS dword ptr [RSP + 0x4],XMM4
MOVAPS xmmword ptr [RSP + 0x40],XMM3
MOVAPS xmmword ptr [RSP + 0x30],XMM2
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVSS XMM0,dword ptr [0x001d9944]
SUBSS XMM0,XMM4
MOVSS dword ptr [RSP],XMM0
MOVSS XMM1,dword ptr [0x001d513c]
CALL 0x001098a0
MOVSS dword ptr [RSP + 0xc],XMM0
MOVSS XMM3,dword ptr [RSP]
MOVAPS XMM0,XMM3
MULSS XMM0,XMM3
MOVSS XMM1,dword ptr [0x001d513c]
MULSS XMM0,XMM1
MOVSS XMM2,dword ptr [RSP + 0x4]
MULSS XMM0,XMM2
MOVSS dword ptr [RSP + 0x8],XMM0
MULSS XMM3,XMM1
MOVAPS XMM0,XMM2
MULSS XMM0,XMM2
MULSS XMM0,XMM3
MOVSS dword ptr [RSP],XMM0
MOVAPS XMM0,XMM2
CALL 0x001098a0
MOVAPS XMM5,xmmword ptr [RSP + 0x10]
MOVAPS XMM1,XMM5
SHUFPS XMM1,XMM5,0x55
MOVAPS XMM6,xmmword ptr [RSP + 0x20]
MOVAPS XMM2,XMM6
SHUFPS XMM2,XMM6,0x55
MOVSS XMM9,dword ptr [RSP + 0x8]
MULSS XMM2,XMM9
MOVSS XMM7,dword ptr [RSP + 0xc]
MULSS XMM1,XMM7
ADDSS XMM1,XMM2
MOVAPS XMM4,xmmword ptr [RSP + 0x30]
MOVAPS XMM2,XMM4
SHUFPS XMM2,XMM4,0x55
MOVSS XMM8,dword ptr [RSP]
MULSS XMM2,XMM8
ADDSS XMM2,XMM1
MOVAPS XMM3,xmmword ptr [RSP + 0x40]
MOVAPS XMM1,XMM3
SHUFPS XMM1,XMM3,0x55
MULSS XMM1,XMM0
ADDSS XMM1,XMM2
MULSS XMM9,XMM6
MOVAPS XMM2,XMM7
MULSS XMM2,XMM5
ADDSS XMM2,XMM9
MULSS XMM8,XMM4
ADDSS XMM8,XMM2
MULSS XMM0,XMM3
ADDSS XMM0,XMM8
UNPCKLPS XMM0,XMM1
ADD RSP,0x58
RET
|
int8
GetSplinePointBezierCubic
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,float param_5
)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
fVar1 = DAT_001d9944 - param_5;
fVar2 = powf(fVar1,DAT_001d513c);
fVar3 = fVar1 * fVar1 * DAT_001d513c * param_5;
fVar1 = param_5 * param_5 * fVar1 * DAT_001d513c;
fVar4 = powf(param_5,DAT_001d513c);
return CONCAT44((float)((ulong)param_4 >> 0x20) * fVar4 +
(float)((ulong)param_3 >> 0x20) * fVar1 +
(float)((ulong)param_1 >> 0x20) * fVar2 + (float)((ulong)param_2 >> 0x20) * fVar3,
fVar4 * (float)param_4 +
fVar1 * (float)param_3 + fVar2 * (float)param_1 + fVar3 * (float)param_2);
}
| |
35,258 | GetSplinePointBezierCubic | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | Vector2 GetSplinePointBezierCubic(Vector2 startPos, Vector2 startControlPos, Vector2 endControlPos, Vector2 endPos, float t)
{
Vector2 point = { 0 };
float a = powf(1.0f - t, 3);
float b = 3.0f*powf(1.0f - t, 2)*t;
float c = 3.0f*(1.0f - t)*powf(t, 2);
float d = powf(t, 3);
point.y = a*startPos.y + b*startControlPos.y + c*endControlPos.y + d*endPos.y;
point.x = a*startPos.x + b*startControlPos.x + c*endControlPos.x + d*endPos.x;
return point;
} | O2 | c | GetSplinePointBezierCubic:
subq $0x88, %rsp
movss %xmm4, 0xc(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movss 0x4df5c(%rip), %xmm0 # 0xb969c
subss %xmm4, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x49a6a(%rip), %xmm1 # 0xb51bc
callq 0x9890
movaps %xmm0, 0x30(%rsp)
movss 0x10(%rsp), %xmm3
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
movss 0x49a4b(%rip), %xmm2 # 0xb51bc
mulss %xmm2, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm0, %xmm1
movaps %xmm1, 0x20(%rsp)
mulss %xmm2, %xmm3
movaps %xmm2, %xmm1
movaps %xmm0, %xmm2
mulss %xmm0, %xmm2
mulss %xmm3, %xmm2
movaps %xmm2, 0x10(%rsp)
callq 0x9890
movaps 0x20(%rsp), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps 0x40(%rsp), %xmm1
movaps %xmm1, %xmm2
movaps 0x30(%rsp), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps 0x50(%rsp), %xmm1
addps %xmm2, %xmm1
movaps 0x10(%rsp), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
mulps 0x60(%rsp), %xmm2
addps %xmm1, %xmm2
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps 0x70(%rsp), %xmm0
addps %xmm2, %xmm0
addq $0x88, %rsp
retq
| GetSplinePointBezierCubic:
sub rsp, 88h
movss [rsp+88h+var_7C], xmm4
movaps [rsp+88h+var_18], xmm3
movaps [rsp+88h+var_28], xmm2
movaps [rsp+88h+var_48], xmm1
movaps [rsp+88h+var_38], xmm0
movss xmm0, cs:dword_B969C
subss xmm0, xmm4
movss dword ptr [rsp+88h+var_78], xmm0
movss xmm1, cs:dword_B51BC
call _powf
movaps [rsp+88h+var_58], xmm0
movss xmm3, dword ptr [rsp+88h+var_78]
movaps xmm1, xmm3
mulss xmm1, xmm3
movss xmm2, cs:dword_B51BC
mulss xmm1, xmm2
movss xmm0, [rsp+88h+var_7C]
mulss xmm1, xmm0
movaps [rsp+88h+var_68], xmm1
mulss xmm3, xmm2
movaps xmm1, xmm2
movaps xmm2, xmm0
mulss xmm2, xmm0
mulss xmm2, xmm3
movaps [rsp+88h+var_78], xmm2
call _powf
movaps xmm1, [rsp+88h+var_68]
shufps xmm1, xmm1, 0
mulps xmm1, [rsp+88h+var_48]
movaps xmm2, xmm1
movaps xmm1, [rsp+88h+var_58]
shufps xmm1, xmm1, 0
mulps xmm1, [rsp+88h+var_38]
addps xmm1, xmm2
movaps xmm2, [rsp+88h+var_78]
shufps xmm2, xmm2, 0
mulps xmm2, [rsp+88h+var_28]
addps xmm2, xmm1
shufps xmm0, xmm0, 0
mulps xmm0, [rsp+88h+var_18]
addps xmm0, xmm2
add rsp, 88h
retn
| __m128 GetSplinePointBezierCubic(__m128 a1, __m128 a2, __m128 a3, __m128 a4, float a5)
{
__m128 v5; // xmm0
__m128 v6; // xmm1
__m128 v7; // xmm0
__m128 v8; // xmm2
unsigned int v11; // [rsp+10h] [rbp-78h]
__m128 v12; // [rsp+30h] [rbp-58h]
v5 = (__m128)0x3F800000u;
*(float *)&v11 = 1.0 - a5;
*(double *)v5.m128_u64 = powf(1.0 - a5, 3.0);
v12 = v5;
v6 = (__m128)v11;
v7 = (__m128)LODWORD(a5);
v6.m128_f32[0] = (float)((float)(v6.m128_f32[0] * v6.m128_f32[0]) * 3.0) * a5;
v8 = v7;
v8.m128_f32[0] = (float)(v7.m128_f32[0] * v7.m128_f32[0]) * (float)(*(float *)&v11 * 3.0);
*(double *)v7.m128_u64 = powf(a5, 3.0);
return _mm_add_ps(
_mm_mul_ps(_mm_shuffle_ps(v7, v7, 0), a4),
_mm_add_ps(
_mm_mul_ps(_mm_shuffle_ps(v8, v8, 0), a3),
_mm_add_ps(_mm_mul_ps(_mm_shuffle_ps(v12, v12, 0), a1), _mm_mul_ps(_mm_shuffle_ps(v6, v6, 0), a2))));
}
| GetSplinePointBezierCubic:
SUB RSP,0x88
MOVSS dword ptr [RSP + 0xc],XMM4
MOVAPS xmmword ptr [RSP + 0x70],XMM3
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVSS XMM0,dword ptr [0x001b969c]
SUBSS XMM0,XMM4
MOVSS dword ptr [RSP + 0x10],XMM0
MOVSS XMM1,dword ptr [0x001b51bc]
CALL 0x00109890
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVSS XMM3,dword ptr [RSP + 0x10]
MOVAPS XMM1,XMM3
MULSS XMM1,XMM3
MOVSS XMM2,dword ptr [0x001b51bc]
MULSS XMM1,XMM2
MOVSS XMM0,dword ptr [RSP + 0xc]
MULSS XMM1,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MULSS XMM3,XMM2
MOVAPS XMM1,XMM2
MOVAPS XMM2,XMM0
MULSS XMM2,XMM0
MULSS XMM2,XMM3
MOVAPS xmmword ptr [RSP + 0x10],XMM2
CALL 0x00109890
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
SHUFPS XMM1,XMM1,0x0
MULPS XMM1,xmmword ptr [RSP + 0x40]
MOVAPS XMM2,XMM1
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
SHUFPS XMM1,XMM1,0x0
MULPS XMM1,xmmword ptr [RSP + 0x50]
ADDPS XMM1,XMM2
MOVAPS XMM2,xmmword ptr [RSP + 0x10]
SHUFPS XMM2,XMM2,0x0
MULPS XMM2,xmmword ptr [RSP + 0x60]
ADDPS XMM2,XMM1
SHUFPS XMM0,XMM0,0x0
MULPS XMM0,xmmword ptr [RSP + 0x70]
ADDPS XMM0,XMM2
ADD RSP,0x88
RET
|
int8
GetSplinePointBezierCubic
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,float param_5
)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
fVar1 = DAT_001b969c - param_5;
fVar2 = powf(fVar1,DAT_001b51bc);
fVar3 = fVar1 * fVar1 * DAT_001b51bc * param_5;
fVar4 = param_5 * param_5 * fVar1 * DAT_001b51bc;
fVar1 = powf(param_5,DAT_001b51bc);
return CONCAT44(fVar1 * (float)((ulong)param_4 >> 0x20) +
fVar4 * (float)((ulong)param_3 >> 0x20) +
fVar2 * (float)((ulong)param_1 >> 0x20) + fVar3 * (float)((ulong)param_2 >> 0x20),
fVar1 * (float)param_4 +
fVar4 * (float)param_3 + fVar2 * (float)param_1 + fVar3 * (float)param_2);
}
| |
35,259 | get_collation_number_internal | eloqsql/mysys/charset.c | static uint
get_collation_number_internal(const char *name)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if (cs[0] && cs[0]->coll_name.str &&
!my_strcasecmp(&my_charset_latin1, cs[0]->coll_name.str, name))
return cs[0]->number;
}
return 0;
} | O3 | c | get_collation_number_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq $-0x8, %r15
leaq 0x364165(%rip), %r12 # 0x3c7620
leaq 0x310b5e(%rip), %r14 # 0x374020
movq 0x8(%r12,%r15), %rax
testq %rax, %rax
je 0x634e9
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x634e9
movq 0xc0(%r14), %rax
movq %r14, %rdi
movq %rbx, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x634fa
addq $0x8, %r15
cmpq $0x3ff8, %r15 # imm = 0x3FF8
jb 0x634c2
xorl %eax, %eax
jmp 0x63501
movq 0x8(%r12,%r15), %rax
movl (%rax), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| get_collation_number_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov r15, 0FFFFFFFFFFFFFFF8h
lea r12, all_charsets
lea r14, my_charset_latin1
loc_634C2:
mov rax, [r12+r15+8]
test rax, rax
jz short loc_634E9
mov rsi, [rax+20h]
test rsi, rsi
jz short loc_634E9
mov rax, [r14+0C0h]
mov rdi, r14
mov rdx, rbx
call qword ptr [rax+40h]
test eax, eax
jz short loc_634FA
loc_634E9:
add r15, 8
cmp r15, 3FF8h
jb short loc_634C2
xor eax, eax
jmp short loc_63501
loc_634FA:
mov rax, [r12+r15+8]
mov eax, [rax]
loc_63501:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long get_collation_number_internal(long long a1)
{
long long v1; // r15
long long v2; // rax
long long v3; // rsi
v1 = 0x1FFFFFFFFFFFFFFFLL;
while ( 1 )
{
v2 = all_charsets[v1 + 1];
if ( v2 )
{
v3 = *(_QWORD *)(v2 + 32);
if ( v3 )
{
if ( !(*(unsigned int ( **)(void *, long long, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
v3,
a1) )
break;
}
}
if ( (unsigned long long)++v1 >= 2047 )
return 0LL;
}
return *(unsigned int *)all_charsets[v1 + 1];
}
| get_collation_number_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R15,-0x8
LEA R12,[0x4c7620]
LEA R14,[0x474020]
LAB_001634c2:
MOV RAX,qword ptr [R12 + R15*0x1 + 0x8]
TEST RAX,RAX
JZ 0x001634e9
MOV RSI,qword ptr [RAX + 0x20]
TEST RSI,RSI
JZ 0x001634e9
MOV RAX,qword ptr [R14 + 0xc0]
MOV RDI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x001634fa
LAB_001634e9:
ADD R15,0x8
CMP R15,0x3ff8
JC 0x001634c2
XOR EAX,EAX
JMP 0x00163501
LAB_001634fa:
MOV RAX,qword ptr [R12 + R15*0x1 + 0x8]
MOV EAX,dword ptr [RAX]
LAB_00163501:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 get_collation_number_internal(int8 param_1)
{
long lVar1;
int iVar2;
ulong uVar3;
uVar3 = 0xfffffffffffffff8;
while (((*(long *)((long)&DAT_004c7628 + uVar3) == 0 ||
(lVar1 = *(long *)(*(long *)((long)&DAT_004c7628 + uVar3) + 0x20), lVar1 == 0)) ||
(iVar2 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,lVar1,param_1), iVar2 != 0))) {
uVar3 = uVar3 + 8;
if (0x3ff7 < uVar3) {
return 0;
}
}
return **(int4 **)((long)&DAT_004c7628 + uVar3);
}
| |
35,260 | Column_definition_attributes::make_field(TABLE_SHARE*, st_mem_root*, Record_addr const*, Type_handler const*, st_mysql_const_lex_string const*, unsigned int) const | eloqsql/sql/field.cc | Field *Column_definition_attributes::make_field(TABLE_SHARE *share,
MEM_ROOT *mem_root,
const Record_addr *rec,
const Type_handler *handler,
const LEX_CSTRING *field_name,
uint32 flags)
const
{
DBUG_ASSERT(length <= UINT_MAX32);
DBUG_PRINT("debug", ("field_type: %s, field_length: %u, interval: %p, pack_flag: %s%s%s%s%s",
handler->name().ptr(), (uint) length, interval,
FLAGSTR(pack_flag, FIELDFLAG_BINARY),
FLAGSTR(pack_flag, FIELDFLAG_INTERVAL),
FLAGSTR(pack_flag, FIELDFLAG_NUMBER),
FLAGSTR(pack_flag, FIELDFLAG_PACK),
FLAGSTR(pack_flag, FIELDFLAG_BLOB)));
Record_addr addr(rec->ptr(), f_maybe_null(pack_flag) ? rec->null() :
Bit_addr());
/*
Special code for the BIT-alike data types
who store data bits together with NULL-bits.
*/
Bit_addr bit(rec->null());
if (f_maybe_null(pack_flag))
bit.inc();
return handler->make_table_field_from_def(share, mem_root, field_name,
addr, bit, this, flags);
} | O0 | cpp | Column_definition_attributes::make_field(TABLE_SHARE*, st_mem_root*, Record_addr const*, Type_handler const*, st_mysql_const_lex_string const*, unsigned int) const:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl 0x10(%rbp), %eax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq %r8, -0x68(%rbp)
movq %r9, -0x70(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0xcf3e6d
jmp 0xcf3e6f
jmp 0xcf3e71
movq -0x60(%rbp), %rdi
callq 0xc00290
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x80(%rbp)
movl 0x1c(%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0xcf3eaa
movq -0x60(%rbp), %rdi
callq 0xc35db0
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movb 0x8(%rax), %al
movb %al, -0x28(%rbp)
jmp 0xcf3eb3
leaq -0x30(%rbp), %rdi
callq 0xc005b0
movq -0x80(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xcf7bf0
movq -0x60(%rbp), %rdi
callq 0xc35db0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq 0x8(%rcx), %rcx
movq %rcx, -0x38(%rbp)
movl 0x1c(%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0xcf3ef9
leaq -0x40(%rbp), %rdi
callq 0xcf7c20
movq -0x78(%rbp), %r9
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x70(%rbp), %rcx
movl 0x10(%rbp), %r10d
movq (%rdi), %rax
movq 0x2a0(%rax), %rax
movq %rsp, %r8
movl %r10d, 0x8(%r8)
movq %r9, (%r8)
leaq -0x20(%rbp), %r8
leaq -0x40(%rbp), %r9
callq *%rax
movq %rax, -0x88(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xcf3f58
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x7754c0
nopl (%rax)
| _ZNK28Column_definition_attributes10make_fieldEP11TABLE_SHAREP11st_mem_rootPK11Record_addrPK12Type_handlerPK25st_mysql_const_lex_stringj:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov eax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_58], rdx
mov [rbp+var_60], rcx
mov [rbp+var_68], r8
mov [rbp+var_70], r9
mov rax, [rbp+var_48]
mov [rbp+var_78], rax
jmp short $+2
loc_CF3E6D:
jmp short $+2
loc_CF3E6F:
jmp short $+2
loc_CF3E71:
mov rdi, [rbp+var_60]; this
call _ZNK11Record_addr3ptrEv; Record_addr::ptr(void)
mov rcx, rax
mov rax, [rbp+var_78]
mov [rbp+var_80], rcx
mov eax, [rax+1Ch]
and eax, 8000h
cmp eax, 0
jz short loc_CF3EAA
mov rdi, [rbp+var_60]; this
call _ZNK11Record_addr4nullEv; Record_addr::null(void)
mov rcx, [rax]
mov [rbp+var_30], rcx
mov al, [rax+8]
mov [rbp+var_28], al
jmp short loc_CF3EB3
loc_CF3EAA:
lea rdi, [rbp+var_30]; this
call _ZN8Bit_addrC2Ev; Bit_addr::Bit_addr(void)
loc_CF3EB3:
mov rsi, [rbp+var_80]; unsigned __int8 *
lea rdi, [rbp+var_20]; this
lea rdx, [rbp+var_30]; Bit_addr *
call _ZN11Record_addrC2EPhRK8Bit_addr; Record_addr::Record_addr(uchar *,Bit_addr const&)
mov rdi, [rbp+var_60]; this
call _ZNK11Record_addr4nullEv; Record_addr::null(void)
mov rcx, rax
mov rax, [rbp+var_78]
mov rdx, [rcx]
mov [rbp+var_40], rdx
mov rcx, [rcx+8]
mov [rbp+var_38], rcx
mov eax, [rax+1Ch]
and eax, 8000h
cmp eax, 0
jz short loc_CF3EF9
lea rdi, [rbp+var_40]; this
call _ZN8Bit_addr3incEv; Bit_addr::inc(void)
loc_CF3EF9:
mov r9, [rbp+var_78]
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_58]
mov rcx, [rbp+var_70]
mov r10d, [rbp+arg_0]
mov rax, [rdi]
mov rax, [rax+2A0h]
mov r8, rsp
mov [r8+8], r10d
mov [r8], r9
lea r8, [rbp+var_20]
lea r9, [rbp+var_40]
call rax
mov [rbp+var_88], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_CF3F58
mov rax, [rbp+var_88]
add rsp, 0A0h
pop rbp
retn
loc_CF3F58:
call ___stack_chk_fail
| long long Column_definition_attributes::make_field(
long long a1,
long long a2,
long long a3,
Record_addr *a4,
long long a5,
long long a6,
int a7)
{
long long v7; // rax
_QWORD *v8; // rax
unsigned __int8 *v10; // [rsp+20h] [rbp-80h]
_QWORD v15[2]; // [rsp+60h] [rbp-40h] BYREF
long long v16; // [rsp+70h] [rbp-30h] BYREF
char v17; // [rsp+78h] [rbp-28h]
_BYTE v18[24]; // [rsp+80h] [rbp-20h] BYREF
unsigned long long v19; // [rsp+98h] [rbp-8h]
v19 = __readfsqword(0x28u);
v10 = (unsigned __int8 *)Record_addr::ptr(a4);
if ( (*(_DWORD *)(a1 + 28) & 0x8000) != 0 )
{
v7 = Record_addr::null(a4);
v16 = *(_QWORD *)v7;
v17 = *(_BYTE *)(v7 + 8);
}
else
{
Bit_addr::Bit_addr((Bit_addr *)&v16);
}
Record_addr::Record_addr((Record_addr *)v18, v10, (const Bit_addr *)&v16);
v8 = (_QWORD *)Record_addr::null(a4);
v15[0] = *v8;
v15[1] = v8[1];
if ( (*(_DWORD *)(a1 + 28) & 0x8000) != 0 )
Bit_addr::inc((Bit_addr *)v15);
return (*(long long ( **)(long long, long long, long long, long long, _BYTE *, _QWORD *, long long, int))(*(_QWORD *)a5 + 672LL))(
a5,
a2,
a3,
a6,
v18,
v15,
a1,
a7);
}
| Item_save_in_value:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
MOV AL,0x1
AND AL,0x1
POP RBP
RET
|
/* Type_handler_null::Item_save_in_value(THD*, Item*, st_value*) const */
int8 Type_handler_null::Item_save_in_value(THD *param_1,Item *param_2,st_value *param_3)
{
int4 *in_RCX;
*in_RCX = 0;
return 1;
}
| |
35,261 | evmone::instr::core::sstore(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions_storage.cpp | Result sstore(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
if (state.in_static_mode())
return {EVMC_STATIC_MODE_VIOLATION, gas_left};
if (state.rev >= EVMC_ISTANBUL && gas_left <= 2300)
return {EVMC_OUT_OF_GAS, gas_left};
const auto key = intx::be::store<evmc::bytes32>(stack.pop());
const auto value = intx::be::store<evmc::bytes32>(stack.pop());
const auto gas_cost_cold =
(state.rev >= EVMC_BERLIN &&
state.host.access_storage(state.msg->recipient, key) == EVMC_ACCESS_COLD) ?
instr::cold_sload_cost :
0;
const auto status = state.host.set_storage(state.msg->recipient, key, value);
const auto [gas_cost_warm, gas_refund] = sstore_costs[state.rev][status];
const auto gas_cost = gas_cost_warm + gas_cost_cold;
if ((gas_left -= gas_cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
state.gas_refund += gas_refund;
return {EVMC_SUCCESS, gas_left};
} | O2 | cpp | evmone::instr::core::sstore(evmone::StackTop, long, evmone::ExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq 0x20(%rdx), %rax
testb $0x1, 0x4(%rax)
jne 0x44d4b
movq %rdx, %r14
movq %rdi, %rsi
cmpq $0x8fc, %rbx # imm = 0x8FC
jg 0x44cf6
cmpl $0x6, 0x40(%r14)
jg 0x44da7
leaq -0x20(%rsi), %r15
leaq 0x20(%rsp), %rdi
callq 0x3c237
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x3c237
cmpl $0x8, 0x40(%r14)
jl 0x44d4f
leaq 0x28(%r14), %rdi
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
movq %rsp, %rsi
movl %ecx, 0x10(%rsi)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rdx
callq 0x2f5d6
xorl %ecx, %ecx
testl %eax, %eax
movq $-0x834, %r15 # imm = 0xF7CC
cmovneq %rcx, %r15
jmp 0x44d52
pushq $0xb
jmp 0x44da9
xorl %r15d, %r15d
leaq 0x28(%r14), %rdi
movq 0x20(%r14), %rax
movl 0x28(%rax), %ecx
movq %rsp, %rsi
movl %ecx, 0x10(%rsi)
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x2f456
movl 0x40(%r14), %ecx
imulq $0x24, %rcx, %rdx
leaq 0x376c2(%rip), %rcx # 0x7c44a
addq %rdx, %rcx
movl %eax, %eax
movswq (%rcx,%rax,4), %rdx
addq %r15, %rbx
subq %rdx, %rbx
js 0x44da7
movswq 0x2(%rcx,%rax,4), %rax
addq %rax, (%r14)
xorl %eax, %eax
jmp 0x44daa
pushq $0x3
popq %rax
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN6evmone5instr4core6sstoreENS_8StackTopElRNS_14ExecutionStateE:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rsi
mov rax, [rdx+20h]
test byte ptr [rax+4], 1
jnz short loc_44D4B
mov r14, rdx
mov rsi, rdi
cmp rbx, 8FCh
jg short loc_44CF6
cmp dword ptr [r14+40h], 6
jg loc_44DA7
loc_44CF6:
lea r15, [rsi-20h]
lea rdi, [rsp+78h+var_58]
call _ZN4intx2be5storeIN4evmc7bytes32ENS_4uintILj256EEEEET_RKT0_; intx::be::store<evmc::bytes32,intx::uint<256u>>(intx::uint<256u> const&)
lea rdi, [rsp+78h+var_38]
mov rsi, r15
call _ZN4intx2be5storeIN4evmc7bytes32ENS_4uintILj256EEEEET_RKT0_; intx::be::store<evmc::bytes32,intx::uint<256u>>(intx::uint<256u> const&)
cmp dword ptr [r14+40h], 8
jl short loc_44D4F
lea rdi, [r14+28h]
mov rax, [r14+20h]
mov ecx, [rax+28h]
mov rsi, rsp
mov [rsi+10h], ecx
movups xmm0, xmmword ptr [rax+18h]
movaps xmmword ptr [rsi], xmm0
lea rdx, [rsp+78h+var_58]
call _ZN4evmc11HostContext14access_storageERKNS_7addressERKNS_7bytes32E; evmc::HostContext::access_storage(evmc::address const&,evmc::bytes32 const&)
xor ecx, ecx
test eax, eax
mov r15, 0FFFFFFFFFFFFF7CCh
cmovnz r15, rcx
jmp short loc_44D52
loc_44D4B:
push 0Bh
jmp short loc_44DA9
loc_44D4F:
xor r15d, r15d
loc_44D52:
lea rdi, [r14+28h]
mov rax, [r14+20h]
mov ecx, [rax+28h]
mov rsi, rsp
mov [rsi+10h], ecx
movups xmm0, xmmword ptr [rax+18h]
movaps xmmword ptr [rsi], xmm0
lea rdx, [rsp+78h+var_58]
lea rcx, [rsp+78h+var_38]
call _ZN4evmc11HostContext11set_storageERKNS_7addressERKNS_7bytes32ES6_; evmc::HostContext::set_storage(evmc::address const&,evmc::bytes32 const&,evmc::bytes32 const&)
mov ecx, [r14+40h]
imul rdx, rcx, 24h ; '$'
lea rcx, _ZN6evmone5instr4core12_GLOBAL__N_112sstore_costsE; evmone::instr::core::`anonymous namespace'::sstore_costs
add rcx, rdx
mov eax, eax
movsx rdx, word ptr [rcx+rax*4]
add rbx, r15
sub rbx, rdx
js short loc_44DA7
movsx rax, word ptr [rcx+rax*4+2]
add [r14], rax
xor eax, eax
jmp short loc_44DAA
loc_44DA7:
push 3
loc_44DA9:
pop rax
loc_44DAA:
mov rdx, rbx
add rsp, 60h
pop rbx
pop r14
pop r15
retn
| long long evmone::instr::core::sstore(long long a1, long long a2, long long a3)
{
long long v4; // r15
int v5; // eax
char *v6; // rcx
__int128 v9; // [rsp+20h] [rbp-58h] BYREF
_OWORD v10[3]; // [rsp+40h] [rbp-38h] BYREF
if ( (*(_BYTE *)(*(_QWORD *)(a3 + 32) + 4LL) & 1) != 0 )
return 11LL;
if ( a2 > 2300 || *(int *)(a3 + 64) <= 6 )
{
intx::be::store<evmc::bytes32,intx::uint<256u>>(&v9);
intx::be::store<evmc::bytes32,intx::uint<256u>>(v10);
if ( *(int *)(a3 + 64) < 8 )
{
v4 = 0LL;
}
else
{
v4 = -2100LL;
if ( (unsigned int)evmc::HostContext::access_storage(a3 + 40) )
v4 = 0LL;
}
v5 = evmc::HostContext::set_storage(a3 + 40);
v6 = (char *)&evmone::instr::core::`anonymous namespace'::sstore_costs + 36 * *(unsigned int *)(a3 + 64);
if ( v4 + a2 - *(__int16 *)&v6[4 * v5] >= 0 )
{
*(_QWORD *)a3 += *(__int16 *)&v6[4 * v5 + 2];
return 0LL;
}
}
return 3LL;
}
| sstore:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RSI
MOV RAX,qword ptr [RDX + 0x20]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x00144d4b
MOV R14,RDX
MOV RSI,RDI
CMP RBX,0x8fc
JG 0x00144cf6
CMP dword ptr [R14 + 0x40],0x6
JG 0x00144da7
LAB_00144cf6:
LEA R15,[RSI + -0x20]
LEA RDI,[RSP + 0x20]
CALL 0x0013c237
LEA RDI,[RSP + 0x40]
MOV RSI,R15
CALL 0x0013c237
CMP dword ptr [R14 + 0x40],0x8
JL 0x00144d4f
LEA RDI,[R14 + 0x28]
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
MOV RSI,RSP
MOV dword ptr [RSI + 0x10],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RSI],XMM0
LEA RDX,[RSP + 0x20]
CALL 0x0012f5d6
XOR ECX,ECX
TEST EAX,EAX
MOV R15,-0x834
CMOVNZ R15,RCX
JMP 0x00144d52
LAB_00144d4b:
PUSH 0xb
JMP 0x00144da9
LAB_00144d4f:
XOR R15D,R15D
LAB_00144d52:
LEA RDI,[R14 + 0x28]
MOV RAX,qword ptr [R14 + 0x20]
MOV ECX,dword ptr [RAX + 0x28]
MOV RSI,RSP
MOV dword ptr [RSI + 0x10],ECX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RSI],XMM0
LEA RDX,[RSP + 0x20]
LEA RCX,[RSP + 0x40]
CALL 0x0012f456
MOV ECX,dword ptr [R14 + 0x40]
IMUL RDX,RCX,0x24
LEA RCX,[0x17c44a]
ADD RCX,RDX
MOV EAX,EAX
MOVSX RDX,word ptr [RCX + RAX*0x4]
ADD RBX,R15
SUB RBX,RDX
JS 0x00144da7
MOVSX RAX,word ptr [RCX + RAX*0x4 + 0x2]
ADD qword ptr [R14],RAX
XOR EAX,EAX
JMP 0x00144daa
LAB_00144da7:
PUSH 0x3
LAB_00144da9:
POP RAX
LAB_00144daa:
MOV RDX,RBX
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* evmone::instr::core::sstore(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::sstore(uint *param_1,long param_2,long *param_3)
{
long lVar1;
int iVar2;
uint uVar3;
long lVar4;
int1 auVar5 [16];
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int4 local_68;
be local_58 [32];
be local_38 [32];
if ((*(byte *)(param_3[4] + 4) & 1) == 0) {
if ((0x8fc < param_2) || ((int)param_3[8] < 7)) {
intx::be::store<evmc::bytes32,intx::uint<256u>>(local_58,param_1);
intx::be::store<evmc::bytes32,intx::uint<256u>>(local_38,param_1 + -0x20);
if ((int)param_3[8] < 8) {
lVar4 = 0;
}
else {
lVar4 = param_3[4];
local_68 = *(int4 *)(lVar4 + 0x28);
local_78 = *(int8 *)(lVar4 + 0x18);
uStack_70 = *(int8 *)(lVar4 + 0x20);
iVar2 = evmc::HostContext::access_storage((address *)(param_3 + 5),(bytes32 *)&local_78);
lVar4 = -0x834;
if (iVar2 != 0) {
lVar4 = 0;
}
}
lVar1 = param_3[4];
local_68 = *(int4 *)(lVar1 + 0x28);
local_78 = *(int8 *)(lVar1 + 0x18);
uStack_70 = *(int8 *)(lVar1 + 0x20);
uVar3 = evmc::HostContext::set_storage
((address *)(param_3 + 5),(bytes32 *)&local_78,(bytes32 *)local_58);
param_2 = (param_2 + lVar4) -
(long)*(short *)((anonymous_namespace)::sstore_costs +
(ulong)uVar3 * 4 + (ulong)*(uint *)(param_3 + 8) * 0x24);
if (-1 < param_2) {
*param_3 = *param_3 +
(long)*(short *)((ulong)*(uint *)(param_3 + 8) * 0x24 + 0x17c44c +
(ulong)uVar3 * 4);
uStack_80 = 0;
goto LAB_00144daa;
}
}
uStack_80 = 3;
}
else {
uStack_80 = 0xb;
}
LAB_00144daa:
auVar5._8_8_ = param_2;
auVar5._0_8_ = uStack_80;
return auVar5;
}
| |
35,262 | get_func_name | bluesky950520[P]quickjs/quickjs.c | static const char *get_func_name(JSContext *ctx, JSValue func)
{
JSProperty *pr;
JSShapeProperty *prs;
JSValue val;
if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
return NULL;
prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
if (!prs)
return NULL;
if ((prs->flags & JS_PROP_TMASK) != JS_PROP_NORMAL)
return NULL;
val = pr->u.value;
if (JS_VALUE_GET_TAG(val) != JS_TAG_STRING)
return NULL;
return JS_ToCString(ctx, val);
} | O1 | c | get_func_name:
movq %rsi, -0x8(%rsp)
cmpl $-0x1, %edx
jne 0x43356
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rdx
movl 0x20(%rdx), %eax
notl %eax
orl $-0x38, %eax
cltq
movl (%rdx,%rax,4), %r9d
testl %r9d, %r9d
je 0x4332f
addq $0x40, %rdx
xorl %eax, %eax
movl $0x3ffffff, %r8d # imm = 0x3FFFFFF
movl %r9d, %r9d
leaq (%rdx,%r9,8), %rsi
addq $-0x8, %rsi
cmpl $0x37, 0x4(%rsi)
je 0x4331f
movl (%rsi), %r9d
movl $0x0, %esi
andl %r8d, %r9d
jne 0x432ff
jmp 0x43333
decq %r9
shlq $0x4, %r9
addq 0x20(%rcx), %r9
movq %r9, %rax
jmp 0x43333
xorl %eax, %eax
xorl %esi, %esi
testq %rsi, %rsi
je 0x43356
cmpl $0x3fffffff, (%rsi) # imm = 0x3FFFFFFF
ja 0x43356
movq 0x8(%rax), %rcx
cmpl $-0x7, %ecx
jne 0x43356
movq (%rax), %rdx
xorl %esi, %esi
xorl %r8d, %r8d
jmp 0x20bf7
xorl %eax, %eax
retq
| get_func_name:
mov [rsp+var_8], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_43356
mov rcx, [rsp+var_8]
mov rdx, [rcx+18h]
mov eax, [rdx+20h]
not eax
or eax, 0FFFFFFC8h
cdqe
mov r9d, [rdx+rax*4]
test r9d, r9d
jz short loc_4332F
add rdx, 40h ; '@'
xor eax, eax
mov r8d, 3FFFFFFh
loc_432FF:
mov r9d, r9d
lea rsi, [rdx+r9*8]
add rsi, 0FFFFFFFFFFFFFFF8h
cmp dword ptr [rsi+4], 37h ; '7'
jz short loc_4331F
mov r9d, [rsi]
mov esi, 0
and r9d, r8d
jnz short loc_432FF
jmp short loc_43333
loc_4331F:
dec r9
shl r9, 4
add r9, [rcx+20h]
mov rax, r9
jmp short loc_43333
loc_4332F:
xor eax, eax
xor esi, esi
loc_43333:
test rsi, rsi
jz short loc_43356
cmp dword ptr [rsi], 3FFFFFFFh
ja short loc_43356
mov rcx, [rax+8]
cmp ecx, 0FFFFFFF9h
jnz short loc_43356
mov rdx, [rax]
xor esi, esi
xor r8d, r8d
jmp JS_ToCStringLen2
loc_43356:
xor eax, eax
retn
| long long get_func_name(long long a1, long long a2, int a3)
{
long long v3; // rdx
unsigned int v4; // r9d
long long v5; // rdx
long long *v6; // rax
int *v7; // rsi
int v8; // r9d
long long v9; // rcx
if ( a3 != -1 )
return 0LL;
v3 = *(_QWORD *)(a2 + 24);
v4 = *(_DWORD *)(v3 + 4LL * (int)(~*(_BYTE *)(v3 + 32) | 0xFFFFFFC8));
if ( v4 )
{
v5 = v3 + 64;
v6 = 0LL;
while ( 1 )
{
v7 = (int *)(v5 + 8LL * v4 - 8);
if ( v7[1] == 55 )
break;
v8 = *v7;
v7 = 0LL;
v4 = v8 & 0x3FFFFFF;
if ( !v4 )
goto LABEL_9;
}
v6 = (long long *)(*(_QWORD *)(a2 + 32) + 16 * (v4 - 1LL));
}
else
{
v6 = 0LL;
v7 = 0LL;
}
LABEL_9:
if ( v7 && (unsigned int)*v7 <= 0x3FFFFFFF && (v9 = v6[1], (_DWORD)v9 == -7) )
return JS_ToCStringLen2(a1, 0LL, *v6, v9, 0);
else
return 0LL;
}
| get_func_name:
MOV qword ptr [RSP + -0x8],RSI
CMP EDX,-0x1
JNZ 0x00143356
MOV RCX,qword ptr [RSP + -0x8]
MOV RDX,qword ptr [RCX + 0x18]
MOV EAX,dword ptr [RDX + 0x20]
NOT EAX
OR EAX,0xffffffc8
CDQE
MOV R9D,dword ptr [RDX + RAX*0x4]
TEST R9D,R9D
JZ 0x0014332f
ADD RDX,0x40
XOR EAX,EAX
MOV R8D,0x3ffffff
LAB_001432ff:
MOV R9D,R9D
LEA RSI,[RDX + R9*0x8]
ADD RSI,-0x8
CMP dword ptr [RSI + 0x4],0x37
JZ 0x0014331f
MOV R9D,dword ptr [RSI]
MOV ESI,0x0
AND R9D,R8D
JNZ 0x001432ff
JMP 0x00143333
LAB_0014331f:
DEC R9
SHL R9,0x4
ADD R9,qword ptr [RCX + 0x20]
MOV RAX,R9
JMP 0x00143333
LAB_0014332f:
XOR EAX,EAX
XOR ESI,ESI
LAB_00143333:
TEST RSI,RSI
JZ 0x00143356
CMP dword ptr [RSI],0x3fffffff
JA 0x00143356
MOV RCX,qword ptr [RAX + 0x8]
CMP ECX,-0x7
JNZ 0x00143356
MOV RDX,qword ptr [RAX]
XOR ESI,ESI
XOR R8D,R8D
JMP 0x00120bf7
LAB_00143356:
XOR EAX,EAX
RET
|
int8 get_func_name(int8 param_1,long param_2,int param_3)
{
long lVar1;
long lVar2;
int8 uVar3;
uint *puVar4;
uint uVar5;
int8 *puVar6;
if (param_3 == -1) {
lVar2 = *(long *)(param_2 + 0x18);
uVar5 = *(uint *)(lVar2 + (long)(int)(~*(uint *)(lVar2 + 0x20) | 0xffffffc8) * 4);
if (uVar5 == 0) {
puVar6 = (int8 *)0x0;
puVar4 = (uint *)0x0;
}
else {
puVar6 = (int8 *)0x0;
do {
lVar1 = lVar2 + 0x40 + (ulong)uVar5 * 8;
puVar4 = (uint *)(lVar1 + -8);
if (*(int *)(lVar1 + -4) == 0x37) {
puVar6 = (int8 *)(((ulong)uVar5 - 1) * 0x10 + *(long *)(param_2 + 0x20));
break;
}
uVar5 = *puVar4;
puVar4 = (uint *)0x0;
uVar5 = uVar5 & 0x3ffffff;
} while (uVar5 != 0);
}
if (((puVar4 != (uint *)0x0) && (*puVar4 < 0x40000000)) && ((int)puVar6[1] == -7)) {
uVar3 = JS_ToCStringLen2(param_1,0,*puVar6,puVar6[1],0);
return uVar3;
}
}
return 0;
}
| |
35,263 | get_func_name | bluesky950520[P]quickjs/quickjs.c | static const char *get_func_name(JSContext *ctx, JSValue func)
{
JSProperty *pr;
JSShapeProperty *prs;
JSValue val;
if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
return NULL;
prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
if (!prs)
return NULL;
if ((prs->flags & JS_PROP_TMASK) != JS_PROP_NORMAL)
return NULL;
val = pr->u.value;
if (JS_VALUE_GET_TAG(val) != JS_TAG_STRING)
return NULL;
return JS_ToCString(ctx, val);
} | O2 | c | get_func_name:
cmpl $-0x1, %edx
jne 0x3af58
movq 0x18(%rsi), %rax
movl 0x20(%rax), %ecx
notl %ecx
orl $-0x38, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movl $0x3ffffff, %edx # imm = 0x3FFFFFF
testl %ecx, %ecx
je 0x3af58
movl %ecx, %ecx
cmpl $0x37, 0x3c(%rax,%rcx,8)
je 0x3af32
movl 0x38(%rax,%rcx,8), %ecx
andl %edx, %ecx
jmp 0x3af1d
cmpl $0x3fffffff, 0x38(%rax,%rcx,8) # imm = 0x3FFFFFFF
ja 0x3af58
decq %rcx
shlq $0x4, %rcx
addq 0x20(%rsi), %rcx
movq 0x8(%rcx), %rdx
cmpl $-0x7, %edx
jne 0x3af58
movq (%rcx), %rsi
jmp 0x1aa0d
xorl %eax, %eax
retq
| get_func_name:
cmp edx, 0FFFFFFFFh
jnz short loc_3AF58
mov rax, [rsi+18h]
mov ecx, [rax+20h]
not ecx
or ecx, 0FFFFFFC8h
movsxd rcx, ecx
mov ecx, [rax+rcx*4]
mov edx, 3FFFFFFh
loc_3AF1D:
test ecx, ecx
jz short loc_3AF58
mov ecx, ecx
cmp dword ptr [rax+rcx*8+3Ch], 37h ; '7'
jz short loc_3AF32
mov ecx, [rax+rcx*8+38h]
and ecx, edx
jmp short loc_3AF1D
loc_3AF32:
cmp dword ptr [rax+rcx*8+38h], 3FFFFFFFh
ja short loc_3AF58
dec rcx
shl rcx, 4
add rcx, [rsi+20h]
mov rdx, [rcx+8]
cmp edx, 0FFFFFFF9h
jnz short loc_3AF58
mov rsi, [rcx]
jmp JS_ToCString_0
loc_3AF58:
xor eax, eax
retn
| long long get_func_name(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned int i; // ecx
long long *v5; // rcx
long long v6; // rdx
if ( a3 == -1 )
{
v3 = *(_QWORD *)(a2 + 24);
for ( i = *(_DWORD *)(v3 + 4LL * (int)(~*(_BYTE *)(v3 + 32) | 0xFFFFFFC8));
i;
i = *(_DWORD *)(v3 + 8LL * i + 56) & 0x3FFFFFF )
{
if ( *(_DWORD *)(v3 + 8LL * i + 60) == 55 )
{
if ( *(_DWORD *)(v3 + 8LL * i + 56) <= 0x3FFFFFFFu )
{
v5 = (long long *)(*(_QWORD *)(a2 + 32) + 16 * (i - 1LL));
v6 = v5[1];
if ( (_DWORD)v6 == -7 )
return JS_ToCString_0(a1, *v5, v6);
}
return 0LL;
}
}
}
return 0LL;
}
| get_func_name:
CMP EDX,-0x1
JNZ 0x0013af58
MOV RAX,qword ptr [RSI + 0x18]
MOV ECX,dword ptr [RAX + 0x20]
NOT ECX
OR ECX,0xffffffc8
MOVSXD RCX,ECX
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV EDX,0x3ffffff
LAB_0013af1d:
TEST ECX,ECX
JZ 0x0013af58
MOV ECX,ECX
CMP dword ptr [RAX + RCX*0x8 + 0x3c],0x37
JZ 0x0013af32
MOV ECX,dword ptr [RAX + RCX*0x8 + 0x38]
AND ECX,EDX
JMP 0x0013af1d
LAB_0013af32:
CMP dword ptr [RAX + RCX*0x8 + 0x38],0x3fffffff
JA 0x0013af58
DEC RCX
SHL RCX,0x4
ADD RCX,qword ptr [RSI + 0x20]
MOV RDX,qword ptr [RCX + 0x8]
CMP EDX,-0x7
JNZ 0x0013af58
MOV RSI,qword ptr [RCX]
JMP 0x0011aa0d
LAB_0013af58:
XOR EAX,EAX
RET
|
int8 get_func_name(int8 param_1,long param_2,int param_3)
{
long lVar1;
int8 uVar2;
uint uVar3;
ulong uVar4;
int8 *puVar5;
if (param_3 == -1) {
lVar1 = *(long *)(param_2 + 0x18);
uVar3 = *(uint *)(lVar1 + (long)(int)(~*(uint *)(lVar1 + 0x20) | 0xffffffc8) * 4);
while (uVar3 != 0) {
uVar4 = (ulong)uVar3;
if (*(int *)(lVar1 + 0x3c + uVar4 * 8) == 0x37) {
if (0x3fffffff < *(uint *)(lVar1 + 0x38 + uVar4 * 8)) {
return 0;
}
puVar5 = (int8 *)((uVar4 - 1) * 0x10 + *(long *)(param_2 + 0x20));
if ((int)puVar5[1] != -7) {
return 0;
}
uVar2 = JS_ToCString(param_1,*puVar5);
return uVar2;
}
uVar3 = *(uint *)(lVar1 + 0x38 + uVar4 * 8) & 0x3ffffff;
}
}
return 0;
}
| |
35,264 | gguf_set_tensor_data | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void gguf_set_tensor_data(struct gguf_context * ctx, const char * name, const void * data, size_t size) {
const int idx = gguf_find_tensor(ctx, name);
if (idx < 0) {
GGML_ASSERT(false && "tensor not found");
}
ctx->infos[idx].data = data;
ctx->infos[idx].size = size;
// update offsets
for (uint32_t i = idx + 1; i < ctx->header.n_tensors; ++i) {
ctx->infos[i].offset = ctx->infos[i - 1].offset + GGML_PAD(ctx->infos[i - 1].size, ctx->alignment);
}
} | O0 | c | gguf_set_tensor_data:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1395c0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x13a858
jmp 0x13a814
movq 0x9d70d(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0x9d77e(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x453e6(%rip), %rsi # 0x17fc1a
leaq 0x4ee33(%rip), %rdx # 0x18966e
movl $0x4c6b, %ecx # imm = 0x4C6B
leaq 0x503d3(%rip), %r8 # 0x18ac1a
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rdx
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rdx
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x50(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x13a931
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq 0x50(%rax), %rax
movq 0x20(%rsp), %rdx
addq 0x28(%rdx), %rax
subq $0x1, %rax
movq 0x20(%rsp), %rdx
movq 0x28(%rdx), %rdx
subq $0x1, %rdx
xorq $-0x1, %rdx
andq %rdx, %rax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rsp), %edx
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x40(%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x13a89e
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| gguf_set_tensor_data:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_20], rcx
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call gguf_find_tensor
mov [rsp+28h+var_24], eax
cmp [rsp+28h+var_24], 0
jge short loc_13A858
jmp short $+2
loc_13A814:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 4C6Bh
lea r8, aFalseTensorNot; "false && \"tensor not found\""
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_13A858:
mov rcx, [rsp+28h+var_18]
mov rax, [rsp+28h+var_8]
mov rax, [rax+20h]
movsxd rdx, [rsp+28h+var_24]
imul rdx, 58h ; 'X'
add rax, rdx
mov [rax+48h], rcx
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_8]
mov rax, [rax+20h]
movsxd rdx, [rsp+28h+var_24]
imul rdx, 58h ; 'X'
add rax, rdx
mov [rax+50h], rcx
mov eax, [rsp+28h+var_24]
add eax, 1
mov [rsp+28h+var_28], eax
loc_13A89E:
mov eax, [rsp+28h+var_28]
mov rcx, [rsp+28h+var_8]
cmp rax, [rcx+8]
jnb loc_13A931
mov rax, [rsp+28h+var_8]
mov rax, [rax+20h]
mov ecx, [rsp+28h+var_28]
sub ecx, 1
mov ecx, ecx
imul rcx, 58h ; 'X'
add rax, rcx
mov rcx, [rax+40h]
mov rax, [rsp+28h+var_8]
mov rax, [rax+20h]
mov edx, [rsp+28h+var_28]
sub edx, 1
mov edx, edx
imul rdx, 58h ; 'X'
add rax, rdx
mov rax, [rax+50h]
mov rdx, [rsp+28h+var_8]
add rax, [rdx+28h]
sub rax, 1
mov rdx, [rsp+28h+var_8]
mov rdx, [rdx+28h]
sub rdx, 1
xor rdx, 0FFFFFFFFFFFFFFFFh
and rax, rdx
add rcx, rax
mov rax, [rsp+28h+var_8]
mov rax, [rax+20h]
mov edx, [rsp+28h+var_28]
imul rdx, 58h ; 'X'
add rax, rdx
mov [rax+40h], rcx
mov eax, [rsp+28h+var_28]
add eax, 1
mov [rsp+28h+var_28], eax
jmp loc_13A89E
loc_13A931:
add rsp, 28h
retn
| long long gguf_set_tensor_data(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long v4; // rdi
long long result; // rax
unsigned int i; // [rsp+0h] [rbp-28h]
int tensor; // [rsp+4h] [rbp-24h]
tensor = gguf_find_tensor((long long)a1, a2);
if ( tensor < 0 )
{
fflush(stdout);
v4 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19563,
"false && \"tensor not found\"");
ggml_print_backtrace();
abort(v4);
}
*(_QWORD *)(88LL * tensor + a1[4] + 72) = a3;
*(_QWORD *)(88LL * tensor + a1[4] + 80) = a4;
for ( i = tensor + 1; ; ++i )
{
result = i;
if ( (unsigned long long)i >= a1[1] )
break;
*(_QWORD *)(88LL * i + a1[4] + 64) = (~(a1[5] - 1LL) & (a1[5] + *(_QWORD *)(88LL * (i - 1) + a1[4] + 80) - 1LL))
+ *(_QWORD *)(88LL * (i - 1) + a1[4] + 64);
}
return result;
}
| |||
35,265 | gguf_set_tensor_data | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void gguf_set_tensor_data(struct gguf_context * ctx, const char * name, const void * data, size_t size) {
const int idx = gguf_find_tensor(ctx, name);
if (idx < 0) {
GGML_ASSERT(false && "tensor not found");
}
ctx->infos[idx].data = data;
ctx->infos[idx].size = size;
// update offsets
for (uint32_t i = idx + 1; i < ctx->header.n_tensors; ++i) {
ctx->infos[i].offset = ctx->infos[i - 1].offset + GGML_PAD(ctx->infos[i - 1].size, ctx->alignment);
}
} | O2 | c | gguf_set_tensor_data:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x781dd
testl %eax, %eax
js 0x78ab6
movq 0x20(%rbx), %rcx
movl %eax, %edx
imulq $0x58, %rdx, %rdx
movq %r15, 0x48(%rcx,%rdx)
movq %r14, 0x50(%rcx,%rdx)
movq 0x8(%rbx), %rdx
leal 0x1(%rax), %esi
cmpq %rsi, %rdx
jbe 0x78ab0
movl %eax, %eax
imulq $0x58, %rax, %rax
movq 0x50(%rcx,%rax), %rdi
movq 0x28(%rbx), %r8
addq %r8, %rdi
decq %rdi
negq %r8
andq %rdi, %r8
addq 0x40(%rcx,%rax), %r8
imulq $0x58, %rsi, %rax
movq %r8, 0x40(%rcx,%rax)
movl %esi, %eax
jmp 0x78a7b
popq %rbx
popq %r14
popq %r15
retq
movq 0x5d48b(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x5d4dc(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x21748(%rip), %rsi # 0x9a21e
leaq 0x28da1(%rip), %rdx # 0xa187e
leaq 0x2a268(%rip), %r8 # 0xa2d4c
movl $0x4c6b, %ecx # imm = 0x4C6B
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| gguf_set_tensor_data:
push r15
push r14
push rbx
mov r14, rcx
mov r15, rdx
mov rbx, rdi
call gguf_find_tensor
test eax, eax
js short loc_78AB6
mov rcx, [rbx+20h]
mov edx, eax
imul rdx, 58h ; 'X'
mov [rcx+rdx+48h], r15
mov [rcx+rdx+50h], r14
mov rdx, [rbx+8]
loc_78A7B:
lea esi, [rax+1]
cmp rdx, rsi
jbe short loc_78AB0
mov eax, eax
imul rax, 58h ; 'X'
mov rdi, [rcx+rax+50h]
mov r8, [rbx+28h]
add rdi, r8
dec rdi
neg r8
and r8, rdi
add r8, [rcx+rax+40h]
imul rax, rsi, 58h ; 'X'
mov [rcx+rax+40h], r8
mov eax, esi
jmp short loc_78A7B
loc_78AB0:
pop rbx
pop r14
pop r15
retn
loc_78AB6:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalseTensorNot; "false && \"tensor not found\""
mov ecx, 4C6Bh
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long gguf_set_tensor_data(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v7; // rcx
long long v8; // rdx
unsigned long long v9; // rdx
unsigned long long v10; // rsi
long long v11; // rdi
result = gguf_find_tensor((long long)a1, a2);
if ( (int)result < 0 )
{
fflush(stdout);
v11 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19563,
"false && \"tensor not found\"");
ggml_print_backtrace();
abort(v11);
}
v7 = a1[4];
v8 = 88LL * (unsigned int)result;
*(_QWORD *)(v7 + v8 + 72) = a3;
*(_QWORD *)(v7 + v8 + 80) = a4;
v9 = a1[1];
while ( 1 )
{
v10 = (unsigned int)(result + 1);
if ( v9 <= v10 )
break;
*(_QWORD *)(v7 + 88 * v10 + 64) = *(_QWORD *)(v7 + 88LL * (unsigned int)result + 64)
+ ((a1[5] + *(_QWORD *)(v7 + 88LL * (unsigned int)result + 80) - 1LL) & -a1[5]);
result = (unsigned int)v10;
}
return result;
}
| gguf_set_tensor_data:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RCX
MOV R15,RDX
MOV RBX,RDI
CALL 0x001781dd
TEST EAX,EAX
JS 0x00178ab6
MOV RCX,qword ptr [RBX + 0x20]
MOV EDX,EAX
IMUL RDX,RDX,0x58
MOV qword ptr [RCX + RDX*0x1 + 0x48],R15
MOV qword ptr [RCX + RDX*0x1 + 0x50],R14
MOV RDX,qword ptr [RBX + 0x8]
LAB_00178a7b:
LEA ESI,[RAX + 0x1]
CMP RDX,RSI
JBE 0x00178ab0
MOV EAX,EAX
IMUL RAX,RAX,0x58
MOV RDI,qword ptr [RCX + RAX*0x1 + 0x50]
MOV R8,qword ptr [RBX + 0x28]
ADD RDI,R8
DEC RDI
NEG R8
AND R8,RDI
ADD R8,qword ptr [RCX + RAX*0x1 + 0x40]
IMUL RAX,RSI,0x58
MOV qword ptr [RCX + RAX*0x1 + 0x40],R8
MOV EAX,ESI
JMP 0x00178a7b
LAB_00178ab0:
POP RBX
POP R14
POP R15
RET
LAB_00178ab6:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2d4c]
MOV ECX,0x4c6b
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void gguf_set_tensor_data(long param_1,int8 param_2,int8 param_3,int8 param_4)
{
long lVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
uVar3 = gguf_find_tensor();
if (-1 < (int)uVar3) {
lVar1 = *(long *)(param_1 + 0x20);
lVar4 = (uVar3 & 0xffffffff) * 0x58;
*(int8 *)(lVar1 + 0x48 + lVar4) = param_3;
*(int8 *)(lVar1 + 0x50 + lVar4) = param_4;
uVar2 = *(ulong *)(param_1 + 8);
while (uVar5 = (ulong)((int)uVar3 + 1), uVar5 < uVar2) {
lVar4 = (uVar3 & 0xffffffff) * 0x58;
*(ulong *)(lVar1 + 0x40 + uVar5 * 0x58) =
(-*(long *)(param_1 + 0x28) &
(*(long *)(lVar1 + 0x50 + lVar4) + *(long *)(param_1 + 0x28)) - 1U) +
*(long *)(lVar1 + 0x40 + lVar4);
uVar3 = uVar5;
}
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
0x4c6b,"false && \"tensor not found\"");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
35,266 | set_dynamic | eloqsql/mysys/array.c | my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O3 | c | set_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %eax
cmpl %edx, %eax
ja 0x5dea2
cmpl %r14d, 0xc(%r15)
ja 0x5de7f
movq %r15, %rdi
movl %r14d, %esi
callq 0x5dec5
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x5deba
movl 0x8(%r15), %eax
movl 0x14(%r15), %ecx
movl %r14d, %edx
subl %eax, %edx
imull %ecx, %edx
movl %ecx, %edi
imull %eax, %edi
addq (%r15), %rdi
xorl %esi, %esi
callq 0x291f0
leal 0x1(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x14(%r15), %edx
imull %edx, %r14d
addq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x292f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| set_dynamic:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, edx
mov rbx, rsi
mov r15, rdi
mov eax, [rdi+8]
cmp eax, edx
ja short loc_5DEA2
cmp [r15+0Ch], r14d
ja short loc_5DE7F
mov rdi, r15
mov esi, r14d
call allocate_dynamic
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_5DEBA
mov eax, [r15+8]
loc_5DE7F:
mov ecx, [r15+14h]
mov edx, r14d
sub edx, eax
imul edx, ecx
mov edi, ecx
imul edi, eax
add rdi, [r15]
xor esi, esi
call _memset
lea eax, [r14+1]
mov [r15+8], eax
loc_5DEA2:
mov edx, [r15+14h]
imul r14d, edx
add r14, [r15]
mov rdi, r14
mov rsi, rbx
call _memcpy
xor eax, eax
loc_5DEBA:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char set_dynamic(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // eax
char dynamic; // cl
char result; // al
v4 = *(_DWORD *)(a1 + 8);
if ( v4 <= a3 )
{
if ( *(_DWORD *)(a1 + 12) <= a3 )
{
dynamic = allocate_dynamic(a1, a3);
result = 1;
if ( dynamic )
return result;
v4 = *(_DWORD *)(a1 + 8);
}
memset(*(_QWORD *)a1 + v4 * *(_DWORD *)(a1 + 20), 0LL, *(_DWORD *)(a1 + 20) * (a3 - v4));
*(_DWORD *)(a1 + 8) = a3 + 1;
}
memcpy(*(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, a2, *(unsigned int *)(a1 + 20));
return 0;
}
| set_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
MOV EAX,dword ptr [RDI + 0x8]
CMP EAX,EDX
JA 0x0015dea2
CMP dword ptr [R15 + 0xc],R14D
JA 0x0015de7f
MOV RDI,R15
MOV ESI,R14D
CALL 0x0015dec5
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x0015deba
MOV EAX,dword ptr [R15 + 0x8]
LAB_0015de7f:
MOV ECX,dword ptr [R15 + 0x14]
MOV EDX,R14D
SUB EDX,EAX
IMUL EDX,ECX
MOV EDI,ECX
IMUL EDI,EAX
ADD RDI,qword ptr [R15]
XOR ESI,ESI
CALL 0x001291f0
LEA EAX,[R14 + 0x1]
MOV dword ptr [R15 + 0x8],EAX
LAB_0015dea2:
MOV EDX,dword ptr [R15 + 0x14]
IMUL R14D,EDX
ADD R14,qword ptr [R15]
MOV RDI,R14
MOV RSI,RBX
CALL 0x001292f0
XOR EAX,EAX
LAB_0015deba:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
uint uVar2;
uVar2 = *(uint *)(param_1 + 1);
if (uVar2 <= param_3) {
if (*(uint *)((long)param_1 + 0xc) <= param_3) {
cVar1 = allocate_dynamic(param_1);
if (cVar1 != '\0') {
return 1;
}
uVar2 = *(uint *)(param_1 + 1);
}
memset((void *)((ulong)(*(int *)((long)param_1 + 0x14) * uVar2) + *param_1),0,
(ulong)((param_3 - uVar2) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
| |
35,267 | SchemaConverter::_generate_constant_rule(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _generate_constant_rule(const json & value) {
return format_literal(value.dump());
} | O1 | cpp | SchemaConverter::_generate_constant_rule(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xa3f8a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1f5c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe881c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc40
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe8845
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1dc40
movq %rbx, %rdi
callq 0x1e650
nop
| _ZN15SchemaConverter23_generate_constant_ruleERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEE:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
mov rdi, r14
mov rsi, rdx
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, rbx
mov rsi, r14
call _ZL14format_literalRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; format_literal(std::string const&)
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E881C
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E881C:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E8845
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E8845:
mov rdi, rbx
call __Unwind_Resume
| long long SchemaConverter::_generate_constant_rule(long long a1, _DWORD a2, long long a3)
{
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-20h] BYREF
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v4,
a3,
-1,
32,
0,
0);
format_literal(a1, (long long *)v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
return a1;
}
| _generate_constant_rule:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RDX
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001a3f8a
LAB_001e87f6:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001e1f5c
LAB_001e8801:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001e881c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011dc40
LAB_001e881c:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* SchemaConverter::_generate_constant_rule(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json * SchemaConverter::_generate_constant_rule(basic_json *param_1)
{
long *local_30 [2];
long local_20 [2];
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_30);
/* try { // try from 001e87f6 to 001e8800 has its CatchHandler @ 001e8827 */
format_literal((string *)param_1);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return param_1;
}
| |
35,268 | mi_ck_write | eloqsql/storage/myisam/mi_write.c | int _mi_ck_write(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
DBUG_ENTER("_mi_ck_write");
if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
{
DBUG_RETURN(_mi_ck_write_tree(info, keynr, key, key_length));
}
else
{
DBUG_RETURN(_mi_ck_write_btree(info, keynr, key, key_length));
}
} | O3 | c | mi_ck_write:
movq %rdi, %rax
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x8b51a
movl %esi, %r8d
imulq $0x298, %r8, %r8 # imm = 0x298
cmpq $0x0, (%rdi,%r8)
je 0x8b51a
pushq %rbp
movq %rsp, %rbp
addq %r8, %rdi
movq (%rax), %rax
addl 0x338(%rax), %ecx
movq 0x230(%rdi), %rax
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xa77e2
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
shll $0x7, %ecx
movl %ecx, %eax
popq %rbp
retq
movq %rax, %rdi
jmp 0x8b567
| _mi_ck_write:
mov rax, rdi
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_8B51A
mov r8d, esi
imul r8, 298h
cmp qword ptr [rdi+r8], 0
jz short loc_8B51A
push rbp
mov rbp, rsp
add rdi, r8
mov rax, [rax]
add ecx, [rax+338h]
mov rax, [rdi+230h]
mov rsi, rdx
mov edx, ecx
mov rcx, rax
call tree_insert
xor ecx, ecx
test rax, rax
setz cl
shl ecx, 7
mov eax, ecx
pop rbp
retn
loc_8B51A:
mov rdi, rax
jmp _mi_ck_write_btree
| long long mi_ck_write(_QWORD *a1, unsigned int a2, long long a3, int a4)
{
long long v5; // rdi
long long v6; // r8
v5 = a1[16];
if ( v5 && (v6 = 664LL * a2, *(_QWORD *)(v5 + v6)) )
return (unsigned __int8)(tree_insert(
v6 + v5,
a3,
(unsigned int)(*(_DWORD *)(*a1 + 824LL) + a4),
*(_QWORD *)(v6 + v5 + 560)) == 0) << 7;
else
return mi_ck_write_btree(a1);
}
| _mi_ck_write:
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x0018b51a
MOV R8D,ESI
IMUL R8,R8,0x298
CMP qword ptr [RDI + R8*0x1],0x0
JZ 0x0018b51a
PUSH RBP
MOV RBP,RSP
ADD RDI,R8
MOV RAX,qword ptr [RAX]
ADD ECX,dword ptr [RAX + 0x338]
MOV RAX,qword ptr [RDI + 0x230]
MOV RSI,RDX
MOV EDX,ECX
MOV RCX,RAX
CALL 0x001a77e2
XOR ECX,ECX
TEST RAX,RAX
SETZ CL
SHL ECX,0x7
MOV EAX,ECX
POP RBP
RET
LAB_0018b51a:
MOV RDI,RAX
JMP 0x0018b567
|
long _mi_ck_write(long *param_1,ulong param_2,int8 param_3,int param_4)
{
long lVar1;
long lVar2;
lVar1 = param_1[0x10];
if ((lVar1 != 0) && (lVar2 = (param_2 & 0xffffffff) * 0x298, *(long *)(lVar1 + lVar2) != 0)) {
lVar1 = lVar1 + lVar2;
lVar1 = tree_insert(lVar1,param_3,param_4 + *(int *)(*param_1 + 0x338),
*(int8 *)(lVar1 + 0x230));
return (ulong)(lVar1 == 0) << 7;
}
lVar1 = _mi_ck_write_btree(param_1);
return lVar1;
}
| |
35,269 | safe_hash_set | eloqsql/mysys/my_safehash.c | my_bool safe_hash_set(SAFE_HASH *hash, const uchar *key, uint length,
uchar *data)
{
SAFE_HASH_ENTRY *entry;
my_bool error= 0;
DBUG_ENTER("safe_hash_set");
DBUG_PRINT("enter",("key: %.*s data: %p", length, key, data));
mysql_rwlock_wrlock(&hash->mutex);
entry= (SAFE_HASH_ENTRY*) my_hash_search(&hash->hash, key, length);
if (data == hash->default_value)
{
/*
The key is to be associated with the default entry. In this case
we can just delete the entry (if it existed) from the hash as a
search will return the default entry
*/
if (!entry) /* nothing to do */
goto end;
/* unlink entry from list */
if ((*entry->prev= entry->next))
entry->next->prev= entry->prev;
my_hash_delete(&hash->hash, (uchar*) entry);
goto end;
}
if (entry)
{
/* Entry existed; Just change the pointer to point at the new data */
entry->data= data;
}
else
{
if (!(entry= (SAFE_HASH_ENTRY *) my_malloc(key_memory_SAFE_HASH_ENTRY,
sizeof(*entry) + length,
MYF(MY_WME))))
{
error= 1;
goto end;
}
entry->key= (uchar*) (entry +1);
memcpy((char*) entry->key, (char*) key, length);
entry->length= length;
entry->data= data;
/* Link entry to list */
if ((entry->next= hash->root))
entry->next->prev= &entry->next;
entry->prev= &hash->root;
hash->root= entry;
if (my_hash_insert(&hash->hash, (uchar*) entry))
{
/* This can only happen if hash got out of memory */
my_free(entry);
error= 1;
goto end;
}
}
end:
mysql_rwlock_unlock(&hash->mutex);
DBUG_RETURN(error);
} | O0 | c | safe_hash_set:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
jmp 0xfea1d
movq -0x8(%rbp), %rdi
leaq 0x55b8f(%rip), %rsi # 0x1545b7
movl $0xcf, %edx
callq 0xfebd0
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xdddb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x108(%rcx), %rax
jne 0xfeab2
cmpq $0x0, -0x28(%rbp)
jne 0xfea6c
jmp 0xfebad
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xfea99
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
movq -0x28(%rbp), %rsi
callq 0xde790
jmp 0xfebad
cmpq $0x0, -0x28(%rbp)
je 0xfeaca
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xfebab
leaq 0xb844c3(%rip), %rax # 0xc82f94
movl (%rax), %edi
movl -0x14(%rbp), %eax
movl %eax, %esi
addq $0x28, %rsi
movl $0x10, %edx
callq 0xf37f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xfeaf9
movb $0x1, -0x29(%rbp)
jmp 0xfebad
movq -0x28(%rbp), %rcx
addq $0x28, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
je 0xfeb60
movq -0x28(%rbp), %rcx
addq $0x18, %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
addq $0x110, %rcx # imm = 0x110
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
movq -0x28(%rbp), %rsi
callq 0xde1a0
cmpb $0x0, %al
je 0xfeba9
movq -0x28(%rbp), %rdi
callq 0xf3b70
movb $0x1, -0x29(%rbp)
jmp 0xfebad
jmp 0xfebab
jmp 0xfebad
movq -0x8(%rbp), %rdi
callq 0xfe990
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| safe_hash_set:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_29], 0
jmp short $+2
loc_FEA1D:
mov rdi, [rbp+var_8]
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0CFh
call inline_mysql_rwlock_wrlock_4
mov rdi, [rbp+var_8]
add rdi, 98h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call my_hash_search
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp rax, [rcx+108h]
jnz short loc_FEAB2
cmp [rbp+var_28], 0
jnz short loc_FEA6C
jmp loc_FEBAD
loc_FEA6C:
mov rax, [rbp+var_28]
mov rax, [rax+18h]
mov rcx, [rbp+var_28]
mov rcx, [rcx+20h]
mov [rcx], rax
cmp rax, 0
jz short loc_FEA99
mov rax, [rbp+var_28]
mov rcx, [rax+20h]
mov rax, [rbp+var_28]
mov rax, [rax+18h]
mov [rax+20h], rcx
loc_FEA99:
mov rdi, [rbp+var_8]
add rdi, 98h
mov rsi, [rbp+var_28]
call my_hash_delete
jmp loc_FEBAD
loc_FEAB2:
cmp [rbp+var_28], 0
jz short loc_FEACA
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax+10h], rcx
jmp loc_FEBAB
loc_FEACA:
lea rax, key_memory_SAFE_HASH_ENTRY
mov edi, [rax]
mov eax, [rbp+var_14]
mov esi, eax
add rsi, 28h ; '('
mov edx, 10h
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_FEAF9
mov [rbp+var_29], 1
jmp loc_FEBAD
loc_FEAF9:
mov rcx, [rbp+var_28]
add rcx, 28h ; '('
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_28]
mov rdi, [rax]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+8], ecx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov rax, [rax+110h]
mov rcx, [rbp+var_28]
mov [rcx+18h], rax
cmp rax, 0
jz short loc_FEB60
mov rcx, [rbp+var_28]
add rcx, 18h
mov rax, [rbp+var_28]
mov rax, [rax+18h]
mov [rax+20h], rcx
loc_FEB60:
mov rcx, [rbp+var_8]
add rcx, 110h
mov rax, [rbp+var_28]
mov [rax+20h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+110h], rcx
mov rdi, [rbp+var_8]
add rdi, 98h
mov rsi, [rbp+var_28]
call my_hash_insert
cmp al, 0
jz short loc_FEBA9
mov rdi, [rbp+var_28]
call my_free
mov [rbp+var_29], 1
jmp short loc_FEBAD
loc_FEBA9:
jmp short $+2
loc_FEBAB:
jmp short $+2
loc_FEBAD:
mov rdi, [rbp+var_8]
call inline_mysql_rwlock_unlock_8
mov al, [rbp+var_29]
mov [rbp+var_2A], al
mov al, [rbp+var_2A]
add rsp, 30h
pop rbp
retn
| char safe_hash_set(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v4; // rax
long long v5; // rax
char v7; // [rsp+7h] [rbp-29h]
long long v8; // [rsp+8h] [rbp-28h]
long long v9; // [rsp+8h] [rbp-28h]
v7 = 0;
inline_mysql_rwlock_wrlock_4(a1, "/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c", 207LL);
v8 = my_hash_search(a1 + 152, a2, a3);
if ( a4 == *(_QWORD *)(a1 + 264) )
{
if ( v8 )
{
v4 = *(_QWORD *)(v8 + 24);
**(_QWORD **)(v8 + 32) = v4;
if ( v4 )
*(_QWORD *)(*(_QWORD *)(v8 + 24) + 32LL) = *(_QWORD *)(v8 + 32);
my_hash_delete(a1 + 152, v8);
}
}
else if ( v8 )
{
*(_QWORD *)(v8 + 16) = a4;
}
else
{
v9 = my_malloc(key_memory_SAFE_HASH_ENTRY, (const char *)(a3 + 40LL), 16);
if ( v9 )
{
*(_QWORD *)v9 = v9 + 40;
memcpy(*(_QWORD *)v9, a2, a3);
*(_DWORD *)(v9 + 8) = a3;
*(_QWORD *)(v9 + 16) = a4;
v5 = *(_QWORD *)(a1 + 272);
*(_QWORD *)(v9 + 24) = v5;
if ( v5 )
*(_QWORD *)(*(_QWORD *)(v9 + 24) + 32LL) = v9 + 24;
*(_QWORD *)(v9 + 32) = a1 + 272;
*(_QWORD *)(a1 + 272) = v9;
if ( my_hash_insert(a1 + 152, v9) )
{
my_free(v9);
v7 = 1;
}
}
else
{
v7 = 1;
}
}
inline_mysql_rwlock_unlock_8(a1);
return v7;
}
| safe_hash_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV byte ptr [RBP + -0x29],0x0
JMP 0x001fea1d
LAB_001fea1d:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x2545b7]
MOV EDX,0xcf
CALL 0x001febd0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x98
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x001dddb0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x108]
JNZ 0x001feab2
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001fea6c
JMP 0x001febad
LAB_001fea6c:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RCX + 0x20]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001fea99
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x20],RCX
LAB_001fea99:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x98
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001de790
JMP 0x001febad
LAB_001feab2:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001feaca
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001febab
LAB_001feaca:
LEA RAX,[0xd82f94]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
ADD RSI,0x28
MOV EDX,0x10
CALL 0x001f37f0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x001feaf9
MOV byte ptr [RBP + -0x29],0x1
JMP 0x001febad
LAB_001feaf9:
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x28
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x0012a090
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],ECX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x110]
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RCX + 0x18],RAX
CMP RAX,0x0
JZ 0x001feb60
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x20],RCX
LAB_001feb60:
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x110
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x110],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x98
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001de1a0
CMP AL,0x0
JZ 0x001feba9
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001f3b70
MOV byte ptr [RBP + -0x29],0x1
JMP 0x001febad
LAB_001feba9:
JMP 0x001febab
LAB_001febab:
JMP 0x001febad
LAB_001febad:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fe990
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0x2a],AL
MOV AL,byte ptr [RBP + -0x2a]
ADD RSP,0x30
POP RBP
RET
|
int1 safe_hash_set(long param_1,void *param_2,uint param_3,long param_4)
{
long lVar1;
char cVar2;
long lVar3;
int8 *puVar4;
int1 local_31;
local_31 = 0;
inline_mysql_rwlock_wrlock
(param_1,"/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c",0xcf);
lVar3 = my_hash_search(param_1 + 0x98,param_2,param_3);
if (param_4 == *(long *)(param_1 + 0x108)) {
if (lVar3 != 0) {
lVar1 = *(long *)(lVar3 + 0x18);
**(long **)(lVar3 + 0x20) = lVar1;
if (lVar1 != 0) {
*(int8 *)(*(long *)(lVar3 + 0x18) + 0x20) = *(int8 *)(lVar3 + 0x20);
}
my_hash_delete(param_1 + 0x98,lVar3);
}
}
else if (lVar3 == 0) {
puVar4 = (int8 *)my_malloc(key_memory_SAFE_HASH_ENTRY,(ulong)param_3 + 0x28,0x10);
if (puVar4 == (int8 *)0x0) {
local_31 = 1;
}
else {
*puVar4 = puVar4 + 5;
memcpy((void *)*puVar4,param_2,(ulong)param_3);
*(uint *)(puVar4 + 1) = param_3;
puVar4[2] = param_4;
lVar3 = *(long *)(param_1 + 0x110);
puVar4[3] = lVar3;
if (lVar3 != 0) {
*(int8 **)(puVar4[3] + 0x20) = puVar4 + 3;
}
puVar4[4] = param_1 + 0x110;
*(int8 **)(param_1 + 0x110) = puVar4;
cVar2 = my_hash_insert(param_1 + 0x98,puVar4);
if (cVar2 != '\0') {
my_free(puVar4);
local_31 = 1;
}
}
}
else {
*(long *)(lVar3 + 0x10) = param_4;
}
inline_mysql_rwlock_unlock(param_1);
return local_31;
}
| |
35,270 | OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessesAroundVertex(int, float const*, float*) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/sdc/../sdc/../sdc/options.h | CreasingMethod GetCreasingMethod() const { return (CreasingMethod) _creasingMethod; } | O1 | c | OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessesAroundVertex(int, float const*, float*) const:
movb 0x2(%rdi), %al
testb %al, %al
setne %dil
cmpl $0x2, %esi
setge %r8b
testb %dil, %r8b
jne 0x3d475
testl %esi, %esi
jle 0x3d5a8
movl %esi, %eax
xorl %esi, %esi
movss 0x74bd5(%rip), %xmm0 # 0xb2004
movss 0x74bc9(%rip), %xmm1 # 0xb2000
movss 0x74bd1(%rip), %xmm2 # 0xb2010
movss (%rdx,%rsi,4), %xmm3
xorps %xmm4, %xmm4
ucomiss %xmm3, %xmm4
jae 0x3d463
ucomiss %xmm0, %xmm3
movaps %xmm0, %xmm4
jae 0x3d463
ucomiss %xmm1, %xmm3
xorps %xmm4, %xmm4
jbe 0x3d463
addss %xmm2, %xmm3
movaps %xmm3, %xmm4
movss %xmm4, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x3d43f
jmp 0x3d5a8
cmpb $0x1, %al
jne 0x3d5a8
movl %esi, %eax
testl %esi, %esi
jle 0x3d4c6
xorl %r8d, %r8d
xorps %xmm0, %xmm0
movss 0x74b73(%rip), %xmm1 # 0xb2004
xorl %edi, %edi
movss (%rdx,%r8,4), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm1, %xmm3
xorps %xmm4, %xmm4
cmpltps %xmm2, %xmm4
andps %xmm3, %xmm4
movd %xmm4, %r9d
testb $0x1, %r9b
je 0x3d4b9
addss %xmm2, %xmm0
subl %r9d, %edi
incq %r8
cmpq %r8, %rax
jne 0x3d493
jmp 0x3d4cb
xorps %xmm0, %xmm0
xorl %edi, %edi
testl %edi, %edi
je 0x3d590
testl %esi, %esi
jle 0x3d5a8
leal -0x1(%rdi), %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
xorl %esi, %esi
movss 0x74b15(%rip), %xmm2 # 0xb2004
movss 0x74b09(%rip), %xmm3 # 0xb2000
movss 0x74b11(%rip), %xmm4 # 0xb2010
movss 0x74b01(%rip), %xmm5 # 0xb2008
movss 0x74afd(%rip), %xmm6 # 0xb200c
xorps %xmm7, %xmm7
movss (%rdx,%rsi,4), %xmm8
ucomiss %xmm8, %xmm7
xorps %xmm9, %xmm9
jae 0x3d580
ucomiss %xmm2, %xmm8
movaps %xmm2, %xmm9
jae 0x3d580
cmpl $0x1, %edi
jne 0x3d550
ucomiss %xmm2, %xmm8
movaps %xmm2, %xmm9
jae 0x3d580
ucomiss %xmm3, %xmm8
xorps %xmm9, %xmm9
jbe 0x3d580
addss %xmm4, %xmm8
movaps %xmm8, %xmm9
jmp 0x3d580
movaps %xmm0, %xmm9
subss %xmm8, %xmm9
divss %xmm1, %xmm9
mulss %xmm5, %xmm9
mulss %xmm6, %xmm8
addss %xmm9, %xmm8
addss %xmm4, %xmm8
ucomiss %xmm8, %xmm7
movaps %xmm8, %xmm9
jb 0x3d580
xorps %xmm9, %xmm9
movss %xmm9, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x3d512
jmp 0x3d5a8
testl %esi, %esi
jle 0x3d5a8
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x3d596
retq
nopl (%rax)
| _ZNK10OpenSubdiv6v3_6_03Sdc6Crease36SubdivideEdgeSharpnessesAroundVertexEiPKfPf:
mov al, [rdi+2]
test al, al
setnz dil
cmp esi, 2
setnl r8b
test r8b, dil
jnz short loc_3D475
test esi, esi
jle locret_3D5A8
mov eax, esi
xor esi, esi
movss xmm0, cs:dword_B2004
movss xmm1, cs:dword_B2000
movss xmm2, cs:dword_B2010
loc_3D43F:
movss xmm3, dword ptr [rdx+rsi*4]
xorps xmm4, xmm4
ucomiss xmm4, xmm3
jnb short loc_3D463
ucomiss xmm3, xmm0
movaps xmm4, xmm0
jnb short loc_3D463
ucomiss xmm3, xmm1
xorps xmm4, xmm4
jbe short loc_3D463
addss xmm3, xmm2
movaps xmm4, xmm3
loc_3D463:
movss dword ptr [rcx+rsi*4], xmm4
inc rsi
cmp rax, rsi
jnz short loc_3D43F
jmp locret_3D5A8
loc_3D475:
cmp al, 1
jnz locret_3D5A8
mov eax, esi
test esi, esi
jle short loc_3D4C6
xor r8d, r8d
xorps xmm0, xmm0
movss xmm1, cs:dword_B2004
xor edi, edi
loc_3D493:
movss xmm2, dword ptr [rdx+r8*4]
movaps xmm3, xmm2
cmpltps xmm3, xmm1
xorps xmm4, xmm4
cmpltps xmm4, xmm2
andps xmm4, xmm3
movd r9d, xmm4
test r9b, 1
jz short loc_3D4B9
addss xmm0, xmm2
loc_3D4B9:
sub edi, r9d
inc r8
cmp rax, r8
jnz short loc_3D493
jmp short loc_3D4CB
loc_3D4C6:
xorps xmm0, xmm0
xor edi, edi
loc_3D4CB:
test edi, edi
jz loc_3D590
test esi, esi
jle locret_3D5A8
lea esi, [rdi-1]
xorps xmm1, xmm1
cvtsi2ss xmm1, esi
xor esi, esi
movss xmm2, cs:dword_B2004
movss xmm3, cs:dword_B2000
movss xmm4, cs:dword_B2010
movss xmm5, cs:dword_B2008
movss xmm6, cs:dword_B200C
xorps xmm7, xmm7
loc_3D512:
movss xmm8, dword ptr [rdx+rsi*4]
ucomiss xmm7, xmm8
xorps xmm9, xmm9
jnb short loc_3D580
ucomiss xmm8, xmm2
movaps xmm9, xmm2
jnb short loc_3D580
cmp edi, 1
jnz short loc_3D550
ucomiss xmm8, xmm2
movaps xmm9, xmm2
jnb short loc_3D580
ucomiss xmm8, xmm3
xorps xmm9, xmm9
jbe short loc_3D580
addss xmm8, xmm4
movaps xmm9, xmm8
jmp short loc_3D580
loc_3D550:
movaps xmm9, xmm0
subss xmm9, xmm8
divss xmm9, xmm1
mulss xmm9, xmm5
mulss xmm8, xmm6
addss xmm8, xmm9
addss xmm8, xmm4
ucomiss xmm7, xmm8
movaps xmm9, xmm8
jb short loc_3D580
xorps xmm9, xmm9
loc_3D580:
movss dword ptr [rcx+rsi*4], xmm9
inc rsi
cmp rax, rsi
jnz short loc_3D512
jmp short locret_3D5A8
loc_3D590:
test esi, esi
jle short locret_3D5A8
xor esi, esi
loc_3D596:
movss xmm0, dword ptr [rdx+rsi*4]
movss dword ptr [rcx+rsi*4], xmm0
inc rsi
cmp rax, rsi
jnz short loc_3D596
locret_3D5A8:
retn
| char OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessesAroundVertex(
OpenSubdiv::v3_6_0::Sdc::Crease *this,
int a2,
const float *a3,
float *a4)
{
long long v4; // rax
long long i; // rsi
float v6; // xmm3_4
float v7; // xmm4_4
long long v8; // r8
float v9; // xmm0_4
int v10; // edi
__m128 v11; // xmm2
int v12; // r9d
long long v13; // rsi
float v14; // xmm8_4
float v15; // xmm9_4
long long v16; // rsi
LOBYTE(v4) = *((_BYTE *)this + 2);
if ( (_BYTE)v4 != 0 && a2 >= 2 )
{
if ( (_BYTE)v4 == 1 )
{
v4 = (unsigned int)a2;
if ( a2 <= 0 )
{
v9 = 0.0;
v10 = 0;
}
else
{
v8 = 0LL;
v9 = 0.0;
v10 = 0;
do
{
v11 = (__m128)LODWORD(a3[v8]);
v12 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(
_mm_cmplt_ps((__m128)0LL, v11),
_mm_cmplt_ps(v11, (__m128)0x41200000u)));
if ( (v12 & 1) != 0 )
v9 = v9 + v11.m128_f32[0];
v10 -= v12;
++v8;
}
while ( a2 != v8 );
}
if ( v10 )
{
if ( a2 > 0 )
{
v13 = 0LL;
do
{
v14 = a3[v13];
v15 = 0.0;
if ( v14 > 0.0 )
{
v15 = 10.0;
if ( v14 < 10.0 )
{
if ( v10 == 1 )
{
v15 = 10.0;
if ( v14 < 10.0 )
{
v15 = 0.0;
if ( v14 > 1.0 )
v15 = v14 + -1.0;
}
}
else
{
v15 = (float)((float)(v14 * 0.75) + (float)((float)((float)(v9 - v14) / (float)(v10 - 1)) * 0.25))
+ -1.0;
if ( v15 <= 0.0 )
v15 = 0.0;
}
}
}
a4[v13++] = v15;
}
while ( v4 != v13 );
}
}
else if ( a2 > 0 )
{
v16 = 0LL;
do
{
a4[v16] = a3[v16];
++v16;
}
while ( v4 != v16 );
}
}
}
else if ( a2 > 0 )
{
v4 = (unsigned int)a2;
for ( i = 0LL; i != v4; ++i )
{
v6 = a3[i];
v7 = 0.0;
if ( v6 > 0.0 )
{
v7 = 10.0;
if ( v6 < 10.0 )
{
v7 = 0.0;
if ( v6 > 1.0 )
v7 = v6 + -1.0;
}
}
a4[i] = v7;
}
}
return v4;
}
| SubdivideEdgeSharpnessesAroundVertex:
MOV AL,byte ptr [RDI + 0x2]
TEST AL,AL
SETNZ DIL
CMP ESI,0x2
SETGE R8B
TEST R8B,DIL
JNZ 0x0013d475
TEST ESI,ESI
JLE 0x0013d5a8
MOV EAX,ESI
XOR ESI,ESI
MOVSS XMM0,dword ptr [0x001b2004]
MOVSS XMM1,dword ptr [0x001b2000]
MOVSS XMM2,dword ptr [0x001b2010]
LAB_0013d43f:
MOVSS XMM3,dword ptr [RDX + RSI*0x4]
XORPS XMM4,XMM4
UCOMISS XMM4,XMM3
JNC 0x0013d463
UCOMISS XMM3,XMM0
MOVAPS XMM4,XMM0
JNC 0x0013d463
UCOMISS XMM3,XMM1
XORPS XMM4,XMM4
JBE 0x0013d463
ADDSS XMM3,XMM2
MOVAPS XMM4,XMM3
LAB_0013d463:
MOVSS dword ptr [RCX + RSI*0x4],XMM4
INC RSI
CMP RAX,RSI
JNZ 0x0013d43f
JMP 0x0013d5a8
LAB_0013d475:
CMP AL,0x1
JNZ 0x0013d5a8
MOV EAX,ESI
TEST ESI,ESI
JLE 0x0013d4c6
XOR R8D,R8D
XORPS XMM0,XMM0
MOVSS XMM1,dword ptr [0x001b2004]
XOR EDI,EDI
LAB_0013d493:
MOVSS XMM2,dword ptr [RDX + R8*0x4]
MOVAPS XMM3,XMM2
CMPLTPS XMM3,XMM1
XORPS XMM4,XMM4
CMPLTPS XMM4,XMM2
ANDPS XMM4,XMM3
MOVD R9D,XMM4
TEST R9B,0x1
JZ 0x0013d4b9
ADDSS XMM0,XMM2
LAB_0013d4b9:
SUB EDI,R9D
INC R8
CMP RAX,R8
JNZ 0x0013d493
JMP 0x0013d4cb
LAB_0013d4c6:
XORPS XMM0,XMM0
XOR EDI,EDI
LAB_0013d4cb:
TEST EDI,EDI
JZ 0x0013d590
TEST ESI,ESI
JLE 0x0013d5a8
LEA ESI,[RDI + -0x1]
XORPS XMM1,XMM1
CVTSI2SS XMM1,ESI
XOR ESI,ESI
MOVSS XMM2,dword ptr [0x001b2004]
MOVSS XMM3,dword ptr [0x001b2000]
MOVSS XMM4,dword ptr [0x001b2010]
MOVSS XMM5,dword ptr [0x001b2008]
MOVSS XMM6,dword ptr [0x001b200c]
XORPS XMM7,XMM7
LAB_0013d512:
MOVSS XMM8,dword ptr [RDX + RSI*0x4]
UCOMISS XMM7,XMM8
XORPS XMM9,XMM9
JNC 0x0013d580
UCOMISS XMM8,XMM2
MOVAPS XMM9,XMM2
JNC 0x0013d580
CMP EDI,0x1
JNZ 0x0013d550
UCOMISS XMM8,XMM2
MOVAPS XMM9,XMM2
JNC 0x0013d580
UCOMISS XMM8,XMM3
XORPS XMM9,XMM9
JBE 0x0013d580
ADDSS XMM8,XMM4
MOVAPS XMM9,XMM8
JMP 0x0013d580
LAB_0013d550:
MOVAPS XMM9,XMM0
SUBSS XMM9,XMM8
DIVSS XMM9,XMM1
MULSS XMM9,XMM5
MULSS XMM8,XMM6
ADDSS XMM8,XMM9
ADDSS XMM8,XMM4
UCOMISS XMM7,XMM8
MOVAPS XMM9,XMM8
JC 0x0013d580
XORPS XMM9,XMM9
LAB_0013d580:
MOVSS dword ptr [RCX + RSI*0x4],XMM9
INC RSI
CMP RAX,RSI
JNZ 0x0013d512
JMP 0x0013d5a8
LAB_0013d590:
TEST ESI,ESI
JLE 0x0013d5a8
XOR ESI,ESI
LAB_0013d596:
MOVSS XMM0,dword ptr [RDX + RSI*0x4]
MOVSS dword ptr [RCX + RSI*0x4],XMM0
INC RSI
CMP RAX,RSI
JNZ 0x0013d596
LAB_0013d5a8:
RET
|
/* OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessesAroundVertex(int, float const*, float*)
const */
void __thiscall
OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessesAroundVertex
(Crease *this,int param_1,float *param_2,float *param_3)
{
float fVar1;
float fVar2;
uint uVar3;
float fVar4;
float fVar5;
float fVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
float fVar10;
float fVar11;
float fVar12;
fVar6 = DAT_001b2010;
fVar11 = DAT_001b200c;
fVar1 = DAT_001b2008;
fVar5 = DAT_001b2004;
fVar4 = DAT_001b2000;
if (param_1 < 2 || this[2] == (Crease)0x0) {
if (0 < param_1) {
uVar7 = 0;
do {
fVar1 = param_2[uVar7];
fVar11 = 0.0;
if (((0.0 < fVar1) && (fVar11 = fVar5, fVar1 < fVar5)) && (fVar11 = 0.0, fVar4 < fVar1)) {
fVar11 = fVar1 + fVar6;
}
param_3[uVar7] = fVar11;
uVar7 = uVar7 + 1;
} while ((uint)param_1 != uVar7);
}
}
else if (this[2] == (Crease)0x1) {
uVar7 = (ulong)(uint)param_1;
if (param_1 < 1) {
fVar10 = 0.0;
iVar8 = 0;
}
else {
uVar9 = 0;
fVar10 = 0.0;
iVar8 = 0;
do {
fVar2 = param_2[uVar9];
uVar3 = (uint)(0.0 < fVar2 && fVar2 < DAT_001b2004);
if ((-uVar3 & 1) != 0) {
fVar10 = fVar10 + fVar2;
}
iVar8 = iVar8 + uVar3;
uVar9 = uVar9 + 1;
} while (uVar7 != uVar9);
}
if (iVar8 == 0) {
if (0 < param_1) {
uVar9 = 0;
do {
param_3[uVar9] = param_2[uVar9];
uVar9 = uVar9 + 1;
} while (uVar7 != uVar9);
}
}
else if (0 < param_1) {
uVar9 = 0;
do {
fVar2 = param_2[uVar9];
fVar12 = 0.0;
if ((0.0 < fVar2) && (fVar12 = fVar5, fVar2 < fVar5)) {
if (iVar8 == 1) {
if ((fVar2 < fVar5) && (fVar12 = 0.0, fVar4 < fVar2)) {
fVar12 = fVar2 + fVar6;
}
}
else {
fVar12 = fVar2 * fVar11 + ((fVar10 - fVar2) / (float)(iVar8 + -1)) * fVar1 + fVar6;
if (fVar12 <= 0.0) {
fVar12 = 0.0;
}
}
}
param_3[uVar9] = fVar12;
uVar9 = uVar9 + 1;
} while (uVar7 != uVar9);
}
}
return;
}
| |
35,271 | OrtCUDAProviderOptions::OrtCUDAProviderOptions() | Depths-CPP/onnxruntime-linux-x64-gpu-1.19.2/include/onnxruntime_c_api.h | OrtCUDAProviderOptions()
: device_id{},
cudnn_conv_algo_search{OrtCudnnConvAlgoSearchExhaustive},
gpu_mem_limit{SIZE_MAX},
arena_extend_strategy{},
do_copy_in_default_stream{1},
has_user_compute_stream{},
user_compute_stream{},
default_memory_arena_cfg{},
tunable_op_enable{false},
tunable_op_tuning_enable{false},
tunable_op_max_tuning_duration_ms{} {} | O0 | c | OrtCUDAProviderOptions::OrtCUDAProviderOptions():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq $-0x1, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x1, 0x14(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movl $0x0, 0x38(%rax)
retq
nopw (%rax,%rax)
| _ZN22OrtCUDAProviderOptionsC2Ev:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov dword ptr [rax], 0
mov dword ptr [rax+4], 0
mov qword ptr [rax+8], 0FFFFFFFFFFFFFFFFh
mov dword ptr [rax+10h], 0
mov dword ptr [rax+14h], 1
mov dword ptr [rax+18h], 0
mov qword ptr [rax+20h], 0
mov qword ptr [rax+28h], 0
mov dword ptr [rax+30h], 0
mov dword ptr [rax+34h], 0
mov dword ptr [rax+38h], 0
retn
| void OrtCUDAProviderOptions::OrtCUDAProviderOptions(OrtCUDAProviderOptions *this)
{
*(_DWORD *)this = 0;
*((_DWORD *)this + 1) = 0;
*((_QWORD *)this + 1) = -1LL;
*((_DWORD *)this + 4) = 0;
*((_DWORD *)this + 5) = 1;
*((_DWORD *)this + 6) = 0;
*((_QWORD *)this + 4) = 0LL;
*((_QWORD *)this + 5) = 0LL;
*((_DWORD *)this + 12) = 0;
*((_DWORD *)this + 13) = 0;
*((_DWORD *)this + 14) = 0;
}
| OrtCUDAProviderOptions:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV dword ptr [RAX],0x0
MOV dword ptr [RAX + 0x4],0x0
MOV qword ptr [RAX + 0x8],-0x1
MOV dword ptr [RAX + 0x10],0x0
MOV dword ptr [RAX + 0x14],0x1
MOV dword ptr [RAX + 0x18],0x0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RAX + 0x28],0x0
MOV dword ptr [RAX + 0x30],0x0
MOV dword ptr [RAX + 0x34],0x0
MOV dword ptr [RAX + 0x38],0x0
RET
|
/* OrtCUDAProviderOptions::OrtCUDAProviderOptions() */
void __thiscall OrtCUDAProviderOptions::OrtCUDAProviderOptions(OrtCUDAProviderOptions *this)
{
*(int4 *)this = 0;
*(int4 *)(this + 4) = 0;
*(int8 *)(this + 8) = 0xffffffffffffffff;
*(int4 *)(this + 0x10) = 0;
*(int4 *)(this + 0x14) = 1;
*(int4 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int4 *)(this + 0x30) = 0;
*(int4 *)(this + 0x34) = 0;
*(int4 *)(this + 0x38) = 0;
return;
}
| |
35,272 | pfs_memory_realloc_v1 | eloqsql/storage/perfschema/pfs.cc | PSI_memory_key pfs_memory_realloc_v1(PSI_memory_key key, size_t old_size, size_t new_size, PSI_thread **owner)
{
PFS_thread ** owner_thread_hdl= reinterpret_cast<PFS_thread**>(owner);
assert(owner != NULL);
PFS_memory_class *klass= find_memory_class(key);
if (klass == NULL)
{
*owner_thread_hdl= NULL;
return PSI_NOT_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 && ! klass->is_global())
{
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (likely(pfs_thread != NULL))
{
#ifdef PFS_PARANOID
PFS_thread *owner_thread= *owner_thread_hdl;
if (owner_thread != pfs_thread)
{
owner_thread= sanitize_thread(owner_thread);
if (owner_thread != NULL)
{
report_memory_accounting_error("pfs_memory_realloc_v1",
pfs_thread, old_size, klass, owner_thread);
}
}
#endif /* PFS_PARANOID */
/* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
event_name_array= pfs_thread->write_instr_class_memory_stats();
stat= & event_name_array[index];
if (flag_global_instrumentation && klass->m_enabled)
{
delta= stat->count_realloc(old_size, new_size, &delta_buffer);
*owner_thread_hdl= pfs_thread;
}
else
{
delta= stat->count_free(old_size, &delta_buffer);
*owner_thread_hdl= NULL;
key= PSI_NOT_INSTRUMENTED;
}
if (delta != NULL)
{
pfs_thread->carry_memory_stat_delta(delta, index);
}
return key;
}
}
/* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
event_name_array= global_instr_class_memory_array;
stat= & event_name_array[index];
if (flag_global_instrumentation && klass->m_enabled)
{
(void) stat->count_realloc(old_size, new_size, &delta_buffer);
}
else
{
(void) stat->count_free(old_size, &delta_buffer);
key= PSI_NOT_INSTRUMENTED;
}
*owner_thread_hdl= NULL;
return key;
} | O0 | cpp | pfs_memory_realloc_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %edi
callq 0x4f000
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3561c
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3577f
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x44(%rbp)
leaq 0x3d6413(%rip), %rax # 0x40ba40
testb $0x1, (%rax)
je 0x35709
movq -0x30(%rbp), %rdi
callq 0x36880
testb $0x1, %al
jne 0x35709
callq 0x2d4b0
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x35707
movq -0x78(%rbp), %rdi
callq 0x368a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq 0x3d6374(%rip), %rax # 0x40ba00
testb $0x1, (%rax)
je 0x356c1
movq -0x30(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x356c1
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x369f0
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x356e8
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x36b60
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x8(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x356ff
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0x43600
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3577f
jmp 0x35709
leaq 0x3d66b8(%rip), %rax # 0x40bdc8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq 0x3d62d0(%rip), %rax # 0x40ba00
testb $0x1, (%rax)
je 0x35756
movq -0x30(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x35756
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x369f0
jmp 0x3576e
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x36b60
movl $0x0, -0x8(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pfs_memory_realloc_v1:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov edi, [rbp+var_8]; unsigned int
call _Z17find_memory_classj; find_memory_class(uint)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_3561C
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_3577F
loc_3561C:
mov rax, [rbp+var_30]
mov eax, [rax+10h]
mov [rbp+var_44], eax
lea rax, flag_thread_instrumentation
test byte ptr [rax], 1
jz loc_35709
mov rdi, [rbp+var_30]; this
call _ZNK16PFS_memory_class9is_globalEv; PFS_memory_class::is_global(void)
test al, 1
jnz loc_35709
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_78], rax
cmp [rbp+var_78], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
jz loc_35707
mov rdi, [rbp+var_78]; this
call _ZN20PFS_connection_slice30write_instr_class_memory_statsEv; PFS_connection_slice::write_instr_class_memory_stats(void)
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_44]
imul rcx, 48h ; 'H'
add rax, rcx
mov [rbp+var_40], rax
lea rax, flag_global_instrumentation
test byte ptr [rax], 1
jz short loc_356C1
mov rax, [rbp+var_30]
test byte ptr [rax+4], 1
jz short loc_356C1
mov rdi, [rbp+var_40]; this
mov rsi, [rbp+var_10]; unsigned __int64
mov rdx, [rbp+var_18]; unsigned __int64
lea rcx, [rbp+var_68]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat13count_reallocEmmP21PFS_memory_stat_delta; PFS_memory_stat::count_realloc(ulong,ulong,PFS_memory_stat_delta *)
mov [rbp+var_70], rax
mov rcx, [rbp+var_78]
mov rax, [rbp+var_28]
mov [rax], rcx
jmp short loc_356E8
loc_356C1:
mov rdi, [rbp+var_40]; this
mov rsi, [rbp+var_10]; unsigned __int64
lea rdx, [rbp+var_68]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat10count_freeEmP21PFS_memory_stat_delta; PFS_memory_stat::count_free(ulong,PFS_memory_stat_delta *)
mov [rbp+var_70], rax
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov [rbp+var_8], 0
loc_356E8:
cmp [rbp+var_70], 0
jz short loc_356FF
mov rdi, [rbp+var_78]; this
mov rsi, [rbp+var_70]; PFS_memory_stat_delta *
mov edx, [rbp+var_44]; unsigned int
call _ZN10PFS_thread23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_356FF:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_3577F
loc_35707:
jmp short $+2
loc_35709:
lea rax, global_instr_class_memory_array
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_44]
imul rcx, 48h ; 'H'
add rax, rcx
mov [rbp+var_40], rax
lea rax, flag_global_instrumentation
test byte ptr [rax], 1
jz short loc_35756
mov rax, [rbp+var_30]
test byte ptr [rax+4], 1
jz short loc_35756
mov rdi, [rbp+var_40]; this
mov rsi, [rbp+var_10]; unsigned __int64
mov rdx, [rbp+var_18]; unsigned __int64
lea rcx, [rbp+var_68]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat13count_reallocEmmP21PFS_memory_stat_delta; PFS_memory_stat::count_realloc(ulong,ulong,PFS_memory_stat_delta *)
jmp short loc_3576E
loc_35756:
mov rdi, [rbp+var_40]; this
mov rsi, [rbp+var_10]; unsigned __int64
lea rdx, [rbp+var_68]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat10count_freeEmP21PFS_memory_stat_delta; PFS_memory_stat::count_free(ulong,PFS_memory_stat_delta *)
mov [rbp+var_8], 0
loc_3576E:
mov rax, [rbp+var_28]
mov qword ptr [rax], 0
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_3577F:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long pfs_memory_realloc_v1(
unsigned int a1,
unsigned long long a2,
unsigned long long a3,
PFS_connection_slice **a4)
{
PFS_connection_slice *THR_PFS; // [rsp+8h] [rbp-78h]
PFS_memory_stat_delta *v6; // [rsp+10h] [rbp-70h]
_BYTE v7[36]; // [rsp+18h] [rbp-68h] BYREF
unsigned int v8; // [rsp+3Ch] [rbp-44h]
PFS_memory_stat *v9; // [rsp+40h] [rbp-40h]
PFS_memory_stat *v10; // [rsp+48h] [rbp-38h]
PFS_memory_class *memory_class; // [rsp+50h] [rbp-30h]
PFS_connection_slice **v12; // [rsp+58h] [rbp-28h]
PFS_connection_slice **v13; // [rsp+60h] [rbp-20h]
unsigned long long v14; // [rsp+68h] [rbp-18h]
unsigned long long v15; // [rsp+70h] [rbp-10h]
unsigned int v16; // [rsp+78h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a4;
memory_class = (PFS_memory_class *)find_memory_class(a1);
if ( memory_class )
{
v8 = *((_DWORD *)memory_class + 4);
if ( (flag_thread_instrumentation & 1) != 0
&& (PFS_memory_class::is_global(memory_class) & 1) == 0
&& (THR_PFS = (PFS_connection_slice *)my_thread_get_THR_PFS()) != 0LL )
{
v10 = (PFS_memory_stat *)PFS_connection_slice::write_instr_class_memory_stats(THR_PFS);
v9 = (PFS_memory_stat *)((char *)v10 + 72 * v8);
if ( (flag_global_instrumentation & 1) != 0 && (*((_BYTE *)memory_class + 4) & 1) != 0 )
{
v6 = (PFS_memory_stat_delta *)PFS_memory_stat::count_realloc(v9, v15, v14, (PFS_memory_stat_delta *)v7);
*v12 = THR_PFS;
}
else
{
v6 = (PFS_memory_stat_delta *)PFS_memory_stat::count_free(v9, v15, (PFS_memory_stat_delta *)v7);
*v12 = 0LL;
v16 = 0;
}
if ( v6 )
PFS_thread::carry_memory_stat_delta(THR_PFS, v6, v8);
return v16;
}
else
{
v10 = global_instr_class_memory_array;
v9 = (PFS_memory_stat *)((char *)global_instr_class_memory_array + 72 * v8);
if ( (flag_global_instrumentation & 1) != 0 && (*((_BYTE *)memory_class + 4) & 1) != 0 )
{
PFS_memory_stat::count_realloc(v9, v15, v14, (PFS_memory_stat_delta *)v7);
}
else
{
PFS_memory_stat::count_free(v9, v15, (PFS_memory_stat_delta *)v7);
v16 = 0;
}
*v12 = 0LL;
return v16;
}
}
else
{
*v12 = 0LL;
return 0;
}
}
| pfs_memory_realloc_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV EDI,dword ptr [RBP + -0x8]
CALL 0x0014f000
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0013561c
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013577f
LAB_0013561c:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x44],EAX
LEA RAX,[0x50ba40]
TEST byte ptr [RAX],0x1
JZ 0x00135709
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00136880
TEST AL,0x1
JNZ 0x00135709
CALL 0x0012d4b0
MOV qword ptr [RBP + -0x78],RAX
CMP qword ptr [RBP + -0x78],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00135707
MOV RDI,qword ptr [RBP + -0x78]
CALL 0x001368a0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x44]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x50ba00]
TEST byte ptr [RAX],0x1
JZ 0x001356c1
MOV RAX,qword ptr [RBP + -0x30]
TEST byte ptr [RAX + 0x4],0x1
JZ 0x001356c1
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x68]
CALL 0x001369f0
MOV qword ptr [RBP + -0x70],RAX
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
JMP 0x001356e8
LAB_001356c1:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x68]
CALL 0x00136b60
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x8],0x0
LAB_001356e8:
CMP qword ptr [RBP + -0x70],0x0
JZ 0x001356ff
MOV RDI,qword ptr [RBP + -0x78]
MOV RSI,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RBP + -0x44]
CALL 0x00143600
LAB_001356ff:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013577f
LAB_00135707:
JMP 0x00135709
LAB_00135709:
LEA RAX,[0x50bdc8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x44]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x50ba00]
TEST byte ptr [RAX],0x1
JZ 0x00135756
MOV RAX,qword ptr [RBP + -0x30]
TEST byte ptr [RAX + 0x4],0x1
JZ 0x00135756
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x68]
CALL 0x001369f0
JMP 0x0013576e
LAB_00135756:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x68]
CALL 0x00136b60
MOV dword ptr [RBP + -0x8],0x0
LAB_0013576e:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013577f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
uint pfs_memory_realloc_v1(uint param_1,ulong param_2,ulong param_3,int8 *param_4)
{
ulong uVar1;
PFS_connection_slice *this;
PFS_memory_stat_delta *local_78;
PFS_memory_stat_delta local_70 [36];
uint local_4c;
PFS_memory_stat *local_48;
long local_40;
PFS_memory_class *local_38;
int8 *local_30;
int8 *local_28;
ulong local_20;
ulong local_18;
uint local_10;
uint local_c;
local_30 = param_4;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_38 = (PFS_memory_class *)find_memory_class(param_1);
if (local_38 == (PFS_memory_class *)0x0) {
*local_30 = 0;
local_c = 0;
}
else {
local_4c = *(uint *)(local_38 + 0x10);
if ((((flag_thread_instrumentation & 1) == 0) ||
(uVar1 = PFS_memory_class::is_global(local_38), (uVar1 & 1) != 0)) ||
(this = (PFS_connection_slice *)my_thread_get_THR_PFS(), this == (PFS_connection_slice *)0x0)
) {
local_40 = global_instr_class_memory_array;
local_48 = (PFS_memory_stat *)(global_instr_class_memory_array + (ulong)local_4c * 0x48);
if (((flag_global_instrumentation & 1) == 0) || (((byte)local_38[4] & 1) == 0)) {
PFS_memory_stat::count_free(local_48,local_18,local_70);
local_10 = 0;
}
else {
PFS_memory_stat::count_realloc(local_48,local_18,local_20,local_70);
}
*local_30 = 0;
local_c = local_10;
}
else {
local_40 = PFS_connection_slice::write_instr_class_memory_stats(this);
local_48 = (PFS_memory_stat *)(local_40 + (ulong)local_4c * 0x48);
if (((flag_global_instrumentation & 1) == 0) || (((byte)local_38[4] & 1) == 0)) {
local_78 = (PFS_memory_stat_delta *)PFS_memory_stat::count_free(local_48,local_18,local_70);
*local_30 = 0;
local_10 = 0;
}
else {
local_78 = (PFS_memory_stat_delta *)
PFS_memory_stat::count_realloc(local_48,local_18,local_20,local_70);
*local_30 = this;
}
if (local_78 != (PFS_memory_stat_delta *)0x0) {
PFS_thread::carry_memory_stat_delta((PFS_thread *)this,local_78,local_4c);
}
local_c = local_10;
}
}
return local_c;
}
| |
35,273 | js_typed_array_set_internal | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_set_internal(JSContext *ctx,
JSValue dst,
JSValue src,
JSValue off)
{
JSObject *p;
JSObject *src_p;
uint32_t i;
int64_t dst_len, src_len, offset;
JSValue val, src_obj = JS_UNDEFINED;
p = get_typed_array(ctx, dst);
if (!p)
goto fail;
if (JS_ToInt64Sat(ctx, &offset, off))
goto fail;
if (offset < 0)
goto range_error;
if (typed_array_is_oob(p)) {
detached:
JS_ThrowTypeErrorArrayBufferOOB(ctx);
goto fail;
}
dst_len = p->u.array.count;
src_obj = JS_ToObject(ctx, src);
if (JS_IsException(src_obj))
goto fail;
src_p = JS_VALUE_GET_OBJ(src_obj);
if (src_p->class_id >= JS_CLASS_UINT8C_ARRAY &&
src_p->class_id <= JS_CLASS_FLOAT64_ARRAY) {
JSTypedArray *dest_ta = p->u.typed_array;
JSArrayBuffer *dest_abuf = dest_ta->buffer->u.array_buffer;
JSTypedArray *src_ta = src_p->u.typed_array;
JSArrayBuffer *src_abuf = src_ta->buffer->u.array_buffer;
int shift = typed_array_size_log2(p->class_id);
if (typed_array_is_oob(src_p))
goto detached;
src_len = src_p->u.array.count;
if (offset > dst_len - src_len)
goto range_error;
/* copying between typed objects */
if (src_p->class_id == p->class_id) {
/* same type, use memmove */
memmove(dest_abuf->data + dest_ta->offset + (offset << shift),
src_abuf->data + src_ta->offset, src_len << shift);
goto done;
}
if (dest_abuf->data == src_abuf->data) {
/* copying between the same buffer using different types of mappings
would require a temporary buffer */
}
/* otherwise, default behavior is slow but correct */
} else {
// can change |dst| as a side effect; per spec,
// perform the range check against its old length
if (js_get_length64(ctx, &src_len, src_obj))
goto fail;
if (offset > dst_len - src_len) {
range_error:
JS_ThrowRangeError(ctx, "invalid array length");
goto fail;
}
}
for(i = 0; i < src_len; i++) {
val = JS_GetPropertyUint32(ctx, src_obj, i);
if (JS_IsException(val))
goto fail;
// Per spec: detaching the TA mid-iteration is allowed and should
// not throw an exception. Because iteration over the source array is
// observable, we cannot bail out early when the TA is first detached.
if (typed_array_is_oob(p)) {
JS_FreeValue(ctx, val);
} else if (JS_SetPropertyUint32(ctx, dst, offset + i, val) < 0) {
goto fail;
}
}
done:
JS_FreeValue(ctx, src_obj);
return JS_UNDEFINED;
fail:
JS_FreeValue(ctx, src_obj);
return JS_EXCEPTION;
} | O0 | c | js_typed_array_set_internal:
subq $0xf8, %rsp
leaq 0x100(%rsp), %rax
movq %rax, (%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movq 0x2aede(%rip), %rax # 0x113b80
movq %rax, 0x70(%rsp)
movq 0x2aeda(%rip), %rax # 0x113b88
movq %rax, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
callq 0x5ec30
movq %rax, 0xb8(%rsp)
cmpq $0x0, 0xb8(%rsp)
jne 0xe8ce8
jmp 0xe90e1
movq (%rsp), %rax
movq 0xc0(%rsp), %rdi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x90(%rsp), %rsi
callq 0x3ec10
cmpl $0x0, %eax
je 0xe8d12
jmp 0xe90e1
cmpq $0x0, 0x90(%rsp)
jge 0xe8d22
jmp 0xe8f74
movq 0xb8(%rsp), %rdi
callq 0x5ecc0
cmpl $0x0, %eax
je 0xe8d52
jmp 0xe8d36
movq 0xc0(%rsp), %rdi
callq 0x5edd0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
jmp 0xe90e1
movq 0xb8(%rsp), %rax
movl 0x40(%rax), %eax
movq %rax, 0xa0(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x3da60
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xe8db9
jmp 0xe90e1
movq 0x70(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x15, %eax
jl 0xe8f2c
movq 0xb0(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x20, %eax
jg 0xe8f2c
movq 0xb8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0xb0(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rax
movzwl 0x6(%rax), %eax
subl $0x15, %eax
movslq %eax, %rcx
leaq 0x29da0(%rip), %rax # 0x112bef
movzbl (%rax,%rcx), %eax
movl %eax, 0x2c(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x5ecc0
cmpl $0x0, %eax
je 0xe8e6e
jmp 0xe8d36
movq 0xb0(%rsp), %rax
movl 0x40(%rax), %eax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rax
movq 0xa0(%rsp), %rcx
subq 0x98(%rsp), %rcx
cmpq %rcx, %rax
jle 0xe8ea3
jmp 0xe8f74
movq 0xb0(%rsp), %rax
movzwl 0x6(%rax), %eax
movq 0xb8(%rsp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jne 0xe8f14
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x48(%rsp), %rax
movl 0x20(%rax), %eax
addq %rax, %rdi
movq 0x90(%rsp), %rax
movl 0x2c(%rsp), %ecx
shlq %cl, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x38(%rsp), %rax
movl 0x20(%rax), %eax
addq %rax, %rsi
movq 0x98(%rsp), %rdx
movl 0x2c(%rsp), %eax
movl %eax, %ecx
shlq %cl, %rdx
callq 0xe770
jmp 0xe90b1
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xe8f2a
jmp 0xe8f2a
jmp 0xe8f9b
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
leaq 0x98(%rsp), %rsi
callq 0x34250
cmpl $0x0, %eax
je 0xe8f55
jmp 0xe90e1
movq 0x90(%rsp), %rax
movq 0xa0(%rsp), %rcx
subq 0x98(%rsp), %rcx
cmpq %rcx, %rax
jle 0xe8f99
jmp 0xe8f74
movq 0xc0(%rsp), %rdi
leaq 0x2b47f(%rip), %rsi # 0x114402
movb $0x0, %al
callq 0x2f960
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0xe90e1
jmp 0xe8f9b
movl $0x0, 0xac(%rsp)
movl 0xac(%rsp), %eax
cmpq 0x98(%rsp), %rax
jge 0xe90af
movq 0xc0(%rsp), %rdi
movl 0xac(%rsp), %ecx
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x37750
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xe901c
jmp 0xe90e1
movq 0xb8(%rsp), %rdi
callq 0x5ecc0
cmpl $0x0, %eax
je 0xe904d
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x29f80
jmp 0xe9097
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rax
movl 0xac(%rsp), %ecx
addq %rcx, %rax
movl %eax, %ecx
movq 0xd8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0x80(%rsp), %r8
movq 0x88(%rsp), %r9
callq 0x39640
cmpl $0x0, %eax
jge 0xe9095
jmp 0xe90e1
jmp 0xe9097
jmp 0xe9099
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0xe8fa6
jmp 0xe90b1
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x29f80
movl $0x0, 0xe8(%rsp)
movq $0x3, 0xf0(%rsp)
jmp 0xe910f
movq 0xc0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x29f80
movl $0x0, 0xe8(%rsp)
movq $0x6, 0xf0(%rsp)
movq 0xe8(%rsp), %rax
movq 0xf0(%rsp), %rdx
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
| js_typed_array_set_internal:
sub rsp, 0F8h
lea rax, [rsp+0F8h+arg_0]
mov [rsp+0F8h+var_F8], rax
mov [rsp+0F8h+var_20], rsi
mov [rsp+0F8h+var_18], rdx
mov [rsp+0F8h+var_30], rcx
mov [rsp+0F8h+var_28], r8
mov [rsp+0F8h+var_38], rdi
mov rax, cs:qword_113B80
mov [rsp+0F8h+var_88], rax
mov rax, cs:qword_113B88
mov [rsp+0F8h+var_80], rax
mov rdi, [rsp+0F8h+var_38]
mov rsi, [rsp+0F8h+var_20]
mov rdx, [rsp+0F8h+var_18]
call get_typed_array
mov [rsp+0F8h+var_40], rax
cmp [rsp+0F8h+var_40], 0
jnz short loc_E8CE8
jmp loc_E90E1
loc_E8CE8:
mov rax, [rsp+0F8h+var_F8]
mov rdi, [rsp+0F8h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0F8h+var_68]
call JS_ToInt64Sat
cmp eax, 0
jz short loc_E8D12
jmp loc_E90E1
loc_E8D12:
cmp [rsp+0F8h+var_68], 0
jge short loc_E8D22
jmp loc_E8F74
loc_E8D22:
mov rdi, [rsp+0F8h+var_40]
call typed_array_is_oob
cmp eax, 0
jz short loc_E8D52
jmp short $+2
loc_E8D36:
mov rdi, [rsp+0F8h+var_38]
call JS_ThrowTypeErrorArrayBufferOOB
mov [rsp+0F8h+var_98], rax
mov [rsp+0F8h+var_90], rdx
jmp loc_E90E1
loc_E8D52:
mov rax, [rsp+0F8h+var_40]
mov eax, [rax+40h]
mov [rsp+0F8h+var_58], rax
mov rdi, [rsp+0F8h+var_38]
mov rsi, [rsp+0F8h+var_30]
mov rdx, [rsp+0F8h+var_28]
call JS_ToObject
mov [rsp+0F8h+var_A8], rax
mov [rsp+0F8h+var_A0], rdx
mov rax, [rsp+0F8h+var_A8]
mov [rsp+0F8h+var_88], rax
mov rax, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_80], rax
mov rdi, [rsp+0F8h+var_88]
mov rsi, [rsp+0F8h+var_80]
call JS_IsException_1
cmp eax, 0
jz short loc_E8DB9
jmp loc_E90E1
loc_E8DB9:
mov rax, [rsp+0F8h+var_88]
mov [rsp+0F8h+var_48], rax
mov rax, [rsp+0F8h+var_48]
movzx eax, word ptr [rax+6]
cmp eax, 15h
jl loc_E8F2C
mov rax, [rsp+0F8h+var_48]
movzx eax, word ptr [rax+6]
cmp eax, 20h ; ' '
jg loc_E8F2C
mov rax, [rsp+0F8h+var_40]
mov rax, [rax+30h]
mov [rsp+0F8h+var_B0], rax
mov rax, [rsp+0F8h+var_B0]
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+0F8h+var_B8], rax
mov rax, [rsp+0F8h+var_48]
mov rax, [rax+30h]
mov [rsp+0F8h+var_C0], rax
mov rax, [rsp+0F8h+var_C0]
mov rax, [rax+18h]
mov rax, [rax+30h]
mov [rsp+0F8h+var_C8], rax
mov rax, [rsp+0F8h+var_40]
movzx eax, word ptr [rax+6]
sub eax, 15h
movsxd rcx, eax
lea rax, typed_array_size_log2
movzx eax, byte ptr [rax+rcx]
mov [rsp+0F8h+var_CC], eax
mov rdi, [rsp+0F8h+var_48]
call typed_array_is_oob
cmp eax, 0
jz short loc_E8E6E
jmp loc_E8D36
loc_E8E6E:
mov rax, [rsp+0F8h+var_48]
mov eax, [rax+40h]
mov [rsp+0F8h+var_60], rax
mov rax, [rsp+0F8h+var_68]
mov rcx, [rsp+0F8h+var_58]
sub rcx, [rsp+0F8h+var_60]
cmp rax, rcx
jle short loc_E8EA3
jmp loc_E8F74
loc_E8EA3:
mov rax, [rsp+0F8h+var_48]
movzx eax, word ptr [rax+6]
mov rcx, [rsp+0F8h+var_40]
movzx ecx, word ptr [rcx+6]
cmp eax, ecx
jnz short loc_E8F14
mov rax, [rsp+0F8h+var_B8]
mov rdi, [rax+10h]
mov rax, [rsp+0F8h+var_B0]
mov eax, [rax+20h]
add rdi, rax
mov rax, [rsp+0F8h+var_68]
mov ecx, [rsp+0F8h+var_CC]
shl rax, cl
add rdi, rax
mov rax, [rsp+0F8h+var_C8]
mov rsi, [rax+10h]
mov rax, [rsp+0F8h+var_C0]
mov eax, [rax+20h]
add rsi, rax
mov rdx, [rsp+0F8h+var_60]
mov eax, [rsp+0F8h+var_CC]
mov ecx, eax
shl rdx, cl
call _memmove
jmp loc_E90B1
loc_E8F14:
mov rax, [rsp+0F8h+var_B8]
mov rax, [rax+10h]
mov rcx, [rsp+0F8h+var_C8]
cmp rax, [rcx+10h]
jnz short loc_E8F2A
jmp short $+2
loc_E8F2A:
jmp short loc_E8F9B
loc_E8F2C:
mov rdi, [rsp+0F8h+var_38]
mov rdx, [rsp+0F8h+var_88]
mov rcx, [rsp+0F8h+var_80]
lea rsi, [rsp+0F8h+var_60]
call js_get_length64
cmp eax, 0
jz short loc_E8F55
jmp loc_E90E1
loc_E8F55:
mov rax, [rsp+0F8h+var_68]
mov rcx, [rsp+0F8h+var_58]
sub rcx, [rsp+0F8h+var_60]
cmp rax, rcx
jle short loc_E8F99
jmp short $+2
loc_E8F74:
mov rdi, [rsp+0F8h+var_38]
lea rsi, aInvalidArrayLe; "invalid array length"
mov al, 0
call JS_ThrowRangeError
mov [rsp+0F8h+var_E0], rax
mov [rsp+0F8h+var_D8], rdx
jmp loc_E90E1
loc_E8F99:
jmp short $+2
loc_E8F9B:
mov [rsp+0F8h+var_4C], 0
loc_E8FA6:
mov eax, [rsp+0F8h+var_4C]
cmp rax, [rsp+0F8h+var_60]
jge loc_E90AF
mov rdi, [rsp+0F8h+var_38]
mov ecx, [rsp+0F8h+var_4C]
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
call JS_GetPropertyUint32
mov [rsp+0F8h+var_F0], rax
mov [rsp+0F8h+var_E8], rdx
mov rax, [rsp+0F8h+var_F0]
mov [rsp+0F8h+var_78], rax
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_70], rax
mov rdi, [rsp+0F8h+var_78]
mov rsi, [rsp+0F8h+var_70]
call JS_IsException_1
cmp eax, 0
jz short loc_E901C
jmp loc_E90E1
loc_E901C:
mov rdi, [rsp+0F8h+var_40]
call typed_array_is_oob
cmp eax, 0
jz short loc_E904D
mov rdi, [rsp+0F8h+var_38]
mov rsi, [rsp+0F8h+var_78]
mov rdx, [rsp+0F8h+var_70]
call JS_FreeValue
jmp short loc_E9097
loc_E904D:
mov rdi, [rsp+0F8h+var_38]
mov rax, [rsp+0F8h+var_68]
mov ecx, [rsp+0F8h+var_4C]
add rax, rcx
mov ecx, eax
mov rsi, [rsp+0F8h+var_20]
mov rdx, [rsp+0F8h+var_18]
mov r8, [rsp+0F8h+var_78]
mov r9, [rsp+0F8h+var_70]
call JS_SetPropertyUint32
cmp eax, 0
jge short loc_E9095
jmp short loc_E90E1
loc_E9095:
jmp short $+2
loc_E9097:
jmp short $+2
loc_E9099:
mov eax, [rsp+0F8h+var_4C]
add eax, 1
mov [rsp+0F8h+var_4C], eax
jmp loc_E8FA6
loc_E90AF:
jmp short $+2
loc_E90B1:
mov rdi, [rsp+0F8h+var_38]
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
call JS_FreeValue
mov dword ptr [rsp+0F8h+var_10], 0
mov [rsp+0F8h+var_8], 3
jmp short loc_E910F
loc_E90E1:
mov rdi, [rsp+0F8h+var_38]
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
call JS_FreeValue
mov dword ptr [rsp+0F8h+var_10], 0
mov [rsp+0F8h+var_8], 6
loc_E910F:
mov rax, [rsp+0F8h+var_10]
mov rdx, [rsp+0F8h+var_8]
add rsp, 0F8h
retn
| long long js_typed_array_set_internal(
long long a1,
long long a2,
long long a3,
_DWORD *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
_DWORD *a15,
unsigned int a16)
{
long long *v16; // rsi
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // rcx
long long *v24; // rdx
long long v25; // rdx
long long PropertyUint32; // [rsp+8h] [rbp-F0h]
char v28; // [rsp+2Ch] [rbp-CCh]
long long v29; // [rsp+30h] [rbp-C8h]
long long v30; // [rsp+38h] [rbp-C0h]
long long v31; // [rsp+40h] [rbp-B8h]
long long v32; // [rsp+48h] [rbp-B0h]
_DWORD *v33; // [rsp+50h] [rbp-A8h]
long long v34; // [rsp+70h] [rbp-88h]
long long v35; // [rsp+78h] [rbp-80h]
long long v36; // [rsp+88h] [rbp-70h]
long long v37; // [rsp+90h] [rbp-68h] BYREF
long long v38; // [rsp+98h] [rbp-60h] BYREF
long long v39; // [rsp+A0h] [rbp-58h]
unsigned int i; // [rsp+ACh] [rbp-4Ch]
_DWORD *v41; // [rsp+B0h] [rbp-48h]
long long typed_array; // [rsp+B8h] [rbp-40h]
long long v43; // [rsp+C0h] [rbp-38h]
_DWORD *v44; // [rsp+C8h] [rbp-30h]
long long v45; // [rsp+D0h] [rbp-28h]
long long v46; // [rsp+D8h] [rbp-20h]
long long v47; // [rsp+E0h] [rbp-18h]
long long v48; // [rsp+E8h] [rbp-10h]
long long v49; // [rsp+F0h] [rbp-8h]
v46 = a2;
v47 = a3;
v44 = a4;
v45 = a5;
v43 = a1;
v34 = 0LL;
v35 = 3LL;
typed_array = get_typed_array(a1, a2, a3, (long long)a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( !typed_array )
goto LABEL_25;
v16 = &v37;
if ( (unsigned int)JS_ToInt64Sat(v43, (long long)&v37, a15, a16) )
goto LABEL_25;
if ( v37 < 0 )
goto LABEL_16;
if ( typed_array_is_oob(typed_array) )
{
LABEL_5:
JS_ThrowTypeErrorArrayBufferOOB(v43, a7, a8, a9, a10, v21, v22, a13, a14, (long long)v16, v17, v23, v19, v20);
LABEL_25:
JS_FreeValue(v43, v34, v35);
LODWORD(v48) = 0;
v49 = 6LL;
return v48;
}
v39 = *(unsigned int *)(typed_array + 64);
v33 = JS_ToObject(v43, v44, v45, a7, a8, a9, a10, v21, v22, a13, a14, v23, v19, v20);
v34 = (long long)v33;
v35 = (long long)v24;
v16 = v24;
if ( JS_IsException_1((long long)v33, (int)v24) )
goto LABEL_25;
v41 = v33;
if ( *((unsigned __int16 *)v33 + 3) < 0x15u || *((unsigned __int16 *)v41 + 3) > 0x20u )
{
if ( (unsigned int)js_get_length64(v43, &v38, (int)v33, v35) )
goto LABEL_25;
v18 = v39 - v38;
if ( v37 <= v39 - v38 )
goto LABEL_17;
LABEL_16:
JS_ThrowRangeError(
v43,
(long long)"invalid array length",
v17,
v18,
v19,
v20,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
(char)&a15);
goto LABEL_25;
}
v32 = *(_QWORD *)(typed_array + 48);
v31 = *(_QWORD *)(*(_QWORD *)(v32 + 24) + 48LL);
v30 = *((_QWORD *)v41 + 6);
v29 = *(_QWORD *)(*(_QWORD *)(v30 + 24) + 48LL);
v28 = typed_array_size_log2[*(unsigned __int16 *)(typed_array + 6) - 21];
if ( typed_array_is_oob((long long)v41) )
goto LABEL_5;
v38 = (unsigned int)v41[16];
v18 = v39 - v38;
if ( v37 > v39 - v38 )
goto LABEL_16;
if ( *((unsigned __int16 *)v41 + 3) != *(unsigned __int16 *)(typed_array + 6) )
{
LABEL_17:
for ( i = 0; i < v38; ++i )
{
PropertyUint32 = JS_GetPropertyUint32(v43, (long long)v33, v35, i);
v36 = v25;
if ( JS_IsException_1(PropertyUint32, v25) )
goto LABEL_25;
if ( typed_array_is_oob(typed_array) )
{
JS_FreeValue(v43, PropertyUint32, v36);
}
else if ( (int)JS_SetPropertyUint32(v43, v46, v47, i + (unsigned int)v37, PropertyUint32, v36) < 0 )
{
goto LABEL_25;
}
}
goto LABEL_24;
}
memmove(
(v37 << v28) + *(unsigned int *)(v32 + 32) + *(_QWORD *)(v31 + 16),
*(unsigned int *)(v30 + 32) + *(_QWORD *)(v29 + 16),
v38 << v28);
LABEL_24:
JS_FreeValue(v43, (long long)v33, v35);
LODWORD(v48) = 0;
v49 = 3LL;
return v48;
}
| js_typed_array_set_internal:
SUB RSP,0xf8
LEA RAX,[RSP + 0x100]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV qword ptr [RSP + 0xc8],RCX
MOV qword ptr [RSP + 0xd0],R8
MOV qword ptr [RSP + 0xc0],RDI
MOV RAX,qword ptr [0x00213b80]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [0x00213b88]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
CALL 0x0015ec30
MOV qword ptr [RSP + 0xb8],RAX
CMP qword ptr [RSP + 0xb8],0x0
JNZ 0x001e8ce8
JMP 0x001e90e1
LAB_001e8ce8:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x90]
CALL 0x0013ec10
CMP EAX,0x0
JZ 0x001e8d12
JMP 0x001e90e1
LAB_001e8d12:
CMP qword ptr [RSP + 0x90],0x0
JGE 0x001e8d22
JMP 0x001e8f74
LAB_001e8d22:
MOV RDI,qword ptr [RSP + 0xb8]
CALL 0x0015ecc0
CMP EAX,0x0
JZ 0x001e8d52
JMP 0x001e8d36
LAB_001e8d36:
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x0015edd0
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
JMP 0x001e90e1
LAB_001e8d52:
MOV RAX,qword ptr [RSP + 0xb8]
MOV EAX,dword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0xa0],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x0013da60
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001e8db9
JMP 0x001e90e1
LAB_001e8db9:
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x15
JL 0x001e8f2c
MOV RAX,qword ptr [RSP + 0xb0]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x20
JG 0x001e8f2c
MOV RAX,qword ptr [RSP + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOVZX EAX,word ptr [RAX + 0x6]
SUB EAX,0x15
MOVSXD RCX,EAX
LEA RAX,[0x212bef]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x2c],EAX
MOV RDI,qword ptr [RSP + 0xb0]
CALL 0x0015ecc0
CMP EAX,0x0
JZ 0x001e8e6e
JMP 0x001e8d36
LAB_001e8e6e:
MOV RAX,qword ptr [RSP + 0xb0]
MOV EAX,dword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0xa0]
SUB RCX,qword ptr [RSP + 0x98]
CMP RAX,RCX
JLE 0x001e8ea3
JMP 0x001e8f74
LAB_001e8ea3:
MOV RAX,qword ptr [RSP + 0xb0]
MOVZX EAX,word ptr [RAX + 0x6]
MOV RCX,qword ptr [RSP + 0xb8]
MOVZX ECX,word ptr [RCX + 0x6]
CMP EAX,ECX
JNZ 0x001e8f14
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x48]
MOV EAX,dword ptr [RAX + 0x20]
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV ECX,dword ptr [RSP + 0x2c]
SHL RAX,CL
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x38]
MOV EAX,dword ptr [RAX + 0x20]
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RSP + 0x2c]
MOV ECX,EAX
SHL RDX,CL
CALL 0x0010e770
JMP 0x001e90b1
LAB_001e8f14:
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x30]
CMP RAX,qword ptr [RCX + 0x10]
JNZ 0x001e8f2a
JMP 0x001e8f2a
LAB_001e8f2a:
JMP 0x001e8f9b
LAB_001e8f2c:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x78]
LEA RSI,[RSP + 0x98]
CALL 0x00134250
CMP EAX,0x0
JZ 0x001e8f55
JMP 0x001e90e1
LAB_001e8f55:
MOV RAX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0xa0]
SUB RCX,qword ptr [RSP + 0x98]
CMP RAX,RCX
JLE 0x001e8f99
JMP 0x001e8f74
LAB_001e8f74:
MOV RDI,qword ptr [RSP + 0xc0]
LEA RSI,[0x214402]
MOV AL,0x0
CALL 0x0012f960
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
JMP 0x001e90e1
LAB_001e8f99:
JMP 0x001e8f9b
LAB_001e8f9b:
MOV dword ptr [RSP + 0xac],0x0
LAB_001e8fa6:
MOV EAX,dword ptr [RSP + 0xac]
CMP RAX,qword ptr [RSP + 0x98]
JGE 0x001e90af
MOV RDI,qword ptr [RSP + 0xc0]
MOV ECX,dword ptr [RSP + 0xac]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00137750
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001e901c
JMP 0x001e90e1
LAB_001e901c:
MOV RDI,qword ptr [RSP + 0xb8]
CALL 0x0015ecc0
CMP EAX,0x0
JZ 0x001e904d
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00129f80
JMP 0x001e9097
LAB_001e904d:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0x90]
MOV ECX,dword ptr [RSP + 0xac]
ADD RAX,RCX
MOV ECX,EAX
MOV RSI,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
MOV R8,qword ptr [RSP + 0x80]
MOV R9,qword ptr [RSP + 0x88]
CALL 0x00139640
CMP EAX,0x0
JGE 0x001e9095
JMP 0x001e90e1
LAB_001e9095:
JMP 0x001e9097
LAB_001e9097:
JMP 0x001e9099
LAB_001e9099:
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x1
MOV dword ptr [RSP + 0xac],EAX
JMP 0x001e8fa6
LAB_001e90af:
JMP 0x001e90b1
LAB_001e90b1:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00129f80
MOV dword ptr [RSP + 0xe8],0x0
MOV qword ptr [RSP + 0xf0],0x3
JMP 0x001e910f
LAB_001e90e1:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00129f80
MOV dword ptr [RSP + 0xe8],0x0
MOV qword ptr [RSP + 0xf0],0x6
LAB_001e910f:
MOV RAX,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xf0]
ADD RSP,0xf8
RET
|
int1 [16]
js_typed_array_set_internal
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8)
{
byte bVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int iVar9;
int1 auVar14 [16];
int1 auVar15 [16];
int8 local_88;
int8 local_80;
long local_68;
ulong local_60;
ulong local_58;
uint local_4c;
long local_48;
long local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
int8 local_18;
int4 uStack_c;
int8 local_8;
long lVar10;
int8 uVar11;
int8 uVar12;
int8 uVar13;
auVar8._8_8_ = DAT_00213b88;
auVar8._0_8_ = DAT_00213b80;
auVar14._8_8_ = DAT_00213b88;
auVar14._0_8_ = DAT_00213b80;
auVar7._8_8_ = DAT_00213b88;
auVar7._0_8_ = DAT_00213b80;
auVar15._8_8_ = DAT_00213b88;
auVar15._0_8_ = DAT_00213b80;
local_38 = param_1;
local_30 = param_4;
local_28 = param_5;
local_20 = param_2;
local_18 = param_3;
local_40 = get_typed_array(param_1,param_2,param_3);
if ((local_40 != 0) &&
(iVar9 = JS_ToInt64Sat(local_38,&local_68,param_7,param_8), auVar7 = auVar15, iVar9 == 0)) {
if (local_68 < 0) goto LAB_001e8f74;
iVar9 = typed_array_is_oob(local_40);
if (iVar9 == 0) {
local_58 = (ulong)*(uint *)(local_40 + 0x40);
auVar14 = JS_ToObject(local_38,local_30,local_28);
uVar12 = auVar14._8_8_;
lVar10 = auVar14._0_8_;
iVar9 = JS_IsException(lVar10,uVar12);
auVar7 = auVar14;
if (iVar9 == 0) {
local_48 = lVar10;
if ((*(ushort *)(lVar10 + 6) < 0x15) || (0x20 < *(ushort *)(lVar10 + 6))) {
iVar9 = js_get_length64(local_38,&local_60,lVar10,uVar12);
if (iVar9 != 0) goto LAB_001e90e1;
if (local_68 <= (long)(local_58 - local_60)) {
LAB_001e8f9b:
for (local_4c = 0; (long)(ulong)local_4c < (long)local_60; local_4c = local_4c + 1) {
auVar15 = JS_GetPropertyUint32(local_38,lVar10,uVar12,local_4c);
uVar13 = auVar15._8_8_;
uVar11 = auVar15._0_8_;
iVar9 = JS_IsException(uVar11,uVar13);
if (iVar9 != 0) goto LAB_001e90e1;
iVar9 = typed_array_is_oob(local_40);
if (iVar9 == 0) {
iVar9 = JS_SetPropertyUint32
(local_38,local_20,local_18,(int)local_68 + local_4c,uVar11,uVar13
);
if (iVar9 < 0) goto LAB_001e90e1;
}
else {
JS_FreeValue(local_38,uVar11,uVar13);
}
}
goto LAB_001e90b1;
}
}
else {
lVar2 = *(long *)(local_40 + 0x30);
lVar3 = *(long *)(*(long *)(lVar2 + 0x18) + 0x30);
lVar4 = *(long *)(lVar10 + 0x30);
lVar5 = *(long *)(*(long *)(lVar4 + 0x18) + 0x30);
bVar1 = (&typed_array_size_log2)[(int)(*(ushort *)(local_40 + 6) - 0x15)];
iVar9 = typed_array_is_oob(lVar10);
auVar8 = auVar14;
if (iVar9 != 0) goto LAB_001e8d36;
local_60 = (ulong)*(uint *)(local_48 + 0x40);
if (local_68 <= (long)(local_58 - local_60)) {
if (*(short *)(local_48 + 6) != *(short *)(local_40 + 6)) goto LAB_001e8f9b;
memmove((void *)(*(long *)(lVar3 + 0x10) + (ulong)*(uint *)(lVar2 + 0x20) +
(local_68 << (bVar1 & 0x3f))),
(void *)(*(long *)(lVar5 + 0x10) + (ulong)*(uint *)(lVar4 + 0x20)),
local_60 << (bVar1 & 0x3f));
LAB_001e90b1:
JS_FreeValue(local_38,lVar10,uVar12);
local_8 = 3;
goto LAB_001e910f;
}
}
LAB_001e8f74:
JS_ThrowRangeError(local_38,"invalid array length");
auVar7 = auVar14;
}
}
else {
LAB_001e8d36:
JS_ThrowTypeErrorArrayBufferOOB(local_38);
auVar7 = auVar8;
}
}
LAB_001e90e1:
local_80 = auVar7._8_8_;
local_88 = auVar7._0_8_;
JS_FreeValue(local_38,local_88,local_80);
local_8 = 6;
LAB_001e910f:
auVar6._4_8_ = local_8;
auVar6._0_4_ = uStack_c;
auVar6._12_4_ = 0;
return auVar6 << 0x20;
}
| |
35,274 | ps_fetch_from_1_to_8_bytes | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | void ps_fetch_from_1_to_8_bytes(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row, unsigned int byte_count)
{
my_bool is_unsigned= test(field->flags & UNSIGNED_FLAG);
r_param->buffer_length= byte_count;
switch (byte_count) {
case 1:
*(uchar *)r_param->buffer= **row;
*r_param->error= is_unsigned != r_param->is_unsigned && *(uchar *)r_param->buffer > INT_MAX8;
break;
case 2:
shortstore(r_param->buffer, ((ushort) sint2korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(ushort *)r_param->buffer > INT_MAX16;
break;
case 4:
{
longstore(r_param->buffer, ((uint32)sint4korr(*row)));
*r_param->error= is_unsigned != r_param->is_unsigned && *(uint32 *)r_param->buffer > INT_MAX32;
}
break;
case 8:
{
ulonglong val= (ulonglong)sint8korr(*row);
longlongstore(r_param->buffer, val);
*r_param->error= is_unsigned != r_param->is_unsigned && val > LONGLONG_MAX ;
}
break;
default:
r_param->buffer_length= 0;
break;
}
(*row)+= byte_count;
} | O3 | c | ps_fetch_from_1_to_8_bytes:
pushq %rbp
movq %rsp, %rbp
movb 0x64(%rsi), %sil
movl %ecx, %eax
movq %rax, 0x40(%rdi)
decl %ecx
cmpl $0x7, %ecx
ja 0x51ca7
shrb $0x5, %sil
andb $0x1, %sil
leaq 0x59fa4(%rip), %r8 # 0xabb70
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movq (%rdx), %rcx
movb (%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, (%r8)
cmpb 0x65(%rdi), %sil
je 0x51c5a
movq 0x10(%rdi), %rcx
movb (%rcx), %cl
shrb $0x7, %cl
jmp 0x51cbb
movq (%rdx), %rcx
movb (%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, (%r8)
movq (%rdx), %rcx
movb 0x1(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x1(%r8)
movq (%rdx), %rcx
movb 0x2(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x2(%r8)
movq (%rdx), %rcx
movb 0x3(%rcx), %cl
movq 0x10(%rdi), %r8
movb %cl, 0x3(%r8)
cmpb 0x65(%rdi), %sil
je 0x51c5a
movq 0x10(%rdi), %rcx
movl (%rcx), %ecx
shrl $0x1f, %ecx
jmp 0x51cbb
movq (%rdx), %rcx
movb (%rcx), %r8b
movb 0x1(%rcx), %cl
movq 0x10(%rdi), %r9
movb %r8b, (%r9)
movq 0x10(%rdi), %r8
movb %cl, 0x1(%r8)
cmpb 0x65(%rdi), %sil
jne 0x51cb1
xorl %ecx, %ecx
jmp 0x51cbb
movq (%rdx), %rcx
movl (%rcx), %r8d
movzwl 0x4(%rcx), %r9d
shlq $0x20, %r9
orq %r8, %r9
movzbl 0x6(%rcx), %r8d
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
shlq $0x30, %r8
orq %r9, %r8
orq %rcx, %r8
movq 0x10(%rdi), %r9
movq %r8, (%r9)
cmpb 0x65(%rdi), %sil
setne %sil
testq %rcx, %rcx
sets %cl
andb %sil, %cl
movq 0x18(%rdi), %rsi
movb %cl, (%rsi)
jmp 0x51cc1
movq $0x0, 0x40(%rdi)
jmp 0x51cc1
movq 0x10(%rdi), %rcx
movzwl (%rcx), %ecx
shrl $0xf, %ecx
movq 0x18(%rdi), %rsi
movb %cl, (%rsi)
addq %rax, (%rdx)
popq %rbp
retq
| ps_fetch_from_1_to_8_bytes:
push rbp
mov rbp, rsp
mov sil, [rsi+64h]
mov eax, ecx
mov [rdi+40h], rax
dec ecx; switch 8 cases
cmp ecx, 7
ja def_51BD3; jumptable 0000000000051BD3 default case, cases 3,5-7
shr sil, 5
and sil, 1
lea r8, jpt_51BD3
movsxd rcx, ds:(jpt_51BD3 - 0ABB70h)[r8+rcx*4]
add rcx, r8
jmp rcx; switch jump
loc_51BD5:
mov rcx, [rdx]; jumptable 0000000000051BD3 case 1
mov cl, [rcx]
mov r8, [rdi+10h]
mov [r8], cl
cmp sil, [rdi+65h]
jz short loc_51C5A
mov rcx, [rdi+10h]
mov cl, [rcx]
shr cl, 7
jmp loc_51CBB
loc_51BF5:
mov rcx, [rdx]; jumptable 0000000000051BD3 case 4
mov cl, [rcx]
mov r8, [rdi+10h]
mov [r8], cl
mov rcx, [rdx]
mov cl, [rcx+1]
mov r8, [rdi+10h]
mov [r8+1], cl
mov rcx, [rdx]
mov cl, [rcx+2]
mov r8, [rdi+10h]
mov [r8+2], cl
mov rcx, [rdx]
mov cl, [rcx+3]
mov r8, [rdi+10h]
mov [r8+3], cl
cmp sil, [rdi+65h]
jz short loc_51C5A
mov rcx, [rdi+10h]
mov ecx, [rcx]
shr ecx, 1Fh
jmp short loc_51CBB
loc_51C3C:
mov rcx, [rdx]; jumptable 0000000000051BD3 case 2
mov r8b, [rcx]
mov cl, [rcx+1]
mov r9, [rdi+10h]
mov [r9], r8b
mov r8, [rdi+10h]
mov [r8+1], cl
cmp sil, [rdi+65h]
jnz short loc_51CB1
loc_51C5A:
xor ecx, ecx
jmp short loc_51CBB
loc_51C5E:
mov rcx, [rdx]; jumptable 0000000000051BD3 case 8
mov r8d, [rcx]
movzx r9d, word ptr [rcx+4]
shl r9, 20h
or r9, r8
movzx r8d, byte ptr [rcx+6]
movzx ecx, byte ptr [rcx+7]
shl rcx, 38h
shl r8, 30h
or r8, r9
or r8, rcx
mov r9, [rdi+10h]
mov [r9], r8
cmp sil, [rdi+65h]
setnz sil
test rcx, rcx
sets cl
and cl, sil
mov rsi, [rdi+18h]
mov [rsi], cl
jmp short loc_51CC1
def_51BD3:
mov qword ptr [rdi+40h], 0; jumptable 0000000000051BD3 default case, cases 3,5-7
jmp short loc_51CC1
loc_51CB1:
mov rcx, [rdi+10h]
movzx ecx, word ptr [rcx]
shr ecx, 0Fh
loc_51CBB:
mov rsi, [rdi+18h]
mov [rsi], cl
loc_51CC1:
add [rdx], rax
pop rbp
retn
| long long ps_fetch_from_1_to_8_bytes(long long a1, long long a2, _BYTE **a3, unsigned int a4)
{
char v4; // si
long long result; // rax
char v6; // si
int v7; // ecx
char v8; // cl
signed long long v9; // rcx
v4 = *(_BYTE *)(a2 + 100);
result = a4;
*(_QWORD *)(a1 + 64) = a4;
v6 = (v4 & 0x20) != 0;
switch ( a4 )
{
case 1u:
**(_BYTE **)(a1 + 16) = **a3;
if ( v6 == *(_BYTE *)(a1 + 101) )
goto LABEL_7;
LOBYTE(v7) = **(_BYTE **)(a1 + 16) >> 7;
goto LABEL_11;
case 2u:
v8 = (*a3)[1];
**(_BYTE **)(a1 + 16) = **a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
if ( v6 == *(_BYTE *)(a1 + 101) )
goto LABEL_7;
v7 = **(unsigned __int16 **)(a1 + 16) >> 15;
goto LABEL_11;
case 4u:
**(_BYTE **)(a1 + 16) = **a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = (*a3)[1];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = (*a3)[2];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = (*a3)[3];
if ( v6 == *(_BYTE *)(a1 + 101) )
LABEL_7:
LOBYTE(v7) = 0;
else
v7 = **(_DWORD **)(a1 + 16) >> 31;
LABEL_11:
**(_BYTE **)(a1 + 24) = v7;
break;
case 8u:
v9 = (unsigned long long)(unsigned __int8)(*a3)[7] << 56;
**(_QWORD **)(a1 + 16) = v9 | *(unsigned int *)*a3 | ((unsigned long long)*((unsigned __int16 *)*a3 + 2) << 32) | ((unsigned long long)(unsigned __int8)(*a3)[6] << 48);
**(_BYTE **)(a1 + 24) = v6 != *(_BYTE *)(a1 + 101) && v9 < 0;
break;
default:
*(_QWORD *)(a1 + 64) = 0LL;
break;
}
*a3 += result;
return result;
}
| ps_fetch_from_1_to_8_bytes:
PUSH RBP
MOV RBP,RSP
MOV SIL,byte ptr [RSI + 0x64]
MOV EAX,ECX
MOV qword ptr [RDI + 0x40],RAX
DEC ECX
CMP ECX,0x7
JA 0x00151ca7
SHR SIL,0x5
AND SIL,0x1
LEA R8,[0x1abb70]
MOVSXD RCX,dword ptr [R8 + RCX*0x4]
ADD RCX,R8
switchD:
JMP RCX
caseD_1:
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8],CL
CMP SIL,byte ptr [RDI + 0x65]
JZ 0x00151c5a
MOV RCX,qword ptr [RDI + 0x10]
MOV CL,byte ptr [RCX]
SHR CL,0x7
JMP 0x00151cbb
caseD_4:
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x1]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x1],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x2]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x2],CL
MOV RCX,qword ptr [RDX]
MOV CL,byte ptr [RCX + 0x3]
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x3],CL
CMP SIL,byte ptr [RDI + 0x65]
JZ 0x00151c5a
MOV RCX,qword ptr [RDI + 0x10]
MOV ECX,dword ptr [RCX]
SHR ECX,0x1f
JMP 0x00151cbb
caseD_2:
MOV RCX,qword ptr [RDX]
MOV R8B,byte ptr [RCX]
MOV CL,byte ptr [RCX + 0x1]
MOV R9,qword ptr [RDI + 0x10]
MOV byte ptr [R9],R8B
MOV R8,qword ptr [RDI + 0x10]
MOV byte ptr [R8 + 0x1],CL
CMP SIL,byte ptr [RDI + 0x65]
JNZ 0x00151cb1
LAB_00151c5a:
XOR ECX,ECX
JMP 0x00151cbb
caseD_8:
MOV RCX,qword ptr [RDX]
MOV R8D,dword ptr [RCX]
MOVZX R9D,word ptr [RCX + 0x4]
SHL R9,0x20
OR R9,R8
MOVZX R8D,byte ptr [RCX + 0x6]
MOVZX ECX,byte ptr [RCX + 0x7]
SHL RCX,0x38
SHL R8,0x30
OR R8,R9
OR R8,RCX
MOV R9,qword ptr [RDI + 0x10]
MOV qword ptr [R9],R8
CMP SIL,byte ptr [RDI + 0x65]
SETNZ SIL
TEST RCX,RCX
SETS CL
AND CL,SIL
MOV RSI,qword ptr [RDI + 0x18]
MOV byte ptr [RSI],CL
JMP 0x00151cc1
caseD_3:
MOV qword ptr [RDI + 0x40],0x0
JMP 0x00151cc1
LAB_00151cb1:
MOV RCX,qword ptr [RDI + 0x10]
MOVZX ECX,word ptr [RCX]
SHR ECX,0xf
LAB_00151cbb:
MOV RSI,qword ptr [RDI + 0x18]
MOV byte ptr [RSI],CL
LAB_00151cc1:
ADD qword ptr [RDX],RAX
POP RBP
RET
|
void ps_fetch_from_1_to_8_bytes(long param_1,long param_2,long *param_3,uint param_4)
{
int1 uVar1;
byte bVar2;
byte bVar3;
bVar3 = *(byte *)(param_2 + 100);
*(ulong *)(param_1 + 0x40) = (ulong)param_4;
if (param_4 - 1 < 8) {
bVar3 = bVar3 >> 5 & 1;
switch(param_4) {
case 1:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
if (bVar3 == *(byte *)(param_1 + 0x65)) {
LAB_00151c5a:
bVar3 = 0;
}
else {
bVar3 = **(byte **)(param_1 + 0x10) >> 7;
}
break;
case 2:
uVar1 = ((int1 *)*param_3)[1];
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar1;
if (bVar3 == *(byte *)(param_1 + 0x65)) goto LAB_00151c5a;
bVar3 = (byte)((ushort)**(int2 **)(param_1 + 0x10) >> 0xf);
break;
default:
goto switchD_00151bd3_caseD_3;
case 4:
**(int1 **)(param_1 + 0x10) = *(int1 *)*param_3;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = *(int1 *)(*param_3 + 1);
*(int1 *)(*(long *)(param_1 + 0x10) + 2) = *(int1 *)(*param_3 + 2);
*(int1 *)(*(long *)(param_1 + 0x10) + 3) = *(int1 *)(*param_3 + 3);
if (bVar3 == *(byte *)(param_1 + 0x65)) goto LAB_00151c5a;
bVar3 = (byte)((uint)**(int4 **)(param_1 + 0x10) >> 0x1f);
break;
case 8:
bVar2 = *(byte *)(*param_3 + 7);
**(int8 **)(param_1 + 0x10) = *(int8 *)*param_3;
*(bool *)*(int8 *)(param_1 + 0x18) =
(long)((ulong)bVar2 << 0x38) < 0 && bVar3 != *(byte *)(param_1 + 0x65);
goto LAB_00151cc1;
}
**(byte **)(param_1 + 0x18) = bVar3;
}
else {
switchD_00151bd3_caseD_3:
*(int8 *)(param_1 + 0x40) = 0;
}
LAB_00151cc1:
*param_3 = *param_3 + (ulong)param_4;
return;
}
| |
35,275 | mysql_cset_escape_slashes | eloqsql/libmariadb/libmariadb/ma_charset.c | size_t mysql_cset_escape_slashes(const MARIADB_CHARSET_INFO * cset, char *newstr,
const char * escapestr, size_t escapestr_len )
{
const char *newstr_s = newstr;
const char *newstr_e = newstr + 2 * escapestr_len;
const char *end = escapestr + escapestr_len;
my_bool escape_overflow = FALSE;
for (;escapestr < end; escapestr++) {
char esc = '\0';
unsigned int len = 0;
/* check unicode characters */
if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
/* check possible overflow */
if ((newstr + len) > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy mb char without escaping it */
while (len--) {
*newstr++ = *escapestr++;
}
escapestr--;
continue;
}
if (cset->char_maxlen > 1 && cset->mb_charlen(*escapestr) > 1) {
esc = *escapestr;
} else {
switch (*escapestr) {
case 0:
esc = '0';
break;
case '\n':
esc = 'n';
break;
case '\r':
esc = 'r';
break;
case '\\':
case '\'':
case '"':
esc = *escapestr;
break;
case '\032':
esc = 'Z';
break;
}
}
if (esc) {
if (newstr + 2 > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy escaped character */
*newstr++ = '\\';
*newstr++ = esc;
} else {
if (newstr + 1 > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy non escaped character */
*newstr++ = *escapestr;
}
}
*newstr = '\0';
if (escape_overflow) {
return((size_t)~0);
}
return((size_t)(newstr - newstr_s));
} | O0 | c | mysql_cset_escape_slashes:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x442d9
movb $0x0, -0x42(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x34(%rax)
jbe 0x441bf
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x48(%rbp)
cmpl $0x0, %eax
je 0x441bf
movq -0x18(%rbp), %rax
movl -0x48(%rbp), %ecx
addq %rcx, %rax
cmpq -0x38(%rbp), %rax
jbe 0x44178
movb $0x1, -0x41(%rbp)
jmp 0x442d9
jmp 0x4417a
movl -0x48(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x48(%rbp)
cmpl $0x0, %eax
je 0x441ae
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x4417a
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x442c8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x34(%rax)
jbe 0x441ea
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %edi
callq *%rax
cmpl $0x1, %eax
jbe 0x441ea
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x42(%rbp)
jmp 0x44259
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
testl %eax, %eax
je 0x44236
jmp 0x441fa
movl -0x4c(%rbp), %eax
subl $0xa, %eax
je 0x4423c
jmp 0x44204
movl -0x4c(%rbp), %eax
subl $0xd, %eax
je 0x44242
jmp 0x4420e
movl -0x4c(%rbp), %eax
subl $0x1a, %eax
je 0x44253
jmp 0x44218
movl -0x4c(%rbp), %eax
subl $0x22, %eax
je 0x44248
jmp 0x44222
movl -0x4c(%rbp), %eax
subl $0x27, %eax
je 0x44248
jmp 0x4422c
movl -0x4c(%rbp), %eax
subl $0x5c, %eax
je 0x44248
jmp 0x44257
movb $0x30, -0x42(%rbp)
jmp 0x44257
movb $0x6e, -0x42(%rbp)
jmp 0x44257
movb $0x72, -0x42(%rbp)
jmp 0x44257
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x42(%rbp)
jmp 0x44257
movb $0x5a, -0x42(%rbp)
jmp 0x44259
cmpb $0x0, -0x42(%rbp)
je 0x4429b
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x38(%rbp), %rax
jbe 0x44273
movb $0x1, -0x41(%rbp)
jmp 0x442d9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x5c, (%rax)
movb -0x42(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x442c6
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x38(%rbp), %rax
jbe 0x442af
movb $0x1, -0x41(%rbp)
jmp 0x442d9
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x442c8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x44122
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpb $0x0, -0x41(%rbp)
je 0x442f0
movq $-0x1, -0x8(%rbp)
jmp 0x442ff
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_cset_escape_slashes:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
shl rcx, 1
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_40], rax
mov [rbp+var_41], 0
loc_44122:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jnb loc_442D9
mov [rbp+var_42], 0
mov [rbp+var_48], 0
mov rax, [rbp+var_10]
cmp dword ptr [rax+34h], 1
jbe short loc_441BF
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_40]
call rax
mov [rbp+var_48], eax
cmp eax, 0
jz short loc_441BF
mov rax, [rbp+var_18]
mov ecx, [rbp+var_48]
add rax, rcx
cmp rax, [rbp+var_38]
jbe short loc_44178
mov [rbp+var_41], 1
jmp loc_442D9
loc_44178:
jmp short $+2
loc_4417A:
mov eax, [rbp+var_48]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_48], ecx
cmp eax, 0
jz short loc_441AE
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov cl, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
jmp short loc_4417A
loc_441AE:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp loc_442C8
loc_441BF:
mov rax, [rbp+var_10]
cmp dword ptr [rax+34h], 1
jbe short loc_441EA
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rcx, [rbp+var_20]
movsx edi, byte ptr [rcx]
call rax
cmp eax, 1
jbe short loc_441EA
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_42], al
jmp short loc_44259
loc_441EA:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
mov [rbp+var_4C], eax
test eax, eax
jz short loc_44236
jmp short $+2
loc_441FA:
mov eax, [rbp+var_4C]
sub eax, 0Ah
jz short loc_4423C
jmp short $+2
loc_44204:
mov eax, [rbp+var_4C]
sub eax, 0Dh
jz short loc_44242
jmp short $+2
loc_4420E:
mov eax, [rbp+var_4C]
sub eax, 1Ah
jz short loc_44253
jmp short $+2
loc_44218:
mov eax, [rbp+var_4C]
sub eax, 22h ; '"'
jz short loc_44248
jmp short $+2
loc_44222:
mov eax, [rbp+var_4C]
sub eax, 27h ; '''
jz short loc_44248
jmp short $+2
loc_4422C:
mov eax, [rbp+var_4C]
sub eax, 5Ch ; '\'
jz short loc_44248
jmp short loc_44257
loc_44236:
mov [rbp+var_42], 30h ; '0'
jmp short loc_44257
loc_4423C:
mov [rbp+var_42], 6Eh ; 'n'
jmp short loc_44257
loc_44242:
mov [rbp+var_42], 72h ; 'r'
jmp short loc_44257
loc_44248:
mov rax, [rbp+var_20]
mov al, [rax]
mov [rbp+var_42], al
jmp short loc_44257
loc_44253:
mov [rbp+var_42], 5Ah ; 'Z'
loc_44257:
jmp short $+2
loc_44259:
cmp [rbp+var_42], 0
jz short loc_4429B
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_38]
jbe short loc_44273
mov [rbp+var_41], 1
jmp short loc_442D9
loc_44273:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 5Ch ; '\'
mov cl, [rbp+var_42]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
jmp short loc_442C6
loc_4429B:
mov rax, [rbp+var_18]
add rax, 1
cmp rax, [rbp+var_38]
jbe short loc_442AF
mov [rbp+var_41], 1
jmp short loc_442D9
loc_442AF:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
loc_442C6:
jmp short $+2
loc_442C8:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_44122
loc_442D9:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
cmp [rbp+var_41], 0
jz short loc_442F0
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_442FF
loc_442F0:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
loc_442FF:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long mysql_cset_escape_slashes(long long a1, char *a2, char *a3, long long a4)
{
char *v5; // rax
char v6; // cl
char *v7; // rax
char *v8; // rax
char *v9; // rax
int v11; // [rsp+4h] [rbp-4Ch]
int v12; // [rsp+8h] [rbp-48h]
char v13; // [rsp+Eh] [rbp-42h]
char v14; // [rsp+Fh] [rbp-41h]
unsigned long long v15; // [rsp+10h] [rbp-40h]
unsigned long long v16; // [rsp+18h] [rbp-38h]
char *v17; // [rsp+30h] [rbp-20h]
char *v18; // [rsp+38h] [rbp-18h]
v18 = a2;
v17 = a3;
v16 = (unsigned long long)&a2[2 * a4];
v15 = (unsigned long long)&a3[a4];
v14 = 0;
while ( (unsigned long long)v17 < v15 )
{
v13 = 0;
if ( *(_DWORD *)(a1 + 52) > 1u
&& (v12 = (*(long long ( **)(char *, unsigned long long))(a1 + 64))(v17, v15)) != 0 )
{
if ( (unsigned long long)&v18[v12] > v16 )
{
v14 = 1;
break;
}
while ( v12-- )
{
v5 = v17++;
v6 = *v5;
v7 = v18++;
*v7 = v6;
}
--v17;
}
else
{
if ( *(_DWORD *)(a1 + 52) <= 1u || (*(unsigned int ( **)(_QWORD))(a1 + 56))((unsigned int)*v17) <= 1 )
{
v11 = *v17;
if ( *v17 )
{
switch ( v11 )
{
case 10:
v13 = 110;
break;
case 13:
v13 = 114;
break;
case 26:
v13 = 90;
break;
case 34:
case 39:
case 92:
v13 = *v17;
break;
}
}
else
{
v13 = 48;
}
}
else
{
v13 = *v17;
}
if ( v13 )
{
if ( (unsigned long long)(v18 + 2) > v16 )
{
v14 = 1;
break;
}
*v18 = 92;
v8 = v18 + 1;
v18 += 2;
*v8 = v13;
}
else
{
if ( (unsigned long long)(v18 + 1) > v16 )
{
v14 = 1;
break;
}
v9 = v18++;
*v9 = *v17;
}
}
++v17;
}
*v18 = 0;
if ( v14 )
return -1LL;
else
return v18 - a2;
}
| mysql_cset_escape_slashes:
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],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV byte ptr [RBP + -0x41],0x0
LAB_00144122:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001442d9
MOV byte ptr [RBP + -0x42],0x0
MOV dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x34],0x1
JBE 0x001441bf
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x48],EAX
CMP EAX,0x0
JZ 0x001441bf
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x48]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x00144178
MOV byte ptr [RBP + -0x41],0x1
JMP 0x001442d9
LAB_00144178:
JMP 0x0014417a
LAB_0014417a:
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x48],ECX
CMP EAX,0x0
JZ 0x001441ae
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x0014417a
LAB_001441ae:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001442c8
LAB_001441bf:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x34],0x1
JBE 0x001441ea
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x20]
MOVSX EDI,byte ptr [RCX]
CALL RAX
CMP EAX,0x1
JBE 0x001441ea
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x42],AL
JMP 0x00144259
LAB_001441ea:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
TEST EAX,EAX
JZ 0x00144236
JMP 0x001441fa
LAB_001441fa:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0xa
JZ 0x0014423c
JMP 0x00144204
LAB_00144204:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0xd
JZ 0x00144242
JMP 0x0014420e
LAB_0014420e:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x1a
JZ 0x00144253
JMP 0x00144218
LAB_00144218:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x22
JZ 0x00144248
JMP 0x00144222
LAB_00144222:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x27
JZ 0x00144248
JMP 0x0014422c
LAB_0014422c:
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x5c
JZ 0x00144248
JMP 0x00144257
LAB_00144236:
MOV byte ptr [RBP + -0x42],0x30
JMP 0x00144257
LAB_0014423c:
MOV byte ptr [RBP + -0x42],0x6e
JMP 0x00144257
LAB_00144242:
MOV byte ptr [RBP + -0x42],0x72
JMP 0x00144257
LAB_00144248:
MOV RAX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x42],AL
JMP 0x00144257
LAB_00144253:
MOV byte ptr [RBP + -0x42],0x5a
LAB_00144257:
JMP 0x00144259
LAB_00144259:
CMP byte ptr [RBP + -0x42],0x0
JZ 0x0014429b
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x00144273
MOV byte ptr [RBP + -0x41],0x1
JMP 0x001442d9
LAB_00144273:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x5c
MOV CL,byte ptr [RBP + -0x42]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x001442c6
LAB_0014429b:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x001442af
MOV byte ptr [RBP + -0x41],0x1
JMP 0x001442d9
LAB_001442af:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
LAB_001442c6:
JMP 0x001442c8
LAB_001442c8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00144122
LAB_001442d9:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
CMP byte ptr [RBP + -0x41],0x0
JZ 0x001442f0
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001442ff
LAB_001442f0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_001442ff:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long mysql_cset_escape_slashes(long param_1,char *param_2,char *param_3,long param_4)
{
char cVar1;
bool bVar2;
uint uVar3;
char *pcVar4;
uint local_50;
char local_4a;
char *local_28;
char *local_20;
long local_10;
pcVar4 = param_2 + param_4 * 2;
bVar2 = false;
local_28 = param_3;
local_20 = param_2;
do {
if (param_3 + param_4 <= local_28) {
LAB_001442d9:
*local_20 = '\0';
if (bVar2) {
local_10 = -1;
}
else {
local_10 = (long)local_20 - (long)param_2;
}
return local_10;
}
local_4a = '\0';
if ((*(uint *)(param_1 + 0x34) < 2) ||
(local_50 = (**(code **)(param_1 + 0x40))(local_28,param_3 + param_4), local_50 == 0)) {
if ((*(uint *)(param_1 + 0x34) < 2) ||
(uVar3 = (**(code **)(param_1 + 0x38))((int)*local_28), uVar3 < 2)) {
cVar1 = *local_28;
if (cVar1 == '\0') {
local_4a = '0';
}
else if (cVar1 == '\n') {
local_4a = 'n';
}
else if (cVar1 == '\r') {
local_4a = 'r';
}
else if (cVar1 == '\x1a') {
local_4a = 'Z';
}
else if (((cVar1 == '\"') || (cVar1 == '\'')) || (cVar1 == '\\')) {
local_4a = *local_28;
}
}
else {
local_4a = *local_28;
}
if (local_4a == '\0') {
if (pcVar4 < local_20 + 1) {
bVar2 = true;
goto LAB_001442d9;
}
*local_20 = *local_28;
local_20 = local_20 + 1;
}
else {
if (pcVar4 < local_20 + 2) {
bVar2 = true;
goto LAB_001442d9;
}
*local_20 = '\\';
local_20[1] = local_4a;
local_20 = local_20 + 2;
}
}
else {
if (pcVar4 < local_20 + local_50) {
bVar2 = true;
goto LAB_001442d9;
}
while (local_50 != 0) {
*local_20 = *local_28;
local_50 = local_50 - 1;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
local_28 = local_28 + -1;
}
local_28 = local_28 + 1;
} while( true );
}
| |
35,276 | mysql_cset_escape_slashes | eloqsql/libmariadb/libmariadb/ma_charset.c | size_t mysql_cset_escape_slashes(const MARIADB_CHARSET_INFO * cset, char *newstr,
const char * escapestr, size_t escapestr_len )
{
const char *newstr_s = newstr;
const char *newstr_e = newstr + 2 * escapestr_len;
const char *end = escapestr + escapestr_len;
my_bool escape_overflow = FALSE;
for (;escapestr < end; escapestr++) {
char esc = '\0';
unsigned int len = 0;
/* check unicode characters */
if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
/* check possible overflow */
if ((newstr + len) > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy mb char without escaping it */
while (len--) {
*newstr++ = *escapestr++;
}
escapestr--;
continue;
}
if (cset->char_maxlen > 1 && cset->mb_charlen(*escapestr) > 1) {
esc = *escapestr;
} else {
switch (*escapestr) {
case 0:
esc = '0';
break;
case '\n':
esc = 'n';
break;
case '\r':
esc = 'r';
break;
case '\\':
case '\'':
case '"':
esc = *escapestr;
break;
case '\032':
esc = 'Z';
break;
}
}
if (esc) {
if (newstr + 2 > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy escaped character */
*newstr++ = '\\';
*newstr++ = esc;
} else {
if (newstr + 1 > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy non escaped character */
*newstr++ = *escapestr;
}
}
*newstr = '\0';
if (escape_overflow) {
return((size_t)~0);
}
return((size_t)(newstr - newstr_s));
} | O3 | c | mysql_cset_escape_slashes:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
testq %rcx, %rcx
jle 0x30290
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movq -0x30(%rbp), %rbx
leaq (%rbx,%rcx,2), %r13
addq %rdx, %r14
cmpl $0x2, 0x34(%r15)
jb 0x30222
movq %r12, %rdi
movq %r14, %rsi
callq *0x40(%r15)
testl %eax, %eax
je 0x30201
movl %eax, %ecx
movl %eax, %eax
addq %rbx, %rax
cmpq %r13, %rax
ja 0x30299
decq %r12
movq %r12, %rdx
leaq 0x1(%rdx), %r12
leaq 0x1(%rbx), %rax
movb 0x1(%rdx), %dl
movb %dl, (%rbx)
movq %r12, %rdx
movq %rax, %rbx
decl %ecx
jne 0x301e5
jmp 0x30281
cmpl $0x2, 0x34(%r15)
jb 0x30222
movsbl (%r12), %edi
callq *0x38(%r15)
cmpl $0x1, %eax
jbe 0x30222
movb (%r12), %cl
testb %cl, %cl
jne 0x30272
xorl %ecx, %ecx
jmp 0x3025b
movb (%r12), %cl
movzbl %cl, %eax
cmpl $0x19, %eax
jle 0x3023f
cmpl $0x26, %eax
jg 0x30251
cmpl $0x1a, %eax
je 0x3026c
cmpl $0x22, %eax
je 0x30272
jmp 0x3025b
testl %eax, %eax
je 0x30268
cmpl $0xa, %eax
je 0x30270
cmpl $0xd, %eax
jne 0x3025b
movb $0x72, %cl
jmp 0x30272
cmpl $0x27, %eax
je 0x30272
cmpl $0x5c, %eax
je 0x30272
leaq 0x1(%rbx), %rax
cmpq %r13, %rax
ja 0x30299
movb %cl, (%rbx)
jmp 0x30281
movb $0x30, %cl
jmp 0x30272
movb $0x5a, %cl
jmp 0x30272
movb $0x6e, %cl
leaq 0x2(%rbx), %rax
cmpq %r13, %rax
ja 0x30299
movb $0x5c, (%rbx)
movb %cl, 0x1(%rbx)
incq %r12
movq %rax, %rbx
cmpq %r14, %r12
jb 0x301ba
movb $0x0, (%rax)
subq -0x30(%rbp), %rax
jmp 0x302a3
movb $0x0, (%rbx)
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mysql_cset_escape_slashes:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], rsi
mov rax, rsi
test rcx, rcx
jle loc_30290
mov r14, rcx
mov r12, rdx
mov r15, rdi
mov rbx, [rbp+var_30]
lea r13, [rbx+rcx*2]
add r14, rdx
loc_301BA:
cmp dword ptr [r15+34h], 2
jb short loc_30222
mov rdi, r12
mov rsi, r14
call qword ptr [r15+40h]
test eax, eax
jz short loc_30201
mov ecx, eax
mov eax, eax
add rax, rbx
cmp rax, r13
ja loc_30299
dec r12
mov rdx, r12
loc_301E5:
lea r12, [rdx+1]
lea rax, [rbx+1]
mov dl, [rdx+1]
mov [rbx], dl
mov rdx, r12
mov rbx, rax
dec ecx
jnz short loc_301E5
jmp loc_30281
loc_30201:
cmp dword ptr [r15+34h], 2
jb short loc_30222
movsx edi, byte ptr [r12]
call qword ptr [r15+38h]
cmp eax, 1
jbe short loc_30222
mov cl, [r12]
test cl, cl
jnz short loc_30272
xor ecx, ecx
jmp short loc_3025B
loc_30222:
mov cl, [r12]
movzx eax, cl
cmp eax, 19h
jle short loc_3023F
cmp eax, 26h ; '&'
jg short loc_30251
cmp eax, 1Ah
jz short loc_3026C
cmp eax, 22h ; '"'
jz short loc_30272
jmp short loc_3025B
loc_3023F:
test eax, eax
jz short loc_30268
cmp eax, 0Ah
jz short loc_30270
cmp eax, 0Dh
jnz short loc_3025B
mov cl, 72h ; 'r'
jmp short loc_30272
loc_30251:
cmp eax, 27h ; '''
jz short loc_30272
cmp eax, 5Ch ; '\'
jz short loc_30272
loc_3025B:
lea rax, [rbx+1]
cmp rax, r13
ja short loc_30299
mov [rbx], cl
jmp short loc_30281
loc_30268:
mov cl, 30h ; '0'
jmp short loc_30272
loc_3026C:
mov cl, 5Ah ; 'Z'
jmp short loc_30272
loc_30270:
mov cl, 6Eh ; 'n'
loc_30272:
lea rax, [rbx+2]
cmp rax, r13
ja short loc_30299
mov byte ptr [rbx], 5Ch ; '\'
mov [rbx+1], cl
loc_30281:
inc r12
mov rbx, rax
cmp r12, r14
jb loc_301BA
loc_30290:
mov byte ptr [rax], 0
sub rax, [rbp+var_30]
jmp short loc_302A3
loc_30299:
mov byte ptr [rbx], 0
mov rax, 0FFFFFFFFFFFFFFFFh
loc_302A3:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mysql_cset_escape_slashes(long long a1, char *a2, char *a3, long long a4)
{
char *v4; // rax
char *v5; // r12
char *v6; // rbx
unsigned long long v7; // r13
unsigned long long v8; // r14
int v9; // eax
int v10; // ecx
char *v11; // rdx
char v12; // cl
unsigned int v13; // eax
v4 = a2;
if ( a4 <= 0 )
{
LABEL_32:
*v4 = 0;
return v4 - a2;
}
v5 = a3;
v6 = a2;
v7 = (unsigned long long)&a2[2 * a4];
v8 = (unsigned long long)&a3[a4];
while ( *(_DWORD *)(a1 + 52) >= 2u )
{
v9 = (*(long long ( **)(char *, unsigned long long))(a1 + 64))(v5, v8);
if ( v9 )
{
v10 = v9;
if ( (unsigned long long)&v6[v9] > v7 )
goto LABEL_33;
v11 = v5 - 1;
do
{
v5 = v11 + 1;
v4 = v6 + 1;
*v6++ = *++v11;
--v10;
}
while ( v10 );
goto LABEL_31;
}
if ( *(_DWORD *)(a1 + 52) < 2u || (*(unsigned int ( **)(_QWORD))(a1 + 56))((unsigned int)*v5) <= 1 )
break;
v12 = *v5;
if ( *v5 )
goto LABEL_29;
v12 = 0;
LABEL_24:
v4 = v6 + 1;
if ( (unsigned long long)(v6 + 1) > v7 )
goto LABEL_33;
*v6 = v12;
LABEL_31:
++v5;
v6 = v4;
if ( (unsigned long long)v5 >= v8 )
goto LABEL_32;
}
v12 = *v5;
v13 = (unsigned __int8)*v5;
if ( v13 > 0x19 )
{
if ( (unsigned __int8)*v5 > 0x26u )
{
if ( v13 == 39 || v13 == 92 )
goto LABEL_29;
}
else
{
if ( v13 == 26 )
{
v12 = 90;
goto LABEL_29;
}
if ( v13 == 34 )
goto LABEL_29;
}
goto LABEL_24;
}
if ( !*v5 )
{
v12 = 48;
goto LABEL_29;
}
if ( v13 != 10 )
{
if ( v13 == 13 )
{
v12 = 114;
goto LABEL_29;
}
goto LABEL_24;
}
v12 = 110;
LABEL_29:
v4 = v6 + 2;
if ( (unsigned long long)(v6 + 2) <= v7 )
{
*v6 = 92;
v6[1] = v12;
goto LABEL_31;
}
LABEL_33:
*v6 = 0;
return -1LL;
}
| mysql_cset_escape_slashes:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
TEST RCX,RCX
JLE 0x00130290
MOV R14,RCX
MOV R12,RDX
MOV R15,RDI
MOV RBX,qword ptr [RBP + -0x30]
LEA R13,[RBX + RCX*0x2]
ADD R14,RDX
LAB_001301ba:
CMP dword ptr [R15 + 0x34],0x2
JC 0x00130222
MOV RDI,R12
MOV RSI,R14
CALL qword ptr [R15 + 0x40]
TEST EAX,EAX
JZ 0x00130201
MOV ECX,EAX
MOV EAX,EAX
ADD RAX,RBX
CMP RAX,R13
JA 0x00130299
DEC R12
MOV RDX,R12
LAB_001301e5:
LEA R12,[RDX + 0x1]
LEA RAX,[RBX + 0x1]
MOV DL,byte ptr [RDX + 0x1]
MOV byte ptr [RBX],DL
MOV RDX,R12
MOV RBX,RAX
DEC ECX
JNZ 0x001301e5
JMP 0x00130281
LAB_00130201:
CMP dword ptr [R15 + 0x34],0x2
JC 0x00130222
MOVSX EDI,byte ptr [R12]
CALL qword ptr [R15 + 0x38]
CMP EAX,0x1
JBE 0x00130222
MOV CL,byte ptr [R12]
TEST CL,CL
JNZ 0x00130272
XOR ECX,ECX
JMP 0x0013025b
LAB_00130222:
MOV CL,byte ptr [R12]
MOVZX EAX,CL
CMP EAX,0x19
JLE 0x0013023f
CMP EAX,0x26
JG 0x00130251
CMP EAX,0x1a
JZ 0x0013026c
CMP EAX,0x22
JZ 0x00130272
JMP 0x0013025b
LAB_0013023f:
TEST EAX,EAX
JZ 0x00130268
CMP EAX,0xa
JZ 0x00130270
CMP EAX,0xd
JNZ 0x0013025b
MOV CL,0x72
JMP 0x00130272
LAB_00130251:
CMP EAX,0x27
JZ 0x00130272
CMP EAX,0x5c
JZ 0x00130272
LAB_0013025b:
LEA RAX,[RBX + 0x1]
CMP RAX,R13
JA 0x00130299
MOV byte ptr [RBX],CL
JMP 0x00130281
LAB_00130268:
MOV CL,0x30
JMP 0x00130272
LAB_0013026c:
MOV CL,0x5a
JMP 0x00130272
LAB_00130270:
MOV CL,0x6e
LAB_00130272:
LEA RAX,[RBX + 0x2]
CMP RAX,R13
JA 0x00130299
MOV byte ptr [RBX],0x5c
MOV byte ptr [RBX + 0x1],CL
LAB_00130281:
INC R12
MOV RBX,RAX
CMP R12,R14
JC 0x001301ba
LAB_00130290:
MOV byte ptr [RAX],0x0
SUB RAX,qword ptr [RBP + -0x30]
JMP 0x001302a3
LAB_00130299:
MOV byte ptr [RBX],0x0
MOV RAX,-0x1
LAB_001302a3:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long mysql_cset_escape_slashes(long param_1,byte *param_2,byte *param_3,long param_4)
{
byte *pbVar1;
uint uVar2;
byte *pbVar3;
byte bVar4;
byte *pbVar5;
byte *pbVar6;
byte *pbVar7;
pbVar3 = param_2;
if (0 < param_4) {
pbVar1 = param_2 + param_4 * 2;
pbVar7 = param_3 + param_4;
pbVar6 = param_2;
do {
if (*(uint *)(param_1 + 0x34) < 2) {
LAB_00130222:
bVar4 = *param_3;
if (bVar4 < 0x1a) {
if (bVar4 == 0) {
bVar4 = 0x30;
}
else if (bVar4 == 10) {
bVar4 = 0x6e;
}
else {
if (bVar4 != 0xd) goto LAB_0013025b;
bVar4 = 0x72;
}
}
else if (bVar4 < 0x27) {
if (bVar4 == 0x1a) {
bVar4 = 0x5a;
}
else if (bVar4 != 0x22) goto LAB_0013025b;
}
else if ((bVar4 != 0x27) && (bVar4 != 0x5c)) {
LAB_0013025b:
pbVar3 = pbVar6 + 1;
if (pbVar1 < pbVar3) goto LAB_00130299;
*pbVar6 = bVar4;
goto LAB_00130281;
}
LAB_00130272:
pbVar3 = pbVar6 + 2;
if (pbVar1 < pbVar3) {
LAB_00130299:
*pbVar6 = 0;
return -1;
}
*pbVar6 = 0x5c;
pbVar6[1] = bVar4;
}
else {
uVar2 = (**(code **)(param_1 + 0x40))(param_3,pbVar7);
if (uVar2 == 0) {
if ((*(uint *)(param_1 + 0x34) < 2) ||
(uVar2 = (**(code **)(param_1 + 0x38))((int)(char)*param_3), uVar2 < 2))
goto LAB_00130222;
bVar4 = *param_3;
if (bVar4 == 0) {
bVar4 = 0;
goto LAB_0013025b;
}
goto LAB_00130272;
}
if (pbVar1 < pbVar6 + uVar2) goto LAB_00130299;
pbVar5 = param_3 + -1;
do {
param_3 = pbVar5 + 1;
pbVar3 = pbVar6 + 1;
*pbVar6 = pbVar5[1];
uVar2 = uVar2 - 1;
pbVar5 = param_3;
pbVar6 = pbVar3;
} while (uVar2 != 0);
}
LAB_00130281:
param_3 = param_3 + 1;
pbVar6 = pbVar3;
} while (param_3 < pbVar7);
}
*pbVar3 = 0;
return (long)pbVar3 - (long)param_2;
}
| |
35,277 | vector_f_mul_scalar | tsotchke[P]eshkol/src/core/utils/vector.c | VectorF* vector_f_mul_scalar(Arena* arena, const VectorF* vec, float scalar) {
assert(arena != NULL);
assert(vec != NULL);
VectorF* result = vector_f_create(arena, vec->dim);
if (!result) {
return NULL;
}
// Get the best implementation
typedef void (*MulScalarFunc)(VectorF*, const VectorF*, float);
MulScalarFunc mul_scalar_func = (MulScalarFunc)simd_get_best_impl(
(void*)vector_f_mul_scalar_generic,
#if defined(__SSE__) || defined(__SSE2__)
(void*)vector_f_mul_scalar_sse,
#else
NULL,
#endif
#if defined(__AVX__) || defined(__AVX2__)
(void*)vector_f_mul_scalar_avx,
#else
NULL,
#endif
NULL,
NULL,
NULL
);
// Multiply the vector by the scalar
mul_scalar_func(result, vec, scalar);
return result;
} | O0 | c | vector_f_mul_scalar:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x585e
jmp 0x587d
leaq 0x4970(%rip), %rdi # 0xa1d5
leaq 0x5eec(%rip), %rsi # 0xb758
movl $0x1fc, %edx # imm = 0x1FC
leaq 0x6190(%rip), %rcx # 0xba08
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x5886
jmp 0x58a5
leaq 0x5fea(%rip), %rdi # 0xb877
leaq 0x5ec4(%rip), %rsi # 0xb758
movl $0x1fd, %edx # imm = 0x1FD
leaq 0x6168(%rip), %rcx # 0xba08
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x49a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x58cb
movq $0x0, -0x8(%rbp)
jmp 0x590b
leaq 0x4e(%rip), %rdi # 0x5920
leaq 0x137(%rip), %rsi # 0x5a10
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8b40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movss -0x1c(%rbp), %xmm0
callq *%rax
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| vector_f_mul_scalar:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
movss [rbp+var_1C], xmm0
cmp [rbp+var_10], 0
jz short loc_585E
jmp short loc_587D
loc_585E:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1FCh
lea rcx, aVectorfVectorF_4; "VectorF *vector_f_mul_scalar(Arena *, c"...
call ___assert_fail
loc_587D:
cmp [rbp+var_18], 0
jz short loc_5886
jmp short loc_58A5
loc_5886:
lea rdi, aVecNull; "vec != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1FDh
lea rcx, aVectorfVectorF_4; "VectorF *vector_f_mul_scalar(Arena *, c"...
call ___assert_fail
loc_58A5:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+10h]
call vector_f_create
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_58CB
mov [rbp+var_8], 0
jmp short loc_590B
loc_58CB:
lea rdi, vector_f_mul_scalar_generic
lea rsi, vector_f_mul_scalar_sse
xor eax, eax
mov r9d, eax
mov rdx, r9
mov rcx, r9
mov r8, r9
call simd_get_best_impl
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
movss xmm0, [rbp+var_1C]
call rax
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_590B:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long vector_f_mul_scalar(_QWORD *a1, long long a2, float a3)
{
void ( *best_impl)(long long, long long, float); // [rsp+0h] [rbp-30h]
long long v5; // [rsp+8h] [rbp-28h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/vector.c",
508LL,
"VectorF *vector_f_mul_scalar(Arena *, const VectorF *, float)");
if ( !a2 )
__assert_fail(
"vec != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/vector.c",
509LL,
"VectorF *vector_f_mul_scalar(Arena *, const VectorF *, float)");
v5 = vector_f_create(a1, *(_QWORD *)(a2 + 16));
if ( !v5 )
return 0LL;
best_impl = (void ( *)(long long, long long, float))simd_get_best_impl(
vector_f_mul_scalar_generic,
vector_f_mul_scalar_sse,
0LL,
0LL,
0LL);
best_impl(v5, a2, a3);
return v5;
}
| vector_f_mul_scalar:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOVSS dword ptr [RBP + -0x1c],XMM0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0010585e
JMP 0x0010587d
LAB_0010585e:
LEA RDI,[0x10a1c3]
LEA RSI,[0x10b724]
MOV EDX,0x1fc
LEA RCX,[0x10b9c2]
CALL 0x00101090
LAB_0010587d:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00105886
JMP 0x001058a5
LAB_00105886:
LEA RDI,[0x10b831]
LEA RSI,[0x10b724]
MOV EDX,0x1fd
LEA RCX,[0x10b9c2]
CALL 0x00101090
LAB_001058a5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x001049a0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001058cb
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0010590b
LAB_001058cb:
LEA RDI,[0x105920]
LEA RSI,[0x105a10]
XOR EAX,EAX
MOV R9D,EAX
MOV RDX,R9
MOV RCX,R9
MOV R8,R9
CALL 0x00108b40
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RBP + -0x1c]
CALL RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0010590b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long vector_f_mul_scalar(int4 param_1,long param_2,long param_3)
{
code *pcVar1;
long local_10;
if (param_2 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/src/core/utils/vector.c",
0x1fc,"VectorF *vector_f_mul_scalar(Arena *, const VectorF *, float)");
}
if (param_3 != 0) {
local_10 = vector_f_create(param_2,*(int8 *)(param_3 + 0x10));
if (local_10 == 0) {
local_10 = 0;
}
else {
pcVar1 = (code *)simd_get_best_impl(vector_f_mul_scalar_generic,vector_f_mul_scalar_sse,0,0,0)
;
(*pcVar1)(param_1,local_10,param_3);
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("vec != NULL","/workspace/llm4binary/github2025/eshkol/src/core/utils/vector.c",
0x1fd,"VectorF *vector_f_mul_scalar(Arena *, const VectorF *, float)");
}
| |
35,278 | ggml_get_n_tasks | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) {
int n_tasks = 0;
switch (node->op) {
case GGML_OP_CPY:
case GGML_OP_DUP:
case GGML_OP_ADD:
case GGML_OP_ADD1:
case GGML_OP_ACC:
{
n_tasks = n_threads;
} break;
case GGML_OP_SUB:
case GGML_OP_SQR:
case GGML_OP_SQRT:
case GGML_OP_LOG:
case GGML_OP_SUM:
case GGML_OP_SUM_ROWS:
case GGML_OP_MEAN:
case GGML_OP_ARGMAX:
case GGML_OP_REPEAT:
case GGML_OP_REPEAT_BACK:
case GGML_OP_LEAKY_RELU:
{
n_tasks = 1;
} break;
case GGML_OP_UNARY:
switch (ggml_get_unary_op(node)) {
case GGML_UNARY_OP_ABS:
case GGML_UNARY_OP_SGN:
case GGML_UNARY_OP_NEG:
case GGML_UNARY_OP_STEP:
case GGML_UNARY_OP_TANH:
case GGML_UNARY_OP_ELU:
case GGML_UNARY_OP_RELU:
{
n_tasks = 1;
} break;
case GGML_UNARY_OP_GELU:
case GGML_UNARY_OP_GELU_QUICK:
case GGML_UNARY_OP_SILU:
{
n_tasks = n_threads;
} break;
default:
GGML_ASSERT(false);
}
break;
case GGML_OP_SILU_BACK:
case GGML_OP_MUL:
case GGML_OP_DIV:
case GGML_OP_NORM:
case GGML_OP_RMS_NORM:
case GGML_OP_RMS_NORM_BACK:
case GGML_OP_GROUP_NORM:
case GGML_OP_CONCAT:
{
n_tasks = n_threads;
} break;
case GGML_OP_MUL_MAT:
{
n_tasks = n_threads;
// TODO: use different scheduling for different matrix sizes
//const int nr0 = ggml_nrows(node->src[0]);
//const int nr1 = ggml_nrows(node->src[1]);
//n_tasks = MIN(n_threads, MAX(1, nr0/128));
//printf("nr0 = %8d, nr1 = %8d, nr0*nr1 = %8d, n_tasks%d\n", nr0, nr1, nr0*nr1, n_tasks);
#if defined(GGML_USE_CUBLAS)
if (ggml_cuda_can_mul_mat(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#elif defined(GGML_USE_CLBLAST)
if (ggml_cl_can_mul_mat(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#endif
#if defined(GGML_USE_ACCELERATE) || defined(GGML_USE_OPENBLAS)
if (ggml_compute_forward_mul_mat_use_blas(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#endif
} break;
case GGML_OP_MUL_MAT_ID:
{
n_tasks = n_threads;
} break;
case GGML_OP_OUT_PROD:
{
n_tasks = n_threads;
} break;
case GGML_OP_SCALE:
case GGML_OP_SET:
case GGML_OP_CONT:
case GGML_OP_RESHAPE:
case GGML_OP_VIEW:
case GGML_OP_PERMUTE:
case GGML_OP_TRANSPOSE:
case GGML_OP_GET_ROWS:
case GGML_OP_GET_ROWS_BACK:
case GGML_OP_DIAG:
{
n_tasks = 1;
} break;
case GGML_OP_DIAG_MASK_ZERO:
case GGML_OP_DIAG_MASK_INF:
case GGML_OP_SOFT_MAX_BACK:
case GGML_OP_ROPE:
case GGML_OP_ROPE_BACK:
case GGML_OP_ADD_REL_POS:
{
n_tasks = n_threads;
} break;
case GGML_OP_ALIBI:
{
n_tasks = 1; //TODO
} break;
case GGML_OP_CLAMP:
{
n_tasks = 1; //TODO
} break;
case GGML_OP_SOFT_MAX:
{
n_tasks = MIN(MIN(4, n_threads), ggml_nrows(node->src[0]));
} break;
case GGML_OP_CONV_TRANSPOSE_1D:
{
n_tasks = n_threads;
} break;
case GGML_OP_IM2COL:
{
n_tasks = n_threads;
} break;
case GGML_OP_CONV_TRANSPOSE_2D:
{
n_tasks = n_threads;
} break;
case GGML_OP_POOL_1D:
case GGML_OP_POOL_2D:
{
n_tasks = 1;
} break;
case GGML_OP_UPSCALE:
{
n_tasks = n_threads;
} break;
case GGML_OP_PAD:
{
n_tasks = n_threads;
} break;
case GGML_OP_ARGSORT:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_ATTN:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_FF:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_ATTN_BACK:
{
n_tasks = n_threads;
} break;
case GGML_OP_WIN_PART:
case GGML_OP_WIN_UNPART:
case GGML_OP_GET_REL_POS:
case GGML_OP_MAP_UNARY:
case GGML_OP_MAP_BINARY:
case GGML_OP_MAP_CUSTOM1_F32:
case GGML_OP_MAP_CUSTOM2_F32:
case GGML_OP_MAP_CUSTOM3_F32:
{
n_tasks = 1;
} break;
case GGML_OP_MAP_CUSTOM1:
{
struct ggml_map_custom1_op_params * p = (struct ggml_map_custom1_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_MAP_CUSTOM2:
{
struct ggml_map_custom2_op_params * p = (struct ggml_map_custom2_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_MAP_CUSTOM3:
{
struct ggml_map_custom3_op_params * p = (struct ggml_map_custom3_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_CROSS_ENTROPY_LOSS:
{
n_tasks = n_threads;
} break;
case GGML_OP_CROSS_ENTROPY_LOSS_BACK:
{
n_tasks = n_threads;
} break;
case GGML_OP_NONE:
{
n_tasks = 1;
} break;
case GGML_OP_COUNT:
{
GGML_ASSERT(false);
} break;
default:
{
fprintf(stderr, "%s: op not implemented: ", __func__);
if (node->op < GGML_OP_COUNT) {
fprintf(stderr, "%s\n", ggml_op_name(node->op));
} else {
fprintf(stderr, "%d\n", node->op);
}
GGML_ASSERT(false);
} break;
}
assert(n_tasks > 0);
return n_tasks;
} | O2 | c | ggml_get_n_tasks:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x50(%rdi), %eax
cmpq $0x48, %rax
ja 0x723d5
movl %esi, %ebx
leaq 0x2ef2f(%rip), %rcx # 0xa1260
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x5c(%r14), %eax
cmpl %ebx, %eax
movl %ebx, %ecx
cmovll %eax, %ecx
cmpl $-0x1, %eax
cmovel %ebx, %ecx
movl %ecx, %ebx
jmp 0x7233d
movq %r14, %rdi
callq 0x67c71
cmpl $0x7, %eax
jb 0x7233a
addl $-0x7, %eax
cmpl $0x2, %eax
jbe 0x7233d
movq 0x63bd0(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x63c21(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x27e8d(%rip), %rsi # 0x9a21e
leaq 0x2f4e6(%rip), %rdx # 0xa187e
leaq 0x25ca0(%rip), %r8 # 0x9803f
movl $0x3f98, %ecx # imm = 0x3F98
jmp 0x72456
cmpl $0x4, %ebx
pushq $0x4
popq %rax
cmovll %ebx, %eax
movq 0xa0(%r14), %rcx
movq 0x20(%rcx), %rdx
imulq 0x18(%rcx), %rdx
imulq 0x28(%rcx), %rdx
movslq %eax, %rbx
cmpq %rbx, %rdx
cmovlel %edx, %ebx
jmp 0x7233d
movq 0x63bcc(%rip), %rbx # 0xd5fa8
movq (%rbx), %rdi
leaq 0x31580(%rip), %rsi # 0xa3966
leaq 0x31592(%rip), %rdx # 0xa397f
xorl %eax, %eax
callq 0xa8b0
movl 0x50(%r14), %edx
movq (%rbx), %rdi
cmpq $0x47, %rdx
ja 0x7241c
leaq 0x633f8(%rip), %rax # 0xd5800
movq (%rax,%rdx,8), %rdx
leaq 0x25bd6(%rip), %rsi # 0x97fe9
xorl %eax, %eax
callq 0xa8b0
jmp 0x7242a
leaq 0x25b22(%rip), %rsi # 0x97f45
xorl %eax, %eax
callq 0xa8b0
movq 0x63b17(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq (%rbx), %rdi
leaq 0x27ddb(%rip), %rsi # 0x9a21e
leaq 0x2f434(%rip), %rdx # 0xa187e
leaq 0x25bee(%rip), %r8 # 0x9803f
movl $0x4054, %ecx # imm = 0x4054
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
movq 0x63ada(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x63b2b(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x27d97(%rip), %rsi # 0x9a21e
leaq 0x2f3f0(%rip), %rdx # 0xa187e
leaq 0x25baa(%rip), %r8 # 0x9803f
movl $0x404a, %ecx # imm = 0x404A
jmp 0x72456
| ggml_get_n_tasks:
push r14
push rbx
push rax
mov r14, rdi
mov eax, [rdi+50h]
cmp rax, 48h; switch 73 cases
ja def_72338; jumptable 0000000000072338 default case
mov ebx, esi
lea rcx, jpt_72338
movsxd rax, ds:(jpt_72338 - 0A1260h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7233A:
push 1; jumptable 0000000000072338 cases 0,5,8-16,26,27,29-36,43,44,48,49,53,57-59,62-66
pop rbx
loc_7233D:
mov eax, ebx; jumptable 0000000000072338 cases 1-4,6,7,17-25,28,37,38,40-42,45-47,50-52,54-56,60,70,71
add rsp, 8
pop rbx
pop r14
retn
loc_72347:
mov eax, [r14+5Ch]; jumptable 0000000000072338 cases 67-69
cmp eax, ebx
mov ecx, ebx
cmovl ecx, eax
cmp eax, 0FFFFFFFFh
cmovz ecx, ebx
mov ebx, ecx
jmp short loc_7233D; jumptable 0000000000072338 cases 1-4,6,7,17-25,28,37,38,40-42,45-47,50-52,54-56,60,70,71
loc_7235C:
mov rdi, r14; jumptable 0000000000072338 case 61
call ggml_get_unary_op
cmp eax, 7
jb short loc_7233A; jumptable 0000000000072338 cases 0,5,8-16,26,27,29-36,43,44,48,49,53,57-59,62-66
add eax, 0FFFFFFF9h
cmp eax, 2
jbe short loc_7233D; jumptable 0000000000072338 cases 1-4,6,7,17-25,28,37,38,40-42,45-47,50-52,54-56,60,70,71
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 3F98h
jmp loc_72456
loc_723A9:
cmp ebx, 4; jumptable 0000000000072338 case 39
push 4
pop rax
cmovl eax, ebx
mov rcx, [r14+0A0h]
mov rdx, [rcx+20h]
imul rdx, [rcx+18h]
imul rdx, [rcx+28h]
movsxd rbx, eax
cmp rdx, rbx
cmovle ebx, edx
jmp loc_7233D; jumptable 0000000000072338 cases 1-4,6,7,17-25,28,37,38,40-42,45-47,50-52,54-56,60,70,71
def_72338:
mov rbx, cs:stderr_ptr; jumptable 0000000000072338 default case
mov rdi, [rbx]
lea rsi, aSOpNotImplemen; "%s: op not implemented: "
lea rdx, aGgmlGetNTasks; "ggml_get_n_tasks"
xor eax, eax
call _fprintf
mov edx, [r14+50h]
mov rdi, [rbx]
cmp rdx, 47h ; 'G'
ja short loc_7241C
lea rax, GGML_OP_NAME
mov rdx, [rax+rdx*8]
lea rsi, aRngS+17h; "%s\n"
xor eax, eax
call _fprintf
jmp short loc_7242A
loc_7241C:
lea rsi, aWidthD+17h; "%d\n"
xor eax, eax
call _fprintf
loc_7242A:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rdi, [rbx]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 4054h
loc_72456:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
loc_72467:
mov rax, cs:stdout_ptr; jumptable 0000000000072338 case 72
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 404Ah
jmp short loc_72456
| long long ggml_get_n_tasks(long long a1, int a2)
{
unsigned int v2; // ebx
int v4; // eax
unsigned int v5; // ecx
unsigned int unary_op; // eax
long long v7; // rdi
int v8; // eax
unsigned long long v9; // rdx
v2 = a2;
switch ( *(_DWORD *)(a1 + 80) )
{
case 0:
case 5:
case 8:
case 9:
case 0xA:
case 0xB:
case 0xC:
case 0xD:
case 0xE:
case 0xF:
case 0x10:
case 0x1A:
case 0x1B:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x2B:
case 0x2C:
case 0x30:
case 0x31:
case 0x35:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
return 1;
case 1:
case 2:
case 3:
case 4:
case 6:
case 7:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1C:
case 0x25:
case 0x26:
case 0x28:
case 0x29:
case 0x2A:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x32:
case 0x33:
case 0x34:
case 0x36:
case 0x37:
case 0x38:
case 0x3C:
case 0x46:
case 0x47:
return v2;
case 0x27:
v8 = 4;
if ( a2 < 4 )
v8 = a2;
v2 = v8;
if ( *(_QWORD *)(*(_QWORD *)(a1 + 160) + 40LL)
* *(_QWORD *)(*(_QWORD *)(a1 + 160) + 24LL)
* *(_QWORD *)(*(_QWORD *)(a1 + 160) + 32LL) <= v8 )
return (unsigned int)(*(_DWORD *)(*(_QWORD *)(a1 + 160) + 40LL)
* *(_DWORD *)(*(_QWORD *)(a1 + 160) + 24LL)
* *(_DWORD *)(*(_QWORD *)(a1 + 160) + 32LL));
return v2;
case 0x3D:
unary_op = ggml_get_unary_op(a1);
if ( unary_op < 7 )
{
return 1;
}
else if ( unary_op - 7 > 2 )
{
fflush(stdout);
v7 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16280LL,
"false");
LABEL_21:
ggml_print_backtrace();
abort(v7);
}
return v2;
case 0x43:
case 0x44:
case 0x45:
v4 = *(_DWORD *)(a1 + 92);
v5 = a2;
if ( v4 < a2 )
v5 = *(_DWORD *)(a1 + 92);
if ( v4 == -1 )
return (unsigned int)a2;
return v5;
case 0x48:
fflush(stdout);
v7 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16458LL,
"false");
goto LABEL_21;
default:
fprintf(stderr, "%s: op not implemented: ", "ggml_get_n_tasks");
v9 = *(unsigned int *)(a1 + 80);
if ( v9 > 0x47 )
fprintf(stderr, "%d\n", v9);
else
fprintf(stderr, "%s\n", (const char *)*(&GGML_OP_NAME + v9));
fflush(stdout);
v7 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16468LL,
"false");
goto LABEL_21;
}
}
| ggml_get_n_tasks:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EAX,dword ptr [RDI + 0x50]
CMP RAX,0x48
JA 0x001723d5
MOV EBX,ESI
LEA RCX,[0x1a1260]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
PUSH 0x1
POP RBX
caseD_1:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
RET
caseD_43:
MOV EAX,dword ptr [R14 + 0x5c]
CMP EAX,EBX
MOV ECX,EBX
CMOVL ECX,EAX
CMP EAX,-0x1
CMOVZ ECX,EBX
MOV EBX,ECX
JMP 0x0017233d
caseD_3d:
MOV RDI,R14
CALL 0x00167c71
CMP EAX,0x7
JC 0x0017233a
ADD EAX,-0x7
CMP EAX,0x2
JBE 0x0017233d
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0x3f98
JMP 0x00172456
caseD_27:
CMP EBX,0x4
PUSH 0x4
POP RAX
CMOVL EAX,EBX
MOV RCX,qword ptr [R14 + 0xa0]
MOV RDX,qword ptr [RCX + 0x20]
IMUL RDX,qword ptr [RCX + 0x18]
IMUL RDX,qword ptr [RCX + 0x28]
MOVSXD RBX,EAX
CMP RDX,RBX
CMOVLE EBX,EDX
JMP 0x0017233d
LAB_001723d5:
MOV RBX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RBX]
LEA RSI,[0x1a3966]
LEA RDX,[0x1a397f]
XOR EAX,EAX
CALL 0x0010a8b0
MOV EDX,dword ptr [R14 + 0x50]
MOV RDI,qword ptr [RBX]
CMP RDX,0x47
JA 0x0017241c
LEA RAX,[0x1d5800]
MOV RDX,qword ptr [RAX + RDX*0x8]
LEA RSI,[0x197fe9]
XOR EAX,EAX
CALL 0x0010a8b0
JMP 0x0017242a
LAB_0017241c:
LEA RSI,[0x197f45]
XOR EAX,EAX
CALL 0x0010a8b0
LAB_0017242a:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RDI,qword ptr [RBX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0x4054
LAB_00172456:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
caseD_48:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0x404a
JMP 0x00172456
|
ulong ggml_get_n_tasks(long param_1,uint param_2)
{
long lVar1;
int *puVar2;
uint uVar3;
uint uVar4;
int8 uVar5;
ulong uVar6;
ulong uVar7;
FILE *pFVar8;
puVar2 = PTR_stderr_001d5fa8;
if (*(uint *)(param_1 + 0x50) < 0x49) {
uVar7 = (ulong)param_2;
switch(*(uint *)(param_1 + 0x50)) {
case 1:
case 2:
case 3:
case 4:
case 6:
case 7:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1c:
case 0x25:
case 0x26:
case 0x28:
case 0x29:
case 0x2a:
case 0x2d:
case 0x2e:
case 0x2f:
case 0x32:
case 0x33:
case 0x34:
case 0x36:
case 0x37:
case 0x38:
case 0x3c:
case 0x46:
case 0x47:
break;
case 0x27:
uVar3 = 4;
if ((int)param_2 < 4) {
uVar3 = param_2;
}
lVar1 = *(long *)(param_1 + 0xa0);
uVar6 = *(long *)(lVar1 + 0x20) * *(long *)(lVar1 + 0x18) * *(long *)(lVar1 + 0x28);
uVar7 = (ulong)uVar3;
if (uVar6 - (long)(int)uVar3 == 0 || (long)uVar6 < (long)(int)uVar3) {
uVar7 = uVar6 & 0xffffffff;
}
break;
case 0x3d:
uVar3 = ggml_get_unary_op(param_1);
if (6 < uVar3) {
if (uVar3 - 7 < 3) {
return uVar7;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
pFVar8 = *(FILE **)PTR_stderr_001d5fa8;
uVar5 = 0x3f98;
goto LAB_00172456;
}
default:
uVar7 = 1;
break;
case 0x43:
case 0x44:
case 0x45:
uVar3 = *(uint *)(param_1 + 0x5c);
uVar4 = param_2;
if ((int)uVar3 < (int)param_2) {
uVar4 = uVar3;
}
if (uVar3 == 0xffffffff) {
uVar4 = param_2;
}
uVar7 = (ulong)uVar4;
break;
case 0x48:
fflush(*(FILE **)PTR_stdout_001d5f48);
pFVar8 = *(FILE **)PTR_stderr_001d5fa8;
uVar5 = 0x404a;
goto LAB_00172456;
}
return uVar7;
}
fprintf(*(FILE **)PTR_stderr_001d5fa8,"%s: op not implemented: ","ggml_get_n_tasks");
pFVar8 = *(FILE **)puVar2;
if ((ulong)*(uint *)(param_1 + 0x50) < 0x48) {
fprintf(pFVar8,"%s\n",(&GGML_OP_NAME)[*(uint *)(param_1 + 0x50)]);
}
else {
fprintf(pFVar8,"%d\n");
}
fflush(*(FILE **)PTR_stdout_001d5f48);
pFVar8 = *(FILE **)puVar2;
uVar5 = 0x4054;
LAB_00172456:
fprintf(pFVar8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar5,"false");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
35,279 | ggml_get_n_tasks | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static int ggml_get_n_tasks(struct ggml_tensor * node, int n_threads) {
int n_tasks = 0;
switch (node->op) {
case GGML_OP_CPY:
case GGML_OP_DUP:
case GGML_OP_ADD:
case GGML_OP_ADD1:
case GGML_OP_ACC:
{
n_tasks = n_threads;
} break;
case GGML_OP_SUB:
case GGML_OP_SQR:
case GGML_OP_SQRT:
case GGML_OP_LOG:
case GGML_OP_SUM:
case GGML_OP_SUM_ROWS:
case GGML_OP_MEAN:
case GGML_OP_ARGMAX:
case GGML_OP_REPEAT:
case GGML_OP_REPEAT_BACK:
case GGML_OP_LEAKY_RELU:
{
n_tasks = 1;
} break;
case GGML_OP_UNARY:
switch (ggml_get_unary_op(node)) {
case GGML_UNARY_OP_ABS:
case GGML_UNARY_OP_SGN:
case GGML_UNARY_OP_NEG:
case GGML_UNARY_OP_STEP:
case GGML_UNARY_OP_TANH:
case GGML_UNARY_OP_ELU:
case GGML_UNARY_OP_RELU:
{
n_tasks = 1;
} break;
case GGML_UNARY_OP_GELU:
case GGML_UNARY_OP_GELU_QUICK:
case GGML_UNARY_OP_SILU:
{
n_tasks = n_threads;
} break;
default:
GGML_ASSERT(false);
}
break;
case GGML_OP_SILU_BACK:
case GGML_OP_MUL:
case GGML_OP_DIV:
case GGML_OP_NORM:
case GGML_OP_RMS_NORM:
case GGML_OP_RMS_NORM_BACK:
case GGML_OP_GROUP_NORM:
case GGML_OP_CONCAT:
{
n_tasks = n_threads;
} break;
case GGML_OP_MUL_MAT:
{
n_tasks = n_threads;
// TODO: use different scheduling for different matrix sizes
//const int nr0 = ggml_nrows(node->src[0]);
//const int nr1 = ggml_nrows(node->src[1]);
//n_tasks = MIN(n_threads, MAX(1, nr0/128));
//printf("nr0 = %8d, nr1 = %8d, nr0*nr1 = %8d, n_tasks%d\n", nr0, nr1, nr0*nr1, n_tasks);
#if defined(GGML_USE_CUBLAS)
if (ggml_cuda_can_mul_mat(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#elif defined(GGML_USE_CLBLAST)
if (ggml_cl_can_mul_mat(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#endif
#if defined(GGML_USE_ACCELERATE) || defined(GGML_USE_OPENBLAS)
if (ggml_compute_forward_mul_mat_use_blas(node->src[0], node->src[1], node)) {
n_tasks = 1; // TODO: this actually is doing nothing
// the threads are still spinning
}
#endif
} break;
case GGML_OP_MUL_MAT_ID:
{
n_tasks = n_threads;
} break;
case GGML_OP_OUT_PROD:
{
n_tasks = n_threads;
} break;
case GGML_OP_SCALE:
case GGML_OP_SET:
case GGML_OP_CONT:
case GGML_OP_RESHAPE:
case GGML_OP_VIEW:
case GGML_OP_PERMUTE:
case GGML_OP_TRANSPOSE:
case GGML_OP_GET_ROWS:
case GGML_OP_GET_ROWS_BACK:
case GGML_OP_DIAG:
{
n_tasks = 1;
} break;
case GGML_OP_DIAG_MASK_ZERO:
case GGML_OP_DIAG_MASK_INF:
case GGML_OP_SOFT_MAX_BACK:
case GGML_OP_ROPE:
case GGML_OP_ROPE_BACK:
case GGML_OP_ADD_REL_POS:
{
n_tasks = n_threads;
} break;
case GGML_OP_ALIBI:
{
n_tasks = 1; //TODO
} break;
case GGML_OP_CLAMP:
{
n_tasks = 1; //TODO
} break;
case GGML_OP_SOFT_MAX:
{
n_tasks = MIN(MIN(4, n_threads), ggml_nrows(node->src[0]));
} break;
case GGML_OP_CONV_TRANSPOSE_1D:
{
n_tasks = n_threads;
} break;
case GGML_OP_IM2COL:
{
n_tasks = n_threads;
} break;
case GGML_OP_CONV_TRANSPOSE_2D:
{
n_tasks = n_threads;
} break;
case GGML_OP_POOL_1D:
case GGML_OP_POOL_2D:
{
n_tasks = 1;
} break;
case GGML_OP_UPSCALE:
{
n_tasks = n_threads;
} break;
case GGML_OP_PAD:
{
n_tasks = n_threads;
} break;
case GGML_OP_ARGSORT:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_ATTN:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_FF:
{
n_tasks = n_threads;
} break;
case GGML_OP_FLASH_ATTN_BACK:
{
n_tasks = n_threads;
} break;
case GGML_OP_WIN_PART:
case GGML_OP_WIN_UNPART:
case GGML_OP_GET_REL_POS:
case GGML_OP_MAP_UNARY:
case GGML_OP_MAP_BINARY:
case GGML_OP_MAP_CUSTOM1_F32:
case GGML_OP_MAP_CUSTOM2_F32:
case GGML_OP_MAP_CUSTOM3_F32:
{
n_tasks = 1;
} break;
case GGML_OP_MAP_CUSTOM1:
{
struct ggml_map_custom1_op_params * p = (struct ggml_map_custom1_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_MAP_CUSTOM2:
{
struct ggml_map_custom2_op_params * p = (struct ggml_map_custom2_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_MAP_CUSTOM3:
{
struct ggml_map_custom3_op_params * p = (struct ggml_map_custom3_op_params *) node->op_params;
if (p->n_tasks == GGML_N_TASKS_MAX) {
n_tasks = n_threads;
} else {
n_tasks = MIN(p->n_tasks, n_threads);
}
} break;
case GGML_OP_CROSS_ENTROPY_LOSS:
{
n_tasks = n_threads;
} break;
case GGML_OP_CROSS_ENTROPY_LOSS_BACK:
{
n_tasks = n_threads;
} break;
case GGML_OP_NONE:
{
n_tasks = 1;
} break;
case GGML_OP_COUNT:
{
GGML_ASSERT(false);
} break;
default:
{
fprintf(stderr, "%s: op not implemented: ", __func__);
if (node->op < GGML_OP_COUNT) {
fprintf(stderr, "%s\n", ggml_op_name(node->op));
} else {
fprintf(stderr, "%d\n", node->op);
}
GGML_ASSERT(false);
} break;
}
assert(n_tasks > 0);
return n_tasks;
} | O3 | c | ggml_get_n_tasks:
pushq %rbx
movl 0x50(%rdi), %eax
cmpq $0x48, %rax
ja 0x96e42
movl %esi, %ebx
leaq 0x2d73e(%rip), %rcx # 0xc4510
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %eax
jmp 0x96de4
movl %ebx, %eax
popq %rbx
retq
movl 0x5c(%rdi), %ecx
cmpl %ebx, %ecx
movl %ebx, %eax
cmovll %ecx, %eax
cmpl $-0x1, %ecx
cmovel %ebx, %eax
jmp 0x96de4
callq 0x8cfd8
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x7, %ecx
jb 0x96de4
addl $-0x7, %ecx
movl %ebx, %eax
cmpl $0x2, %ecx
jbe 0x96de4
callq 0x1009c
cmpl $0x4, %ebx
movl $0x4, %eax
cmovll %ebx, %eax
movq 0xa0(%rdi), %rcx
movq 0x20(%rcx), %rdx
imulq 0x18(%rcx), %rdx
imulq 0x28(%rcx), %rdx
cltq
cmpq %rax, %rdx
cmovlel %edx, %eax
jmp 0x96de4
addq $0x50, %rdi
callq 0x100e1
callq 0x10057
| ggml_get_n_tasks:
push rbx
mov eax, [rdi+50h]
cmp rax, 48h; switch 73 cases
ja short def_96DD9; jumptable 0000000000096DD9 default case
mov ebx, esi
lea rcx, jpt_96DD9
movsxd rax, ds:(jpt_96DD9 - 0C4510h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_96DDB:
mov eax, 1; jumptable 0000000000096DD9 cases 0,5,8-16,26,27,29-36,43,44,48,49,53,57-59,62-66
jmp short loc_96DE4
loc_96DE2:
mov eax, ebx; jumptable 0000000000096DD9 cases 1-4,6,7,17-25,28,37,38,40-42,45-47,50-52,54-56,60,70,71
loc_96DE4:
pop rbx
retn
loc_96DE6:
mov ecx, [rdi+5Ch]; jumptable 0000000000096DD9 cases 67-69
cmp ecx, ebx
mov eax, ebx
cmovl eax, ecx
cmp ecx, 0FFFFFFFFh
cmovz eax, ebx
jmp short loc_96DE4
loc_96DF8:
call ggml_get_unary_op; jumptable 0000000000096DD9 case 61
mov ecx, eax
mov eax, 1
cmp ecx, 7
jb short loc_96DE4
add ecx, 0FFFFFFF9h
mov eax, ebx
cmp ecx, 2
jbe short loc_96DE4
call ggml_get_n_tasks_cold_2
loc_96E18:
cmp ebx, 4; jumptable 0000000000096DD9 case 39
mov eax, 4
cmovl eax, ebx
mov rcx, [rdi+0A0h]
mov rdx, [rcx+20h]
imul rdx, [rcx+18h]
imul rdx, [rcx+28h]
cdqe
cmp rdx, rax
cmovle eax, edx
jmp short loc_96DE4
def_96DD9:
add rdi, 50h ; 'P'; jumptable 0000000000096DD9 default case
call ggml_get_n_tasks_cold_3
loc_96E4B:
call ggml_get_n_tasks_cold_1; jumptable 0000000000096DD9 case 72
| long long ggml_get_n_tasks(long long a1, unsigned int a2)
{
long long result; // rax
signed int v3; // ecx
unsigned int unary_op; // ecx
long long v5; // rdx
switch ( *(_DWORD *)(a1 + 80) )
{
case 0:
case 5:
case 8:
case 9:
case 0xA:
case 0xB:
case 0xC:
case 0xD:
case 0xE:
case 0xF:
case 0x10:
case 0x1A:
case 0x1B:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x2B:
case 0x2C:
case 0x30:
case 0x31:
case 0x35:
case 0x39:
case 0x3A:
case 0x3B:
case 0x3E:
case 0x3F:
case 0x40:
case 0x41:
case 0x42:
result = 1LL;
break;
case 1:
case 2:
case 3:
case 4:
case 6:
case 7:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1C:
case 0x25:
case 0x26:
case 0x28:
case 0x29:
case 0x2A:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x32:
case 0x33:
case 0x34:
case 0x36:
case 0x37:
case 0x38:
case 0x3C:
case 0x46:
case 0x47:
result = a2;
break;
case 0x27:
LODWORD(result) = 4;
if ( (int)a2 < 4 )
LODWORD(result) = a2;
v5 = *(_QWORD *)(*(_QWORD *)(a1 + 160) + 40LL)
* *(_QWORD *)(*(_QWORD *)(a1 + 160) + 24LL)
* *(_QWORD *)(*(_QWORD *)(a1 + 160) + 32LL);
result = (int)result;
if ( v5 <= (int)result )
result = (unsigned int)v5;
break;
case 0x3D:
unary_op = ggml_get_unary_op(a1);
result = 1LL;
if ( unary_op >= 7 )
{
result = a2;
if ( unary_op - 7 > 2 )
ggml_get_n_tasks_cold_2();
}
return result;
case 0x43:
case 0x44:
case 0x45:
v3 = *(_DWORD *)(a1 + 92);
result = a2;
if ( v3 < (int)a2 )
result = (unsigned int)v3;
if ( v3 == -1 )
result = a2;
break;
case 0x48:
ggml_get_n_tasks_cold_1();
default:
ggml_get_n_tasks_cold_3((unsigned int *)(a1 + 80));
}
return result;
}
| |||
35,280 | func_uni_ksc5601_onechar | eloqsql/strings/ctype-euc_kr.c | static int func_uni_ksc5601_onechar(int code){
if ((code>=0x00A1)&&(code<=0x0167))
return(tab_uni_ksc56010[code-0x00A1]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_ksc56011[code-0x02C7]);
if ((code>=0x2015)&&(code<=0x2312))
return(tab_uni_ksc56012[code-0x2015]);
if ((code>=0x2460)&&(code<=0x266D))
return(tab_uni_ksc56013[code-0x2460]);
if ((code>=0x3000)&&(code<=0x327F))
return(tab_uni_ksc56014[code-0x3000]);
if ((code>=0x3380)&&(code<=0x33DD))
return(tab_uni_ksc56015[code-0x3380]);
if ((code>=0x4E00)&&(code<=0x947F))
return(tab_uni_ksc56016[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9F9C))
return(tab_uni_ksc56017[code-0x9577]);
if ((code>=0xAC00)&&(code<=0xD7A3))
return(tab_uni_ksc56018[code-0xAC00]);
if ((code>=0xF900)&&(code<=0xFA0B))
return(tab_uni_ksc56019[code-0xF900]);
if ((code>=0xFF01)&&(code<=0xFFE6))
return(tab_uni_ksc560110[code-0xFF01]);
return(0);
} | O0 | c | func_uni_ksc5601_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa1, -0x8(%rbp)
jl 0x45417
cmpl $0x167, -0x8(%rbp) # imm = 0x167
jg 0x45417
movl -0x8(%rbp), %eax
subl $0xa1, %eax
movslq %eax, %rcx
leaq 0xabe05(%rip), %rax # 0xf1210
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x45447
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x45447
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0xabf65(%rip), %rax # 0xf13a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x2015, -0x8(%rbp) # imm = 0x2015
jl 0x45477
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x45477
movl -0x8(%rbp), %eax
subl $0x2015, %eax # imm = 0x2015
movslq %eax, %rcx
leaq 0xac255(%rip), %rax # 0xf16c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x454a7
cmpl $0x266d, -0x8(%rbp) # imm = 0x266D
jg 0x454a7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xac825(%rip), %rax # 0xf1cc0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x454d7
cmpl $0x327f, -0x8(%rbp) # imm = 0x327F
jg 0x454d7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xacc15(%rip), %rax # 0xf20e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x3380, -0x8(%rbp) # imm = 0x3380
jl 0x45507
cmpl $0x33dd, -0x8(%rbp) # imm = 0x33DD
jg 0x45507
movl -0x8(%rbp), %eax
subl $0x3380, %eax # imm = 0x3380
movslq %eax, %rcx
leaq 0xad0e5(%rip), %rax # 0xf25e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x45537
cmpl $0x947f, -0x8(%rbp) # imm = 0x947F
jg 0x45537
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xad175(%rip), %rax # 0xf26a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x45567
cmpl $0x9f9c, -0x8(%rbp) # imm = 0x9F9C
jg 0x45567
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0xb5e45(%rip), %rax # 0xfb3a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0xac00, -0x8(%rbp) # imm = 0xAC00
jl 0x45594
cmpl $0xd7a3, -0x8(%rbp) # imm = 0xD7A3
jg 0x45594
movl -0x8(%rbp), %eax
subl $0xac00, %eax # imm = 0xAC00
movslq %eax, %rcx
leaq 0xb7265(%rip), %rax # 0xfc7f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0xf900, -0x8(%rbp) # imm = 0xF900
jl 0x455c1
cmpl $0xfa0b, -0x8(%rbp) # imm = 0xFA0B
jg 0x455c1
movl -0x8(%rbp), %eax
subl $0xf900, %eax # imm = 0xF900
movslq %eax, %rcx
leaq 0xbc988(%rip), %rax # 0x101f40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
cmpl $0xff01, -0x8(%rbp) # imm = 0xFF01
jl 0x455ee
cmpl $0xffe6, -0x8(%rbp) # imm = 0xFFE6
jg 0x455ee
movl -0x8(%rbp), %eax
subl $0xff01, %eax # imm = 0xFF01
movslq %eax, %rcx
leaq 0xbcb7b(%rip), %rax # 0x102160
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x455f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_ksc5601_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A1h
jl short loc_45417
cmp [rbp+var_8], 167h
jg short loc_45417
mov eax, [rbp+var_8]
sub eax, 0A1h
movsxd rcx, eax
lea rax, tab_uni_ksc56010
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45417:
cmp [rbp+var_8], 2C7h
jl short loc_45447
cmp [rbp+var_8], 451h
jg short loc_45447
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_ksc56011
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45447:
cmp [rbp+var_8], 2015h
jl short loc_45477
cmp [rbp+var_8], 2312h
jg short loc_45477
mov eax, [rbp+var_8]
sub eax, 2015h
movsxd rcx, eax
lea rax, tab_uni_ksc56012
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45477:
cmp [rbp+var_8], 2460h
jl short loc_454A7
cmp [rbp+var_8], 266Dh
jg short loc_454A7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_ksc56013
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_454A7:
cmp [rbp+var_8], 3000h
jl short loc_454D7
cmp [rbp+var_8], 327Fh
jg short loc_454D7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_ksc56014
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_454D7:
cmp [rbp+var_8], 3380h
jl short loc_45507
cmp [rbp+var_8], 33DDh
jg short loc_45507
mov eax, [rbp+var_8]
sub eax, 3380h
movsxd rcx, eax
lea rax, tab_uni_ksc56015
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45507:
cmp [rbp+var_8], 4E00h
jl short loc_45537
cmp [rbp+var_8], 947Fh
jg short loc_45537
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_ksc56016
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45537:
cmp [rbp+var_8], 9577h
jl short loc_45567
cmp [rbp+var_8], 9F9Ch
jg short loc_45567
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_ksc56017
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_455F5
loc_45567:
cmp [rbp+var_8], 0AC00h
jl short loc_45594
cmp [rbp+var_8], 0D7A3h
jg short loc_45594
mov eax, [rbp+var_8]
sub eax, 0AC00h
movsxd rcx, eax
lea rax, tab_uni_ksc56018
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_455F5
loc_45594:
cmp [rbp+var_8], 0F900h
jl short loc_455C1
cmp [rbp+var_8], 0FA0Bh
jg short loc_455C1
mov eax, [rbp+var_8]
sub eax, 0F900h
movsxd rcx, eax
lea rax, tab_uni_ksc56019
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_455F5
loc_455C1:
cmp [rbp+var_8], 0FF01h
jl short loc_455EE
cmp [rbp+var_8], 0FFE6h
jg short loc_455EE
mov eax, [rbp+var_8]
sub eax, 0FF01h
movsxd rcx, eax
lea rax, tab_uni_ksc560110
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_455F5
loc_455EE:
mov [rbp+var_4], 0
loc_455F5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_ksc5601_onechar(int a1)
{
if ( a1 < 161 || a1 > 359 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8213 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9837 )
{
if ( a1 < 12288 || a1 > 12927 )
{
if ( a1 < 13184 || a1 > 13277 )
{
if ( a1 < 19968 || a1 > 38015 )
{
if ( a1 < 38263 || a1 > 40860 )
{
if ( a1 < 44032 || a1 > 55203 )
{
if ( a1 < 63744 || a1 > 64011 )
{
if ( a1 < 65281 || a1 > 65510 )
return 0;
else
return tab_uni_ksc560110[a1 - 65281];
}
else
{
return tab_uni_ksc56019[a1 - 63744];
}
}
else
{
return tab_uni_ksc56018[a1 - 44032];
}
}
else
{
return tab_uni_ksc56017[a1 - 38263];
}
}
else
{
return tab_uni_ksc56016[a1 - 19968];
}
}
else
{
return tab_uni_ksc56015[a1 - 13184];
}
}
else
{
return tab_uni_ksc56014[a1 - 12288];
}
}
else
{
return tab_uni_ksc56013[a1 - 9312];
}
}
else
{
return tab_uni_ksc56012[a1 - 8213];
}
}
else
{
return tab_uni_ksc56011[a1 - 711];
}
}
else
{
return tab_uni_ksc56010[a1 - 161];
}
}
| func_uni_ksc5601_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa1
JL 0x00145417
CMP dword ptr [RBP + -0x8],0x167
JG 0x00145417
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa1
MOVSXD RCX,EAX
LEA RAX,[0x1f1210]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145417:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x00145447
CMP dword ptr [RBP + -0x8],0x451
JG 0x00145447
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x1f13a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145447:
CMP dword ptr [RBP + -0x8],0x2015
JL 0x00145477
CMP dword ptr [RBP + -0x8],0x2312
JG 0x00145477
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2015
MOVSXD RCX,EAX
LEA RAX,[0x1f16c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145477:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x001454a7
CMP dword ptr [RBP + -0x8],0x266d
JG 0x001454a7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x1f1cc0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_001454a7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x001454d7
CMP dword ptr [RBP + -0x8],0x327f
JG 0x001454d7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x1f20e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_001454d7:
CMP dword ptr [RBP + -0x8],0x3380
JL 0x00145507
CMP dword ptr [RBP + -0x8],0x33dd
JG 0x00145507
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3380
MOVSXD RCX,EAX
LEA RAX,[0x1f25e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145507:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x00145537
CMP dword ptr [RBP + -0x8],0x947f
JG 0x00145537
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x1f26a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145537:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x00145567
CMP dword ptr [RBP + -0x8],0x9f9c
JG 0x00145567
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x1fb3a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145567:
CMP dword ptr [RBP + -0x8],0xac00
JL 0x00145594
CMP dword ptr [RBP + -0x8],0xd7a3
JG 0x00145594
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xac00
MOVSXD RCX,EAX
LEA RAX,[0x1fc7f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_00145594:
CMP dword ptr [RBP + -0x8],0xf900
JL 0x001455c1
CMP dword ptr [RBP + -0x8],0xfa0b
JG 0x001455c1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xf900
MOVSXD RCX,EAX
LEA RAX,[0x201f40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_001455c1:
CMP dword ptr [RBP + -0x8],0xff01
JL 0x001455ee
CMP dword ptr [RBP + -0x8],0xffe6
JG 0x001455ee
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xff01
MOVSXD RCX,EAX
LEA RAX,[0x202160]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001455f5
LAB_001455ee:
MOV dword ptr [RBP + -0x4],0x0
LAB_001455f5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_ksc5601_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa1) || (0x167 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2015) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x266d < param_1)) {
if ((param_1 < 0x3000) || (0x327f < param_1)) {
if ((param_1 < 0x3380) || (0x33dd < param_1)) {
if ((param_1 < 0x4e00) || (0x947f < param_1)) {
if ((param_1 < 0x9577) || (0x9f9c < param_1)) {
if ((param_1 < 0xac00) || (0xd7a3 < param_1)) {
if ((param_1 < 0xf900) || (0xfa0b < param_1)) {
if ((param_1 < 0xff01) || (0xffe6 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_ksc560110 + (long)(param_1 + -0xff01) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56019 + (long)(param_1 + -0xf900) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56018 + (long)(param_1 + -0xac00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56017 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56016 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56015 + (long)(param_1 + -0x3380) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56014 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56013 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56012 + (long)(param_1 + -0x2015) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56011 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56010 + (long)(param_1 + -0xa1) * 2);
}
return uVar1;
}
| |
35,281 | minja::Parser::parseLogicalOr() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseLogicalOr() {
auto left = parseLogicalAnd();
if (!left) throw std::runtime_error("Expected left side of 'logical or' expression");
static std::regex or_tok(R"(or\b)");
auto location = get_location();
while (!consumeToken(or_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'or' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::Or);
}
return left;
} | O1 | cpp | minja::Parser::parseLogicalOr():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x866aa
cmpq $0x0, (%rbx)
je 0x86385
leaq 0xa9dbe(%rip), %rax # 0x12ffd8
movb (%rax), %al
testb %al, %al
je 0x863b7
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x8624f
movq 0xa8d47(%rip), %rcx # 0x12ef88
cmpb $0x0, (%rcx)
je 0x8624b
incl 0x8(%rax)
jmp 0x8624f
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %rsp, %r13
leaq 0xa771e(%rip), %r12 # 0x12d988
addq $0x10, %r12
movq %r13, %rdi
movq %r14, %rsi
leaq 0xa9d3d(%rip), %rdx # 0x12ffb8
movl $0x1, %ecx
callq 0x85094
movq (%rsp), %rdi
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x862a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b900
testq %r15, %r15
je 0x86330
movq %r13, %rdi
movq %r14, %rsi
callq 0x866aa
cmpq $0x0, (%rsp)
je 0x86351
movl $0x58, %edi
callq 0x1b8d0
movq %rax, %rbp
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbp)
movq %r12, (%rbp)
movq %rbp, %r15
addq $0x10, %r15
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl $0xf, %r8d
callq 0x972d2
movq %r15, (%rbx)
movq 0x8(%rbx), %rdi
movq %rbp, 0x8(%rbx)
testq %rdi, %rdi
je 0x86318
callq 0x6e160
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8626e
callq 0x6e160
jmp 0x8626e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8633f
callq 0x6e160
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b460
movq %rax, %r15
leaq 0x6c959(%rip), %rsi # 0xf2cbe
movq %rax, %rdi
callq 0x1b330
movq 0xa8c7c(%rip), %rsi # 0x12eff0
movq 0xa8be5(%rip), %rdx # 0x12ef60
movq %r15, %rdi
callq 0x1bf40
jmp 0x863b7
movl $0x10, %edi
callq 0x1b460
movq %rax, %r15
leaq 0x6c8f2(%rip), %rsi # 0xf2c8b
movq %rax, %rdi
callq 0x1b330
movq 0xa8c48(%rip), %rsi # 0x12eff0
movq 0xa8bb1(%rip), %rdx # 0x12ef60
movq %r15, %rdi
callq 0x1bf40
leaq 0xa9c1a(%rip), %rdi # 0x12ffd8
callq 0x1c030
testl %eax, %eax
je 0x86224
leaq 0xa9be6(%rip), %rdi # 0x12ffb8
leaq 0x6c8e0(%rip), %rsi # 0xf2cb9
movl $0x10, %edx
callq 0x63190
leaq -0x22f52(%rip), %rdi # 0x63498
leaq 0xa9bc7(%rip), %rsi # 0x12ffb8
leaq 0xa94f0(%rip), %rdx # 0x12f8e8
callq 0x1b7c0
leaq 0xa9bd4(%rip), %rdi # 0x12ffd8
callq 0x1b5d0
jmp 0x86224
movq %rax, %r14
leaq 0xa9bc0(%rip), %rdi # 0x12ffd8
callq 0x1b5c0
jmp 0x86468
movq %rax, %r14
jmp 0x86468
movq %rax, %r14
movq %r15, %rdi
callq 0x1b690
jmp 0x86468
jmp 0x86442
movq %rax, %r14
movq %r15, %rdi
callq 0x1b690
jmp 0x86445
jmp 0x86456
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x86459
callq 0x6e160
jmp 0x86459
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x86468
callq 0x6e160
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x86476
callq 0x6e160
movq %r14, %rdi
callq 0x1bfd0
| _ZN5minja6Parser14parseLogicalOrEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp qword ptr [rbx], 0
jz loc_86385
lea rax, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; `guard variable for'minja::Parser::parseLogicalOr(void)::or_tok
mov al, [rax]
test al, al
jz loc_863B7
loc_86224:
mov rax, [r14]
mov [rsp+68h+var_48], rax
mov rax, [r14+8]
mov [rsp+68h+var_40], rax
test rax, rax
jz short loc_8624F
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_8624B
inc dword ptr [rax+8]
jmp short loc_8624F
loc_8624B:
lock inc dword ptr [rax+8]
loc_8624F:
mov rax, [r14+20h]
sub rax, [r14+10h]
lea rcx, [rsp+68h+var_48]
mov [rcx+10h], rax
mov r13, rsp
lea r12, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja12BinaryOpExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
add r12, 10h
loc_8626E:
mov rdi, r13
mov rsi, r14
lea rdx, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rdi, [rsp+68h+var_68]; void *
mov r15, [rsp+68h+var_60]
lea rax, [rsp+68h+var_58]
cmp rdi, rax
jz short loc_862A5
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_862A5:
test r15, r15
jz loc_86330
mov rdi, r13; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+68h+var_68], 0
jz loc_86351
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbp, rax
mov rax, 100000001h
mov [rbp+8], rax
mov [rbp+0], r12
mov r15, rbp
add r15, 10h
mov rdi, r15
lea rsi, [rsp+68h+var_48]
mov rdx, rbx
mov rcx, r13
mov r8d, 0Fh
call _ZN5minja12BinaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_NS0_2OpE; minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,minja::BinaryOpExpr::Op)
mov [rbx], r15
mov rdi, [rbx+8]
mov [rbx+8], rbp
test rdi, rdi
jz short loc_86318
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_86318:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz loc_8626E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp loc_8626E
loc_86330:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_8633F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_8633F:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_86351:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS; "Expected right side of 'or' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_863B7
loc_86385:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi; "Expected left side of 'logical or' expr"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_863B7:
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_86224
lea rdi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rsi, aOrB; "or\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_86224
mov r14, rax
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_86468
mov r14, rax
jmp short loc_86468
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_86468
jmp short loc_86442
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_86445
jmp short loc_86456
loc_86442:
mov r14, rax
loc_86445:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_86459
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_86459
loc_86456:
mov r14, rax
loc_86459:
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_86468
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_86468:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_86476
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_86476:
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseLogicalOr(volatile signed __int32 **this, long long *a2)
{
volatile signed __int32 *v3; // rax
volatile signed __int32 *v4; // r15
volatile signed __int32 *v5; // rbp
volatile signed __int32 *v6; // rdi
std::runtime_error *v8; // r15
std::runtime_error *exception; // r15
void *v10; // [rsp+0h] [rbp-68h] BYREF
volatile signed __int32 *v11; // [rsp+8h] [rbp-60h]
long long v12; // [rsp+10h] [rbp-58h] BYREF
long long v13; // [rsp+20h] [rbp-48h] BYREF
volatile signed __int32 *v14; // [rsp+28h] [rbp-40h]
long long v15; // [rsp+30h] [rbp-38h]
minja::Parser::parseLogicalAnd((minja::Parser *)this);
if ( !*this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical or' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
(long long)"or\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]);
}
v13 = *a2;
v3 = (volatile signed __int32 *)a2[1];
v14 = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v3 + 2);
else
_InterlockedIncrement(v3 + 2);
}
v15 = a2[4] - a2[2];
while ( 1 )
{
minja::Parser::consumeToken(
(long long)&v10,
(long long)a2,
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
1u);
v4 = v11;
if ( v10 != &v12 )
operator delete(v10, v12 + 1);
if ( !v4 )
break;
minja::Parser::parseLogicalAnd((minja::Parser *)&v10);
if ( !v10 )
{
v8 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v8, "Expected right side of 'or' expression");
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v5 = (volatile signed __int32 *)operator new(0x58uLL);
*((_QWORD *)v5 + 1) = 0x100000001LL;
*(_QWORD *)v5 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<minja::BinaryOpExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
minja::BinaryOpExpr::BinaryOpExpr(v5 + 4, &v13, this, &v10, 15LL);
*this = v5 + 4;
v6 = this[1];
this[1] = v5;
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
}
if ( v14 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v14);
return (minja::Parser *)this;
}
| parseLogicalOr:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
CALL 0x001866aa
CMP qword ptr [RBX],0x0
JZ 0x00186385
LEA RAX,[0x22ffd8]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001863b7
LAB_00186224:
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JZ 0x0018624f
MOV RCX,qword ptr [0x0022ef88]
CMP byte ptr [RCX],0x0
JZ 0x0018624b
INC dword ptr [RAX + 0x8]
JMP 0x0018624f
LAB_0018624b:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0018624f:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
LEA RCX,[RSP + 0x20]
MOV qword ptr [RCX + 0x10],RAX
MOV R13,RSP
LEA R12,[0x22d988]
ADD R12,0x10
LAB_0018626e:
MOV RDI,R13
MOV RSI,R14
LEA RDX,[0x22ffb8]
MOV ECX,0x1
CALL 0x00185094
MOV RDI,qword ptr [RSP]
MOV R15,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001862a5
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b900
LAB_001862a5:
TEST R15,R15
JZ 0x00186330
LAB_001862ae:
MOV RDI,R13
MOV RSI,R14
CALL 0x001866aa
CMP qword ptr [RSP],0x0
JZ 0x00186351
LAB_001862c4:
MOV EDI,0x58
CALL 0x0011b8d0
LAB_001862ce:
MOV RBP,RAX
MOV RAX,0x100000001
MOV qword ptr [RBP + 0x8],RAX
MOV qword ptr [RBP],R12
MOV R15,RBP
ADD R15,0x10
MOV RDI,R15
LEA RSI,[RSP + 0x20]
MOV RDX,RBX
MOV RCX,R13
MOV R8D,0xf
CALL 0x001972d2
MOV qword ptr [RBX],R15
MOV RDI,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x8],RBP
TEST RDI,RDI
JZ 0x00186318
CALL 0x0016e160
LAB_00186318:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0018626e
CALL 0x0016e160
JMP 0x0018626e
LAB_00186330:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0018633f
CALL 0x0016e160
LAB_0018633f:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00186351:
MOV EDI,0x10
CALL 0x0011b460
MOV R15,RAX
LAB_0018635e:
LEA RSI,[0x1f2cbe]
MOV RDI,RAX
CALL 0x0011b330
LAB_0018636d:
MOV RSI,qword ptr [0x0022eff0]
MOV RDX,qword ptr [0x0022ef60]
MOV RDI,R15
CALL 0x0011bf40
LAB_00186385:
MOV EDI,0x10
CALL 0x0011b460
MOV R15,RAX
LAB_00186392:
LEA RSI,[0x1f2c8b]
MOV RDI,RAX
CALL 0x0011b330
LAB_001863a1:
MOV RSI,qword ptr [0x0022eff0]
MOV RDX,qword ptr [0x0022ef60]
MOV RDI,R15
CALL 0x0011bf40
LAB_001863b7:
LEA RDI,[0x22ffd8]
CALL 0x0011c030
TEST EAX,EAX
JZ 0x00186224
LAB_001863cb:
LEA RDI,[0x22ffb8]
LEA RSI,[0x1f2cb9]
MOV EDX,0x10
CALL 0x00163190
LAB_001863e3:
LEA RDI,[0x163498]
LEA RSI,[0x22ffb8]
LEA RDX,[0x22f8e8]
CALL 0x0011b7c0
LEA RDI,[0x22ffd8]
CALL 0x0011b5d0
JMP 0x00186224
|
/* minja::Parser::parseLogicalOr() */
void minja::Parser::parseLogicalOr(void)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
int iVar2;
int8 *puVar3;
runtime_error *prVar4;
int8 *in_RSI;
long *in_RDI;
long *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
long local_58 [2];
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
long local_38;
parseLogicalAnd();
if (*in_RDI == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00186392 to 001863a0 has its CatchHandler @ 00186424 */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'logical or\' expression");
/* try { // try from 001863a1 to 001863b6 has its CatchHandler @ 0018641f */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_0022eff0,PTR__runtime_error_0022ef60);
}
if (parseLogicalOr()::or_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseLogicalOr()::or_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 001863cb to 001863e2 has its CatchHandler @ 0018640e */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseLogicalOr()::or_tok_abi_cxx11_,&DAT_001f2cb9,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalOr()::or_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalOr()::or_tok_abi_cxx11_);
}
}
local_48 = *in_RSI;
local_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0022ef88 == '\0') {
LOCK();
*(int *)(local_40 + 8) = *(int *)(local_40 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_40 + 8) = *(int *)(local_40 + 8) + 1;
}
}
local_38 = in_RSI[4] - in_RSI[2];
while( true ) {
/* try { // try from 0018626e to 00186284 has its CatchHandler @ 00186456 */
consumeToken(&local_68);
p_Var1 = local_60;
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (p_Var1 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) break;
/* try { // try from 001862ae to 001862b8 has its CatchHandler @ 00186440 */
parseLogicalAnd();
if (local_68 == (long *)0x0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018635e to 0018636c has its CatchHandler @ 00186433 */
std::runtime_error::runtime_error(prVar4,"Expected right side of \'or\' expression");
/* try { // try from 0018636d to 00186382 has its CatchHandler @ 00186431 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_0022eff0,PTR__runtime_error_0022ef60);
}
/* try { // try from 001862c4 to 001862cd has its CatchHandler @ 00186442 */
puVar3 = (int8 *)operator_new(0x58);
puVar3[1] = 0x100000001;
*puVar3 = &PTR___Sp_counted_ptr_inplace_0022d998;
BinaryOpExpr::BinaryOpExpr((BinaryOpExpr *)(puVar3 + 2),&local_48);
*in_RDI = (long)(puVar3 + 2);
p_Var1 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RDI[1];
in_RDI[1] = (long)puVar3;
if (p_Var1 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var1);
}
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_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
return;
}
| |
35,282 | llama_model_meta_key_by_index | monkey531[P]llama/src/llama-model.cpp | int32_t llama_model_meta_key_by_index(const struct llama_model * model, int i, char * buf, size_t buf_size) {
if (i < 0 || i >= (int)model->gguf_kv.size()) {
if (buf_size > 0) {
buf[0] = '\0';
}
return -1;
}
auto it = model->gguf_kv.begin();
std::advance(it, i);
return snprintf(buf, buf_size, "%s", it->first.c_str());
} | O1 | cpp | llama_model_meta_key_by_index:
testl %esi, %esi
js 0xd826f
cmpl %esi, 0x1a18(%rdi)
jle 0xd826f
movq 0x1a10(%rdi), %rax
testl %esi, %esi
je 0xd8251
movl %esi, %esi
movq (%rax), %rax
decq %rsi
jne 0xd8249
movq 0x8(%rax), %rax
leaq 0x41ed3(%rip), %r8 # 0x11a12f
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %rax, %rcx
xorl %eax, %eax
jmp 0x6b950
testq %rcx, %rcx
je 0xd8277
movb $0x0, (%rdx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
| llama_model_meta_key_by_index:
test esi, esi
js short loc_D826F
cmp [rdi+1A18h], esi
jle short loc_D826F
mov rax, [rdi+1A10h]
test esi, esi
jz short loc_D8251
mov esi, esi
loc_D8249:
mov rax, [rax]
dec rsi
jnz short loc_D8249
loc_D8251:
mov rax, [rax+8]
lea r8, aWarningFailedT+52h; "%s"
mov rdi, rdx
mov rsi, rcx
mov rdx, r8
mov rcx, rax
xor eax, eax
jmp _snprintf
loc_D826F:
test rcx, rcx
jz short loc_D8277
mov byte ptr [rdx], 0
loc_D8277:
mov eax, 0FFFFFFFFh
retn
| long long llama_model_meta_key_by_index(long long a1, long long a2, _BYTE *a3, long long a4)
{
long long **v4; // rax
if ( (int)a2 < 0 || *(_DWORD *)(a1 + 6680) <= (int)a2 )
{
if ( a4 )
*a3 = 0;
return 0xFFFFFFFFLL;
}
else
{
v4 = *(long long ***)(a1 + 6672);
if ( (_DWORD)a2 )
{
a2 = (unsigned int)a2;
do
{
v4 = (long long **)*v4;
--a2;
}
while ( a2 );
}
return snprintf(a3, a4, "%s", (const char *)v4[1]);
}
}
| llama_model_meta_key_by_index:
TEST ESI,ESI
JS 0x001d826f
CMP dword ptr [RDI + 0x1a18],ESI
JLE 0x001d826f
MOV RAX,qword ptr [RDI + 0x1a10]
TEST ESI,ESI
JZ 0x001d8251
MOV ESI,ESI
LAB_001d8249:
MOV RAX,qword ptr [RAX]
DEC RSI
JNZ 0x001d8249
LAB_001d8251:
MOV RAX,qword ptr [RAX + 0x8]
LEA R8,[0x21a12f]
MOV RDI,RDX
MOV RSI,RCX
MOV RDX,R8
MOV RCX,RAX
XOR EAX,EAX
JMP 0x0016b950
LAB_001d826f:
TEST RCX,RCX
JZ 0x001d8277
MOV byte ptr [RDX],0x0
LAB_001d8277:
MOV EAX,0xffffffff
RET
|
int llama_model_meta_key_by_index(long param_1,uint param_2,char *param_3,size_t param_4)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
if ((-1 < (int)param_2) && ((int)param_2 < *(int *)(param_1 + 0x1a18))) {
puVar2 = *(int8 **)(param_1 + 0x1a10);
if (param_2 != 0) {
uVar3 = (ulong)param_2;
do {
puVar2 = (int8 *)*puVar2;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
}
iVar1 = snprintf(param_3,param_4,"%s",puVar2[1]);
return iVar1;
}
if (param_4 != 0) {
*param_3 = '\0';
}
return -1;
}
| |
35,283 | llama_model_meta_key_by_index | monkey531[P]llama/src/llama-model.cpp | int32_t llama_model_meta_key_by_index(const struct llama_model * model, int i, char * buf, size_t buf_size) {
if (i < 0 || i >= (int)model->gguf_kv.size()) {
if (buf_size > 0) {
buf[0] = '\0';
}
return -1;
}
auto it = model->gguf_kv.begin();
std::advance(it, i);
return snprintf(buf, buf_size, "%s", it->first.c_str());
} | O3 | cpp | llama_model_meta_key_by_index:
testl %esi, %esi
js 0xd4585
cmpl %esi, 0x1a18(%rdi)
jle 0xd4585
movq 0x1a10(%rdi), %rax
testl %esi, %esi
je 0xd4567
movl %esi, %esi
movq (%rax), %rax
decq %rsi
jne 0xd455f
movq 0x8(%rax), %rax
leaq 0x41bb0(%rip), %r8 # 0x116122
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %rax, %rcx
xorl %eax, %eax
jmp 0x6a8e0
testq %rcx, %rcx
je 0xd458d
movb $0x0, (%rdx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
| llama_model_meta_key_by_index:
test esi, esi
js short loc_D4585
cmp [rdi+1A18h], esi
jle short loc_D4585
mov rax, [rdi+1A10h]
test esi, esi
jz short loc_D4567
mov esi, esi
loc_D455F:
mov rax, [rax]
dec rsi
jnz short loc_D455F
loc_D4567:
mov rax, [rax+8]
lea r8, aWarningFailedT+52h; "%s"
mov rdi, rdx
mov rsi, rcx
mov rdx, r8
mov rcx, rax
xor eax, eax
jmp _snprintf
loc_D4585:
test rcx, rcx
jz short loc_D458D
mov byte ptr [rdx], 0
loc_D458D:
mov eax, 0FFFFFFFFh
retn
| long long llama_model_meta_key_by_index(long long a1, long long a2, _BYTE *a3, long long a4)
{
long long **v4; // rax
if ( (int)a2 < 0 || *(_DWORD *)(a1 + 6680) <= (int)a2 )
{
if ( a4 )
*a3 = 0;
return 0xFFFFFFFFLL;
}
else
{
v4 = *(long long ***)(a1 + 6672);
if ( (_DWORD)a2 )
{
a2 = (unsigned int)a2;
do
{
v4 = (long long **)*v4;
--a2;
}
while ( a2 );
}
return snprintf(a3, a4, "%s", (const char *)v4[1]);
}
}
| llama_model_meta_key_by_index:
TEST ESI,ESI
JS 0x001d4585
CMP dword ptr [RDI + 0x1a18],ESI
JLE 0x001d4585
MOV RAX,qword ptr [RDI + 0x1a10]
TEST ESI,ESI
JZ 0x001d4567
MOV ESI,ESI
LAB_001d455f:
MOV RAX,qword ptr [RAX]
DEC RSI
JNZ 0x001d455f
LAB_001d4567:
MOV RAX,qword ptr [RAX + 0x8]
LEA R8,[0x216122]
MOV RDI,RDX
MOV RSI,RCX
MOV RDX,R8
MOV RCX,RAX
XOR EAX,EAX
JMP 0x0016a8e0
LAB_001d4585:
TEST RCX,RCX
JZ 0x001d458d
MOV byte ptr [RDX],0x0
LAB_001d458d:
MOV EAX,0xffffffff
RET
|
int llama_model_meta_key_by_index(long param_1,uint param_2,char *param_3,size_t param_4)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
if ((-1 < (int)param_2) && ((int)param_2 < *(int *)(param_1 + 0x1a18))) {
puVar2 = *(int8 **)(param_1 + 0x1a10);
if (param_2 != 0) {
uVar3 = (ulong)param_2;
do {
puVar2 = (int8 *)*puVar2;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
}
iVar1 = snprintf(param_3,param_4,"%s",puVar2[1]);
return iVar1;
}
if (param_4 != 0) {
*param_3 = '\0';
}
return -1;
}
| |
35,284 | trnman_get_max_trid | eloqsql/storage/maria/trnman.c | TrID trnman_get_max_trid()
{
TrID id;
/* Check if trnman has been initalized */
if (short_trid_to_active_trn == NULL)
return 0;
mysql_mutex_lock(&LOCK_trn_list);
id= global_trid_generator;
mysql_mutex_unlock(&LOCK_trn_list);
return id;
} | O0 | c | trnman_get_max_trid:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x446300(%rip) # 0x4da1c0
jne 0x93ecc
movq $0x0, -0x8(%rbp)
jmp 0x93f03
leaq 0x44669d(%rip), %rdi # 0x4da570
leaq 0xf7e18(%rip), %rsi # 0x18bcf2
movl $0x38c, %edx # imm = 0x38C
callq 0x92f00
movq 0x4465b5(%rip), %rax # 0x4da4a0
movq %rax, -0x10(%rbp)
leaq 0x44667a(%rip), %rdi # 0x4da570
callq 0x92f70
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| trnman_get_max_trid:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:short_trid_to_active_trn, 0
jnz short loc_93ECC
mov [rbp+var_8], 0
jmp short loc_93F03
loc_93ECC:
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 38Ch
call inline_mysql_mutex_lock_12
mov rax, cs:global_trid_generator
mov [rbp+var_10], rax
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_13
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_93F03:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long trnman_get_max_trid()
{
long long v1; // [rsp+0h] [rbp-10h]
if ( !short_trid_to_active_trn )
return 0LL;
inline_mysql_mutex_lock_12(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x38Cu);
v1 = global_trid_generator;
inline_mysql_mutex_unlock_13((long long)&LOCK_trn_list);
return v1;
}
| trnman_get_max_trid:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP qword ptr [0x005da1c0],0x0
JNZ 0x00193ecc
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00193f03
LAB_00193ecc:
LEA RDI,[0x5da570]
LEA RSI,[0x28bcf2]
MOV EDX,0x38c
CALL 0x00192f00
MOV RAX,qword ptr [0x005da4a0]
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[0x5da570]
CALL 0x00192f70
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00193f03:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 trnman_get_max_trid(void)
{
int8 local_10;
if (short_trid_to_active_trn == 0) {
local_10 = 0;
}
else {
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x38c
);
local_10 = global_trid_generator;
inline_mysql_mutex_unlock(LOCK_trn_list);
}
return local_10;
}
| |
35,285 | TerminalSupportsColor() | ng-log[P]ng-log/src/logging.cc | static bool TerminalSupportsColor() {
bool term_supports_color = false;
#ifdef NGLOG_OS_WINDOWS
// on Windows TERM variable is usually not set, but the console does
// support colors.
term_supports_color = true;
#else
// On non-Windows platforms, we rely on the TERM variable.
const char* const term = getenv("TERM");
if (term != nullptr && term[0] != '\0') {
term_supports_color =
!strcmp(term, "xterm") || !strcmp(term, "xterm-color") ||
!strcmp(term, "xterm-256color") || !strcmp(term, "screen-256color") ||
!strcmp(term, "konsole") || !strcmp(term, "konsole-16color") ||
!strcmp(term, "konsole-256color") || !strcmp(term, "screen") ||
!strcmp(term, "linux") || !strcmp(term, "cygwin");
}
#endif
return term_supports_color;
} | O0 | cpp | TerminalSupportsColor():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x1(%rbp)
leaq 0x3ff1f(%rip), %rdi # 0x53112
callq 0x9900
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1334a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1334a
movq -0x10(%rbp), %rdi
leaq 0x3ea18(%rip), %rsi # 0x51c3a
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9fe(%rip), %rsi # 0x51c40
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9ea(%rip), %rsi # 0x51c4c
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9d9(%rip), %rsi # 0x51c5b
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9c9(%rip), %rsi # 0x51c6b
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9b1(%rip), %rsi # 0x51c73
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e9a5(%rip), %rsi # 0x51c83
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e99a(%rip), %rsi # 0x51c94
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e985(%rip), %rsi # 0x51c9b
callq 0x9a70
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x13342
movq -0x10(%rbp), %rdi
leaq 0x3e96f(%rip), %rsi # 0x51ca1
callq 0x9a70
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL21TerminalSupportsColorv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_1], 0
lea rdi, aSigterm+3; "TERM"
call _getenv
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz loc_1334A
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz loc_1334A
mov rdi, [rbp+var_10]
lea rsi, aXterm; "xterm"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz loc_13342
mov rdi, [rbp+var_10]
lea rsi, aXtermColor; "xterm-color"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz loc_13342
mov rdi, [rbp+var_10]
lea rsi, aXterm256color; "xterm-256color"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz loc_13342
mov rdi, [rbp+var_10]
lea rsi, aScreen256color; "screen-256color"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz loc_13342
mov rdi, [rbp+var_10]
lea rsi, aKonsole; "konsole"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz loc_13342
mov rdi, [rbp+var_10]
lea rsi, aKonsole16color; "konsole-16color"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_13342
mov rdi, [rbp+var_10]
lea rsi, aKonsole256colo; "konsole-256color"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_13342
mov rdi, [rbp+var_10]
lea rsi, aScreen; "screen"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_13342
mov rdi, [rbp+var_10]
lea rsi, aLinux; "linux"
call _strcmp
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_13342
mov rdi, [rbp+var_10]
lea rsi, aCygwin; "cygwin"
call _strcmp
cmp eax, 0
setnz al
xor al, 0FFh
mov [rbp+var_11], al
loc_13342:
mov al, [rbp+var_11]
and al, 1
mov [rbp+var_1], al
loc_1334A:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char TerminalSupportsColor(void)
{
char v1; // [rsp+Fh] [rbp-11h]
_BYTE *v2; // [rsp+10h] [rbp-10h]
char v3; // [rsp+1Fh] [rbp-1h]
v3 = 0;
v2 = (_BYTE *)getenv("TERM");
if ( v2 && *v2 )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "xterm") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "xterm-color") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "xterm-256color") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "screen-256color") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "konsole") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "konsole-16color") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "konsole-256color") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "screen") )
{
v1 = 1;
if ( (unsigned int)strcmp(v2, "linux") )
v1 = ~((unsigned int)strcmp(v2, "cygwin") != 0);
}
}
}
}
}
}
}
}
return v1 & 1;
}
return v3;
}
| TerminalSupportsColor:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV byte ptr [RBP + -0x1],0x0
LEA RDI,[0x153112]
CALL 0x00109900
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0011334a
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0011334a
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c3a]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c40]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c4c]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c5b]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c6b]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c73]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c83]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c94]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151c9b]
CALL 0x00109a70
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x00113342
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x151ca1]
CALL 0x00109a70
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x11],AL
LAB_00113342:
MOV AL,byte ptr [RBP + -0x11]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_0011334a:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* TerminalSupportsColor() */
byte TerminalSupportsColor(void)
{
int iVar1;
char *__s1;
byte local_19;
byte local_9;
local_9 = 0;
__s1 = getenv("TERM");
if ((__s1 != (char *)0x0) && (*__s1 != '\0')) {
iVar1 = strcmp(__s1,"xterm");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"xterm-color");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"xterm-256color");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"screen-256color");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"konsole");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"konsole-16color");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"konsole-256color");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"screen");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"linux");
local_19 = 1;
if (iVar1 != 0) {
iVar1 = strcmp(__s1,"cygwin");
local_19 = iVar1 != 0 ^ 0xff;
}
}
}
}
}
}
}
}
}
local_9 = local_19 & 1;
}
return local_9;
}
| |
35,286 | common_embd_similarity_cos(float const*, float const*, int) | monkey531[P]llama/common/common.cpp | float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
} | O1 | cpp | common_embd_similarity_cos(float const*, float const*, int):
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x78ae3
movl %edx, %eax
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm2
movss (%rsi,%rcx,4), %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
cvtss2sd %xmm4, %xmm4
unpcklps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm2, %xmm2
cvtps2pd %xmm2, %xmm2
addsd %xmm4, %xmm5
addpd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x78ab3
jmp 0x78aeb
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
subq $0x28, %rsp
ucomisd %xmm1, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2 # xmm2 = xmm2[1],xmm0[1]
jne 0x78aff
jnp 0x78b20
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x78b0b
jnp 0x78b20
ucomisd %xmm1, %xmm0
movsd %xmm5, 0x8(%rsp)
jb 0x78b4a
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x78b5f
xorpd %xmm1, %xmm1
cmpeqpd %xmm1, %xmm2
cmpeqpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
jne 0x78b40
xorpd %xmm0, %xmm0
jmp 0x78b9c
movss 0x705c8(%rip), %xmm0 # 0xe9110
jmp 0x78b9c
movapd %xmm2, 0x10(%rsp)
callq 0x1b720
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x78b72
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x78b87
movapd %xmm2, %xmm0
movsd %xmm3, 0x10(%rsp)
callq 0x1b720
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm3
divsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x28, %rsp
retq
nop
| _Z26common_embd_similarity_cosPKfS0_i:
xorpd xmm1, xmm1
test edx, edx
jle short loc_78AE3
mov eax, edx
xorpd xmm0, xmm0
xorpd xmm5, xmm5
xor ecx, ecx
loc_78AB3:
movss xmm2, dword ptr [rdi+rcx*4]
movss xmm3, dword ptr [rsi+rcx*4]
movaps xmm4, xmm2
mulss xmm4, xmm3
cvtss2sd xmm4, xmm4
unpcklps xmm2, xmm3
mulps xmm2, xmm2
cvtps2pd xmm2, xmm2
addsd xmm5, xmm4
addpd xmm0, xmm2
inc rcx
cmp rax, rcx
jnz short loc_78AB3
jmp short loc_78AEB
loc_78AE3:
xorpd xmm0, xmm0
xorpd xmm5, xmm5
loc_78AEB:
sub rsp, 28h
ucomisd xmm0, xmm1
movapd xmm2, xmm0
unpckhpd xmm2, xmm0
jnz short loc_78AFF
jnp short loc_78B20
loc_78AFF:
xorpd xmm1, xmm1
ucomisd xmm2, xmm1
jnz short loc_78B0B
jnp short loc_78B20
loc_78B0B:
ucomisd xmm0, xmm1
movsd [rsp+28h+var_20], xmm5
jb short loc_78B4A
xorps xmm3, xmm3
sqrtsd xmm3, xmm0
jmp short loc_78B5F
loc_78B20:
xorpd xmm1, xmm1
cmpeqpd xmm2, xmm1
cmpeqpd xmm1, xmm0
andpd xmm1, xmm2
movd eax, xmm1
test al, 1
jnz short loc_78B40
xorpd xmm0, xmm0
jmp short loc_78B9C
loc_78B40:
movss xmm0, cs:dword_E9110
jmp short loc_78B9C
loc_78B4A:
movapd [rsp+28h+var_18], xmm2
call _sqrt
movapd xmm2, [rsp+28h+var_18]
movapd xmm3, xmm0
loc_78B5F:
xorpd xmm0, xmm0
ucomisd xmm2, xmm0
jb short loc_78B72
xorps xmm0, xmm0
sqrtsd xmm0, xmm2
jmp short loc_78B87
loc_78B72:
movapd xmm0, xmm2
movsd qword ptr [rsp+28h+var_18], xmm3
call _sqrt
movsd xmm3, qword ptr [rsp+28h+var_18]
loc_78B87:
movsd xmm1, [rsp+28h+var_20]
mulsd xmm3, xmm0
divsd xmm1, xmm3
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm1
loc_78B9C:
add rsp, 28h
retn
| float common_embd_similarity_cos(const float *a1, const float *a2, int a3)
{
__m128d v3; // xmm0
double v4; // xmm5_8
long long i; // rcx
__m128 v6; // xmm3
__m128 v7; // xmm2
__m128d v8; // xmm2
double v9; // xmm3_8
double v11; // xmm0_8
double v12; // [rsp+0h] [rbp-20h]
if ( a3 <= 0 )
{
v3 = 0LL;
v4 = 0.0;
}
else
{
v3 = 0LL;
v4 = 0.0;
for ( i = 0LL; i != a3; ++i )
{
v6 = (__m128)LODWORD(a2[i]);
v7 = _mm_unpacklo_ps((__m128)LODWORD(a1[i]), v6);
v4 = v4 + (float)(a1[i] * v6.m128_f32[0]);
v3 = _mm_add_pd(v3, _mm_cvtps_pd(_mm_mul_ps(v7, v7)));
}
}
v8 = _mm_unpackhi_pd(v3, v3);
if ( v3.m128d_f64[0] == 0.0 || v8.m128d_f64[0] == 0.0 )
{
if ( (_mm_cvtsi128_si32((__m128i)_mm_and_pd(_mm_cmpeq_pd((__m128d)0LL, v3), _mm_cmpeq_pd(v8, (__m128d)0LL))) & 1) != 0 )
return 1.0;
else
return 0.0;
}
else
{
v12 = v4;
if ( v3.m128d_f64[0] < 0.0 )
v9 = sqrt(v3.m128d_f64[0]);
else
v9 = sqrt(v3.m128d_f64[0]);
if ( v8.m128d_f64[0] < 0.0 )
v11 = sqrt(v8.m128d_f64[0]);
else
v11 = sqrt(v8.m128d_f64[0]);
return v12 / (v9 * v11);
}
}
| common_embd_similarity_cos:
XORPD XMM1,XMM1
TEST EDX,EDX
JLE 0x00178ae3
MOV EAX,EDX
XORPD XMM0,XMM0
XORPD XMM5,XMM5
XOR ECX,ECX
LAB_00178ab3:
MOVSS XMM2,dword ptr [RDI + RCX*0x4]
MOVSS XMM3,dword ptr [RSI + RCX*0x4]
MOVAPS XMM4,XMM2
MULSS XMM4,XMM3
CVTSS2SD XMM4,XMM4
UNPCKLPS XMM2,XMM3
MULPS XMM2,XMM2
CVTPS2PD XMM2,XMM2
ADDSD XMM5,XMM4
ADDPD XMM0,XMM2
INC RCX
CMP RAX,RCX
JNZ 0x00178ab3
JMP 0x00178aeb
LAB_00178ae3:
XORPD XMM0,XMM0
XORPD XMM5,XMM5
LAB_00178aeb:
SUB RSP,0x28
UCOMISD XMM0,XMM1
MOVAPD XMM2,XMM0
UNPCKHPD XMM2,XMM0
JNZ 0x00178aff
JNP 0x00178b20
LAB_00178aff:
XORPD XMM1,XMM1
UCOMISD XMM2,XMM1
JNZ 0x00178b0b
JNP 0x00178b20
LAB_00178b0b:
UCOMISD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM5
JC 0x00178b4a
XORPS XMM3,XMM3
SQRTSD XMM3,XMM0
JMP 0x00178b5f
LAB_00178b20:
XORPD XMM1,XMM1
CMPEQPD XMM2,XMM1
CMPEQPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVD EAX,XMM1
TEST AL,0x1
JNZ 0x00178b40
XORPD XMM0,XMM0
JMP 0x00178b9c
LAB_00178b40:
MOVSS XMM0,dword ptr [0x001e9110]
JMP 0x00178b9c
LAB_00178b4a:
MOVAPD xmmword ptr [RSP + 0x10],XMM2
CALL 0x0011b720
MOVAPD XMM2,xmmword ptr [RSP + 0x10]
MOVAPD XMM3,XMM0
LAB_00178b5f:
XORPD XMM0,XMM0
UCOMISD XMM2,XMM0
JC 0x00178b72
XORPS XMM0,XMM0
SQRTSD XMM0,XMM2
JMP 0x00178b87
LAB_00178b72:
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x10],XMM3
CALL 0x0011b720
MOVSD XMM3,qword ptr [RSP + 0x10]
LAB_00178b87:
MOVSD XMM1,qword ptr [RSP + 0x8]
MULSD XMM3,XMM0
DIVSD XMM1,XMM3
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM1
LAB_00178b9c:
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
float fVar1;
ulong uVar2;
float fVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_3 < 1) {
dVar4 = 0.0;
dVar5 = 0.0;
dVar6 = 0.0;
}
else {
dVar4 = 0.0;
dVar5 = 0.0;
dVar6 = 0.0;
uVar2 = 0;
do {
fVar3 = param_1[uVar2];
fVar1 = param_2[uVar2];
dVar6 = dVar6 + (double)(fVar3 * fVar1);
dVar4 = dVar4 + (double)(fVar3 * fVar3);
dVar5 = dVar5 + (double)(fVar1 * fVar1);
uVar2 = uVar2 + 1;
} while ((uint)param_3 != uVar2);
}
if (((dVar4 == 0.0) && (!NAN(dVar4))) || ((dVar5 == 0.0 && (!NAN(dVar5))))) {
fVar3 = _DAT_001e9110;
if (dVar4 != 0.0 || dVar5 != 0.0) {
fVar3 = 0.0;
}
}
else {
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
}
else {
dVar4 = SQRT(dVar4);
}
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
fVar3 = (float)(dVar6 / (dVar4 * dVar5));
}
return fVar3;
}
| |
35,287 | common_embd_similarity_cos(float const*, float const*, int) | monkey531[P]llama/common/common.cpp | float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
} | O3 | cpp | common_embd_similarity_cos(float const*, float const*, int):
subq $0x28, %rsp
testl %edx, %edx
jle 0x780e3
movl %edx, %eax
xorpd %xmm0, %xmm0
xorpd %xmm4, %xmm4
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm3
movss (%rdi,%rcx,4), %xmm1
movaps %xmm1, %xmm2
shufps $0x0, %xmm1, %xmm2 # xmm2 = xmm2[0,0],xmm1[0,0]
unpcklps %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
mulps %xmm2, %xmm1
cvtps2pd %xmm1, %xmm1
addpd %xmm1, %xmm0
mulss %xmm3, %xmm3
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
addsd %xmm1, %xmm4
incq %rcx
cmpq %rcx, %rax
jne 0x78060
xorps %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpeqsd %xmm2, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
movapd %xmm4, %xmm1
cmpeqsd %xmm2, %xmm1
movq %xmm1, %rcx
andl $0x1, %ecx
ucomisd %xmm2, %xmm0
jne 0x780c2
jnp 0x780e7
ucomisd %xmm2, %xmm4
jne 0x780ca
jnp 0x780e7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
jb 0x780fb
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0x78114
movb $0x1, %cl
movb $0x1, %al
testb %cl, %al
jne 0x780f1
xorpd %xmm0, %xmm0
jmp 0x78151
movss 0x6e017(%rip), %xmm0 # 0xe6110
jmp 0x78151
movsd %xmm4, 0x8(%rsp)
callq 0x1a720
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm2
ucomisd %xmm1, %xmm4
jb 0x78123
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
jmp 0x78138
movapd %xmm4, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x1a720
movsd 0x8(%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
unpckhpd %xmm1, %xmm1 # xmm1 = xmm1[1,1]
divsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
addq $0x28, %rsp
retq
| _Z26common_embd_similarity_cosPKfS0_i:
sub rsp, 28h
test edx, edx
jle loc_780E3
mov eax, edx
xorpd xmm0, xmm0
xorpd xmm4, xmm4
xor ecx, ecx
loc_78060:
movss xmm3, dword ptr [rsi+rcx*4]
movss xmm1, dword ptr [rdi+rcx*4]
movaps xmm2, xmm1
shufps xmm2, xmm1, 0
unpcklps xmm1, xmm3
mulps xmm1, xmm2
cvtps2pd xmm1, xmm1
addpd xmm0, xmm1
mulss xmm3, xmm3
xorps xmm1, xmm1
cvtss2sd xmm1, xmm3
addsd xmm4, xmm1
inc rcx
cmp rax, rcx
jnz short loc_78060
xorps xmm2, xmm2
movapd xmm1, xmm0
cmpeqsd xmm1, xmm2
movq rax, xmm1
and eax, 1
movapd xmm1, xmm4
cmpeqsd xmm1, xmm2
movq rcx, xmm1
and ecx, 1
ucomisd xmm0, xmm2
jnz short loc_780C2
jnp short loc_780E7
loc_780C2:
ucomisd xmm4, xmm2
jnz short loc_780CA
jnp short loc_780E7
loc_780CA:
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
movapd [rsp+28h+var_18], xmm0
jb short loc_780FB
xorps xmm2, xmm2
sqrtsd xmm2, xmm0
jmp short loc_78114
loc_780E3:
mov cl, 1
mov al, 1
loc_780E7:
test al, cl
jnz short loc_780F1
xorpd xmm0, xmm0
jmp short loc_78151
loc_780F1:
movss xmm0, cs:dword_E6110
jmp short loc_78151
loc_780FB:
movsd [rsp+28h+var_20], xmm4
call _sqrt
xorpd xmm1, xmm1
movsd xmm4, [rsp+28h+var_20]
movapd xmm2, xmm0
loc_78114:
ucomisd xmm4, xmm1
jb short loc_78123
xorps xmm0, xmm0
sqrtsd xmm0, xmm4
jmp short loc_78138
loc_78123:
movapd xmm0, xmm4
movsd [rsp+28h+var_20], xmm2
call _sqrt
movsd xmm2, [rsp+28h+var_20]
loc_78138:
movapd xmm1, [rsp+28h+var_18]
mulsd xmm2, xmm0
unpckhpd xmm1, xmm1
divsd xmm1, xmm2
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm1
loc_78151:
add rsp, 28h
retn
| float common_embd_similarity_cos(const float *a1, const float *a2, int a3)
{
__m128d v3; // xmm0
__m128d v4; // xmm4
long long i; // rcx
__m128 v6; // xmm3
char v7; // al
char v8; // cl
double v9; // xmm2_8
double v11; // xmm0_8
double v12; // xmm0_8
double v13; // [rsp+8h] [rbp-20h]
__m128d v14; // [rsp+10h] [rbp-18h]
if ( a3 <= 0 )
{
v8 = 1;
v7 = 1;
LABEL_9:
if ( ((unsigned __int8)v8 & (unsigned __int8)v7) != 0 )
return 1.0;
else
return 0.0;
}
v3 = 0LL;
v4 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v6 = (__m128)LODWORD(a2[i]);
v3 = _mm_add_pd(
v3,
_mm_cvtps_pd(
_mm_mul_ps(
_mm_unpacklo_ps((__m128)LODWORD(a1[i]), v6),
_mm_shuffle_ps((__m128)LODWORD(a1[i]), (__m128)LODWORD(a1[i]), 0))));
v4.m128d_f64[0] = v4.m128d_f64[0] + (float)(v6.m128_f32[0] * v6.m128_f32[0]);
}
v7 = *(_OWORD *)&_mm_cmpeq_sd(v3, (__m128d)0LL) & 1;
v8 = *(_OWORD *)&_mm_cmpeq_sd(v4, (__m128d)0LL) & 1;
if ( v3.m128d_f64[0] == 0.0 || v4.m128d_f64[0] == 0.0 )
goto LABEL_9;
v14 = v3;
if ( v3.m128d_f64[0] < 0.0 )
{
v13 = v4.m128d_f64[0];
v11 = sqrt(v3.m128d_f64[0]);
v4.m128d_f64[0] = v13;
v9 = v11;
}
else
{
v9 = sqrt(v3.m128d_f64[0]);
}
if ( v4.m128d_f64[0] < 0.0 )
v12 = sqrt(v4.m128d_f64[0]);
else
v12 = sqrt(v4.m128d_f64[0]);
return _mm_unpackhi_pd(v14, v14).m128d_f64[0] / (v9 * v12);
}
| common_embd_similarity_cos:
SUB RSP,0x28
TEST EDX,EDX
JLE 0x001780e3
MOV EAX,EDX
XORPD XMM0,XMM0
XORPD XMM4,XMM4
XOR ECX,ECX
LAB_00178060:
MOVSS XMM3,dword ptr [RSI + RCX*0x4]
MOVSS XMM1,dword ptr [RDI + RCX*0x4]
MOVAPS XMM2,XMM1
SHUFPS XMM2,XMM1,0x0
UNPCKLPS XMM1,XMM3
MULPS XMM1,XMM2
CVTPS2PD XMM1,XMM1
ADDPD XMM0,XMM1
MULSS XMM3,XMM3
XORPS XMM1,XMM1
CVTSS2SD XMM1,XMM3
ADDSD XMM4,XMM1
INC RCX
CMP RAX,RCX
JNZ 0x00178060
XORPS XMM2,XMM2
MOVAPD XMM1,XMM0
CMPEQSD XMM1,XMM2
MOVQ RAX,XMM1
AND EAX,0x1
MOVAPD XMM1,XMM4
CMPEQSD XMM1,XMM2
MOVQ RCX,XMM1
AND ECX,0x1
UCOMISD XMM0,XMM2
JNZ 0x001780c2
JNP 0x001780e7
LAB_001780c2:
UCOMISD XMM4,XMM2
JNZ 0x001780ca
JNP 0x001780e7
LAB_001780ca:
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
MOVAPD xmmword ptr [RSP + 0x10],XMM0
JC 0x001780fb
XORPS XMM2,XMM2
SQRTSD XMM2,XMM0
JMP 0x00178114
LAB_001780e3:
MOV CL,0x1
MOV AL,0x1
LAB_001780e7:
TEST AL,CL
JNZ 0x001780f1
XORPD XMM0,XMM0
JMP 0x00178151
LAB_001780f1:
MOVSS XMM0,dword ptr [0x001e6110]
JMP 0x00178151
LAB_001780fb:
MOVSD qword ptr [RSP + 0x8],XMM4
CALL 0x0011a720
XORPD XMM1,XMM1
MOVSD XMM4,qword ptr [RSP + 0x8]
MOVAPD XMM2,XMM0
LAB_00178114:
UCOMISD XMM4,XMM1
JC 0x00178123
XORPS XMM0,XMM0
SQRTSD XMM0,XMM4
JMP 0x00178138
LAB_00178123:
MOVAPD XMM0,XMM4
MOVSD qword ptr [RSP + 0x8],XMM2
CALL 0x0011a720
MOVSD XMM2,qword ptr [RSP + 0x8]
LAB_00178138:
MOVAPD XMM1,xmmword ptr [RSP + 0x10]
MULSD XMM2,XMM0
UNPCKHPD XMM1,XMM1
DIVSD XMM1,XMM2
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM1
LAB_00178151:
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
float fVar1;
int1 auVar2 [16];
double dVar3;
bool bVar4;
bool bVar5;
ulong uVar6;
float fVar7;
double dVar8;
double dVar9;
double dStack_10;
if (param_3 < 1) {
bVar5 = true;
bVar4 = true;
}
else {
dVar8 = 0.0;
dVar3 = 0.0;
dVar9 = 0.0;
uVar6 = 0;
do {
fVar7 = param_2[uVar6];
fVar1 = param_1[uVar6];
dVar8 = dVar8 + (double)(fVar1 * fVar1);
dVar3 = dVar3 + (double)(fVar7 * fVar1);
dVar9 = dVar9 + (double)(fVar7 * fVar7);
uVar6 = uVar6 + 1;
} while ((uint)param_3 != uVar6);
bVar4 = dVar8 == 0.0;
bVar5 = dVar9 == 0.0;
if (((dVar8 != 0.0) || (NAN(dVar8))) && ((dVar9 != 0.0 || (NAN(dVar9))))) {
auVar2._8_4_ = SUB84(dVar3,0);
auVar2._0_8_ = dVar8;
auVar2._12_4_ = (int)((ulong)dVar3 >> 0x20);
dStack_10 = auVar2._8_8_;
if (dVar8 < 0.0) {
dVar8 = sqrt(dVar8);
}
else {
dVar8 = SQRT(dVar8);
}
if (dVar9 < 0.0) {
dVar9 = sqrt(dVar9);
}
else {
dVar9 = SQRT(dVar9);
}
return (float)(dStack_10 / (dVar8 * dVar9));
}
}
fVar7 = _DAT_001e6110;
if (!(bool)(bVar4 & bVar5)) {
fVar7 = 0.0;
}
return fVar7;
}
| |
35,288 | testing::TempDir[abi:cxx11]() | seiftnesse[P]memoryallocator/build_O2/_deps/googletest-src/googletest/src/gtest.cc | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE
return GetTempDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
#elif GTEST_OS_LINUX_ANDROID
return GetTempDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/');
#else
return GetTempDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/');
#endif
} | O2 | cpp | testing::TempDir[abi:cxx11]():
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xeeda(%rip), %rax # 0x33daf
movq %rax, 0x10(%rsp)
leaq 0xeed3(%rip), %rax # 0x33db4
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x24f0c
movq 0x10(%rsp,%r15), %rdi
callq 0x9680
testq %rax, %rax
je 0x24f06
movq %rax, %r14
cmpb $0x0, (%rax)
jne 0x24f1d
addq $0x8, %r15
jmp 0x24ee9
leaq 0xeea8(%rip), %rsi # 0x33dbb
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
jmp 0x24f38
movq %r14, %rdi
callq 0x9200
cmpb $0x2f, -0x1(%r14,%rax)
jne 0x24f4a
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd602
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd602
pushq $0x1
popq %rsi
pushq $0x2f
popq %rdx
movq %r15, %rdi
callq 0x9560
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97d0
leaq 0x20(%rsp), %rdi
callq 0x9af8
jmp 0x24f3d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9af8
movq %rbx, %rdi
callq 0x99d0
nop
| _ZN7testing7TempDirB5cxx11Ev:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
lea rax, aTestTmpdir; "TEST_TMPDIR"
mov [rsp+58h+var_48], rax
lea rax, aTestTmpdir+5; "TMPDIR"
mov [rsp+58h+var_40], rax
xor r15d, r15d
loc_24EE9:
cmp r15, 10h
jz short loc_24F0C
mov rdi, [rsp+r15+58h+var_48]
call _getenv
test rax, rax
jz short loc_24F06
mov r14, rax
cmp byte ptr [rax], 0
jnz short loc_24F1D
loc_24F06:
add r15, 8
jmp short loc_24EE9
loc_24F0C:
lea rsi, aTmp; "/tmp/"
lea rdx, [rsp+58h+var_38]
mov rdi, rbx
jmp short loc_24F38
loc_24F1D:
mov rdi, r14
call _strlen
cmp byte ptr [r14+rax-1], 2Fh ; '/'
jnz short loc_24F4A
lea rdx, [rsp+58h+var_38]
mov rdi, rbx
mov rsi, r14
loc_24F38:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_24F3D:
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_24F4A:
lea r15, [rsp+58h+var_38]
lea rdx, [rsp+58h+var_49]
mov rdi, r15
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
push 1
pop rsi
push 2Fh ; '/'
pop rdx
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEmc; std::string::append(ulong,char)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_24F3D
mov rbx, rax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| _QWORD * testing::TempDir[abi:cxx11](_QWORD *a1)
{
long long i; // r15
_BYTE *v2; // rax
long long v3; // r14
const char *v4; // rsi
long long v6; // rax
_QWORD v7[2]; // [rsp+10h] [rbp-48h]
_QWORD v8[7]; // [rsp+20h] [rbp-38h] BYREF
v7[0] = "TEST_TMPDIR";
v7[1] = "TMPDIR";
for ( i = 0LL; ; ++i )
{
if ( i == 2 )
{
v4 = "/tmp/";
LABEL_9:
std::string::basic_string<std::allocator<char>>(a1, (long long)v4);
return a1;
}
v2 = (_BYTE *)getenv(v7[i]);
if ( v2 )
{
v3 = (long long)v2;
if ( *v2 )
break;
}
}
if ( v2[strlen(v2) - 1] == 47 )
{
v4 = (const char *)v3;
goto LABEL_9;
}
std::string::basic_string<std::allocator<char>>(v8, v3);
v6 = std::string::append(v8, 1LL, 47LL);
std::string::basic_string(a1, v6);
std::string::~string(v8);
return a1;
}
| TempDir[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA RAX,[0x133daf]
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[0x133db4]
MOV qword ptr [RSP + 0x18],RAX
XOR R15D,R15D
LAB_00124ee9:
CMP R15,0x10
JZ 0x00124f0c
MOV RDI,qword ptr [RSP + R15*0x1 + 0x10]
CALL 0x00109680
TEST RAX,RAX
JZ 0x00124f06
MOV R14,RAX
CMP byte ptr [RAX],0x0
JNZ 0x00124f1d
LAB_00124f06:
ADD R15,0x8
JMP 0x00124ee9
LAB_00124f0c:
LEA RSI,[0x133dbb]
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
JMP 0x00124f38
LAB_00124f1d:
MOV RDI,R14
CALL 0x00109200
CMP byte ptr [R14 + RAX*0x1 + -0x1],0x2f
JNZ 0x00124f4a
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV RSI,R14
LAB_00124f38:
CALL 0x0010d602
LAB_00124f3d:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_00124f4a:
LEA R15,[RSP + 0x20]
LEA RDX,[RSP + 0xf]
MOV RDI,R15
MOV RSI,R14
CALL 0x0010d602
LAB_00124f5f:
PUSH 0x1
POP RSI
PUSH 0x2f
POP RDX
MOV RDI,R15
CALL 0x00109560
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001097d0
LAB_00124f78:
LEA RDI,[RSP + 0x20]
CALL 0x00109af8
JMP 0x00124f3d
|
/* testing::TempDir[abi:cxx11]() */
testing * __thiscall testing::TempDir_abi_cxx11_(testing *this)
{
char *__s;
size_t sVar1;
string *psVar2;
long lVar3;
allocator local_49;
char *local_48 [2];
allocator local_38 [32];
local_48[0] = "TEST_TMPDIR";
local_48[1] = "TMPDIR";
lVar3 = 0;
do {
if (lVar3 == 0x10) {
__s = "/tmp/";
LAB_00124f38:
std::__cxx11::string::string<std::allocator<char>>((string *)this,__s,local_38);
return this;
}
__s = getenv(*(char **)((long)local_48 + lVar3));
if ((__s != (char *)0x0) && (*__s != '\0')) {
sVar1 = strlen(__s);
if (__s[sVar1 - 1] != '/') {
std::__cxx11::string::string<std::allocator<char>>((string *)local_38,__s,&local_49);
/* try { // try from 00124f5f to 00124f77 has its CatchHandler @ 00124f84 */
psVar2 = (string *)std::__cxx11::string::append((ulong)local_38,'\x01');
std::__cxx11::string::string((string *)this,psVar2);
std::__cxx11::string::~string((string *)local_38);
return this;
}
goto LAB_00124f38;
}
lVar3 = lVar3 + 8;
} while( true );
}
| |
35,289 | deflateCopy | 3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/deflate.c | int ZEXPORT deflateCopy(dest, source)
z_streamp dest;
z_streamp source;
{
#ifdef MAXSEG_64K
return Z_STREAM_ERROR;
#else
deflate_state *ds;
deflate_state *ss;
if (deflateStateCheck(source) || dest == Z_NULL) {
return Z_STREAM_ERROR;
}
ss = source->state;
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
if (ds == Z_NULL) return Z_MEM_ERROR;
dest->state = (struct internal_state FAR *) ds;
zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
ds->strm = dest;
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, 4);
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
ds->pending_buf == Z_NULL) {
deflateEnd (dest);
return Z_MEM_ERROR;
}
/* following zmemcpy do not work for 16-bit MSDOS */
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
ds->sym_buf = ds->pending_buf + ds->lit_bufsize;
ds->l_desc.dyn_tree = ds->dyn_ltree;
ds->d_desc.dyn_tree = ds->dyn_dtree;
ds->bl_desc.dyn_tree = ds->bl_tree;
return Z_OK;
#endif /* MAXSEG_64K */
} | O3 | c | deflateCopy:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x4452
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %r15, %r15
je 0x62d2
testl %eax, %eax
jne 0x62d2
movq 0x38(%r14), %rbx
movl $0x70, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
movq 0x50(%r15), %rdi
movl $0x1, %esi
movl $0x1740, %edx # imm = 0x1740
callq *0x40(%r15)
movl $0xfffffffc, %ebp # imm = 0xFFFFFFFC
testq %rax, %rax
je 0x62d2
movq %rax, %r14
movq %rax, 0x38(%r15)
movl $0x1740, %edx # imm = 0x1740
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31b0
movq %r15, (%r14)
movq 0x50(%r15), %rdi
movl 0x50(%r14), %esi
movl $0x2, %edx
callq *0x40(%r15)
movq %rax, 0x60(%r14)
movq 0x50(%r15), %rdi
movl 0x50(%r14), %esi
movl $0x2, %edx
callq *0x40(%r15)
movq %rax, 0x70(%r14)
movq 0x50(%r15), %rdi
movl 0x84(%r14), %esi
movl $0x2, %edx
callq *0x40(%r15)
movq %rax, 0x78(%r14)
movq 0x50(%r15), %rdi
movl 0x1708(%r14), %esi
movl $0x4, %edx
callq *0x40(%r15)
movq %rax, 0x10(%r14)
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x62ca
cmpq $0x0, 0x70(%r14)
je 0x62ca
cmpq $0x0, 0x78(%r14)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x62df
movq %r15, %rdi
callq 0x3210
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x60(%rbx), %rsi
movl 0x50(%r14), %edx
addl %edx, %edx
callq 0x31b0
movq 0x70(%r14), %rdi
movq 0x70(%rbx), %rsi
movl 0x50(%r14), %edx
addq %rdx, %rdx
callq 0x31b0
movq 0x78(%r14), %rdi
movq 0x78(%rbx), %rsi
movl 0x84(%r14), %edx
addq %rdx, %rdx
callq 0x31b0
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
movl 0x18(%r14), %edx
callq 0x31b0
movq 0x10(%r14), %rax
movq 0x20(%rbx), %rcx
subq 0x10(%rbx), %rcx
addq %rax, %rcx
movq %rcx, 0x20(%r14)
movl 0x1708(%r14), %ecx
addq %rax, %rcx
movq %rcx, 0x1700(%r14)
leaq 0xd4(%r14), %rax
movq %rax, 0xb58(%r14)
leaq 0x9c8(%r14), %rax
movq %rax, 0xb70(%r14)
movq %r14, %rax
addq $0xabc, %rax # imm = 0xABC
movq %rax, 0xb88(%r14)
xorl %ebp, %ebp
jmp 0x62d2
| deflateCopy:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call deflateStateCheck
mov ebp, 0FFFFFFFEh
test r15, r15
jz loc_62D2
test eax, eax
jnz loc_62D2
mov rbx, [r14+38h]
mov edx, 70h ; 'p'
mov rdi, r15
mov rsi, r14
call _memcpy
mov rdi, [r15+50h]
mov esi, 1
mov edx, 1740h
call qword ptr [r15+40h]
mov ebp, 0FFFFFFFCh
test rax, rax
jz loc_62D2
mov r14, rax
mov [r15+38h], rax
mov edx, 1740h
mov rdi, rax
mov rsi, rbx
call _memcpy
mov [r14], r15
mov rdi, [r15+50h]
mov esi, [r14+50h]
mov edx, 2
call qword ptr [r15+40h]
mov [r14+60h], rax
mov rdi, [r15+50h]
mov esi, [r14+50h]
mov edx, 2
call qword ptr [r15+40h]
mov [r14+70h], rax
mov rdi, [r15+50h]
mov esi, [r14+84h]
mov edx, 2
call qword ptr [r15+40h]
mov [r14+78h], rax
mov rdi, [r15+50h]
mov esi, [r14+1708h]
mov edx, 4
call qword ptr [r15+40h]
mov [r14+10h], rax
mov rdi, [r14+60h]
test rdi, rdi
jz short loc_62CA
cmp qword ptr [r14+70h], 0
jz short loc_62CA
cmp qword ptr [r14+78h], 0
setz cl
test rax, rax
setz al
or al, cl
cmp al, 1
jnz short loc_62DF
loc_62CA:
mov rdi, r15
call _deflateEnd
loc_62D2:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_62DF:
mov rsi, [rbx+60h]
mov edx, [r14+50h]
add edx, edx
call _memcpy
mov rdi, [r14+70h]
mov rsi, [rbx+70h]
mov edx, [r14+50h]
add rdx, rdx
call _memcpy
mov rdi, [r14+78h]
mov rsi, [rbx+78h]
mov edx, [r14+84h]
add rdx, rdx
call _memcpy
mov rdi, [r14+10h]
mov rsi, [rbx+10h]
mov edx, [r14+18h]
call _memcpy
mov rax, [r14+10h]
mov rcx, [rbx+20h]
sub rcx, [rbx+10h]
add rcx, rax
mov [r14+20h], rcx
mov ecx, [r14+1708h]
add rcx, rax
mov [r14+1700h], rcx
lea rax, [r14+0D4h]
mov [r14+0B58h], rax
lea rax, [r14+9C8h]
mov [r14+0B70h], rax
mov rax, r14
add rax, 0ABCh
mov [r14+0B88h], rax
xor ebp, ebp
jmp loc_62D2
| long long deflateCopy(long long a1, _QWORD *a2)
{
int v3; // eax
unsigned int v4; // ebp
_QWORD *v5; // rbx
long long v6; // rax
long long v7; // r14
long long v8; // rax
long long v9; // rdi
long long v11; // rax
v3 = deflateStateCheck(a2);
v4 = -2;
if ( a1 )
{
if ( !v3 )
{
v5 = (_QWORD *)a2[7];
memcpy(a1, a2, 112LL);
v6 = (*(long long ( **)(_QWORD, long long, long long))(a1 + 64))(*(_QWORD *)(a1 + 80), 1LL, 5952LL);
v4 = -4;
if ( v6 )
{
v7 = v6;
*(_QWORD *)(a1 + 56) = v6;
memcpy(v6, v5, 5952LL);
*(_QWORD *)v7 = a1;
*(_QWORD *)(v7 + 96) = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 64))(
*(_QWORD *)(a1 + 80),
*(unsigned int *)(v7 + 80),
2LL);
*(_QWORD *)(v7 + 112) = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 64))(
*(_QWORD *)(a1 + 80),
*(unsigned int *)(v7 + 80),
2LL);
*(_QWORD *)(v7 + 120) = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 64))(
*(_QWORD *)(a1 + 80),
*(unsigned int *)(v7 + 132),
2LL);
v8 = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 64))(
*(_QWORD *)(a1 + 80),
*(unsigned int *)(v7 + 5896),
4LL);
*(_QWORD *)(v7 + 16) = v8;
v9 = *(_QWORD *)(v7 + 96);
if ( v9 && *(_QWORD *)(v7 + 112) && *(_QWORD *)(v7 + 120) != 0LL && v8 != 0 )
{
memcpy(v9, v5[12], (unsigned int)(2 * *(_DWORD *)(v7 + 80)));
memcpy(*(_QWORD *)(v7 + 112), v5[14], 2LL * *(unsigned int *)(v7 + 80));
memcpy(*(_QWORD *)(v7 + 120), v5[15], 2LL * *(unsigned int *)(v7 + 132));
memcpy(*(_QWORD *)(v7 + 16), v5[2], *(unsigned int *)(v7 + 24));
v11 = *(_QWORD *)(v7 + 16);
*(_QWORD *)(v7 + 32) = v11 + v5[4] - v5[2];
*(_QWORD *)(v7 + 5888) = v11 + *(unsigned int *)(v7 + 5896);
*(_QWORD *)(v7 + 2904) = v7 + 212;
*(_QWORD *)(v7 + 2928) = v7 + 2504;
*(_QWORD *)(v7 + 2952) = v7 + 2748;
return 0;
}
else
{
deflateEnd(a1);
}
}
}
}
return v4;
}
| deflateCopy:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x00104452
MOV EBP,0xfffffffe
TEST R15,R15
JZ 0x001062d2
TEST EAX,EAX
JNZ 0x001062d2
MOV RBX,qword ptr [R14 + 0x38]
MOV EDX,0x70
MOV RDI,R15
MOV RSI,R14
CALL 0x001031b0
MOV RDI,qword ptr [R15 + 0x50]
MOV ESI,0x1
MOV EDX,0x1740
CALL qword ptr [R15 + 0x40]
MOV EBP,0xfffffffc
TEST RAX,RAX
JZ 0x001062d2
MOV R14,RAX
MOV qword ptr [R15 + 0x38],RAX
MOV EDX,0x1740
MOV RDI,RAX
MOV RSI,RBX
CALL 0x001031b0
MOV qword ptr [R14],R15
MOV RDI,qword ptr [R15 + 0x50]
MOV ESI,dword ptr [R14 + 0x50]
MOV EDX,0x2
CALL qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x60],RAX
MOV RDI,qword ptr [R15 + 0x50]
MOV ESI,dword ptr [R14 + 0x50]
MOV EDX,0x2
CALL qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x70],RAX
MOV RDI,qword ptr [R15 + 0x50]
MOV ESI,dword ptr [R14 + 0x84]
MOV EDX,0x2
CALL qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x78],RAX
MOV RDI,qword ptr [R15 + 0x50]
MOV ESI,dword ptr [R14 + 0x1708]
MOV EDX,0x4
CALL qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x10],RAX
MOV RDI,qword ptr [R14 + 0x60]
TEST RDI,RDI
JZ 0x001062ca
CMP qword ptr [R14 + 0x70],0x0
JZ 0x001062ca
CMP qword ptr [R14 + 0x78],0x0
SETZ CL
TEST RAX,RAX
SETZ AL
OR AL,CL
CMP AL,0x1
JNZ 0x001062df
LAB_001062ca:
MOV RDI,R15
CALL 0x00103210
LAB_001062d2:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001062df:
MOV RSI,qword ptr [RBX + 0x60]
MOV EDX,dword ptr [R14 + 0x50]
ADD EDX,EDX
CALL 0x001031b0
MOV RDI,qword ptr [R14 + 0x70]
MOV RSI,qword ptr [RBX + 0x70]
MOV EDX,dword ptr [R14 + 0x50]
ADD RDX,RDX
CALL 0x001031b0
MOV RDI,qword ptr [R14 + 0x78]
MOV RSI,qword ptr [RBX + 0x78]
MOV EDX,dword ptr [R14 + 0x84]
ADD RDX,RDX
CALL 0x001031b0
MOV RDI,qword ptr [R14 + 0x10]
MOV RSI,qword ptr [RBX + 0x10]
MOV EDX,dword ptr [R14 + 0x18]
CALL 0x001031b0
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [RBX + 0x20]
SUB RCX,qword ptr [RBX + 0x10]
ADD RCX,RAX
MOV qword ptr [R14 + 0x20],RCX
MOV ECX,dword ptr [R14 + 0x1708]
ADD RCX,RAX
MOV qword ptr [R14 + 0x1700],RCX
LEA RAX,[R14 + 0xd4]
MOV qword ptr [R14 + 0xb58],RAX
LEA RAX,[R14 + 0x9c8]
MOV qword ptr [R14 + 0xb70],RAX
MOV RAX,R14
ADD RAX,0xabc
MOV qword ptr [R14 + 0xb88],RAX
XOR EBP,EBP
JMP 0x001062d2
|
int8 deflateCopy(void *param_1,void *param_2)
{
void *__src;
int iVar1;
int8 *__dest;
int8 uVar2;
long lVar3;
int8 uVar4;
iVar1 = deflateStateCheck(param_2);
uVar4 = 0xfffffffe;
if ((param_1 != (void *)0x0) && (iVar1 == 0)) {
__src = *(void **)((long)param_2 + 0x38);
memcpy(param_1,param_2,0x70);
__dest = (int8 *)
(**(code **)((long)param_1 + 0x40))(*(int8 *)((long)param_1 + 0x50),1,0x1740);
uVar4 = 0xfffffffc;
if (__dest != (int8 *)0x0) {
*(int8 **)((long)param_1 + 0x38) = __dest;
memcpy(__dest,__src,0x1740);
*__dest = param_1;
uVar2 = (**(code **)((long)param_1 + 0x40))
(*(int8 *)((long)param_1 + 0x50),*(int4 *)(__dest + 10),2);
__dest[0xc] = uVar2;
uVar2 = (**(code **)((long)param_1 + 0x40))
(*(int8 *)((long)param_1 + 0x50),*(int4 *)(__dest + 10),2);
__dest[0xe] = uVar2;
uVar2 = (**(code **)((long)param_1 + 0x40))
(*(int8 *)((long)param_1 + 0x50),*(int4 *)((long)__dest + 0x84),
2);
__dest[0xf] = uVar2;
lVar3 = (**(code **)((long)param_1 + 0x40))
(*(int8 *)((long)param_1 + 0x50),*(int4 *)(__dest + 0x2e1),4);
__dest[2] = lVar3;
if ((((void *)__dest[0xc] == (void *)0x0) || (__dest[0xe] == 0)) ||
(lVar3 == 0 || __dest[0xf] == 0)) {
deflateEnd(param_1);
}
else {
memcpy((void *)__dest[0xc],*(void **)((long)__src + 0x60),
(ulong)(uint)(*(int *)(__dest + 10) * 2));
memcpy((void *)__dest[0xe],*(void **)((long)__src + 0x70),(ulong)*(uint *)(__dest + 10) * 2)
;
memcpy((void *)__dest[0xf],*(void **)((long)__src + 0x78),
(ulong)*(uint *)((long)__dest + 0x84) * 2);
memcpy((void *)__dest[2],*(void **)((long)__src + 0x10),(ulong)*(uint *)(__dest + 3));
__dest[4] = (*(long *)((long)__src + 0x20) - *(long *)((long)__src + 0x10)) + __dest[2];
__dest[0x2e0] = (ulong)*(uint *)(__dest + 0x2e1) + __dest[2];
__dest[0x16b] = (long)__dest + 0xd4;
__dest[0x16e] = __dest + 0x139;
__dest[0x171] = (long)__dest + 0xabc;
uVar4 = 0;
}
}
}
return uVar4;
}
| |
35,290 | 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 0xd2817
testb $0x20, 0xd(%r15)
jne 0xd2817
movl $0x1, %eax
testq %rbx, %rbx
jle 0xd287d
addq %r14, %rbx
cmpb $0x0, (%r14)
js 0xd288a
incq %r14
cmpq %rbx, %r14
jb 0xd2807
jmp 0xd287d
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 0xd2873
cmpq $0x7f, -0x28(%rbp)
ja 0xd2873
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 0xd2873
cmpq $0x80, -0x28(%rbp)
jb 0xd2843
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 0xd287d
| 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_D2817
test byte ptr [r15+0Dh], 20h
jnz short loc_D2817
mov eax, 1
test rbx, rbx
jle short loc_D287D
add rbx, r14
loc_D2807:
cmp byte ptr [r14], 0
js short loc_D288A
inc r14
cmp r14, rbx
jb short loc_D2807
jmp short loc_D287D
loc_D2817:
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_D2873
cmp [rbp+var_28], 7Fh
ja short loc_D2873
lea r12, [rbp+var_28]
loc_D2843:
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_D2873
cmp [rbp+var_28], 80h
jb short loc_D2843
loc_D2873:
movzx eax, cl
lea eax, ds:1[rax*2]
loc_D287D:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_D288A:
mov eax, 3
jmp short loc_D287D
| 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 0x001d2817
TEST byte ptr [R15 + 0xd],0x20
JNZ 0x001d2817
MOV EAX,0x1
TEST RBX,RBX
JLE 0x001d287d
ADD RBX,R14
LAB_001d2807:
CMP byte ptr [R14],0x0
JS 0x001d288a
INC R14
CMP R14,RBX
JC 0x001d2807
JMP 0x001d287d
LAB_001d2817:
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 0x001d2873
CMP qword ptr [RBP + -0x28],0x7f
JA 0x001d2873
LEA R12,[RBP + -0x28]
LAB_001d2843:
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 0x001d2873
CMP qword ptr [RBP + -0x28],0x80
JC 0x001d2843
LAB_001d2873:
MOVZX EAX,CL
LEA EAX,[0x1 + RAX*0x2]
LAB_001d287d:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001d288a:
MOV EAX,0x3
JMP 0x001d287d
|
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;
}
| |
35,291 | get_current_logfile | eloqsql/storage/maria/ma_loghandler.c | static TRANSLOG_FILE *get_current_logfile()
{
TRANSLOG_FILE *file;
DBUG_ENTER("get_current_logfile");
mysql_rwlock_rdlock(&log_descriptor.open_files_lock);
DBUG_PRINT("info", ("max_file: %lu min_file: %lu open_files: %lu",
(ulong) log_descriptor.max_file,
(ulong) log_descriptor.min_file,
(ulong) log_descriptor.open_files.elements));
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
file= *dynamic_element(&log_descriptor.open_files, 0, TRANSLOG_FILE **);
mysql_rwlock_unlock(&log_descriptor.open_files_lock);
DBUG_RETURN(file);
} | O0 | c | get_current_logfile:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x446c81(%rip), %rdi # 0x47fd90
addq $0x258, %rdi # imm = 0x258
leaq 0x11e28d(%rip), %rsi # 0x1573aa
movl $0x43f, %edx # imm = 0x43F
callq 0x34d40
jmp 0x39129
jmp 0x3912b
jmp 0x3912d
movq 0x446e84(%rip), %rax # 0x47ffb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0x446c4e(%rip), %rdi # 0x47fd90
addq $0x258, %rdi # imm = 0x258
callq 0x33bd0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| get_current_logfile:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, log_descriptor
add rdi, 258h
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 43Fh
call inline_mysql_rwlock_rdlock
jmp short $+2
loc_39129:
jmp short $+2
loc_3912B:
jmp short $+2
loc_3912D:
mov rax, cs:qword_47FFB8
mov rax, [rax]
mov [rbp+var_8], rax
lea rdi, log_descriptor
add rdi, 258h
call inline_mysql_rwlock_unlock
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
add rsp, 10h
pop rbp
retn
| long long get_current_logfile()
{
long long v1; // [rsp+8h] [rbp-8h]
inline_mysql_rwlock_rdlock(
(long long)&log_descriptor[75],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43Fu);
v1 = *(_QWORD *)qword_47FFB8;
inline_mysql_rwlock_unlock((long long)&log_descriptor[75]);
return v1;
}
| get_current_logfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x57fd90]
ADD RDI,0x258
LEA RSI,[0x2573aa]
MOV EDX,0x43f
CALL 0x00134d40
JMP 0x00139129
LAB_00139129:
JMP 0x0013912b
LAB_0013912b:
JMP 0x0013912d
LAB_0013912d:
MOV RAX,qword ptr [0x0057ffb8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0x57fd90]
ADD RDI,0x258
CALL 0x00133bd0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x10
POP RBP
RET
|
int8 get_current_logfile(void)
{
int8 uVar1;
inline_mysql_rwlock_rdlock
(&DAT_0057ffe8,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x43f);
uVar1 = *DAT_0057ffb8;
inline_mysql_rwlock_unlock(&DAT_0057ffe8);
return uVar1;
}
| |
35,292 | string_view::operator==(string_view const&) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | bool operator==(const string_view & other) const {
std::string this_str = *this;
std::string other_str = other;
return this_str == other_str;
} | O3 | cpp | string_view::operator==(string_view const&) const:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x8(%rsp), %rdi
callq 0x19700
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x19700
movq 0x10(%rsp), %rdx
cmpq 0x30(%rsp), %rdx
jne 0x52736
movq 0x28(%rsp), %r14
testq %rdx, %rdx
je 0x5273f
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x196f0
testl %eax, %eax
sete %bl
jmp 0x52741
movq 0x28(%rsp), %r14
xorl %ebx, %ebx
jmp 0x52741
movb $0x1, %bl
leaq 0x38(%rsp), %rax
cmpq %rax, %r14
je 0x5275b
movq 0x38(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x196b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52776
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5279e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
movq %rbx, %rdi
callq 0x19be0
| _ZNK11string_vieweqERKS_:
push r14
push rbx
sub rsp, 48h
mov rbx, rsi
mov rsi, [rdi]
mov rdx, [rdi+8]
mov rcx, [rdi+10h]
sub rcx, rdx
lea rdi, [rsp+58h+var_50]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rcx, [rbx+10h]
sub rcx, rdx
lea rdi, [rsp+58h+var_30]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdx, [rsp+58h+var_48]
cmp rdx, [rsp+58h+var_28]
jnz short loc_52736
mov r14, [rsp+58h+var_30]
test rdx, rdx
jz short loc_5273F
mov rdi, [rsp+58h+var_50]
mov rsi, r14
call _bcmp
test eax, eax
setz bl
jmp short loc_52741
loc_52736:
mov r14, [rsp+58h+var_30]
xor ebx, ebx
jmp short loc_52741
loc_5273F:
mov bl, 1
loc_52741:
lea rax, [rsp+58h+var_20]
cmp r14, rax
jz short loc_5275B
mov rsi, [rsp+58h+var_20]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_5275B:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_52776
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_52776:
mov eax, ebx
add rsp, 48h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5279E
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5279E:
mov rdi, rbx
call __Unwind_Resume
| long long string_view::operator==(_QWORD *a1, _QWORD *a2)
{
long long *v3; // r14
long long *v5; // [rsp+8h] [rbp-50h] BYREF
void *v6; // [rsp+10h] [rbp-48h]
long long v7; // [rsp+18h] [rbp-40h] BYREF
void *v8[2]; // [rsp+28h] [rbp-30h] BYREF
long long v9; // [rsp+38h] [rbp-20h] BYREF
std::string::substr(&v5, *a1, a1[1], a1[2] - a1[1]);
std::string::substr(v8, *a2, a2[1], a2[2] - a2[1]);
if ( v6 == v8[1] )
{
v3 = (long long *)v8[0];
if ( v6 )
LOBYTE(a2) = (unsigned int)bcmp(v5, v8[0], v6) == 0;
else
LOBYTE(a2) = 1;
}
else
{
v3 = (long long *)v8[0];
LODWORD(a2) = 0;
}
if ( v3 != &v9 )
operator delete(v3, v9 + 1);
if ( v5 != &v7 )
operator delete(v5, v7 + 1);
return (unsigned int)a2;
}
| operator==:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV RSI,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
SUB RCX,RDX
LEA RDI,[RSP + 0x8]
CALL 0x00119700
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
SUB RCX,RDX
LAB_00152702:
LEA RDI,[RSP + 0x28]
CALL 0x00119700
LAB_0015270c:
MOV RDX,qword ptr [RSP + 0x10]
CMP RDX,qword ptr [RSP + 0x30]
JNZ 0x00152736
MOV R14,qword ptr [RSP + 0x28]
TEST RDX,RDX
JZ 0x0015273f
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
CALL 0x001196f0
TEST EAX,EAX
SETZ BL
JMP 0x00152741
LAB_00152736:
MOV R14,qword ptr [RSP + 0x28]
XOR EBX,EBX
JMP 0x00152741
LAB_0015273f:
MOV BL,0x1
LAB_00152741:
LEA RAX,[RSP + 0x38]
CMP R14,RAX
JZ 0x0015275b
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
MOV RDI,R14
CALL 0x001196b0
LAB_0015275b:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00152776
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001196b0
LAB_00152776:
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* string_view::TEMPNAMEPLACEHOLDERVALUE(string_view const&) const */
ulong __thiscall string_view::operator==(string_view *this,string_view *param_1)
{
int iVar1;
int7 uVar3;
ulong uVar2;
long *local_50;
size_t local_48;
long local_40 [2];
long *local_30;
size_t local_28;
long local_20 [2];
std::__cxx11::string::substr((ulong)&local_50,*(ulong *)this);
/* try { // try from 00152702 to 0015270b has its CatchHandler @ 00152780 */
std::__cxx11::string::substr((ulong)&local_30,*(ulong *)param_1);
if (local_48 == local_28) {
uVar3 = (int7)((ulong)param_1 >> 8);
if (local_48 == 0) {
uVar2 = CONCAT71(uVar3,1);
}
else {
iVar1 = bcmp(local_50,local_30,local_48);
uVar2 = CONCAT71(uVar3,iVar1 == 0);
}
}
else {
uVar2 = 0;
}
if (local_30 != local_20) {
operator_delete(local_30,local_20[0] + 1);
}
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
return uVar2 & 0xffffffff;
}
| |
35,293 | my_interval_timer | eloqsql/mysys/my_getsystime.c | ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
} | O3 | c | my_interval_timer:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x24260
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
addq 0x8(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| my_interval_timer:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
lea rbx, [rbp+var_18]
mov edi, 1
mov rsi, rbx
call _clock_gettime
imul rax, [rbx], 3B9ACA00h
add rax, [rbx+8]
add rsp, 18h
pop rbx
pop rbp
retn
| long long my_interval_timer()
{
_QWORD v1[3]; // [rsp+8h] [rbp-18h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
| my_interval_timer:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
LEA RBX,[RBP + -0x18]
MOV EDI,0x1
MOV RSI,RBX
CALL 0x00124260
IMUL RAX,qword ptr [RBX],0x3b9aca00
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_20;
clock_gettime(1,&local_20);
return local_20.tv_sec * 1000000000 + local_20.tv_nsec;
}
| |
35,294 | save_pack_length | eloqsql/storage/myisam/mi_packrec.c | uint save_pack_length(uint version, uchar *block_buff, ulong length)
{
if (length < 254)
{
*(uchar*) block_buff= (uchar) length;
return 1;
}
if (length <= 65535)
{
*(uchar*) block_buff=254;
int2store(block_buff+1,(uint) length);
return 3;
}
*(uchar*) block_buff=255;
if (version == 1) /* old format */
{
DBUG_ASSERT(length <= 0xFFFFFF);
int3store(block_buff + 1, (ulong) length);
return 4;
}
else
{
int4store(block_buff + 1, (ulong) length);
return 5;
}
} | O0 | c | save_pack_length:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xfe, -0x18(%rbp)
jae 0x44321
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x443c0
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x44355
movq -0x10(%rbp), %rax
movb $-0x2, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x443c0
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
cmpl $0x1, -0x8(%rbp)
jne 0x4439f
jmp 0x44364
jmp 0x44366
jmp 0x44368
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x443c0
jmp 0x443a1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| save_pack_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_18], 0FEh
jnb short loc_44321
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_443C0
loc_44321:
cmp [rbp+var_18], 0FFFFh
ja short loc_44355
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FEh
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov cx, ax
mov rax, [rbp+var_20]
mov [rax], cx
mov [rbp+var_4], 3
jmp short loc_443C0
loc_44355:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FFh
cmp [rbp+var_8], 1
jnz short loc_4439F
jmp short $+2
loc_44364:
jmp short $+2
loc_44366:
jmp short $+2
loc_44368:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov [rbp+var_4], 4
jmp short loc_443C0
loc_4439F:
jmp short $+2
loc_443A1:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax], ecx
mov [rbp+var_4], 5
loc_443C0:
mov eax, [rbp+var_4]
pop rbp
retn
| long long save_pack_length(int a1, long long a2, unsigned long long a3)
{
if ( a3 >= 0xFE )
{
if ( a3 > 0xFFFF )
{
*(_BYTE *)a2 = -1;
if ( a1 == 1 )
{
*(_WORD *)(a2 + 1) = a3;
*(_BYTE *)(a2 + 3) = BYTE2(a3);
return 4;
}
else
{
*(_DWORD *)(a2 + 1) = a3;
return 5;
}
}
else
{
*(_BYTE *)a2 = -2;
*(_WORD *)(a2 + 1) = a3;
return 3;
}
}
else
{
*(_BYTE *)a2 = a3;
return 1;
}
}
| save_pack_length:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x18],0xfe
JNC 0x00144321
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001443c0
LAB_00144321:
CMP qword ptr [RBP + -0x18],0xffff
JA 0x00144355
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xfe
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX],CX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001443c0
LAB_00144355:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xff
CMP dword ptr [RBP + -0x8],0x1
JNZ 0x0014439f
JMP 0x00144364
LAB_00144364:
JMP 0x00144366
LAB_00144366:
JMP 0x00144368
LAB_00144368:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV dword ptr [RBP + -0x4],0x4
JMP 0x001443c0
LAB_0014439f:
JMP 0x001443a1
LAB_001443a1:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x5
LAB_001443c0:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 save_pack_length(int param_1,int1 *param_2,ulong param_3)
{
int4 local_c;
if (param_3 < 0xfe) {
*param_2 = (char)param_3;
local_c = 1;
}
else if (param_3 < 0x10000) {
*param_2 = 0xfe;
*(short *)(param_2 + 1) = (short)param_3;
local_c = 3;
}
else {
*param_2 = 0xff;
if (param_1 == 1) {
param_2[1] = (char)param_3;
param_2[2] = (char)(param_3 >> 8);
param_2[3] = (char)(param_3 >> 0x10);
local_c = 4;
}
else {
*(int *)(param_2 + 1) = (int)param_3;
local_c = 5;
}
}
return local_c;
}
| |
35,295 | save_pack_length | eloqsql/storage/myisam/mi_packrec.c | uint save_pack_length(uint version, uchar *block_buff, ulong length)
{
if (length < 254)
{
*(uchar*) block_buff= (uchar) length;
return 1;
}
if (length <= 65535)
{
*(uchar*) block_buff=254;
int2store(block_buff+1,(uint) length);
return 3;
}
*(uchar*) block_buff=255;
if (version == 1) /* old format */
{
DBUG_ASSERT(length <= 0xFFFFFF);
int3store(block_buff + 1, (ulong) length);
return 4;
}
else
{
int4store(block_buff + 1, (ulong) length);
return 5;
}
} | O3 | c | save_pack_length:
pushq %rbp
movq %rsp, %rbp
cmpq $0xfd, %rdx
ja 0x3a14c
movb %dl, (%rsi)
movl $0x1, %eax
jmp 0x3a186
cmpq $0xffff, %rdx # imm = 0xFFFF
ja 0x3a163
movb $-0x2, (%rsi)
movw %dx, 0x1(%rsi)
movl $0x3, %eax
jmp 0x3a186
movb $-0x1, (%rsi)
cmpl $0x1, %edi
jne 0x3a17e
movb %dl, 0x1(%rsi)
movb %dh, 0x2(%rsi)
shrl $0x10, %edx
movb %dl, 0x3(%rsi)
movl $0x4, %eax
jmp 0x3a186
movl %edx, 0x1(%rsi)
movl $0x5, %eax
popq %rbp
retq
| save_pack_length:
push rbp
mov rbp, rsp
cmp rdx, 0FDh
ja short loc_3A14C
mov [rsi], dl
mov eax, 1
jmp short loc_3A186
loc_3A14C:
cmp rdx, 0FFFFh
ja short loc_3A163
mov byte ptr [rsi], 0FEh
mov [rsi+1], dx
mov eax, 3
jmp short loc_3A186
loc_3A163:
mov byte ptr [rsi], 0FFh
cmp edi, 1
jnz short loc_3A17E
mov [rsi+1], dl
mov [rsi+2], dh
shr edx, 10h
mov [rsi+3], dl
mov eax, 4
jmp short loc_3A186
loc_3A17E:
mov [rsi+1], edx
mov eax, 5
loc_3A186:
pop rbp
retn
| long long save_pack_length(int a1, long long a2, unsigned long long a3)
{
if ( a3 > 0xFD )
{
if ( a3 > 0xFFFF )
{
*(_BYTE *)a2 = -1;
if ( a1 == 1 )
{
*(_WORD *)(a2 + 1) = a3;
*(_BYTE *)(a2 + 3) = BYTE2(a3);
return 4LL;
}
else
{
*(_DWORD *)(a2 + 1) = a3;
return 5LL;
}
}
else
{
*(_BYTE *)a2 = -2;
*(_WORD *)(a2 + 1) = a3;
return 3LL;
}
}
else
{
*(_BYTE *)a2 = a3;
return 1LL;
}
}
| save_pack_length:
PUSH RBP
MOV RBP,RSP
CMP RDX,0xfd
JA 0x0013a14c
MOV byte ptr [RSI],DL
MOV EAX,0x1
JMP 0x0013a186
LAB_0013a14c:
CMP RDX,0xffff
JA 0x0013a163
MOV byte ptr [RSI],0xfe
MOV word ptr [RSI + 0x1],DX
MOV EAX,0x3
JMP 0x0013a186
LAB_0013a163:
MOV byte ptr [RSI],0xff
CMP EDI,0x1
JNZ 0x0013a17e
MOV byte ptr [RSI + 0x1],DL
MOV byte ptr [RSI + 0x2],DH
SHR EDX,0x10
MOV byte ptr [RSI + 0x3],DL
MOV EAX,0x4
JMP 0x0013a186
LAB_0013a17e:
MOV dword ptr [RSI + 0x1],EDX
MOV EAX,0x5
LAB_0013a186:
POP RBP
RET
|
int8 save_pack_length(int param_1,int1 *param_2,ulong param_3)
{
int8 uVar1;
if (param_3 < 0xfe) {
*param_2 = (char)param_3;
uVar1 = 1;
}
else if (param_3 < 0x10000) {
*param_2 = 0xfe;
*(short *)(param_2 + 1) = (short)param_3;
uVar1 = 3;
}
else {
*param_2 = 0xff;
if (param_1 == 1) {
param_2[1] = (char)param_3;
param_2[2] = (char)(param_3 >> 8);
param_2[3] = (char)(param_3 >> 0x10);
uVar1 = 4;
}
else {
*(int *)(param_2 + 1) = (int)param_3;
uVar1 = 5;
}
}
return uVar1;
}
| |
35,296 | mi_make_key | eloqsql/storage/myisam/mi_key.c | uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
const uchar *record, my_off_t filepos)
{
uchar *pos;
uchar *start;
reg1 HA_KEYSEG *keyseg;
my_bool is_ft= info->s->keyinfo[keynr].flag & HA_FULLTEXT;
DBUG_ENTER("_mi_make_key");
if (info->s->keyinfo[keynr].flag & HA_SPATIAL)
{
/*
TODO: nulls processing
*/
#ifdef HAVE_SPATIAL
DBUG_RETURN(sp_make_key(info,keynr,key,record,filepos));
#else
DBUG_ASSERT(0); /* mi_open should check that this never happens*/
#endif
}
start=key;
for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
size_t length=keyseg->length;
size_t char_length;
CHARSET_INFO *cs=keyseg->charset;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
*key++= 0; /* NULL in key */
continue;
}
*key++=1; /* Not NULL */
}
char_length= ((!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
length);
pos= (uchar*) record+keyseg->start;
if (type == HA_KEYTYPE_BIT)
{
if (keyseg->bit_length)
{
uchar bits= get_rec_bits((uchar*) record + keyseg->bit_pos,
keyseg->bit_start, keyseg->bit_length);
*key++= bits;
length--;
}
memcpy((uchar*) key, pos, length);
key+= length;
continue;
}
if (keyseg->flag & HA_SPACE_PACK)
{
if (type != HA_KEYTYPE_NUM)
{
length= my_ci_lengthsp(cs, (char*) pos, length);
}
else
{
uchar *end= pos + length;
while (pos < end && pos[0] == ' ')
pos++;
length=(size_t) (end-pos);
}
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos,char_length);
key+=char_length;
continue;
}
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= (keyseg->bit_start == 1 ? 1 : 2);
uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos, char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy(&pos,pos+keyseg->bit_start,sizeof(char*));
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
if (char_length)
{
memcpy(key, pos, char_length);
key+= char_length;
}
continue;
}
else if (keyseg->flag & HA_SWAP_KEY)
{ /* Numerical column */
if (type == HA_KEYTYPE_FLOAT)
{
float nr;
float4get(nr,pos);
if (isnan(nr))
{
/* Replace NAN with zero */
bzero(key,length);
key+=length;
continue;
}
}
else if (type == HA_KEYTYPE_DOUBLE)
{
double nr;
float8get(nr,pos);
if (isnan(nr))
{
bzero(key,length);
key+=length;
continue;
}
}
pos+=length;
while (length--)
{
*key++ = *--pos;
}
continue;
}
FIX_LENGTH(cs, pos, length, char_length);
memcpy((uchar*) key, pos, char_length);
if (length > char_length)
my_ci_fill(cs, (char*) key+char_length, length-char_length, ' ');
key+= length;
}
_mi_dpointer(info,key,filepos);
DBUG_PRINT("exit",("keynr: %d",keynr));
DBUG_DUMP("key",(uchar*) start,(uint) (key-start)+keyseg->length);
DBUG_EXECUTE("key",
_mi_print_key(DBUG_FILE,info->s->keyinfo[keynr].seg,start,
(uint) (key-start)););
DBUG_RETURN((uint) (key-start)); /* Return keylength */
} | O3 | c | mi_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r9
movq (%rdi), %rax
movq 0x218(%rax), %rax
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
movzwl 0xa(%rax,%rcx), %r10d
movl %r10d, -0x44(%rbp)
btl $0xa, %r10d
jb 0x333cc
movq %rdi, -0x60(%rbp)
movq %r8, -0x68(%rbp)
addq %rcx, %rax
movq 0x28(%rax), %r15
movb 0x18(%r15), %cl
movq %rdx, -0x50(%rbp)
movq %rdx, %rdi
testb %cl, %cl
je 0x333e2
leaq -0x1(%r9), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %r9, -0x30(%rbp)
movzwl 0x14(%r15), %ebx
movq (%r15), %r13
movb 0x19(%r15), %dl
testb %dl, %dl
je 0x33031
movl 0xc(%r15), %esi
leaq 0x1(%rax), %rdi
testb %dl, (%r9,%rsi)
je 0x33036
movb $0x0, (%rax)
jmp 0x33331
movq %rax, %rdi
jmp 0x33039
movb $0x1, (%rax)
cmpb $0x0, -0x44(%rbp)
setns %al
testq %r13, %r13
setne %dl
andb %al, %dl
movq %rbx, %r12
cmpb $0x1, %dl
jne 0x33068
movl 0x9c(%r13), %esi
movq %rbx, %r12
cmpl $0x2, %esi
jb 0x33068
movl %ebx, %eax
xorl %edx, %edx
divl %esi
movl %eax, %r12d
movl 0x8(%r15), %eax
leaq (%r9,%rax), %r14
cmpb $0x13, %cl
jne 0x330da
movzbl 0x1b(%r15), %eax
testl %eax, %eax
je 0x330be
movq %rdi, %r8
movzwl 0x10(%r15), %esi
movzbl 0x1a(%r15), %ecx
movzbl (%r9,%rsi), %edx
leal (%rcx,%rax), %edi
cmpl $0x9, %edi
jb 0x330a3
movzbl 0x1(%r9,%rsi), %esi
shll $0x8, %esi
orl %esi, %edx
movq %r8, %rdi
shrl %cl, %edx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %esi
notl %esi
andl %edx, %esi
movb %sil, (%r8)
incq %rdi
decq %rbx
movq %rbx, %r12
movq %rdi, %rbx
movq %r14, %rsi
movq %r12, %rdx
callq 0x282c0
movq %rbx, %rdi
addq %r12, %rdi
jmp 0x3332d
movzwl 0x12(%r15), %edx
testb $0x1, %dl
jne 0x33180
testb $0x8, %dl
jne 0x331a7
testb $0x20, %dl
jne 0x33238
testb $0x40, %dl
jne 0x33349
cmpl %ebx, %r12d
jae 0x33130
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %rbx, -0x40(%rbp)
movq %rdi, %rbx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rbx, %rdi
movq -0x40(%rbp), %rbx
movq %rax, %r12
cmpq %rbx, %r12
movq %rbx, %rax
cmovbq %r12, %rbx
movq %rdi, -0x38(%rbp)
movq %r14, %rsi
movq %rax, %r14
movq %rbx, %rdx
callq 0x282c0
cmpq %r14, %r12
movq -0x38(%rbp), %r12
jae 0x33171
leaq (%r12,%rbx), %rsi
movq %r14, %rdx
subq %rbx, %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movl $0x20, %ecx
callq *0x78(%rax)
addq %r14, %r12
movq -0x30(%rbp), %r9
movq %r12, %rdi
jmp 0x33331
cmpb $0x7, %cl
movq %rdi, -0x38(%rbp)
jne 0x331c0
movq %rbx, %rax
addq %r14, %rbx
testq %rax, %rax
je 0x331a2
cmpb $0x20, (%r14)
jne 0x331a2
incq %r14
cmpq %rbx, %r14
jb 0x33194
subq %r14, %rbx
jmp 0x331d6
cmpb $0x1, 0x1a(%r15)
jne 0x332ac
movzbl (%r14), %eax
movl $0x1, %ecx
jmp 0x332b5
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rax, %rbx
cmpq %r12, %rbx
jbe 0x331f5
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rax, %r12
movq -0x38(%rbp), %rcx
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x33211
leaq 0x1(%rcx), %r12
movl %ebx, %eax
jmp 0x3321d
movb %bl, 0x2(%rcx)
movb %bh, 0x1(%rcx)
leaq 0x3(%rcx), %r12
movb $-0x1, %al
movb %al, (%rcx)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x282c0
addq %rbx, %r12
movq %r12, %rdi
jmp 0x3332d
movq %rdi, -0x38(%rbp)
movzbl 0x1a(%r15), %edi
movq %r14, %rsi
callq 0x30cad
movzbl 0x1a(%r15), %ecx
movq (%r14,%rcx), %rsi
movl %eax, %eax
cmpq %rbx, %rax
cmovbq %rax, %rbx
cmpq %r12, %rbx
jbe 0x3327d
leaq (%rsi,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %rsi, %r14
movq %r12, %rcx
callq *0x10(%rax)
movq %r14, %rsi
movq %rax, %r12
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rdi
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x3337e
movb %bl, (%rdi)
incq %rdi
testq %rbx, %rbx
jne 0x3338b
jmp 0x33331
movzwl (%r14), %eax
movl $0x2, %ecx
addq %rcx, %r14
cmpq %rbx, %rax
cmovbq %rax, %rbx
cmpq %r12, %rbx
jbe 0x332ec
leaq (%r14,%rbx), %rdx
movq 0xb8(%r13), %rax
movq %rbx, -0x40(%rbp)
movq %rdi, %rbx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq *0x10(%rax)
movq %rbx, %rdi
movq -0x40(%rbp), %rbx
movq %rax, %r12
cmpq %rbx, %r12
cmovbq %r12, %rbx
cmpq $0xff, %rbx
jae 0x33308
movq %rbx, %r12
leaq 0x1(%rdi), %rbx
movl %r12d, %eax
jmp 0x33317
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
movq %rbx, %r12
leaq 0x3(%rdi), %rbx
movb $-0x1, %al
movb %al, (%rdi)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x282c0
addq %r12, %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %r9
movb 0x38(%r15), %cl
addq $0x20, %r15
movq %rdi, %rax
testb %cl, %cl
jne 0x3300b
jmp 0x333e2
cmpb $0x6, %cl
je 0x333a2
movzbl %cl, %ecx
cmpl $0x5, %ecx
jne 0x33360
movss (%r14), %xmm0
ucomiss %xmm0, %xmm0
jp 0x333ad
testl %ebx, %ebx
je 0x33331
addq -0x58(%rbp), %rax
movq %rdi, %rcx
leaq 0x1(%rcx), %rdi
movb (%rax,%rbx), %dl
movb %dl, (%rcx)
movq %rdi, %rcx
decq %rbx
jne 0x3336b
jmp 0x33331
movb $-0x1, (%rdi)
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
addq $0x3, %rdi
movq %rdi, %r14
movq %rbx, %rdx
callq 0x282c0
movq %r14, %rdi
movq -0x30(%rbp), %r9
addq %rbx, %rdi
jmp 0x33331
movsd (%r14), %xmm0
ucomisd %xmm0, %xmm0
jnp 0x33360
movq %rbx, %r14
movq %rdi, %rbx
xorl %esi, %esi
movq %r14, %rdx
callq 0x281c0
movq %rbx, %rdi
movq -0x30(%rbp), %r9
addq %r14, %rdi
jmp 0x33331
movq %r9, %rcx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x476d4
movq %rdi, %rbx
movq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq -0x68(%rbp), %rdx
callq 0x3d71f
subl -0x50(%rbp), %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r9, rcx
mov rax, [rdi]
mov rax, [rax+218h]
mov ecx, esi
imul rcx, 70h ; 'p'
movzx r10d, word ptr [rax+rcx+0Ah]
mov [rbp+var_44], r10d
bt r10d, 0Ah
jb loc_333CC
mov [rbp+var_60], rdi
mov [rbp+var_68], r8
add rax, rcx
mov r15, [rax+28h]
mov cl, [r15+18h]
mov [rbp+var_50], rdx
mov rdi, rdx
test cl, cl
jz loc_333E2
lea rax, [r9-1]
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov [rbp+var_30], r9
loc_3300B:
movzx ebx, word ptr [r15+14h]
mov r13, [r15]
mov dl, [r15+19h]
test dl, dl
jz short loc_33031
mov esi, [r15+0Ch]
lea rdi, [rax+1]
test [r9+rsi], dl
jz short loc_33036
mov byte ptr [rax], 0
jmp loc_33331
loc_33031:
mov rdi, rax
jmp short loc_33039
loc_33036:
mov byte ptr [rax], 1
loc_33039:
cmp byte ptr [rbp+var_44], 0
setns al
test r13, r13
setnz dl
and dl, al
mov r12, rbx
cmp dl, 1
jnz short loc_33068
mov esi, [r13+9Ch]
mov r12, rbx
cmp esi, 2
jb short loc_33068
mov eax, ebx
xor edx, edx
div esi
mov r12d, eax
loc_33068:
mov eax, [r15+8]
lea r14, [r9+rax]
cmp cl, 13h
jnz short loc_330DA
movzx eax, byte ptr [r15+1Bh]
test eax, eax
jz short loc_330BE
mov r8, rdi
movzx esi, word ptr [r15+10h]
movzx ecx, byte ptr [r15+1Ah]
movzx edx, byte ptr [r9+rsi]
lea edi, [rcx+rax]
cmp edi, 9
jb short loc_330A3
movzx esi, byte ptr [r9+rsi+1]
shl esi, 8
or edx, esi
loc_330A3:
mov rdi, r8
shr edx, cl
mov esi, 0FFFFFFFFh
mov ecx, eax
shl esi, cl
not esi
and esi, edx
mov [r8], sil
inc rdi
dec rbx
loc_330BE:
mov r12, rbx
mov rbx, rdi
mov rsi, r14
mov rdx, r12
call _memcpy
mov rdi, rbx
add rdi, r12
jmp loc_3332D
loc_330DA:
movzx edx, word ptr [r15+12h]
test dl, 1
jnz loc_33180
test dl, 8
jnz loc_331A7
test dl, 20h
jnz loc_33238
test dl, 40h
jnz loc_33349
cmp r12d, ebx
jnb short loc_33130
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov [rbp+var_40], rbx
mov rbx, rdi
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov rdi, rbx
mov rbx, [rbp+var_40]
mov r12, rax
loc_33130:
cmp r12, rbx
mov rax, rbx
cmovb rbx, r12
mov [rbp+var_38], rdi
mov rsi, r14
mov r14, rax
mov rdx, rbx
call _memcpy
cmp r12, r14
mov r12, [rbp+var_38]
jnb short loc_33171
lea rsi, [r12+rbx]
mov rdx, r14
sub rdx, rbx
mov rax, [r13+0B8h]
mov rdi, r13
mov ecx, 20h ; ' '
call qword ptr [rax+78h]
loc_33171:
add r12, r14
mov r9, [rbp+var_30]
mov rdi, r12
jmp loc_33331
loc_33180:
cmp cl, 7
mov [rbp+var_38], rdi
jnz short loc_331C0
mov rax, rbx
add rbx, r14
test rax, rax
jz short loc_331A2
loc_33194:
cmp byte ptr [r14], 20h ; ' '
jnz short loc_331A2
inc r14
cmp r14, rbx
jb short loc_33194
loc_331A2:
sub rbx, r14
jmp short loc_331D6
loc_331A7:
cmp byte ptr [r15+1Ah], 1
jnz loc_332AC
movzx eax, byte ptr [r14]
mov ecx, 1
jmp loc_332B5
loc_331C0:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r14
mov rdx, rbx
call qword ptr [rax+18h]
mov rbx, rax
loc_331D6:
cmp rbx, r12
jbe short loc_331F5
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov r12, rax
loc_331F5:
mov rcx, [rbp+var_38]
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb short loc_33211
lea r12, [rcx+1]
mov eax, ebx
jmp short loc_3321D
loc_33211:
mov [rcx+2], bl
mov [rcx+1], bh
lea r12, [rcx+3]
mov al, 0FFh
loc_3321D:
mov [rcx], al
mov rdi, r12
mov rsi, r14
mov rdx, rbx
call _memcpy
add r12, rbx
mov rdi, r12
jmp loc_3332D
loc_33238:
mov [rbp+var_38], rdi
movzx edi, byte ptr [r15+1Ah]
mov rsi, r14
call _mi_calc_blob_length
movzx ecx, byte ptr [r15+1Ah]
mov rsi, [r14+rcx]
mov eax, eax
cmp rax, rbx
cmovb rbx, rax
cmp rbx, r12
jbe short loc_3327D
lea rdx, [rsi+rbx]
mov rax, [r13+0B8h]
mov rdi, r13
mov r14, rsi
mov rcx, r12
call qword ptr [rax+10h]
mov rsi, r14
mov r12, rax
loc_3327D:
mov r9, [rbp+var_30]
mov rdi, [rbp+var_38]
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb loc_3337E
mov [rdi], bl
inc rdi
test rbx, rbx
jnz loc_3338B
jmp loc_33331
loc_332AC:
movzx eax, word ptr [r14]
mov ecx, 2
loc_332B5:
add r14, rcx
cmp rax, rbx
cmovb rbx, rax
cmp rbx, r12
jbe short loc_332EC
lea rdx, [r14+rbx]
mov rax, [r13+0B8h]
mov [rbp+var_40], rbx
mov rbx, rdi
mov rdi, r13
mov rsi, r14
mov rcx, r12
call qword ptr [rax+10h]
mov rdi, rbx
mov rbx, [rbp+var_40]
mov r12, rax
loc_332EC:
cmp r12, rbx
cmovb rbx, r12
cmp rbx, 0FFh
jnb short loc_33308
mov r12, rbx
lea rbx, [rdi+1]
mov eax, r12d
jmp short loc_33317
loc_33308:
mov [rdi+2], bl
mov [rdi+1], bh
mov r12, rbx
lea rbx, [rdi+3]
mov al, 0FFh
loc_33317:
mov [rdi], al
mov rdi, rbx
mov rsi, r14
mov rdx, r12
call _memcpy
add rbx, r12
mov rdi, rbx
loc_3332D:
mov r9, [rbp+var_30]
loc_33331:
mov cl, [r15+38h]
add r15, 20h ; ' '
mov rax, rdi
test cl, cl
jnz loc_3300B
jmp loc_333E2
loc_33349:
cmp cl, 6
jz short loc_333A2
movzx ecx, cl
cmp ecx, 5
jnz short loc_33360
movss xmm0, dword ptr [r14]
ucomiss xmm0, xmm0
jp short loc_333AD
loc_33360:
test ebx, ebx
jz short loc_33331
add rax, [rbp+var_58]
mov rcx, rdi
loc_3336B:
lea rdi, [rcx+1]
mov dl, [rax+rbx]
mov [rcx], dl
mov rcx, rdi
dec rbx
jnz short loc_3336B
jmp short loc_33331
loc_3337E:
mov byte ptr [rdi], 0FFh
mov [rdi+2], bl
mov [rdi+1], bh
add rdi, 3
loc_3338B:
mov r14, rdi
mov rdx, rbx
call _memcpy
mov rdi, r14
mov r9, [rbp+var_30]
add rdi, rbx
jmp short loc_33331
loc_333A2:
movsd xmm0, qword ptr [r14]
ucomisd xmm0, xmm0
jnp short loc_33360
loc_333AD:
mov r14, rbx
mov rbx, rdi
xor esi, esi
mov rdx, r14
call _memset
mov rdi, rbx
mov r9, [rbp+var_30]
add rdi, r14
jmp loc_33331
loc_333CC:
mov rcx, r9
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp sp_make_key
loc_333E2:
mov rbx, rdi
mov rdi, [rbp+var_60]
mov rsi, rbx
mov rdx, [rbp+var_68]
call _mi_dpointer
sub ebx, dword ptr [rbp+var_50]
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_make_key(long long a1, long long a2, char *a3, long long a4, long long a5)
{
long long v6; // rax
long long v7; // rcx
long long *v8; // r15
char v9; // cl
char *v10; // rdi
char *v11; // rax
unsigned long long v12; // rbx
long long v13; // r13
unsigned __int8 v14; // dl
unsigned long long v15; // r12
unsigned int v16; // esi
long long v17; // rax
_BYTE *v18; // r14
int v19; // eax
long long v20; // rsi
int v21; // ecx
unsigned int v22; // edx
__int16 v23; // dx
unsigned long long v24; // rax
_BYTE *v25; // rsi
unsigned long long v26; // r14
unsigned long long v27; // rax
_BYTE *v28; // rbx
unsigned long long v29; // rbx
unsigned long long v30; // rax
long long v31; // rcx
_BYTE *v32; // r12
char v33; // al
unsigned int v34; // eax
long long v35; // rsi
_BYTE *v36; // r14
unsigned long long v37; // r12
_BYTE *v38; // rbx
char v39; // al
long long v40; // rax
char *v41; // rcx
long long v45; // [rsp+18h] [rbp-58h]
int v46; // [rsp+20h] [rbp-50h]
__int16 v47; // [rsp+2Ch] [rbp-44h]
long long v48; // [rsp+40h] [rbp-30h]
v6 = *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v7 = 112LL * (unsigned int)a2;
v47 = *(_WORD *)(v6 + v7 + 10);
if ( (v47 & 0x400) != 0 )
return sp_make_key(a1, a2, a3, a4);
v8 = *(long long **)(v7 + v6 + 40);
v9 = *((_BYTE *)v8 + 24);
v46 = (int)a3;
v10 = a3;
if ( v9 )
{
v45 = a4 - 1;
v11 = a3;
v48 = a4;
do
{
v12 = *((unsigned __int16 *)v8 + 10);
v13 = *v8;
v14 = *((_BYTE *)v8 + 25);
if ( v14 )
{
v10 = v11 + 1;
if ( (v14 & *(_BYTE *)(a4 + *((unsigned int *)v8 + 3))) != 0 )
{
*v11 = 0;
goto LABEL_66;
}
*v11 = 1;
}
else
{
v10 = v11;
}
v15 = v12;
if ( (v47 & 0x80u) == 0 && v13 != 0 )
{
v16 = *(_DWORD *)(v13 + 156);
v15 = v12;
if ( v16 >= 2 )
v15 = (unsigned int)v12 / v16;
}
v17 = *((unsigned int *)v8 + 2);
v18 = (_BYTE *)(a4 + v17);
if ( v9 == 19 )
{
v19 = *((unsigned __int8 *)v8 + 27);
if ( *((_BYTE *)v8 + 27) )
{
v20 = *((unsigned __int16 *)v8 + 8);
v21 = *((unsigned __int8 *)v8 + 26);
v22 = *(unsigned __int8 *)(a4 + v20);
if ( (unsigned int)(v21 + v19) >= 9 )
v22 = *(unsigned __int16 *)(a4 + v20);
*v10++ = (v22 >> v21) & ~(-1 << v19);
--v12;
}
memcpy(v10, v18, v12);
v10 += v12;
LABEL_65:
a4 = v48;
goto LABEL_66;
}
v23 = *((_WORD *)v8 + 9);
if ( (v23 & 1) != 0 )
{
if ( v9 == 7 )
{
v27 = v12;
v28 = &v18[v12];
if ( v27 )
{
do
{
if ( *v18 != 32 )
break;
++v18;
}
while ( v18 < v28 );
}
v29 = v28 - v18;
}
else
{
v29 = (*(long long ( **)(long long, _BYTE *, unsigned long long))(*(_QWORD *)(v13 + 184) + 24LL))(
v13,
v18,
v12);
}
if ( v29 > v15 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v13 + 184) + 16LL))(
v13,
v18,
&v18[v29],
v15);
if ( v15 < v29 )
v29 = v15;
if ( v29 >= 0xFF )
{
v10[2] = v29;
v10[1] = BYTE1(v29);
v32 = v10 + 3;
v33 = -1;
}
else
{
v32 = v10 + 1;
v33 = v29;
}
*v10 = v33;
memcpy(v32, v18, v29);
v10 = &v32[v29];
goto LABEL_65;
}
if ( (v23 & 8) != 0 )
{
if ( *((_BYTE *)v8 + 26) == 1 )
{
v30 = (unsigned __int8)*v18;
v31 = 1LL;
}
else
{
v30 = *(unsigned __int16 *)v18;
v31 = 2LL;
}
v36 = &v18[v31];
if ( v30 < v12 )
v12 = v30;
if ( v12 > v15 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v13 + 184) + 16LL))(
v13,
v36,
&v36[v12],
v15);
if ( v15 < v12 )
v12 = v15;
if ( v12 >= 0xFF )
{
v10[2] = v12;
v10[1] = BYTE1(v12);
v37 = v12;
v38 = v10 + 3;
v39 = -1;
}
else
{
v37 = v12;
v38 = v10 + 1;
v39 = v37;
}
*v10 = v39;
memcpy(v38, v36, v37);
v10 = &v38[v37];
goto LABEL_65;
}
if ( (v23 & 0x20) == 0 )
{
if ( (v23 & 0x40) != 0 )
{
if ( (_DWORD)v12 )
{
v40 = v45 + v17;
v41 = v10;
do
{
v10 = v41 + 1;
*v41++ = *(_BYTE *)(v40 + v12--);
}
while ( v12 );
}
}
else
{
if ( (unsigned int)v15 < (unsigned int)v12 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, unsigned long long))(*(_QWORD *)(v13 + 184) + 16LL))(
v13,
v18,
&v18[v12],
v15);
v24 = v12;
if ( v15 < v12 )
v12 = v15;
v25 = v18;
v26 = v24;
memcpy(v10, v25, v12);
if ( v15 < v26 )
(*(void ( **)(long long, char *, unsigned long long, long long))(*(_QWORD *)(v13 + 184) + 120LL))(
v13,
&v10[v12],
v26 - v12,
32LL);
a4 = v48;
v10 += v26;
}
goto LABEL_66;
}
v34 = mi_calc_blob_length(*((unsigned __int8 *)v8 + 26), (unsigned __int8 *)(a4 + v17));
v35 = *(_QWORD *)&v18[*((unsigned __int8 *)v8 + 26)];
if ( v34 < v12 )
v12 = v34;
if ( v12 > v15 )
v15 = (*(long long ( **)(long long, long long, unsigned long long, unsigned long long))(*(_QWORD *)(v13 + 184)
+ 16LL))(
v13,
v35,
v35 + v12,
v15);
a4 = v48;
if ( v15 < v12 )
v12 = v15;
if ( v12 >= 0xFF )
{
*v10 = -1;
v10[2] = v12;
v10[1] = BYTE1(v12);
v10 += 3;
}
else
{
*v10++ = v12;
if ( !v12 )
goto LABEL_66;
}
memcpy(v10, v35, v12);
a4 = v48;
v10 += v12;
LABEL_66:
v9 = *((_BYTE *)v8 + 56);
v8 += 4;
v11 = v10;
}
while ( v9 );
}
mi_dpointer(a1, v10, a5);
return (unsigned int)((_DWORD)v10 - v46);
}
| _mi_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R9,RCX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,ESI
IMUL RCX,RCX,0x70
MOVZX R10D,word ptr [RAX + RCX*0x1 + 0xa]
MOV dword ptr [RBP + -0x44],R10D
BT R10D,0xa
JC 0x001333cc
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],R8
ADD RAX,RCX
MOV R15,qword ptr [RAX + 0x28]
MOV CL,byte ptr [R15 + 0x18]
MOV qword ptr [RBP + -0x50],RDX
MOV RDI,RDX
TEST CL,CL
JZ 0x001333e2
LEA RAX,[R9 + -0x1]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x30],R9
LAB_0013300b:
MOVZX EBX,word ptr [R15 + 0x14]
MOV R13,qword ptr [R15]
MOV DL,byte ptr [R15 + 0x19]
TEST DL,DL
JZ 0x00133031
MOV ESI,dword ptr [R15 + 0xc]
LEA RDI,[RAX + 0x1]
TEST byte ptr [R9 + RSI*0x1],DL
JZ 0x00133036
MOV byte ptr [RAX],0x0
JMP 0x00133331
LAB_00133031:
MOV RDI,RAX
JMP 0x00133039
LAB_00133036:
MOV byte ptr [RAX],0x1
LAB_00133039:
CMP byte ptr [RBP + -0x44],0x0
SETNS AL
TEST R13,R13
SETNZ DL
AND DL,AL
MOV R12,RBX
CMP DL,0x1
JNZ 0x00133068
MOV ESI,dword ptr [R13 + 0x9c]
MOV R12,RBX
CMP ESI,0x2
JC 0x00133068
MOV EAX,EBX
XOR EDX,EDX
DIV ESI
MOV R12D,EAX
LAB_00133068:
MOV EAX,dword ptr [R15 + 0x8]
LEA R14,[R9 + RAX*0x1]
CMP CL,0x13
JNZ 0x001330da
MOVZX EAX,byte ptr [R15 + 0x1b]
TEST EAX,EAX
JZ 0x001330be
MOV R8,RDI
MOVZX ESI,word ptr [R15 + 0x10]
MOVZX ECX,byte ptr [R15 + 0x1a]
MOVZX EDX,byte ptr [R9 + RSI*0x1]
LEA EDI,[RCX + RAX*0x1]
CMP EDI,0x9
JC 0x001330a3
MOVZX ESI,byte ptr [R9 + RSI*0x1 + 0x1]
SHL ESI,0x8
OR EDX,ESI
LAB_001330a3:
MOV RDI,R8
SHR EDX,CL
MOV ESI,0xffffffff
MOV ECX,EAX
SHL ESI,CL
NOT ESI
AND ESI,EDX
MOV byte ptr [R8],SIL
INC RDI
DEC RBX
LAB_001330be:
MOV R12,RBX
MOV RBX,RDI
MOV RSI,R14
MOV RDX,R12
CALL 0x001282c0
MOV RDI,RBX
ADD RDI,R12
JMP 0x0013332d
LAB_001330da:
MOVZX EDX,word ptr [R15 + 0x12]
TEST DL,0x1
JNZ 0x00133180
TEST DL,0x8
JNZ 0x001331a7
TEST DL,0x20
JNZ 0x00133238
TEST DL,0x40
JNZ 0x00133349
CMP R12D,EBX
JNC 0x00133130
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV qword ptr [RBP + -0x40],RBX
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x40]
MOV R12,RAX
LAB_00133130:
CMP R12,RBX
MOV RAX,RBX
CMOVC RBX,R12
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R14
MOV R14,RAX
MOV RDX,RBX
CALL 0x001282c0
CMP R12,R14
MOV R12,qword ptr [RBP + -0x38]
JNC 0x00133171
LEA RSI,[R12 + RBX*0x1]
MOV RDX,R14
SUB RDX,RBX
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV ECX,0x20
CALL qword ptr [RAX + 0x78]
LAB_00133171:
ADD R12,R14
MOV R9,qword ptr [RBP + -0x30]
MOV RDI,R12
JMP 0x00133331
LAB_00133180:
CMP CL,0x7
MOV qword ptr [RBP + -0x38],RDI
JNZ 0x001331c0
MOV RAX,RBX
ADD RBX,R14
TEST RAX,RAX
JZ 0x001331a2
LAB_00133194:
CMP byte ptr [R14],0x20
JNZ 0x001331a2
INC R14
CMP R14,RBX
JC 0x00133194
LAB_001331a2:
SUB RBX,R14
JMP 0x001331d6
LAB_001331a7:
CMP byte ptr [R15 + 0x1a],0x1
JNZ 0x001332ac
MOVZX EAX,byte ptr [R14]
MOV ECX,0x1
JMP 0x001332b5
LAB_001331c0:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x18]
MOV RBX,RAX
LAB_001331d6:
CMP RBX,R12
JBE 0x001331f5
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV R12,RAX
LAB_001331f5:
MOV RCX,qword ptr [RBP + -0x38]
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x00133211
LEA R12,[RCX + 0x1]
MOV EAX,EBX
JMP 0x0013321d
LAB_00133211:
MOV byte ptr [RCX + 0x2],BL
MOV byte ptr [RCX + 0x1],BH
LEA R12,[RCX + 0x3]
MOV AL,0xff
LAB_0013321d:
MOV byte ptr [RCX],AL
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
CALL 0x001282c0
ADD R12,RBX
MOV RDI,R12
JMP 0x0013332d
LAB_00133238:
MOV qword ptr [RBP + -0x38],RDI
MOVZX EDI,byte ptr [R15 + 0x1a]
MOV RSI,R14
CALL 0x00130cad
MOVZX ECX,byte ptr [R15 + 0x1a]
MOV RSI,qword ptr [R14 + RCX*0x1]
MOV EAX,EAX
CMP RAX,RBX
CMOVC RBX,RAX
CMP RBX,R12
JBE 0x0013327d
LEA RDX,[RSI + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV R14,RSI
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RSI,R14
MOV R12,RAX
LAB_0013327d:
MOV R9,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x0013337e
MOV byte ptr [RDI],BL
INC RDI
TEST RBX,RBX
JNZ 0x0013338b
JMP 0x00133331
LAB_001332ac:
MOVZX EAX,word ptr [R14]
MOV ECX,0x2
LAB_001332b5:
ADD R14,RCX
CMP RAX,RBX
CMOVC RBX,RAX
CMP RBX,R12
JBE 0x001332ec
LEA RDX,[R14 + RBX*0x1]
MOV RAX,qword ptr [R13 + 0xb8]
MOV qword ptr [RBP + -0x40],RBX
MOV RBX,RDI
MOV RDI,R13
MOV RSI,R14
MOV RCX,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,RBX
MOV RBX,qword ptr [RBP + -0x40]
MOV R12,RAX
LAB_001332ec:
CMP R12,RBX
CMOVC RBX,R12
CMP RBX,0xff
JNC 0x00133308
MOV R12,RBX
LEA RBX,[RDI + 0x1]
MOV EAX,R12D
JMP 0x00133317
LAB_00133308:
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
MOV R12,RBX
LEA RBX,[RDI + 0x3]
MOV AL,0xff
LAB_00133317:
MOV byte ptr [RDI],AL
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
CALL 0x001282c0
ADD RBX,R12
MOV RDI,RBX
LAB_0013332d:
MOV R9,qword ptr [RBP + -0x30]
LAB_00133331:
MOV CL,byte ptr [R15 + 0x38]
ADD R15,0x20
MOV RAX,RDI
TEST CL,CL
JNZ 0x0013300b
JMP 0x001333e2
LAB_00133349:
CMP CL,0x6
JZ 0x001333a2
MOVZX ECX,CL
CMP ECX,0x5
JNZ 0x00133360
MOVSS XMM0,dword ptr [R14]
UCOMISS XMM0,XMM0
JP 0x001333ad
LAB_00133360:
TEST EBX,EBX
JZ 0x00133331
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,RDI
LAB_0013336b:
LEA RDI,[RCX + 0x1]
MOV DL,byte ptr [RAX + RBX*0x1]
MOV byte ptr [RCX],DL
MOV RCX,RDI
DEC RBX
JNZ 0x0013336b
JMP 0x00133331
LAB_0013337e:
MOV byte ptr [RDI],0xff
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
ADD RDI,0x3
LAB_0013338b:
MOV R14,RDI
MOV RDX,RBX
CALL 0x001282c0
MOV RDI,R14
MOV R9,qword ptr [RBP + -0x30]
ADD RDI,RBX
JMP 0x00133331
LAB_001333a2:
MOVSD XMM0,qword ptr [R14]
UCOMISD XMM0,XMM0
JNP 0x00133360
LAB_001333ad:
MOV R14,RBX
MOV RBX,RDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x001281c0
MOV RDI,RBX
MOV R9,qword ptr [RBP + -0x30]
ADD RDI,R14
JMP 0x00133331
LAB_001333cc:
MOV RCX,R9
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001476d4
LAB_001333e2:
MOV RBX,RDI
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x0013d71f
SUB EBX,dword ptr [RBP + -0x50]
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _mi_make_key(long *param_1,ulong param_2,byte *param_3,long param_4,int8 param_5)
{
byte bVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
byte bVar5;
ulong uVar6;
ulong uVar7;
char cVar8;
long lVar9;
long lVar10;
byte *pbVar11;
uint uVar12;
ulong uVar13;
double *pdVar14;
byte *__dest;
double *__src;
void *pvVar15;
long *plVar16;
int local_58;
char local_4c;
lVar9 = (param_2 & 0xffffffff) * 0x70;
uVar2 = *(ushort *)(*(long *)(*param_1 + 0x218) + 10 + lVar9);
if ((uVar2 >> 10 & 1) != 0) {
uVar13 = sp_make_key();
return uVar13;
}
plVar16 = *(long **)(*(long *)(*param_1 + 0x218) + lVar9 + 0x28);
cVar8 = (char)plVar16[3];
__dest = param_3;
if (cVar8 != '\0') {
do {
uVar3 = *(ushort *)((long)plVar16 + 0x14);
uVar13 = (ulong)uVar3;
lVar9 = *plVar16;
if (*(byte *)((long)plVar16 + 0x19) == 0) {
LAB_00133039:
local_4c = (char)uVar2;
uVar6 = uVar13;
if ((lVar9 != 0 && -1 < local_4c) && (1 < *(uint *)(lVar9 + 0x9c))) {
uVar6 = uVar13 / *(uint *)(lVar9 + 0x9c);
}
uVar12 = *(uint *)(plVar16 + 1);
__src = (double *)(param_4 + (ulong)uVar12);
if (cVar8 == '\x13') {
bVar5 = *(byte *)((long)plVar16 + 0x1b);
if (bVar5 != 0) {
bVar1 = *(byte *)(param_4 + (ulong)*(ushort *)(plVar16 + 2));
uVar12 = (uint)bVar1;
if (8 < (uint)*(byte *)((long)plVar16 + 0x1a) + (uint)bVar5) {
uVar12 = (uint)CONCAT11(*(int1 *)(param_4 + 1 + (ulong)*(ushort *)(plVar16 + 2))
,bVar1);
}
*__dest = ~(byte)(-1 << (bVar5 & 0x1f)) &
(byte)(uVar12 >> (*(byte *)((long)plVar16 + 0x1a) & 0x1f));
__dest = __dest + 1;
uVar13 = uVar13 - 1;
}
memcpy(__dest,__src,uVar13);
__dest = __dest + uVar13;
}
else {
uVar4 = *(ushort *)((long)plVar16 + 0x12);
if ((uVar4 & 1) == 0) {
if ((uVar4 & 8) == 0) {
if ((uVar4 & 0x20) == 0) {
if ((uVar4 & 0x40) == 0) {
if ((uint)uVar6 < (uint)uVar3) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,__src,(long)__src + uVar13,uVar6);
}
uVar7 = uVar13;
if (uVar6 < uVar13) {
uVar7 = uVar6;
}
memcpy(__dest,__src,uVar7);
if (uVar6 < uVar13) {
(**(code **)(*(long *)(lVar9 + 0xb8) + 0x78))
(lVar9,__dest + uVar7,uVar13 - uVar7,0x20);
}
__dest = __dest + uVar13;
}
else {
if (cVar8 == '\x06') {
if (NAN(*__src)) goto LAB_001333ad;
}
else if ((cVar8 == '\x05') && (NAN(*(float *)__src))) {
LAB_001333ad:
memset(__dest,0,uVar13);
__dest = __dest + uVar13;
goto LAB_00133331;
}
if (uVar3 != 0) {
pbVar11 = __dest;
do {
__dest = pbVar11 + 1;
*pbVar11 = *(byte *)((ulong)uVar12 + param_4 + -1 + uVar13);
uVar13 = uVar13 - 1;
pbVar11 = __dest;
} while (uVar13 != 0);
}
}
}
else {
uVar12 = _mi_calc_blob_length(*(int1 *)((long)plVar16 + 0x1a),__src);
pvVar15 = *(void **)((long)__src + (ulong)*(byte *)((long)plVar16 + 0x1a));
if (uVar12 < uVar13) {
uVar13 = (ulong)uVar12;
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,pvVar15,(long)pvVar15 + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
if (uVar13 < 0xff) {
*__dest = (byte)uVar13;
__dest = __dest + 1;
if (uVar13 == 0) goto LAB_00133331;
}
else {
*__dest = 0xff;
__dest[2] = (byte)uVar13;
__dest[1] = (byte)(uVar13 >> 8);
__dest = __dest + 3;
}
memcpy(__dest,pvVar15,uVar13);
__dest = __dest + uVar13;
}
}
else {
if (*(char *)((long)plVar16 + 0x1a) == '\x01') {
uVar7 = (ulong)*(byte *)__src;
lVar10 = 1;
}
else {
uVar7 = (ulong)*(ushort *)__src;
lVar10 = 2;
}
pvVar15 = (void *)((long)__src + lVar10);
if (uVar7 < uVar13) {
uVar13 = uVar7;
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,pvVar15,(long)pvVar15 + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
bVar5 = (byte)uVar13;
if (uVar13 < 0xff) {
pbVar11 = __dest + 1;
}
else {
__dest[2] = bVar5;
__dest[1] = (byte)(uVar13 >> 8);
pbVar11 = __dest + 3;
bVar5 = 0xff;
}
*__dest = bVar5;
memcpy(pbVar11,pvVar15,uVar13);
__dest = pbVar11 + uVar13;
}
}
else {
if (cVar8 == '\a') {
pdVar14 = (double *)(uVar13 + (long)__src);
if (uVar13 != 0) {
do {
if (*(char *)__src != ' ') break;
__src = (double *)((long)__src + 1);
} while (__src < pdVar14);
}
uVar13 = (long)pdVar14 - (long)__src;
}
else {
uVar13 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x18))(lVar9,__src,uVar13);
}
if (uVar6 < uVar13) {
uVar6 = (**(code **)(*(long *)(lVar9 + 0xb8) + 0x10))
(lVar9,__src,(long)__src + uVar13,uVar6);
}
if (uVar6 < uVar13) {
uVar13 = uVar6;
}
bVar5 = (byte)uVar13;
if (uVar13 < 0xff) {
pbVar11 = __dest + 1;
}
else {
__dest[2] = bVar5;
__dest[1] = (byte)(uVar13 >> 8);
pbVar11 = __dest + 3;
bVar5 = 0xff;
}
*__dest = bVar5;
memcpy(pbVar11,__src,uVar13);
__dest = pbVar11 + uVar13;
}
}
}
else {
if ((*(byte *)(param_4 + (ulong)*(uint *)((long)plVar16 + 0xc)) &
*(byte *)((long)plVar16 + 0x19)) == 0) {
*__dest = 1;
__dest = __dest + 1;
goto LAB_00133039;
}
*__dest = 0;
__dest = __dest + 1;
}
LAB_00133331:
cVar8 = (char)plVar16[7];
plVar16 = plVar16 + 4;
} while (cVar8 != '\0');
}
_mi_dpointer(param_1,__dest,param_5);
local_58 = (int)param_3;
return (ulong)(uint)((int)__dest - local_58);
}
| |
35,297 | my_mutex_init | eloqsql/mysys/thr_mutex.c | void my_mutex_init()
{
/* Initialize mutex attributes */
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
/*
Set mutex type to "fast" a.k.a "adaptive"
In this case the thread may steal the mutex from some other thread
that is waiting for the same mutex. This will save us some
context switches but may cause a thread to 'starve forever' while
waiting for the mutex (not likely if the code within the mutex is
short).
*/
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_settype(&my_fast_mutexattr,
PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
/*
Set mutex type to "errorcheck"
*/
pthread_mutexattr_init(&my_errorcheck_mutexattr);
pthread_mutexattr_settype(&my_errorcheck_mutexattr,
PTHREAD_MUTEX_ERRORCHECK);
#endif
#if defined(SAFE_MUTEX_DEFINED)
safe_mutex_global_init();
#endif
} | O3 | c | my_mutex_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x33fa03(%rip), %rbx # 0x366958
movq %rbx, %rdi
callq 0x24070
movq %rbx, %rdi
movl $0x3, %esi
callq 0x24540
leaq 0x33f9eb(%rip), %rbx # 0x36695c
movq %rbx, %rdi
callq 0x24070
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24540
| my_mutex_init:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, my_fast_mutexattr
mov rdi, rbx
call _pthread_mutexattr_init
mov rdi, rbx
mov esi, 3
call _pthread_mutexattr_settype
lea rbx, my_errorcheck_mutexattr
mov rdi, rbx
call _pthread_mutexattr_init
mov rdi, rbx
mov esi, 2
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutexattr_settype
| long long my_mutex_init()
{
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_settype(&my_fast_mutexattr, 3LL);
pthread_mutexattr_init(&my_errorcheck_mutexattr);
return pthread_mutexattr_settype(&my_errorcheck_mutexattr, 2LL);
}
| my_mutex_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0x466958]
MOV RDI,RBX
CALL 0x00124070
MOV RDI,RBX
MOV ESI,0x3
CALL 0x00124540
LEA RBX,[0x46695c]
MOV RDI,RBX
CALL 0x00124070
MOV RDI,RBX
MOV ESI,0x2
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00124540
|
void my_mutex_init(void)
{
pthread_mutexattr_init((pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_mutexattr_settype((pthread_mutexattr_t *)&my_fast_mutexattr,3);
pthread_mutexattr_init((pthread_mutexattr_t *)&my_errorcheck_mutexattr);
pthread_mutexattr_settype((pthread_mutexattr_t *)&my_errorcheck_mutexattr,2);
return;
}
| |
35,298 | minja::ExpressionNode::~ExpressionNode() | monkey531[P]llama/common/minja.hpp | ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {} | O3 | cpp | minja::ExpressionNode::~ExpressionNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8c801(%rip), %rax # 0x12a2b8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x9dacc
callq 0x6d1fe
leaq 0x8c505(%rip), %rax # 0x129fd8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9dae8
callq 0x6d1fe
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8b0
| _ZN5minja14ExpressionNodeD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+28h]
test rdi, rdi
jz short loc_9DACC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DACC:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9DAE8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DAE8:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::ExpressionNode::~ExpressionNode(minja::ExpressionNode *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionNode + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x30uLL);
}
| ~ExpressionNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22a2b8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x28]
TEST RDI,RDI
JZ 0x0019dacc
CALL 0x0016d1fe
LAB_0019dacc:
LEA RAX,[0x229fd8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019dae8
CALL 0x0016d1fe
LAB_0019dae8:
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x0011a8b0
|
/* minja::ExpressionNode::~ExpressionNode() */
void __thiscall minja::ExpressionNode::~ExpressionNode(ExpressionNode *this)
{
*(int ***)this = &PTR_do_render_0022a2c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28));
}
*(int ***)this = &PTR___cxa_pure_virtual_00229fe8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x30);
return;
}
| |
35,299 | maria_versioning | eloqsql/storage/maria/ma_state.c | void maria_versioning(MARIA_HA *info, my_bool versioning)
{
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_versioning");
/* For now, this is a hack */
if (share->have_versioning)
{
enum thr_lock_type save_lock_type;
share->lock_key_trees= versioning;
/* Set up info->lock.type temporary for _ma_block_get_status() */
save_lock_type= info->lock.type;
info->lock.type= versioning ? TL_WRITE_CONCURRENT_INSERT : TL_WRITE;
_ma_block_get_status((void*) info, versioning);
info->lock.type= save_lock_type;
if (versioning)
info->state= &share->state.common;
else
info->state= &share->state.state; /* Change global values by default */
info->state_start= info->state; /* Initial values */
}
DBUG_VOID_RETURN;
} | O3 | c | maria_versioning:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpb $0x0, 0x7e8(%rax)
je 0x343de
movb %sil, 0x7e3(%rax)
movl 0x6d0(%rdi), %ecx
xorl %r8d, %r8d
movl $0x50, %edx
testb %sil, %sil
sete %r8b
leal 0x8(%r8,%r8,4), %esi
movl %esi, 0x6d0(%rdi)
movq (%rdi), %r8
movl 0x7c4(%r8), %esi
movq %rsi, 0x610(%rdi)
movl 0x418(%r8), %r8d
movl %r8d, 0x618(%rdi)
je 0x343bf
orl $0x1, %r8d
movl %r8d, 0x618(%rdi)
addq $0x6, %rsi
movq %rsi, 0x610(%rdi)
jmp 0x343cd
movl $0x18, %edx
cmpb $0x0, 0x688(%rdi)
je 0x343a7
movl %ecx, 0x6d0(%rdi)
addq %rdx, %rax
movq %rax, 0x20(%rdi)
movq %rax, 0x60(%rdi)
popq %rbp
retq
| maria_versioning:
push rbp
mov rbp, rsp
mov rax, [rdi]
cmp byte ptr [rax+7E8h], 0
jz short loc_343DE
mov [rax+7E3h], sil
mov ecx, [rdi+6D0h]
xor r8d, r8d
mov edx, 50h ; 'P'
test sil, sil
setz r8b
lea esi, [r8+r8*4+8]
mov [rdi+6D0h], esi
mov r8, [rdi]
mov esi, [r8+7C4h]
mov [rdi+610h], rsi
mov r8d, [r8+418h]
mov [rdi+618h], r8d
jz short loc_343BF
loc_343A7:
or r8d, 1
mov [rdi+618h], r8d
add rsi, 6
mov [rdi+610h], rsi
jmp short loc_343CD
loc_343BF:
mov edx, 18h
cmp byte ptr [rdi+688h], 0
jz short loc_343A7
loc_343CD:
mov [rdi+6D0h], ecx
add rax, rdx
mov [rdi+20h], rax
mov [rdi+60h], rax
loc_343DE:
pop rbp
retn
| long long maria_versioning(long long *a1, char a2)
{
long long result; // rax
int v3; // ecx
long long v4; // rdx
bool v5; // zf
long long v6; // r8
long long v7; // rsi
int v8; // r8d
result = *a1;
if ( *(_BYTE *)(*a1 + 2024) )
{
*(_BYTE *)(result + 2019) = a2;
v3 = *((_DWORD *)a1 + 436);
v4 = 80LL;
v5 = a2 == 0;
*((_DWORD *)a1 + 436) = 5 * (a2 == 0) + 8;
v6 = *a1;
v7 = *(unsigned int *)(*a1 + 1988);
a1[194] = v7;
v8 = *(_DWORD *)(v6 + 1048);
*((_DWORD *)a1 + 390) = v8;
if ( !v5 || (v4 = 24LL, !*((_BYTE *)a1 + 1672)) )
{
*((_DWORD *)a1 + 390) = v8 | 1;
a1[194] = v7 + 6;
}
*((_DWORD *)a1 + 436) = v3;
result += v4;
a1[4] = result;
a1[12] = result;
}
return result;
}
| maria_versioning:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e8],0x0
JZ 0x001343de
MOV byte ptr [RAX + 0x7e3],SIL
MOV ECX,dword ptr [RDI + 0x6d0]
XOR R8D,R8D
MOV EDX,0x50
TEST SIL,SIL
SETZ R8B
LEA ESI,[R8 + R8*0x4 + 0x8]
MOV dword ptr [RDI + 0x6d0],ESI
MOV R8,qword ptr [RDI]
MOV ESI,dword ptr [R8 + 0x7c4]
MOV qword ptr [RDI + 0x610],RSI
MOV R8D,dword ptr [R8 + 0x418]
MOV dword ptr [RDI + 0x618],R8D
JZ 0x001343bf
LAB_001343a7:
OR R8D,0x1
MOV dword ptr [RDI + 0x618],R8D
ADD RSI,0x6
MOV qword ptr [RDI + 0x610],RSI
JMP 0x001343cd
LAB_001343bf:
MOV EDX,0x18
CMP byte ptr [RDI + 0x688],0x0
JZ 0x001343a7
LAB_001343cd:
MOV dword ptr [RDI + 0x6d0],ECX
ADD RAX,RDX
MOV qword ptr [RDI + 0x20],RAX
MOV qword ptr [RDI + 0x60],RAX
LAB_001343de:
POP RBP
RET
|
void maria_versioning(long *param_1,char param_2)
{
uint uVar1;
long lVar2;
long lVar3;
long lVar4;
ulong uVar5;
lVar2 = *param_1;
if (*(char *)(lVar2 + 0x7e8) != '\0') {
*(char *)(lVar2 + 0x7e3) = param_2;
lVar3 = param_1[0xda];
lVar4 = 0x50;
*(uint *)(param_1 + 0xda) = (uint)(param_2 == '\0') * 5 + 8;
uVar5 = (ulong)*(uint *)(*param_1 + 0x7c4);
param_1[0xc2] = uVar5;
uVar1 = *(uint *)(*param_1 + 0x418);
*(uint *)(param_1 + 0xc3) = uVar1;
if ((param_2 != '\0') || (lVar4 = 0x18, (char)param_1[0xd1] == '\0')) {
*(uint *)(param_1 + 0xc3) = uVar1 | 1;
param_1[0xc2] = uVar5 + 6;
}
*(int *)(param_1 + 0xda) = (int)lVar3;
param_1[4] = lVar2 + lVar4;
param_1[0xc] = lVar2 + lVar4;
}
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.