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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
5,000 |
string_get_sortable_timestamp[abi:cxx11]()
|
monkey531[P]llama/common/common.cpp
|
std::string string_get_sortable_timestamp() {
using clock = std::chrono::system_clock;
const clock::time_point current_time = clock::now();
const time_t as_time_t = clock::to_time_t(current_time);
char timestamp_no_ns[100];
std::strftime(timestamp_no_ns, 100, "%Y_%m_%d-%H_%M_%S", std::localtime(&as_time_t));
const int64_t ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
current_time.time_since_epoch() % 1000000000).count();
char timestamp_ns[11];
snprintf(timestamp_ns, 11, "%09" PRId64, ns);
return std::string(timestamp_no_ns) + "." + std::string(timestamp_ns);
}
|
O0
|
cpp
|
string_get_sortable_timestamp[abi:cxx11]():
subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x160(%rsp)
callq 0x5acf0
movq %rax, 0x158(%rsp)
leaq 0x158(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xf9340
movq %rax, 0x150(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x5abe0
movq %rax, %rcx
leaq 0x123c11(%rip), %rdx # 0x211ddb
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x64, %esi
callq 0x5afa0
movq 0x18(%rsp), %rdi
callq 0xf9430
movq %rax, 0xc0(%rsp)
movl $0x3b9aca00, 0xbc(%rsp) # imm = 0x3B9ACA00
leaq 0xc0(%rsp), %rdi
leaq 0xbc(%rsp), %rsi
callq 0xf93e0
movq %rax, 0xc8(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xf93b0
movq %rax, 0xd0(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0xf9450
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rcx
leaq 0x123b99(%rip), %rdx # 0x211ded
xorl %eax, %eax
leaq 0xb1(%rsp), %rdi
movl $0xb, %esi
callq 0x5a900
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5b0d0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x62190
jmp 0xee28d
leaq 0x11ec71(%rip), %rdx # 0x20cf05
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x676e0
jmp 0xee2a8
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5b0d0
movq (%rsp), %rdx
leaq 0x38(%rsp), %rdi
leaq 0xb1(%rsp), %rsi
callq 0x62190
jmp 0xee2ce
movq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x8de10
jmp 0xee2e7
leaq 0x38(%rsp), %rdi
callq 0x5b568
leaq 0x37(%rsp), %rdi
callq 0x5b540
leaq 0x90(%rsp), %rdi
callq 0x5b568
leaq 0x70(%rsp), %rdi
callq 0x5b568
leaq 0x6f(%rsp), %rdi
callq 0x5b540
movq 0x10(%rsp), %rax
addq $0x168, %rsp # imm = 0x168
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xee392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xee388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xee371
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5b568
leaq 0x37(%rsp), %rdi
callq 0x5b540
leaq 0x90(%rsp), %rdi
callq 0x5b568
leaq 0x70(%rsp), %rdi
callq 0x5b568
leaq 0x6f(%rsp), %rdi
callq 0x5b540
movq 0x60(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
|
_Z29string_get_sortable_timestampB5cxx11v:
sub rsp, 168h
mov [rsp+168h+var_160], rdi
mov rax, rdi
mov [rsp+168h+var_158], rax
mov [rsp+168h+var_8], rdi
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rsp+168h+var_10], rax
lea rdi, [rsp+168h+var_10]
mov [rsp+168h+var_150], rdi
call _ZNSt6chrono3_V212system_clock9to_time_tERKNS_10time_pointIS1_NS_8durationIlSt5ratioILl1ELl1000000000EEEEEE; std::chrono::_V2::system_clock::to_time_t(std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&)
mov [rsp+168h+var_18], rax
lea rdi, [rsp+168h+var_18]
call _localtime
mov rcx, rax
lea rdx, aYMDHMS; "%Y_%m_%d-%H_%M_%S"
lea rdi, [rsp+168h+var_88]
mov [rsp+168h+var_148], rdi
mov esi, 64h ; 'd'
call _strftime
mov rdi, [rsp+168h+var_150]
call _ZNKSt6chrono10time_pointINS_3_V212system_clockENS_8durationIlSt5ratioILl1ELl1000000000EEEEE16time_since_epochEv; std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>>::time_since_epoch(void)
mov [rsp+168h+var_A8], rax
mov [rsp+168h+var_AC], 3B9ACA00h
lea rdi, [rsp+168h+var_A8]
lea rsi, [rsp+168h+var_AC]
call _ZNSt6chronormIlSt5ratioILl1ELl1000000000EEiEENS_8durationINSt9enable_ifIXsr14is_convertibleIRKNS4_IXntsr13__is_durationIT1_EE5valueES5_E4typeENSt11common_typeIJT_S7_EE4typeEEE5valueESD_E4typeET0_EERKNS3_ISB_SG_EERKS5_
mov [rsp+168h+var_A0], rax
lea rdi, [rsp+168h+var_A0]
call _ZNSt6chrono13duration_castINS_8durationIlSt5ratioILl1ELl1000000000EEEElS3_EENSt9enable_ifIXsr13__is_durationIT_EE5valueES6_E4typeERKNS1_IT0_T1_EE
mov [rsp+168h+var_98], rax
lea rdi, [rsp+168h+var_98]
call _ZNKSt6chrono8durationIlSt5ratioILl1ELl1000000000EEE5countEv; std::chrono::duration<long,std::ratio<1l,1000000000l>>::count(void)
mov [rsp+168h+var_90], rax
mov rcx, [rsp+168h+var_90]
lea rdx, a09ld; "%09ld"
xor eax, eax
lea rdi, [rsp+168h+var_B7]
mov esi, 0Bh
call _snprintf
lea rdi, [rsp+168h+var_F9]
mov [rsp+168h+var_140], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+168h+var_148]
mov rdx, [rsp+168h+var_140]
lea rdi, [rsp+168h+var_F8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_EE28D:
lea rdx, aN0N1+8; "."
lea rdi, [rsp+168h+var_D8]
lea rsi, [rsp+168h+var_F8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_EE2A8:
lea rdi, [rsp+168h+var_131]
mov [rsp+168h+var_168], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+168h+var_168]
lea rdi, [rsp+168h+var_130]
lea rsi, [rsp+168h+var_B7]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_EE2CE:
mov rdi, [rsp+168h+var_160]
lea rsi, [rsp+168h+var_D8]
lea rdx, [rsp+168h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
jmp short $+2
loc_EE2E7:
lea rdi, [rsp+168h+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+168h+var_131]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+168h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+168h+var_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+168h+var_F9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rax, [rsp+168h+var_158]
add rsp, 168h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_EE392
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_EE388
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
jmp short loc_EE371
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EE371:
lea rdi, [rsp+arg_2F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EE388:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EE392:
lea rdi, [rsp+arg_67]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rsp+arg_58]
call __Unwind_Resume
|
std::chrono::_V2::system_clock * string_get_sortable_timestamp[abi:cxx11](std::chrono::_V2::system_clock *a1)
{
long long v1; // rax
char v3; // [rsp+37h] [rbp-131h] BYREF
_BYTE v4[55]; // [rsp+38h] [rbp-130h] BYREF
char v5; // [rsp+6Fh] [rbp-F9h] BYREF
_BYTE v6[32]; // [rsp+70h] [rbp-F8h] BYREF
_BYTE v7[33]; // [rsp+90h] [rbp-D8h] BYREF
_BYTE v8[11]; // [rsp+B1h] [rbp-B7h] BYREF
int v9; // [rsp+BCh] [rbp-ACh] BYREF
long long v10; // [rsp+C0h] [rbp-A8h] BYREF
long long v11; // [rsp+C8h] [rbp-A0h] BYREF
long long v12; // [rsp+D0h] [rbp-98h] BYREF
long long v13; // [rsp+D8h] [rbp-90h]
_BYTE v14[112]; // [rsp+E0h] [rbp-88h] BYREF
long long v15; // [rsp+150h] [rbp-18h] BYREF
_QWORD v16[2]; // [rsp+158h] [rbp-10h] BYREF
v16[1] = a1;
v16[0] = std::chrono::_V2::system_clock::now(a1);
v15 = std::chrono::_V2::system_clock::to_time_t();
v1 = localtime(&v15);
strftime(v14, 100LL, "%Y_%m_%d-%H_%M_%S", v1);
v10 = std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>>::time_since_epoch(v16);
v9 = 1000000000;
v11 = std::chrono::operator%<long,std::ratio<1l,1000000000l>,int>(&v10, &v9);
v12 = std::chrono::duration_cast<std::chrono::duration<long,std::ratio<1l,1000000000l>>,long,std::ratio<1l,1000000000l>>(&v11);
v13 = std::chrono::duration<long,std::ratio<1l,1000000000l>>::count(&v12);
snprintf(v8, 11LL, "%09ld", v13);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v6, (long long)v14, (long long)&v5);
std::operator+<char>((long long)v7, (long long)v6, (long long)".");
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v4, (long long)v8, (long long)&v3);
std::operator+<char>((long long)a1, (long long)v7, (long long)v4);
std::string::~string(v4);
std::allocator<char>::~allocator(&v3);
std::string::~string(v7);
std::string::~string(v6);
std::allocator<char>::~allocator(&v5);
return a1;
}
|
string_get_sortable_timestamp[abi:cxx11]:
SUB RSP,0x168
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x160],RDI
CALL 0x0015acf0
MOV qword ptr [RSP + 0x158],RAX
LEA RDI,[RSP + 0x158]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001f9340
MOV qword ptr [RSP + 0x150],RAX
LEA RDI,[RSP + 0x150]
CALL 0x0015abe0
MOV RCX,RAX
LEA RDX,[0x311ddb]
LEA RDI,[RSP + 0xe0]
MOV qword ptr [RSP + 0x20],RDI
MOV ESI,0x64
CALL 0x0015afa0
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001f9430
MOV qword ptr [RSP + 0xc0],RAX
MOV dword ptr [RSP + 0xbc],0x3b9aca00
LEA RDI,[RSP + 0xc0]
LEA RSI,[RSP + 0xbc]
CALL 0x001f93e0
MOV qword ptr [RSP + 0xc8],RAX
LEA RDI,[RSP + 0xc8]
CALL 0x001f93b0
MOV qword ptr [RSP + 0xd0],RAX
LEA RDI,[RSP + 0xd0]
CALL 0x001f9450
MOV qword ptr [RSP + 0xd8],RAX
MOV RCX,qword ptr [RSP + 0xd8]
LEA RDX,[0x311ded]
XOR EAX,EAX
LEA RDI,[RSP + 0xb1]
MOV ESI,0xb
CALL 0x0015a900
LEA RDI,[RSP + 0x6f]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0015b0d0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_001ee281:
LEA RDI,[RSP + 0x70]
CALL 0x00162190
JMP 0x001ee28d
LAB_001ee28d:
LEA RDX,[0x30cf05]
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x70]
CALL 0x001676e0
JMP 0x001ee2a8
LAB_001ee2a8:
LEA RDI,[RSP + 0x37]
MOV qword ptr [RSP],RDI
CALL 0x0015b0d0
MOV RDX,qword ptr [RSP]
LAB_001ee2ba:
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0xb1]
CALL 0x00162190
JMP 0x001ee2ce
LAB_001ee2ce:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x90]
LEA RDX,[RSP + 0x38]
CALL 0x0018de10
LAB_001ee2e5:
JMP 0x001ee2e7
LAB_001ee2e7:
LEA RDI,[RSP + 0x38]
CALL 0x0015b568
LEA RDI,[RSP + 0x37]
CALL 0x0015b540
LEA RDI,[RSP + 0x90]
CALL 0x0015b568
LEA RDI,[RSP + 0x70]
CALL 0x0015b568
LEA RDI,[RSP + 0x6f]
CALL 0x0015b540
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x168
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* string_get_sortable_timestamp[abi:cxx11]() */
string * string_get_sortable_timestamp_abi_cxx11_(void)
{
tm *__tp;
string *in_RDI;
allocator local_131;
string local_130 [55];
allocator local_f9;
string local_f8 [32];
string local_d8 [33];
char local_b7 [11];
int local_ac;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_90;
char local_88 [112];
time_t local_18;
int8 local_10 [2];
local_10[0] = std::chrono::_V2::system_clock::now();
local_18 = std::chrono::_V2::system_clock::to_time_t((time_point *)local_10);
__tp = localtime(&local_18);
strftime(local_88,100,"%Y_%m_%d-%H_%M_%S",__tp);
local_a8 = std::chrono::
time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>>
::time_since_epoch((time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>>
*)local_10);
local_ac = 1000000000;
local_a0 = std::chrono::operator%((duration *)&local_a8,&local_ac);
local_98 = std::chrono::
duration_cast<std::chrono::duration<long,std::ratio<1l,1000000000l>>,long,std::ratio<1l,1000000000l>>
((duration *)&local_a0);
local_90 = std::chrono::duration<long,std::ratio<1l,1000000000l>>::count
((duration<long,std::ratio<1l,1000000000l>> *)&local_98);
snprintf(local_b7,0xb,"%09ld",local_90);
std::allocator<char>::allocator();
/* try { // try from 001ee281 to 001ee28a has its CatchHandler @ 001ee329 */
std::__cxx11::string::string<std::allocator<char>>(local_f8,local_88,&local_f9);
/* try { // try from 001ee28d to 001ee2a5 has its CatchHandler @ 001ee339 */
std::operator+(local_d8,(char *)local_f8);
std::allocator<char>::allocator();
/* try { // try from 001ee2ba to 001ee2cb has its CatchHandler @ 001ee349 */
std::__cxx11::string::string<std::allocator<char>>(local_130,local_b7,&local_131);
/* try { // try from 001ee2ce to 001ee2e4 has its CatchHandler @ 001ee359 */
std::operator+(in_RDI,local_d8);
std::__cxx11::string::~string(local_130);
std::allocator<char>::~allocator((allocator<char> *)&local_131);
std::__cxx11::string::~string(local_d8);
std::__cxx11::string::~string(local_f8);
std::allocator<char>::~allocator((allocator<char> *)&local_f9);
return in_RDI;
}
|
|
5,001 |
string_get_sortable_timestamp[abi:cxx11]()
|
monkey531[P]llama/common/common.cpp
|
std::string string_get_sortable_timestamp() {
using clock = std::chrono::system_clock;
const clock::time_point current_time = clock::now();
const time_t as_time_t = clock::to_time_t(current_time);
char timestamp_no_ns[100];
std::strftime(timestamp_no_ns, 100, "%Y_%m_%d-%H_%M_%S", std::localtime(&as_time_t));
const int64_t ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
current_time.time_since_epoch() % 1000000000).count();
char timestamp_ns[11];
snprintf(timestamp_ns, 11, "%09" PRId64, ns);
return std::string(timestamp_no_ns) + "." + std::string(timestamp_ns);
}
|
O3
|
cpp
|
string_get_sortable_timestamp[abi:cxx11]():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
callq 0x1a090
movq %rax, %r14
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdx, %r12
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %r12
addq %rax, %r12
leaq 0x78(%rsp), %rdi
movq %r12, (%rdi)
callq 0x1a6b0
leaq 0x7d2a6(%rip), %rdx # 0xef417
leaq 0x80(%rsp), %r15
movl $0x64, %esi
movq %r15, %rdi
movq %rax, %rcx
callq 0x1a730
imulq $0x3b9aca00, %r12, %rax # imm = 0x3B9ACA00
subq %rax, %r14
leaq 0x7d28f(%rip), %rdx # 0xef429
leaq 0x4d(%rsp), %rdi
movl $0xb, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1adf0
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a3f0
leaq (%rsp,%rax), %rdx
addq $0x80, %rdx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x22338
leaq 0x7883f(%rip), %rsi # 0xeaa21
movq %r14, %rdi
callq 0x1b100
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x72211
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x72218
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4d(%rsp), %r14
movq %r14, %rdi
callq 0x1a3f0
leaq (%rsp,%rax), %rdx
addq $0x4d, %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x22338
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x30(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r15, %rcx
je 0x7227d
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x7229b
movl $0xf, %edi
cmpq %r13, %rsi
je 0x72296
movq 0x38(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x722a7
leaq 0x8(%rsp), %rdi
callq 0x1a270
jmp 0x722b5
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a9f0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x722d4
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x722da
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7230d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x72324
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0x7233b
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7236e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8f0
jmp 0x7236e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7238a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8f0
jmp 0x7238a
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r12, %rdi
je 0x723a1
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq %rbx, %rdi
callq 0x1afb0
|
_Z29string_get_sortable_timestampB5cxx11v:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F0h
mov rbx, rdi
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov r14, rax
mov rcx, 112E0BE826D694B3h
imul rcx
mov r12, rdx
mov rax, rdx
shr rax, 3Fh
sar r12, 1Ah
add r12, rax
lea rdi, [rsp+118h+var_A0]
mov [rdi], r12
call _localtime
lea rdx, aYMDHMS; "%Y_%m_%d-%H_%M_%S"
lea r15, [rsp+118h+var_98]
mov esi, 64h ; 'd'
mov rdi, r15
mov rcx, rax
call _strftime
imul rax, r12, 3B9ACA00h
sub r14, rax
lea rdx, a09ld; "%09ld"
lea rdi, [rsp+118h+var_CB]
mov esi, 0Bh
mov rcx, r14
xor eax, eax
call _snprintf
lea r12, [rsp+118h+var_B0]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rsp+rax+118h+var_118]
add rdx, 80h
lea r14, [rsp+118h+var_C0]
mov rdi, r14
mov rsi, 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, aN0N1+8; "."
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+118h+var_100]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_72211
mov [rsp+118h+var_110], rdx
mov rdx, [rcx]
mov [rsp+118h+var_100], rdx
jmp short loc_72218
loc_72211:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_72218:
mov rdx, [rax+8]
mov [rsp+118h+var_108], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea r13, [rsp+118h+var_E0]
mov [r13-10h], r13
lea r14, [rsp+118h+var_CB]
mov rdi, r14
call _strlen
lea rdx, [rsp+rax+118h+var_118]
add rdx, 4Dh ; 'M'
lea rdi, [rsp+118h+var_F0]
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [rsp+118h+var_110]
mov r8, [rsp+118h+var_108]
mov rdx, [rsp+118h+var_E8]
lea rax, [rdx+r8]
mov edi, 0Fh
cmp rcx, r15
jz short loc_7227D
mov rdi, [rsp+118h+var_100]
loc_7227D:
mov rsi, [rsp+118h+var_F0]
cmp rax, rdi
jbe short loc_7229B
mov edi, 0Fh
cmp rsi, r13
jz short loc_72296
mov rdi, [rsp+118h+var_E0]
loc_72296:
cmp rax, rdi
jbe short loc_722A7
loc_7229B:
lea rdi, [rsp+118h+var_110]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_722B5
loc_722A7:
lea rdi, [rsp+118h+var_F0]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_722B5:
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
lea rcx, [rax+10h]
cmp rsi, rcx
jz short loc_722D4
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_722DA
loc_722D4:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_722DA:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rbx+8], rsi
mov [rax], rcx
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
mov rdi, [rsp+118h+var_F0]; void *
cmp rdi, r13
jz short loc_7230D
mov rsi, [rsp+118h+var_E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7230D:
mov rdi, [rsp+118h+var_110]; void *
cmp rdi, r15
jz short loc_72324
mov rsi, [rsp+118h+var_100]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_72324:
mov rdi, [rsp+118h+var_C0]; void *
cmp rdi, r12
jz short loc_7233B
mov rsi, [rsp+118h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7233B:
mov rax, rbx
add rsp, 0F0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_7236E
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7236E
mov rbx, rax
loc_7236E:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_7238A
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7238A
mov rbx, rax
loc_7238A:
mov rdi, [rsp+arg_50]; void *
cmp rdi, r12
jz short loc_723A1
mov rsi, [rsp+arg_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_723A1:
mov rdi, rbx
call __Unwind_Resume
|
long long string_get_sortable_timestamp[abi:cxx11](long long a1)
{
long long v2; // r14
long long v3; // rax
long long v4; // rax
long long v5; // rax
__int128 *v6; // rcx
long long v7; // rax
unsigned long long v8; // rax
unsigned long long v9; // rdi
unsigned long long v10; // rdi
_QWORD *v11; // rax
_OWORD *v12; // rcx
void *v14; // [rsp+8h] [rbp-110h] BYREF
long long v15; // [rsp+10h] [rbp-108h]
__int128 v16; // [rsp+18h] [rbp-100h] BYREF
void *v17; // [rsp+28h] [rbp-F0h] BYREF
long long v18; // [rsp+30h] [rbp-E8h]
_QWORD v19[2]; // [rsp+38h] [rbp-E0h] BYREF
char v20[11]; // [rsp+4Dh] [rbp-CBh] BYREF
void *v21[2]; // [rsp+58h] [rbp-C0h] BYREF
_QWORD v22[3]; // [rsp+68h] [rbp-B0h] BYREF
char v23[152]; // [rsp+80h] [rbp-98h] BYREF
v2 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)a1);
v22[2] = v2 / 1000000000;
v3 = localtime();
strftime(v23, 100LL, "%Y_%m_%d-%H_%M_%S", v3);
snprintf(v20, 11LL, "%09ld", v2 % 1000000000);
v21[0] = v22;
v4 = strlen(v23);
std::string::_M_construct<char const*>((long long)v21, v23, (long long)&v23[v4]);
v5 = std::string::append(v21, ".");
v14 = &v16;
v6 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v16 = *v6;
}
else
{
v14 = *(void **)v5;
*(_QWORD *)&v16 = *(_QWORD *)v6;
}
v15 = *(_QWORD *)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
v17 = v19;
v7 = strlen(v20);
std::string::_M_construct<char const*>((long long)&v17, v20, (long long)&v20[v7]);
v8 = v18 + v15;
v9 = 15LL;
if ( v14 != &v16 )
v9 = v16;
if ( v8 <= v9 )
goto LABEL_10;
v10 = 15LL;
if ( v17 != v19 )
v10 = v19[0];
if ( v8 <= v10 )
v11 = (_QWORD *)std::string::replace(&v17, 0LL, 0LL, v14, v15);
else
LABEL_10:
v11 = (_QWORD *)std::string::_M_append(&v14, v17, v18);
*(_QWORD *)a1 = a1 + 16;
v12 = v11 + 2;
if ( (_QWORD *)*v11 == v11 + 2 )
{
*(_OWORD *)(a1 + 16) = *v12;
}
else
{
*(_QWORD *)a1 = *v11;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v12;
}
*(_QWORD *)(a1 + 8) = v11[1];
*v11 = v12;
v11[1] = 0LL;
*(_BYTE *)v12 = 0;
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v14 != &v16 )
operator delete(v14, v16 + 1);
if ( v21[0] != v22 )
operator delete(v21[0], v22[0] + 1LL);
return a1;
}
|
string_get_sortable_timestamp[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf0
MOV RBX,RDI
CALL 0x0011a090
MOV R14,RAX
MOV RCX,0x112e0be826d694b3
IMUL RCX
MOV R12,RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR R12,0x1a
ADD R12,RAX
LEA RDI,[RSP + 0x78]
MOV qword ptr [RDI],R12
CALL 0x0011a6b0
LEA RDX,[0x1ef417]
LEA R15,[RSP + 0x80]
MOV ESI,0x64
MOV RDI,R15
MOV RCX,RAX
CALL 0x0011a730
IMUL RAX,R12,0x3b9aca00
SUB R14,RAX
LEA RDX,[0x1ef429]
LEA RDI,[RSP + 0x4d]
MOV ESI,0xb
MOV RCX,R14
XOR EAX,EAX
CALL 0x0011adf0
LEA R12,[RSP + 0x68]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a3f0
LEA RDX,[RSP + RAX*0x1]
ADD RDX,0x80
LEA R14,[RSP + 0x58]
MOV RDI,R14
MOV RSI,R15
CALL 0x00122338
LAB_001721db:
LEA RSI,[0x1eaa21]
MOV RDI,R14
CALL 0x0011b100
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 0x00172211
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00172218
LAB_00172211:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_00172218:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LEA R14,[RSP + 0x4d]
MOV RDI,R14
CALL 0x0011a3f0
LEA RDX,[RSP + RAX*0x1]
ADD RDX,0x4d
LAB_0017224e:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x00122338
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x30]
LEA RAX,[RDX + R8*0x1]
MOV EDI,0xf
CMP RCX,R15
JZ 0x0017227d
MOV RDI,qword ptr [RSP + 0x18]
LAB_0017227d:
MOV RSI,qword ptr [RSP + 0x28]
CMP RAX,RDI
JBE 0x0017229b
MOV EDI,0xf
CMP RSI,R13
JZ 0x00172296
MOV RDI,qword ptr [RSP + 0x38]
LAB_00172296:
CMP RAX,RDI
JBE 0x001722a7
LAB_0017229b:
LEA RDI,[RSP + 0x8]
CALL 0x0011a270
JMP 0x001722b5
LAB_001722a7:
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011a9f0
LAB_001722b5:
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RSI,RCX
JZ 0x001722d4
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x001722da
LAB_001722d4:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_001722da:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RSI
MOV qword ptr [RAX],RCX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0017230d
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8f0
LAB_0017230d:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00172324
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a8f0
LAB_00172324:
MOV RDI,qword ptr [RSP + 0x58]
CMP RDI,R12
JZ 0x0017233b
MOV RSI,qword ptr [RSP + 0x68]
INC RSI
CALL 0x0011a8f0
LAB_0017233b:
MOV RAX,RBX
ADD RSP,0xf0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* string_get_sortable_timestamp[abi:cxx11]() */
void string_get_sortable_timestamp_abi_cxx11_(void)
{
int8 *puVar1;
int8 uVar2;
long lVar3;
tm *__tp;
size_t sVar4;
long *plVar5;
int8 *puVar6;
ulong *puVar7;
int8 *in_RDI;
ulong uVar8;
ulong *local_110;
long local_108;
ulong local_100;
long lStack_f8;
ulong *local_f0;
long local_e8;
ulong local_e0 [2];
char local_cb [11];
long *local_c0 [2];
long local_b0 [2];
long local_a0;
char local_98 [112];
lVar3 = std::chrono::_V2::system_clock::now();
local_a0 = lVar3 / 1000000000;
__tp = localtime(&local_a0);
strftime(local_98,100,"%Y_%m_%d-%H_%M_%S",__tp);
snprintf(local_cb,0xb,"%09ld",lVar3 % 1000000000);
local_c0[0] = local_b0;
sVar4 = strlen(local_98);
std::__cxx11::string::_M_construct<char_const*>(local_c0,local_98,local_98 + sVar4);
/* try { // try from 001721db to 001721e9 has its CatchHandler @ 00172387 */
plVar5 = (long *)std::__cxx11::string::append((char *)local_c0);
puVar7 = (ulong *)(plVar5 + 2);
if ((ulong *)*plVar5 == puVar7) {
local_100 = *puVar7;
lStack_f8 = plVar5[3];
local_110 = &local_100;
}
else {
local_100 = *puVar7;
local_110 = (ulong *)*plVar5;
}
local_108 = plVar5[1];
*plVar5 = (long)puVar7;
plVar5[1] = 0;
*(int1 *)(plVar5 + 2) = 0;
local_f0 = local_e0;
sVar4 = strlen(local_cb);
/* try { // try from 0017224e to 0017225a has its CatchHandler @ 0017236b */
std::__cxx11::string::_M_construct<char_const*>(&local_f0,local_cb,local_cb + sVar4);
uVar8 = 0xf;
if (local_110 != &local_100) {
uVar8 = local_100;
}
if (uVar8 < (ulong)(local_e8 + local_108)) {
uVar8 = 0xf;
if (local_f0 != local_e0) {
uVar8 = local_e0[0];
}
if ((ulong)(local_e8 + local_108) <= uVar8) {
puVar6 = (int8 *)
std::__cxx11::string::replace((ulong)&local_f0,0,(char *)0x0,(ulong)local_110);
goto LAB_001722b5;
}
}
/* try { // try from 0017229b to 001722b4 has its CatchHandler @ 0017234f */
puVar6 = (int8 *)std::__cxx11::string::_M_append((char *)&local_110,(ulong)local_f0);
LAB_001722b5:
*in_RDI = in_RDI + 2;
puVar1 = puVar6 + 2;
if ((int8 *)*puVar6 == puVar1) {
uVar2 = puVar6[3];
in_RDI[2] = *puVar1;
in_RDI[3] = uVar2;
}
else {
*in_RDI = (int8 *)*puVar6;
in_RDI[2] = *puVar1;
}
in_RDI[1] = puVar6[1];
*puVar6 = puVar1;
puVar6[1] = 0;
*(int1 *)puVar1 = 0;
if (local_f0 != local_e0) {
operator_delete(local_f0,local_e0[0] + 1);
}
if (local_110 != &local_100) {
operator_delete(local_110,local_100 + 1);
}
if (local_c0[0] != local_b0) {
operator_delete(local_c0[0],local_b0[0] + 1);
}
return;
}
|
|
5,002 |
httplib::detail::BufferStream::read(char*, unsigned long)
|
monkey531[P]llama/examples/server/httplib.h
|
inline ssize_t BufferStream::read(char *ptr, size_t size) {
#if defined(_MSC_VER) && _MSC_VER < 1910
auto len_read = buffer._Copy_s(ptr, size, size, position);
#else
auto len_read = buffer.copy(ptr, size, position);
#endif
position += static_cast<size_t>(len_read);
return static_cast<ssize_t>(len_read);
}
|
O2
|
c
|
httplib::detail::BufferStream::read(char*, unsigned long):
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x28(%rbx), %rcx
callq 0x28120
addq %rax, 0x28(%rbx)
popq %rbx
retq
nop
|
_ZN7httplib6detail12BufferStream4readEPcm:
push rbx
mov rbx, rdi
add rdi, 8
mov rcx, [rbx+28h]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4copyEPcmm; std::string::copy(char *,ulong,ulong)
add [rbx+28h], rax
pop rbx
retn
|
long long httplib::detail::BufferStream::read(httplib::detail::BufferStream *this, char *a2, long long a3)
{
long long result; // rax
result = std::string::copy((char *)this + 8, a2, a3, *((_QWORD *)this + 5));
*((_QWORD *)this + 5) += result;
return result;
}
|
read:
PUSH RBX
MOV RBX,RDI
ADD RDI,0x8
MOV RCX,qword ptr [RBX + 0x28]
CALL 0x00128120
ADD qword ptr [RBX + 0x28],RAX
POP RBX
RET
|
/* httplib::detail::BufferStream::read(char*, unsigned long) */
void __thiscall httplib::detail::BufferStream::read(BufferStream *this,char *param_1,ulong param_2)
{
long lVar1;
lVar1 = std::__cxx11::string::copy((char *)(this + 8),(ulong)param_1,param_2);
*(long *)(this + 0x28) = *(long *)(this + 0x28) + lVar1;
return;
}
|
|
5,003 |
wait_for_readers
|
eloqsql/mysys/mf_keycache.c
|
static void wait_for_readers(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(!(block->status & (BLOCK_IN_FLUSH | BLOCK_CHANGED)));
DBUG_ASSERT(block->hash_link);
DBUG_ASSERT(block->hash_link->block == block);
/* Linked in file_blocks or changed_blocks hash. */
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
/* Not linked in LRU ring. */
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
while (block->hash_link->requests)
{
KEYCACHE_DBUG_PRINT("wait_for_readers: wait",
("suspend thread %ld block %u",
(ulong) thread->id, BLOCK_NUMBER(block)));
/* There must be no other waiter. We have no queue here. */
DBUG_ASSERT(!block->condvar);
block->condvar= &thread->suspend;
keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock);
block->condvar= NULL;
}
}
|
O3
|
c
|
wait_for_readers:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa2412
movq %rax, %r15
movq 0x20(%rbx), %rax
cmpl $0x0, 0x28(%rax)
je 0x991f9
movq %r15, %r12
addq $0x8, %r12
addq $0xc0, %r14
leaq 0x432fd(%rip), %r13 # 0xdc4b7
movq %r12, 0x68(%rbx)
cmpq $0x0, 0x38(%r15)
jne 0x991e4
movq %r12, %rdi
movq %r14, %rsi
callq 0x29430
movq $0x0, 0x68(%rbx)
movq 0x20(%rbx), %rax
cmpl $0x0, 0x28(%rax)
jne 0x991ba
jmp 0x991f9
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x68f, %ecx # imm = 0x68F
callq 0x2eec0
jmp 0x991d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
wait_for_readers_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call _my_thread_var
mov r15, rax
mov rax, [rbx+20h]
cmp dword ptr [rax+28h], 0
jz short loc_991F9
mov r12, r15
add r12, 8
add r14, 0C0h
lea r13, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
loc_991BA:
mov [rbx+68h], r12
cmp qword ptr [r15+38h], 0
jnz short loc_991E4
mov rdi, r12
mov rsi, r14
call _pthread_cond_wait
loc_991D0:
mov qword ptr [rbx+68h], 0
mov rax, [rbx+20h]
cmp dword ptr [rax+28h], 0
jnz short loc_991BA
jmp short loc_991F9
loc_991E4:
mov rdi, r12
mov rsi, r14
mov rdx, r13
mov ecx, 68Fh
call psi_cond_wait
jmp short loc_991D0
loc_991F9:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long wait_for_readers_0(long long a1, long long a2)
{
long long v2; // r15
long long result; // rax
long long v4; // r14
v2 = my_thread_var(a1);
result = *(_QWORD *)(a2 + 32);
if ( *(_DWORD *)(result + 40) )
{
v4 = a1 + 192;
do
{
*(_QWORD *)(a2 + 104) = v2 + 8;
if ( *(_QWORD *)(v2 + 56) )
psi_cond_wait(v2 + 8, v4, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0x68Fu);
else
pthread_cond_wait(v2 + 8, v4);
*(_QWORD *)(a2 + 104) = 0LL;
result = *(_QWORD *)(a2 + 32);
}
while ( *(_DWORD *)(result + 40) );
}
return result;
}
|
wait_for_readers:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001a2412
MOV R15,RAX
MOV RAX,qword ptr [RBX + 0x20]
CMP dword ptr [RAX + 0x28],0x0
JZ 0x001991f9
MOV R12,R15
ADD R12,0x8
ADD R14,0xc0
LEA R13,[0x1dc4b7]
LAB_001991ba:
MOV qword ptr [RBX + 0x68],R12
CMP qword ptr [R15 + 0x38],0x0
JNZ 0x001991e4
MOV RDI,R12
MOV RSI,R14
CALL 0x00129430
LAB_001991d0:
MOV qword ptr [RBX + 0x68],0x0
MOV RAX,qword ptr [RBX + 0x20]
CMP dword ptr [RAX + 0x28],0x0
JNZ 0x001991ba
JMP 0x001991f9
LAB_001991e4:
MOV RDI,R12
MOV RSI,R14
MOV RDX,R13
MOV ECX,0x68f
CALL 0x0012eec0
JMP 0x001991d0
LAB_001991f9:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
pthread_cond_t *__cond;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x28) != 0) {
__cond = (pthread_cond_t *)(lVar1 + 8);
do {
*(pthread_cond_t **)(param_2 + 0x68) = __cond;
if (*(long *)(lVar1 + 0x38) == 0) {
pthread_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 0xc0));
}
else {
psi_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 0xc0),
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x68f);
}
*(int8 *)(param_2 + 0x68) = 0;
} while (*(int *)(*(long *)(param_2 + 0x20) + 0x28) != 0);
}
return;
}
|
|
5,004 |
mi_ck_real_delete
|
eloqsql/storage/myisam/mi_delete.c
|
static int _mi_ck_real_delete(register MI_INFO *info, MI_KEYDEF *keyinfo,
uchar *key, uint key_length, my_off_t *root)
{
int error;
uint nod_flag;
my_off_t old_root;
uchar *root_buff;
DBUG_ENTER("_mi_ck_real_delete");
if ((old_root=*root) == HA_OFFSET_ERROR)
{
mi_print_error(info->s, HA_ERR_CRASHED);
DBUG_RETURN(my_errno=HA_ERR_CRASHED);
}
if (!(root_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
HA_MAX_KEY_BUFF*2)))
{
DBUG_PRINT("error",("Couldn't allocate memory"));
DBUG_RETURN(my_errno=ENOMEM);
}
DBUG_PRINT("info",("root_page: %ld", (long) old_root));
if (!_mi_fetch_keypage(info,keyinfo,old_root,DFLT_INIT_HITS,root_buff,0))
{
error= -1;
goto err;
}
if ((error=d_search(info,keyinfo,
(keyinfo->flag & HA_FULLTEXT ?
SEARCH_FIND | SEARCH_UPDATE | SEARCH_INSERT :
SEARCH_SAME),
key,key_length,old_root,root_buff)) >0)
{
if (error == 2)
{
DBUG_PRINT("test",("Enlarging of root when deleting"));
error=_mi_enlarge_root(info,keyinfo,key,root);
}
else /* error == 1 */
{
if (mi_getint(root_buff) <= (nod_flag=mi_test_if_nod(root_buff))+3)
{
error=0;
if (nod_flag)
*root=_mi_kpos(nod_flag,root_buff+2+nod_flag);
else
*root=HA_OFFSET_ERROR;
if (_mi_dispose(info,keyinfo,old_root,DFLT_INIT_HITS))
error= -1;
}
else
error=_mi_write_keypage(info,keyinfo,old_root,
DFLT_INIT_HITS,root_buff);
}
}
err:
my_afree((uchar*) root_buff);
DBUG_PRINT("exit",("Return: %d",error));
DBUG_RETURN(error);
}
|
O3
|
c
|
mi_ck_real_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%r8), %r12
cmpq $-0x1, %r12
je 0x75d29
movl %ecx, %r14d
movq %rsi, %rbx
movq %r8, -0x38(%rbp)
movzwl 0xe(%rsi), %eax
movq %rsp, %r13
addl $0x97f, %eax # imm = 0x97F
andl $-0x10, %eax
subq %rax, %r13
movq %r13, %rsp
movq %r15, %rdi
movq %r12, %rdx
movl $0x3, %ecx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x84c04
testq %rax, %rax
je 0x75d53
cmpb $0x0, 0xa(%rbx)
movl $0x4, %eax
movl $0x20041, %edx # imm = 0x20041
cmovnsl %eax, %edx
subq $0x8, %rsp
movq %r15, %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rcx
movl %r14d, %r8d
movq %r12, %r9
pushq %r13
callq 0x75e11
addq $0x10, %rsp
movl %eax, %r14d
testl %eax, %eax
jle 0x75deb
cmpl $0x2, %r14d
jne 0x75d5e
movq %r15, %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x896e8
jmp 0x75da9
movq (%r15), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %r14d
movl $0x7e, %edi
callq 0x7be7a
callq 0xa2a4e
movl $0x7e, (%rax)
jmp 0x75deb
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x75deb
movzbl 0x1(%r13), %eax
movl (%r13), %edx
movl %edx, %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
testb %dl, %dl
js 0x75d83
movq $-0x1, %rax
cmpl $0x3, %ecx
ja 0x75d93
jmp 0x75dc9
movq (%r15), %rax
movl 0x17c(%rax), %edi
leal 0x3(%rdi), %eax
cmpl %eax, %ecx
jbe 0x75dae
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x3, %ecx
movq %r13, %r8
callq 0x84cb0
movl %eax, %r14d
jmp 0x75deb
testq %rdi, %rdi
je 0x75dc2
leaq (%rdi,%r13), %rsi
addq $0x2, %rsi
callq 0x8557e
jmp 0x75dc9
movq $-0x1, %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x3, %ecx
callq 0x84d83
xorl %r14d, %r14d
negl %eax
sbbl %r14d, %r14d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x75e0c
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
_mi_ck_real_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], rdx
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r12, [r8]
cmp r12, 0FFFFFFFFFFFFFFFFh
jz loc_75D29
mov r14d, ecx
mov rbx, rsi
mov [rbp+var_38], r8
movzx eax, word ptr [rsi+0Eh]
mov r13, rsp
add eax, 97Fh
and eax, 0FFFFFFF0h
sub r13, rax
mov rsp, r13
mov rdi, r15
mov rdx, r12
mov ecx, 3
mov r8, r13
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_75D53
cmp byte ptr [rbx+0Ah], 0
mov eax, 4
mov edx, 20041h
cmovns edx, eax
sub rsp, 8
mov rdi, r15
mov rsi, rbx
mov rcx, [rbp+var_40]
mov r8d, r14d
mov r9, r12
push r13
call d_search_0
add rsp, 10h
mov r14d, eax
test eax, eax
jle loc_75DEB
cmp r14d, 2
jnz short loc_75D5E
mov rdi, r15
mov rsi, rbx
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_38]
call _mi_enlarge_root
jmp loc_75DA9
loc_75D29:
mov rax, [r15]
mov rsi, [rax+268h]
mov r14d, 7Eh ; '~'
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
jmp loc_75DEB
loc_75D53:
mov r14d, 0FFFFFFFFh
jmp loc_75DEB
loc_75D5E:
movzx eax, byte ptr [r13+1]
mov edx, [r13+0]
mov ecx, edx
and ecx, 7Fh
shl ecx, 8
or ecx, eax
test dl, dl
js short loc_75D83
mov rax, 0FFFFFFFFFFFFFFFFh
cmp ecx, 3
ja short loc_75D93
jmp short loc_75DC9
loc_75D83:
mov rax, [r15]
mov edi, [rax+17Ch]
lea eax, [rdi+3]
cmp ecx, eax
jbe short loc_75DAE
loc_75D93:
mov rdi, r15
mov rsi, rbx
mov rdx, r12
mov ecx, 3
mov r8, r13
call _mi_write_keypage
loc_75DA9:
mov r14d, eax
jmp short loc_75DEB
loc_75DAE:
test rdi, rdi
jz short loc_75DC2
lea rsi, [rdi+r13]
add rsi, 2
call _mi_kpos
jmp short loc_75DC9
loc_75DC2:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_75DC9:
mov rcx, [rbp+var_38]
mov [rcx], rax
mov rdi, r15
mov rsi, rbx
mov rdx, r12
mov ecx, 3
call _mi_dispose
xor r14d, r14d
neg eax
sbb r14d, r14d
loc_75DEB:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_75E0C
mov eax, r14d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75E0C:
call ___stack_chk_fail
|
long long mi_ck_real_delete(long long a1, long long a2, long long a3, int a4, long long *a5)
{
long long v6; // r12
char *v8; // r13
int v9; // edx
int v10; // r14d
const char *v12; // rsi
unsigned int v13; // ecx
long long v14; // rax
long long v15; // rdi
long long v17; // [rsp+0h] [rbp-40h] BYREF
long long *v18; // [rsp+8h] [rbp-38h]
unsigned long long v19; // [rsp+10h] [rbp-30h]
v17 = a3;
v19 = __readfsqword(0x28u);
v6 = *a5;
if ( *a5 == -1 )
{
v12 = *(const char **)(*(_QWORD *)a1 + 616LL);
v10 = 126;
mi_report_error(126LL, v12);
*(_DWORD *)my_thread_var(126LL, v12) = 126;
}
else
{
v18 = a5;
v8 = (char *)&v17 - ((*(unsigned __int16 *)(a2 + 14) + 2431) & 0xFFFFFFF0);
if ( mi_fetch_keypage(a1, a2, v6, 3LL, v8, 0LL) )
{
v9 = 131137;
if ( *(char *)(a2 + 10) >= 0 )
v9 = 4;
v10 = d_search_0(a1, a2, v9, v17, a4, v6, (long long)v8);
if ( v10 > 0 )
{
if ( v10 == 2 )
return (unsigned int)mi_enlarge_root(a1, a2, v17, v18);
v13 = (unsigned __int8)v8[1] | ((*(_DWORD *)v8 & 0x7F) << 8);
if ( (*(_DWORD *)v8 & 0x80u) != 0 )
{
v15 = *(unsigned int *)(*(_QWORD *)a1 + 380LL);
if ( v13 <= (int)v15 + 3 )
{
if ( *(_DWORD *)(*(_QWORD *)a1 + 380LL) )
v14 = mi_kpos(v15, &v8[v15 + 2]);
else
v14 = -1LL;
goto LABEL_19;
}
}
else
{
v14 = -1LL;
if ( v13 <= 3 )
{
LABEL_19:
*v18 = v14;
return (unsigned int)-((unsigned int)mi_dispose(a1, a2, v6, 3LL) != 0);
}
}
return (unsigned int)mi_write_keypage(a1, a2, v6, 3LL, v8);
}
}
else
{
return (unsigned int)-1;
}
}
return (unsigned int)v10;
}
|
_mi_ck_real_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],RDX
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R12,qword ptr [R8]
CMP R12,-0x1
JZ 0x00175d29
MOV R14D,ECX
MOV RBX,RSI
MOV qword ptr [RBP + -0x38],R8
MOVZX EAX,word ptr [RSI + 0xe]
MOV R13,RSP
ADD EAX,0x97f
AND EAX,0xfffffff0
SUB R13,RAX
MOV RSP,R13
MOV RDI,R15
MOV RDX,R12
MOV ECX,0x3
MOV R8,R13
XOR R9D,R9D
CALL 0x00184c04
TEST RAX,RAX
JZ 0x00175d53
CMP byte ptr [RBX + 0xa],0x0
MOV EAX,0x4
MOV EDX,0x20041
CMOVNS EDX,EAX
SUB RSP,0x8
MOV RDI,R15
MOV RSI,RBX
MOV RCX,qword ptr [RBP + -0x40]
MOV R8D,R14D
MOV R9,R12
PUSH R13
CALL 0x00175e11
ADD RSP,0x10
MOV R14D,EAX
TEST EAX,EAX
JLE 0x00175deb
CMP R14D,0x2
JNZ 0x00175d5e
MOV RDI,R15
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x001896e8
JMP 0x00175da9
LAB_00175d29:
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RAX + 0x268]
MOV R14D,0x7e
MOV EDI,0x7e
CALL 0x0017be7a
CALL 0x001a2a4e
MOV dword ptr [RAX],0x7e
JMP 0x00175deb
LAB_00175d53:
MOV R14D,0xffffffff
JMP 0x00175deb
LAB_00175d5e:
MOVZX EAX,byte ptr [R13 + 0x1]
MOV EDX,dword ptr [R13]
MOV ECX,EDX
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
TEST DL,DL
JS 0x00175d83
MOV RAX,-0x1
CMP ECX,0x3
JA 0x00175d93
JMP 0x00175dc9
LAB_00175d83:
MOV RAX,qword ptr [R15]
MOV EDI,dword ptr [RAX + 0x17c]
LEA EAX,[RDI + 0x3]
CMP ECX,EAX
JBE 0x00175dae
LAB_00175d93:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
MOV ECX,0x3
MOV R8,R13
CALL 0x00184cb0
LAB_00175da9:
MOV R14D,EAX
JMP 0x00175deb
LAB_00175dae:
TEST RDI,RDI
JZ 0x00175dc2
LEA RSI,[RDI + R13*0x1]
ADD RSI,0x2
CALL 0x0018557e
JMP 0x00175dc9
LAB_00175dc2:
MOV RAX,-0x1
LAB_00175dc9:
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX],RAX
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
MOV ECX,0x3
CALL 0x00184d83
XOR R14D,R14D
NEG EAX
SBB R14D,R14D
LAB_00175deb:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00175e0c
MOV EAX,R14D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175e0c:
CALL 0x00129270
|
int _mi_ck_real_delete(long *param_1,long param_2,int8 param_3,int4 param_4,
long *param_5)
{
long lVar1;
long lVar2;
int8 uVar3;
long *plVar4;
int iVar5;
long lVar6;
int4 *puVar7;
uint uVar8;
int8 uVar9;
uint *puVar10;
ulong uVar11;
long in_FS_OFFSET;
int8 auStack_60 [3];
int8 local_48;
long *local_40;
long local_38;
puVar10 = (uint *)&local_48;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_5;
local_48 = param_3;
if (lVar1 == -1) {
iVar5 = 0x7e;
auStack_60[2] = 0x175d43;
mi_report_error(0x7e,*(int8 *)(*param_1 + 0x268));
auStack_60[2] = 0x175d48;
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x7e;
goto LAB_00175deb;
}
lVar2 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0x97f & 0xfffffff0);
puVar10 = (uint *)((long)&local_48 + lVar2);
local_40 = param_5;
*(int8 *)((long)auStack_60 + lVar2 + 0x10) = 0x175cc7;
lVar6 = _mi_fetch_keypage(param_1,param_2,lVar1,3,puVar10,0);
uVar3 = local_48;
if (lVar6 == 0) {
iVar5 = -1;
goto LAB_00175deb;
}
uVar9 = 0x20041;
if (-1 < *(char *)(param_2 + 10)) {
uVar9 = 4;
}
*(uint **)((long)auStack_60 + lVar2 + 8) = puVar10;
*(int8 *)((long)auStack_60 + lVar2) = 0x175cfc;
iVar5 = d_search(param_1,param_2,uVar9,uVar3,param_4,lVar1);
plVar4 = local_40;
uVar3 = local_48;
if (iVar5 < 1) goto LAB_00175deb;
if (iVar5 == 2) {
*(int8 *)((long)auStack_60 + lVar2 + 0x10) = 0x175d24;
iVar5 = _mi_enlarge_root(param_1,param_2,uVar3,plVar4);
goto LAB_00175deb;
}
uVar8 = (*puVar10 & 0x7f) << 8 | (uint)*(byte *)((long)&local_48 + lVar2 + 1);
if ((char)*puVar10 < '\0') {
uVar11 = (ulong)*(uint *)(*param_1 + 0x17c);
if (*(uint *)(*param_1 + 0x17c) + 3 < uVar8) goto LAB_00175d93;
if (uVar11 == 0) {
lVar6 = -1;
}
else {
*(int8 *)((long)auStack_60 + lVar2 + 0x10) = 0x175dc0;
lVar6 = _mi_kpos(uVar11,(long)puVar10 + uVar11 + 2);
}
}
else {
lVar6 = -1;
if (3 < uVar8) {
LAB_00175d93:
*(int8 *)((long)auStack_60 + lVar2 + 0x10) = 0x175da9;
iVar5 = _mi_write_keypage(param_1,param_2,lVar1,3,puVar10);
goto LAB_00175deb;
}
}
*local_40 = lVar6;
*(int8 *)((long)auStack_60 + lVar2 + 0x10) = 0x175de3;
iVar5 = _mi_dispose(param_1,param_2,lVar1,3);
iVar5 = -(uint)(iVar5 != 0);
LAB_00175deb:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)(puVar10 + -2) = d_search;
__stack_chk_fail();
}
return iVar5;
}
|
|
5,005 |
mi_ft_store
|
eloqsql/storage/myisam/ft_update.c
|
static int _mi_ft_store(MI_INFO *info, uint keynr, uchar *keybuf,
FT_WORD *wlist, my_off_t filepos)
{
uint key_length;
DBUG_ENTER("_mi_ft_store");
for (; wlist->pos; wlist++)
{
key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
if (_mi_ck_write(info,keynr,(uchar*) keybuf,key_length))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
mi_ft_store:
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x77818
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x77685
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
movl %eax, %ecx
callq 0x8b2eb
testl %eax, %eax
jne 0x77805
cmpq $0x0, 0x18(%r12)
leaq 0x18(%r12), %r12
jne 0x777cc
xorl %eax, %eax
jmp 0x7780a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_mi_ft_store:
xor eax, eax
cmp qword ptr [rcx], 0
jz short locret_77818
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r12, rcx
mov r15, rdx
mov r13d, esi
mov rbx, rdi
loc_777CC:
mov rdi, rbx
mov esi, r13d
mov rdx, r15
mov rcx, r12
mov r8, r14
call _ft_make_key
mov rdi, rbx
mov esi, r13d
mov rdx, r15
mov ecx, eax
call _mi_ck_write
test eax, eax
jnz short loc_77805
cmp qword ptr [r12+18h], 0
lea r12, [r12+18h]
jnz short loc_777CC
xor eax, eax
jmp short loc_7780A
loc_77805:
mov eax, 1
loc_7780A:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_77818:
retn
|
long long mi_ft_store(long long a1, unsigned int a2, long long a3, _QWORD *a4, long long a5, __m128i a6)
{
long long result; // rax
long long i; // r12
unsigned int key; // eax
result = 0LL;
if ( *a4 )
{
for ( i = (long long)a4; ; i += 24LL )
{
key = ft_make_key(a1, a2, a3, i, a5, a6);
if ( (unsigned int)mi_ck_write(a1, a2, a3, key) )
break;
if ( *(_QWORD *)(i + 24) == 0LL )
return 0LL;
}
return 1LL;
}
return result;
}
|
_mi_ft_store:
XOR EAX,EAX
CMP qword ptr [RCX],0x0
JZ 0x00177818
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R12,RCX
MOV R15,RDX
MOV R13D,ESI
MOV RBX,RDI
LAB_001777cc:
MOV RDI,RBX
MOV ESI,R13D
MOV RDX,R15
MOV RCX,R12
MOV R8,R14
CALL 0x00177685
MOV RDI,RBX
MOV ESI,R13D
MOV RDX,R15
MOV ECX,EAX
CALL 0x0018b2eb
TEST EAX,EAX
JNZ 0x00177805
CMP qword ptr [R12 + 0x18],0x0
LEA R12,[R12 + 0x18]
JNZ 0x001777cc
XOR EAX,EAX
JMP 0x0017780a
LAB_00177805:
MOV EAX,0x1
LAB_0017780a:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00177818:
RET
|
int8
_mi_ft_store(int8 param_1,int4 param_2,int8 param_3,long *param_4,
int8 param_5,int8 param_6)
{
long *plVar1;
int4 uVar2;
int iVar3;
int8 uVar4;
if (*param_4 != 0) {
uVar4 = 0;
do {
uVar2 = _ft_make_key(param_1,param_2,param_3,param_4,param_5,param_6,uVar4);
iVar3 = _mi_ck_write(param_1,param_2,param_3,uVar2);
if (iVar3 != 0) {
return 1;
}
plVar1 = param_4 + 3;
param_4 = param_4 + 3;
} while (*plVar1 != 0);
}
return 0;
}
|
|
5,006 |
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, char, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::locale_ref)
|
aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/fmt/bundled/format.h
|
FMT_CONSTEXPR auto write(OutputIt out, Char value,
const basic_format_specs<Char>& specs,
locale_ref loc = {}) -> OutputIt {
return check_char_specs(specs)
? write_char(out, value, specs)
: write(out, static_cast<int>(value), specs, loc);
}
|
O0
|
c
|
fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, char, fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::locale_ref):
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1f(%rsp), %rsi
callq 0xb3640
testb $0x1, %al
jne 0xb35df
jmp 0xb3606
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0x2f(%rsp), %al
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rdi
movsbl %al, %esi
callq 0x9d430
movq %rax, 0x40(%rsp)
jmp 0xb3636
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movsbl 0x2f(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
callq 0x9be80
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
|
_ZN3fmt2v86detail5writeIcNS0_8appenderEEET0_S4_T_RKNS0_18basic_format_specsIS5_EENS1_10locale_refE:
sub rsp, 48h
mov al, sil
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rcx
mov [rsp+48h+var_19], al
mov [rsp+48h+var_28], rdx
mov rdi, [rsp+48h+var_28]
lea rsi, [rsp+48h+var_29]
call _ZN3fmt2v86detail16check_char_specsIcNS1_13error_handlerEEEbRKNS0_18basic_format_specsIT_EEOT0_; fmt::v8::detail::check_char_specs<char,fmt::v8::detail::error_handler>(fmt::v8::basic_format_specs<char> const&,fmt::v8::detail::error_handler &&)
test al, 1
jnz short loc_B35DF
jmp short loc_B3606
loc_B35DF:
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_38], rax
mov al, [rsp+48h+var_19]
mov rdx, [rsp+48h+var_28]
mov rdi, [rsp+48h+var_38]
movsx esi, al
call _ZN3fmt2v86detail10write_charIcNS0_8appenderEEET0_S4_T_RKNS0_18basic_format_specsIS5_EE; fmt::v8::detail::write_char<char,fmt::v8::appender>(fmt::v8::appender,char,fmt::v8::basic_format_specs<char> const&)
mov [rsp+48h+var_8], rax
jmp short loc_B3636
loc_B3606:
mov rax, [rsp+48h+var_10]
mov [rsp+48h+var_40], rax
movsx esi, [rsp+48h+var_19]
mov rdx, [rsp+48h+var_28]
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_48], rax
mov rdi, [rsp+48h+var_40]
mov rcx, [rsp+48h+var_48]
call _ZN3fmt2v86detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuesr3std7is_sameIT0_NSt11conditionalIXsr3std7is_sameIT_cEE5valueES3_St20back_insert_iteratorINS1_6bufferIS8_EEEE4typeEEE5valueEiE4typeELi0EEES6_S6_S5_RKNS0_18basic_format_specsIS8_EENS1_10locale_refE
mov [rsp+48h+var_8], rax
loc_B3636:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
|
long long fmt::v8::detail::write<char,fmt::v8::appender>(long long a1, char a2, long long a3, long long a4)
{
char v5; // [rsp+1Fh] [rbp-29h] BYREF
long long v6; // [rsp+20h] [rbp-28h]
char v7; // [rsp+2Fh] [rbp-19h]
long long v8; // [rsp+30h] [rbp-18h]
long long v9; // [rsp+38h] [rbp-10h]
v9 = a1;
v8 = a4;
v7 = a2;
v6 = a3;
if ( (fmt::v8::detail::check_char_specs<char,fmt::v8::detail::error_handler>(a3, &v5) & 1) != 0 )
return fmt::v8::detail::write_char<char,fmt::v8::appender>(v9, v7, v6);
else
return ZN3fmt2v86detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuesr3std7is_sameIT0_NSt11conditionalIXsr3std7is_sameIT_cEE5valueES3_St20back_insert_iteratorINS1_6bufferIS8_EEEE4typeEEE5valueEiE4typeELi0EEES6_S6_S5_RKNS0_18basic_format_specsIS8_EENS1_10locale_refE(
v9,
v7,
v6,
v8);
}
|
write<char,fmt::v8::appender>:
SUB RSP,0x48
MOV AL,SIL
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RCX
MOV byte ptr [RSP + 0x2f],AL
MOV qword ptr [RSP + 0x20],RDX
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0x1f]
CALL 0x001b3640
TEST AL,0x1
JNZ 0x001b35df
JMP 0x001b3606
LAB_001b35df:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x10],RAX
MOV AL,byte ptr [RSP + 0x2f]
MOV RDX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP + 0x10]
MOVSX ESI,AL
CALL 0x0019d430
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001b3636
LAB_001b3606:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOVSX ESI,byte ptr [RSP + 0x2f]
MOV RDX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP]
CALL 0x0019be80
MOV qword ptr [RSP + 0x40],RAX
LAB_001b3636:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
/* fmt::v8::appender fmt::v8::detail::write<char, fmt::v8::appender>(fmt::v8::appender, char,
fmt::v8::basic_format_specs<char> const&, fmt::v8::detail::locale_ref) */
int8
fmt::v8::detail::write<char,fmt::v8::appender>
(int8 param_1,char param_2,basic_format_specs *param_3,int8 param_4)
{
bool bVar1;
error_handler local_29;
basic_format_specs *local_28;
char local_19;
int8 local_18;
int8 local_10;
int8 local_8;
local_28 = param_3;
local_19 = param_2;
local_18 = param_4;
local_10 = param_1;
bVar1 = check_char_specs<char,fmt::v8::detail::error_handler>(param_3,&local_29);
if (bVar1) {
local_8 = write_char<char,fmt::v8::appender>(local_10,(int)local_19,local_28);
}
else {
local_8 = _ZN3fmt2v86detail5writeIcNS0_8appenderEiTnNSt9enable_ifIXaaaasr11is_integralIT1_EE5valuentsr3std7is_sameIS5_bEE5valuesr3std7is_sameIT0_NSt11conditionalIXsr3std7is_sameIT_cEE5valueES3_St20back_insert_iteratorINS1_6bufferIS8_EEEE4typeEEE5valueEiE4typeELi0EEES6_S6_S5_RKNS0_18basic_format_specsIS8_EENS1_10locale_refE
(local_10,(int)local_19,local_28,local_18);
}
return local_8;
}
|
|
5,007 |
host_account_exists
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c
|
static bool host_account_exists(void* context, const evmc_address* addr) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("account_exists for", addr);
changed_account_t* ac = get_changed_account(ctx, addr->bytes);
if (ac) return ac->deleted;
bool exists = get_src_account(ctx, addr->bytes, false).def != NULL;
// TODO existance check over the values of the account!
EVM_LOG("account_exists result: %s", exists ? "true" : "false");
return exists;
}
|
O0
|
c
|
host_account_exists:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xb0076(%rip), %rdi # 0xdb359
callq 0x2b2a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2b30e
movq -0x28(%rbp), %rax
movb 0x58(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2b338
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
xorl %ecx, %ecx
callq 0x2b120
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x2b330
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
host_account_exists:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rsi, [rbp+var_18]
lea rdi, aAccountExistsF; "account_exists for"
call debug_print_address
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
call get_changed_account
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_2B30E
mov rax, [rbp+var_28]
mov al, [rax+58h]
and al, 1
mov [rbp+var_1], al
jmp short loc_2B338
loc_2B30E:
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
lea rdi, [rbp+var_48]
xor ecx, ecx
call get_src_account
cmp [rbp+var_38], 0
setnz al
and al, 1
mov [rbp+var_29], al
jmp short $+2
loc_2B330:
mov al, [rbp+var_29]
and al, 1
mov [rbp+var_1], al
loc_2B338:
mov al, [rbp+var_1]
and al, 1
add rsp, 50h
pop rbp
retn
|
bool host_account_exists(_QWORD *a1, long long a2)
{
int v2; // r8d
int v3; // r9d
_BYTE v5[16]; // [rsp+8h] [rbp-48h] BYREF
long long v6; // [rsp+18h] [rbp-38h]
bool v7; // [rsp+27h] [rbp-29h]
long long changed_account; // [rsp+28h] [rbp-28h]
_QWORD *v9; // [rsp+30h] [rbp-20h]
long long v10; // [rsp+38h] [rbp-18h]
_QWORD *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a1;
debug_print_address();
changed_account = get_changed_account((long long)a1, a2);
if ( changed_account )
return *(_BYTE *)(changed_account + 88) & 1;
get_src_account((long long)v5, v9, v10, 0, v2, v3);
v7 = v6 != 0;
return v6 != 0;
}
|
host_account_exists:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x1db359]
CALL 0x0012b2a0
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012b090
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0012b30e
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX + 0x58]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
JMP 0x0012b338
LAB_0012b30e:
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x48]
XOR ECX,ECX
CALL 0x0012b120
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RBP + -0x29],AL
JMP 0x0012b330
LAB_0012b330:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
LAB_0012b338:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x50
POP RBP
RET
|
int8 host_account_exists(int8 param_1,int8 param_2)
{
int7 uVar2;
int8 uVar1;
int1 local_50 [16];
long local_40;
long local_30;
int8 local_28;
int8 local_20;
int8 local_18;
bool local_9;
local_28 = param_1;
local_20 = param_2;
local_18 = param_1;
debug_print_address("account_exists for",param_2);
local_30 = get_changed_account(local_28,local_20);
if (local_30 == 0) {
uVar1 = get_src_account(local_50,local_28,local_20,0);
local_9 = local_40 != 0;
uVar2 = (int7)((ulong)uVar1 >> 8);
}
else {
uVar2 = (int7)((ulong)local_30 >> 8);
local_9 = (bool)(*(byte *)(local_30 + 0x58) & 1);
}
return CONCAT71(uVar2,local_9);
}
|
|
5,008 |
host_account_exists
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c
|
static bool host_account_exists(void* context, const evmc_address* addr) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("account_exists for", addr);
changed_account_t* ac = get_changed_account(ctx, addr->bytes);
if (ac) return ac->deleted;
bool exists = get_src_account(ctx, addr->bytes, false).def != NULL;
// TODO existance check over the values of the account!
EVM_LOG("account_exists result: %s", exists ? "true" : "false");
return exists;
}
|
O1
|
c
|
host_account_exists:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x27bd3
testq %rax, %rax
je 0x27d6a
movb 0x58(%rax), %al
jmp 0x27d87
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x27c22
cmpq $0x0, 0x10(%r15)
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
host_account_exists:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rsi
mov r14, rdi
call get_changed_account
test rax, rax
jz short loc_27D6A
mov al, [rax+58h]
jmp short loc_27D87
loc_27D6A:
lea r15, [rsp+38h+var_30]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call get_src_account
cmp qword ptr [r15+10h], 0
setnz al
loc_27D87:
add rsp, 20h
pop rbx
pop r14
pop r15
retn
|
__int8 host_account_exists(const __m128i *a1, const __m128i *a2)
{
const __m128i *changed_account; // rax
int v3; // r8d
int v4; // r9d
_BYTE v6[16]; // [rsp+8h] [rbp-30h] BYREF
long long v7; // [rsp+18h] [rbp-20h]
changed_account = get_changed_account((long long)a1, a2);
if ( changed_account )
return changed_account[5].m128i_i8[8];
get_src_account((long long)v6, a1, a2, 0, v3, v4);
return v7 != 0;
}
|
host_account_exists:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RSI
MOV R14,RDI
CALL 0x00127bd3
TEST RAX,RAX
JZ 0x00127d6a
MOV AL,byte ptr [RAX + 0x58]
JMP 0x00127d87
LAB_00127d6a:
LEA R15,[RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00127c22
CMP qword ptr [R15 + 0x10],0x0
SETNZ AL
LAB_00127d87:
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
int1 host_account_exists(int8 param_1,int8 param_2)
{
long lVar1;
int1 uVar2;
int1 local_30 [16];
long local_20;
lVar1 = get_changed_account();
if (lVar1 == 0) {
get_src_account(local_30,param_1,param_2,0);
uVar2 = local_20 != 0;
}
else {
uVar2 = *(int1 *)(lVar1 + 0x58);
}
return uVar2;
}
|
|
5,009 |
host_account_exists
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c
|
static bool host_account_exists(void* context, const evmc_address* addr) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("account_exists for", addr);
changed_account_t* ac = get_changed_account(ctx, addr->bytes);
if (ac) return ac->deleted;
bool exists = get_src_account(ctx, addr->bytes, false).def != NULL;
// TODO existance check over the values of the account!
EVM_LOG("account_exists result: %s", exists ? "true" : "false");
return exists;
}
|
O3
|
c
|
host_account_exists:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x27648
testq %rax, %rax
je 0x277d5
movb 0x58(%rax), %al
jmp 0x277f2
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x27690
cmpq $0x0, 0x10(%r15)
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
host_account_exists:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rsi
mov r14, rdi
call get_changed_account
test rax, rax
jz short loc_277D5
mov al, [rax+58h]
jmp short loc_277F2
loc_277D5:
lea r15, [rsp+38h+var_30]
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call get_src_account
cmp qword ptr [r15+10h], 0
setnz al
loc_277F2:
add rsp, 20h
pop rbx
pop r14
pop r15
retn
|
__int8 host_account_exists(const __m128i *a1, const __m128i *a2)
{
const __m128i *changed_account; // rax
int v3; // r8d
int v4; // r9d
_BYTE v6[16]; // [rsp+8h] [rbp-30h] BYREF
long long v7; // [rsp+18h] [rbp-20h]
changed_account = get_changed_account((long long)a1, a2);
if ( changed_account )
return changed_account[5].m128i_i8[8];
get_src_account((long long)v6, a1, a2, 0, v3, v4);
return v7 != 0;
}
|
host_account_exists:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RSI
MOV R14,RDI
CALL 0x00127648
TEST RAX,RAX
JZ 0x001277d5
MOV AL,byte ptr [RAX + 0x58]
JMP 0x001277f2
LAB_001277d5:
LEA R15,[RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00127690
CMP qword ptr [R15 + 0x10],0x0
SETNZ AL
LAB_001277f2:
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
int1 host_account_exists(int8 param_1,int8 param_2)
{
long lVar1;
int1 uVar2;
int1 local_30 [16];
long local_20;
lVar1 = get_changed_account();
if (lVar1 == 0) {
get_src_account(local_30,param_1,param_2,0);
uVar2 = local_20 != 0;
}
else {
uVar2 = *(int1 *)(lVar1 + 0x58);
}
return uVar2;
}
|
|
5,010 |
js_new_callsite_data2
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_new_callsite_data2(JSContext *ctx, JSCallSiteData *csd, const char *filename, int line_num, int col_num)
{
csd->func = JS_NULL;
csd->func_name = JS_NULL;
csd->native = FALSE;
csd->line_num = line_num;
csd->col_num = col_num;
/* filename is UTF-8 encoded if needed (original argument to __JS_EvalInternal()) */
csd->filename = JS_NewString(ctx, filename);
if (JS_IsException(csd->filename)) {
csd->filename = JS_NULL;
JS_FreeValue(ctx, JS_GetException(ctx)); // Clear exception.
}
}
|
O0
|
c
|
js_new_callsite_data2:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movl %r8d, 0x68(%rsp)
movq 0x78(%rsp), %rax
movl $0x0, 0x58(%rsp)
movq $0x2, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x78(%rsp), %rax
movl $0x0, 0x48(%rsp)
movq $0x2, 0x50(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x78(%rsp), %rax
movl $0x0, 0x30(%rax)
movl 0x6c(%rsp), %ecx
movq 0x78(%rsp), %rax
movl %ecx, 0x34(%rax)
movl 0x68(%rsp), %ecx
movq 0x78(%rsp), %rax
movl %ecx, 0x38(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x4d600
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x78(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x7279a
movq 0x78(%rsp), %rax
movl $0x0, 0x28(%rsp)
movq $0x2, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2cf70
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x23c90
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_new_callsite_data2:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_1C], ecx
mov [rsp+88h+var_20], r8d
mov rax, [rsp+88h+var_10]
mov dword ptr [rsp+88h+var_30], 0
mov [rsp+88h+var_28], 2
mov rcx, [rsp+88h+var_30]
mov [rax+10h], rcx
mov rcx, [rsp+88h+var_28]
mov [rax+18h], rcx
mov rax, [rsp+88h+var_10]
mov dword ptr [rsp+88h+var_40], 0
mov [rsp+88h+var_38], 2
mov rcx, [rsp+88h+var_40]
mov [rax+20h], rcx
mov rcx, [rsp+88h+var_38]
mov [rax+28h], rcx
mov rax, [rsp+88h+var_10]
mov dword ptr [rax+30h], 0
mov ecx, [rsp+88h+var_1C]
mov rax, [rsp+88h+var_10]
mov [rax+34h], ecx
mov ecx, [rsp+88h+var_20]
mov rax, [rsp+88h+var_10]
mov [rax+38h], ecx
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_78], rax
mov rdi, [rsp+88h+var_8]
mov rsi, [rsp+88h+var_18]
call JS_NewString_0
mov rcx, rax
mov rax, [rsp+88h+var_78]
mov [rsp+88h+var_50], rcx
mov [rsp+88h+var_48], rdx
mov rcx, [rsp+88h+var_50]
mov [rax], rcx
mov rcx, [rsp+88h+var_48]
mov [rax+8], rcx
mov rax, [rsp+88h+var_10]
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsException_1
cmp eax, 0
jz short loc_7279A
mov rax, [rsp+88h+var_10]
mov dword ptr [rsp+88h+var_60], 0
mov [rsp+88h+var_58], 2
mov rcx, [rsp+88h+var_60]
mov [rax], rcx
mov rcx, [rsp+88h+var_58]
mov [rax+8], rcx
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_80], rax
mov rdi, [rsp+88h+var_8]
call JS_GetException
mov rdi, [rsp+88h+var_80]
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_68], rdx
mov rsi, [rsp+88h+var_70]
mov rdx, [rsp+88h+var_68]
call JS_FreeValue
loc_7279A:
add rsp, 88h
retn
|
long long js_new_callsite_data2(long long a1, long long a2, unsigned __int8 *a3, int a4, int a5)
{
long long v5; // rdx
long long result; // rax
long long v7; // rdx
long long Exception; // [rsp+18h] [rbp-70h]
long long v9; // [rsp+28h] [rbp-60h]
long long v10; // [rsp+48h] [rbp-40h]
long long v11; // [rsp+58h] [rbp-30h]
LODWORD(v11) = 0;
*(_QWORD *)(a2 + 16) = v11;
*(_QWORD *)(a2 + 24) = 2LL;
LODWORD(v10) = 0;
*(_QWORD *)(a2 + 32) = v10;
*(_QWORD *)(a2 + 40) = 2LL;
*(_DWORD *)(a2 + 48) = 0;
*(_DWORD *)(a2 + 52) = a4;
*(_DWORD *)(a2 + 56) = a5;
*(_QWORD *)a2 = JS_NewString_0(a1, a3);
*(_QWORD *)(a2 + 8) = v5;
result = JS_IsException_1(*(_QWORD *)a2, *(_QWORD *)(a2 + 8));
if ( (_DWORD)result )
{
LODWORD(v9) = 0;
*(_QWORD *)a2 = v9;
*(_QWORD *)(a2 + 8) = 2LL;
Exception = JS_GetException(a1);
return JS_FreeValue(a1, Exception, v7);
}
return result;
}
|
js_new_callsite_data2:
SUB RSP,0x88
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV dword ptr [RSP + 0x6c],ECX
MOV dword ptr [RSP + 0x68],R8D
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x2
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x2
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RAX + 0x30],0x0
MOV ECX,dword ptr [RSP + 0x6c]
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RAX + 0x34],ECX
MOV ECX,dword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RAX + 0x38],ECX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x0014d600
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RDX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x78]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0017279a
MOV RAX,qword ptr [RSP + 0x78]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x2
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0012cf70
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x00123c90
LAB_0017279a:
ADD RSP,0x88
RET
|
void js_new_callsite_data2
(int8 param_1,int1 (*param_2) [16],int8 param_3,int4 param_4,
int4 param_5)
{
int iVar1;
int1 auVar2 [16];
uint uStack_5c;
uint uStack_3c;
uint uStack_2c;
*(ulong *)param_2[1] = (ulong)uStack_2c << 0x20;
*(int8 *)(param_2[1] + 8) = 2;
*(ulong *)param_2[2] = (ulong)uStack_3c << 0x20;
*(int8 *)(param_2[2] + 8) = 2;
*(int4 *)param_2[3] = 0;
*(int4 *)(param_2[3] + 4) = param_4;
*(int4 *)(param_2[3] + 8) = param_5;
auVar2 = JS_NewString(param_1,param_3);
*param_2 = auVar2;
iVar1 = JS_IsException(*(int8 *)*param_2,*(int8 *)(*param_2 + 8));
if (iVar1 != 0) {
*(ulong *)*param_2 = (ulong)uStack_5c << 0x20;
*(int8 *)(*param_2 + 8) = 2;
auVar2 = JS_GetException(param_1);
JS_FreeValue(param_1,auVar2._0_8_,auVar2._8_8_);
}
return;
}
|
|
5,011 |
ma_remove_not_visible_states_with_lock
|
eloqsql/storage/maria/ma_state.c
|
void _ma_remove_not_visible_states_with_lock(MARIA_SHARE *share,
my_bool all)
{
my_bool is_lock_trman;
if ((is_lock_trman= trman_is_inited()))
trnman_lock();
mysql_mutex_lock(&share->intern_lock);
share->state_history= _ma_remove_not_visible_states(share->state_history,
all, 1);
mysql_mutex_unlock(&share->intern_lock);
if (is_lock_trman)
trnman_unlock();
}
|
O3
|
c
|
ma_remove_not_visible_states_with_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
xorl %eax, %eax
callq 0x47287
testb %al, %al
je 0x380ab
xorl %eax, %eax
callq 0x47237
leaq 0x8f0(%rbx), %r15
cmpq $0x0, 0x930(%rbx)
jne 0x380fe
movq %r15, %rdi
callq 0x29220
movq 0x450(%rbx), %rdi
movsbl %r14b, %esi
movl $0x1, %edx
callq 0x37f76
movq %rax, 0x450(%rbx)
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x38117
movq %r15, %rdi
callq 0x291e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x47258
leaq 0x8f0(%rbx), %r15
cmpq $0x0, 0x930(%rbx)
jne 0x3812c
movq %r15, %rdi
callq 0x29220
movq 0x450(%rbx), %rdi
movsbl %r14b, %esi
movl $0x1, %edx
callq 0x37f76
movq %rax, 0x450(%rbx)
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x38142
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
leaq 0xa12e2(%rip), %rsi # 0xd93e7
movq %r15, %rdi
movl $0xe1, %edx
callq 0x2eb8f
jmp 0x38066
leaq 0x34def2(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x38092
leaq 0xa12b4(%rip), %rsi # 0xd93e7
movq %r15, %rdi
movl $0xe1, %edx
callq 0x2eb8f
jmp 0x380c4
leaq 0x34dec7(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x380ec
|
_ma_remove_not_visible_states_with_lock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14d, esi
mov rbx, rdi
xor eax, eax
call trman_is_inited
test al, al
jz short loc_380AB
xor eax, eax
call trnman_lock
lea r15, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz loc_380FE
mov rdi, r15
call _pthread_mutex_lock
loc_38066:
mov rdi, [rbx+450h]
movsx esi, r14b
mov edx, 1
call _ma_remove_not_visible_states
mov [rbx+450h], rax
mov rdi, [rbx+930h]
test rdi, rdi
jnz loc_38117
loc_38092:
mov rdi, r15
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp trnman_unlock
loc_380AB:
lea r15, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz short loc_3812C
mov rdi, r15
call _pthread_mutex_lock
loc_380C4:
mov rdi, [rbx+450h]
movsx esi, r14b
mov edx, 1
call _ma_remove_not_visible_states
mov [rbx+450h], rax
mov rdi, [rbx+930h]
test rdi, rdi
jnz short loc_38142
loc_380EC:
mov rdi, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_380FE:
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0E1h
call psi_mutex_lock
jmp loc_38066
loc_38117:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_38092
loc_3812C:
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov edx, 0E1h
call psi_mutex_lock
jmp short loc_380C4
loc_38142:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_380EC
|
long long ma_remove_not_visible_states_with_lock(long long a1, char a2)
{
if ( (unsigned __int8)trman_is_inited(a1) )
{
trnman_lock();
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(a1 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0xE1u);
else
pthread_mutex_lock(a1 + 2288);
*(_QWORD *)(a1 + 1104) = ma_remove_not_visible_states(*(_QWORD **)(a1 + 1104), a2, 1);
if ( *(_QWORD *)(a1 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 2288);
return trnman_unlock();
}
else
{
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(a1 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0xE1u);
else
pthread_mutex_lock(a1 + 2288);
*(_QWORD *)(a1 + 1104) = ma_remove_not_visible_states(*(_QWORD **)(a1 + 1104), a2, 1);
if ( *(_QWORD *)(a1 + 2352) )
PSI_server[44]();
return pthread_mutex_unlock(a1 + 2288);
}
}
|
_ma_remove_not_visible_states_with_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
XOR EAX,EAX
CALL 0x00147287
TEST AL,AL
JZ 0x001380ab
XOR EAX,EAX
CALL 0x00147237
LEA R15,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x001380fe
MOV RDI,R15
CALL 0x00129220
LAB_00138066:
MOV RDI,qword ptr [RBX + 0x450]
MOVSX ESI,R14B
MOV EDX,0x1
CALL 0x00137f76
MOV qword ptr [RBX + 0x450],RAX
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x00138117
LAB_00138092:
MOV RDI,R15
CALL 0x001291e0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00147258
LAB_001380ab:
LEA R15,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x0013812c
MOV RDI,R15
CALL 0x00129220
LAB_001380c4:
MOV RDI,qword ptr [RBX + 0x450]
MOVSX ESI,R14B
MOV EDX,0x1
CALL 0x00137f76
MOV qword ptr [RBX + 0x450],RAX
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x00138142
LAB_001380ec:
MOV RDI,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_001380fe:
LEA RSI,[0x1d93e7]
MOV RDI,R15
MOV EDX,0xe1
CALL 0x0012eb8f
JMP 0x00138066
LAB_00138117:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00138092
LAB_0013812c:
LEA RSI,[0x1d93e7]
MOV RDI,R15
MOV EDX,0xe1
CALL 0x0012eb8f
JMP 0x001380c4
LAB_00138142:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001380ec
|
void _ma_remove_not_visible_states_with_lock(long param_1,char param_2)
{
pthread_mutex_t *ppVar1;
char cVar2;
int8 uVar3;
cVar2 = trman_is_inited();
if (cVar2 != '\0') {
trnman_lock();
ppVar1 = (pthread_mutex_t *)(param_1 + 0x8f0);
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock(ppVar1);
}
else {
psi_mutex_lock(ppVar1,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0xe1
);
}
uVar3 = _ma_remove_not_visible_states(*(int8 *)(param_1 + 0x450),(int)param_2,1);
*(int8 *)(param_1 + 0x450) = uVar3;
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar1);
trnman_unlock();
return;
}
ppVar1 = (pthread_mutex_t *)(param_1 + 0x8f0);
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock(ppVar1);
}
else {
psi_mutex_lock(ppVar1,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0xe1);
}
uVar3 = _ma_remove_not_visible_states(*(int8 *)(param_1 + 0x450),(int)param_2,1);
*(int8 *)(param_1 + 0x450) = uVar3;
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar1);
return;
}
|
|
5,012 |
flux::parser::Parser::asmDeclaration()
|
kvthweatt[P]FluxLang/src/parser/parser.cpp
|
std::unique_ptr<Decl> Parser::asmDeclaration() {
auto start = previous_; // 'asm' keyword
// Parse the ASM block
consume(lexer::TokenType::LEFT_BRACE, "Expected '{' after 'asm'");
// Collect the ASM code as a string
std::stringstream asmCode;
// Track nested braces
int braceLevel = 1;
// Continue until we find the matching closing brace
while (braceLevel > 0 && !check(lexer::TokenType::END_OF_FILE)) {
if (check(lexer::TokenType::LEFT_BRACE)) {
braceLevel++;
} else if (check(lexer::TokenType::RIGHT_BRACE)) {
braceLevel--;
if (braceLevel == 0) {
break; // Found the matching closing brace
}
}
// Add the current token's lexeme to the ASM code
// Add a space to preserve token separation
if (asmCode.tellp() > 0) {
asmCode << " ";
}
asmCode << current_.lexeme();
// Move to the next token
advance();
}
auto endToken = consume(lexer::TokenType::RIGHT_BRACE, "Expected '}' after ASM block");
consume(lexer::TokenType::SEMICOLON, "Expected ';' after ASM block");
return std::make_unique<AsmDecl>(
asmCode.str(),
makeRange(start, endToken)
);
}
|
O0
|
cpp
|
flux::parser::Parser::asmDeclaration():
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rdi, -0x440(%rbp)
movq %rdi, %rax
movq %rax, -0x438(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x430(%rbp)
addq $0x68, %rsi
leaq -0x70(%rbp), %rdi
callq 0x15420
leaq 0x19aed(%rip), %rsi # 0x645e0
leaq -0xe0(%rbp), %rdi
callq 0xd130
movq -0x430(%rbp), %rsi
movq -0xe0(%rbp), %rcx
movq -0xd8(%rbp), %r8
leaq -0xd0(%rbp), %rdi
movl $0x5f, %edx
callq 0x43180
jmp 0x4ab27
leaq -0xd0(%rbp), %rdi
callq 0xa300
leaq -0x278(%rbp), %rdi
callq 0x7240
jmp 0x4ab41
movl $0x1, -0x27c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x27c(%rbp)
movb %al, -0x441(%rbp)
jle 0x4ab80
movq -0x430(%rbp), %rdi
xorl %esi, %esi
callq 0x417c0
movb %al, -0x442(%rbp)
jmp 0x4ab72
movb -0x442(%rbp), %al
xorb $-0x1, %al
movb %al, -0x441(%rbp)
movb -0x441(%rbp), %al
testb $0x1, %al
jne 0x4ab8f
jmp 0x4ad36
movq -0x430(%rbp), %rdi
movl $0x5f, %esi
callq 0x417c0
movb %al, -0x443(%rbp)
jmp 0x4aba8
movb -0x443(%rbp), %al
testb $0x1, %al
jne 0x4abb4
jmp 0x4abf3
movl -0x27c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x27c(%rbp)
jmp 0x4ac39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4aeaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4aea3
movq -0x430(%rbp), %rdi
movl $0x60, %esi
callq 0x417c0
movb %al, -0x444(%rbp)
jmp 0x4ac0c
movb -0x444(%rbp), %al
testb $0x1, %al
jne 0x4ac18
jmp 0x4ac37
movl -0x27c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x27c(%rbp)
cmpl $0x0, -0x27c(%rbp)
jne 0x4ac35
jmp 0x4ad36
jmp 0x4ac37
jmp 0x4ac39
leaq -0x268(%rbp), %rdi
callq 0x72d0
movq %rdx, -0x458(%rbp)
movq %rax, -0x450(%rbp)
jmp 0x4ac55
movq -0x458(%rbp), %rax
movq -0x450(%rbp), %rcx
movq %rcx, -0x290(%rbp)
movq %rax, -0x288(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x10da0
movq %rax, -0x460(%rbp)
jmp 0x4ac86
movq -0x460(%rbp), %rax
cmpq $0x0, %rax
jle 0x4acaa
leaq -0x268(%rbp), %rdi
leaq 0x174e2(%rip), %rsi # 0x62183
callq 0x7330
jmp 0x4aca8
jmp 0x4acaa
movq -0x430(%rbp), %rdi
leaq -0x268(%rbp), %rax
movq %rax, -0x478(%rbp)
addq $0x8, %rdi
callq 0x2a860
movq %rdx, -0x470(%rbp)
movq %rax, -0x468(%rbp)
jmp 0x4acd8
movq -0x478(%rbp), %rdi
movq -0x470(%rbp), %rax
movq -0x468(%rbp), %rcx
movq %rcx, -0x2a0(%rbp)
movq %rax, -0x298(%rbp)
movq -0x2a0(%rbp), %rsi
movq -0x298(%rbp), %rdx
callq 0x91b0
jmp 0x4ad10
movq -0x430(%rbp), %rsi
leaq -0x300(%rbp), %rdi
callq 0x417f0
jmp 0x4ad25
leaq -0x300(%rbp), %rdi
callq 0xa300
jmp 0x4ab4b
leaq 0x198bc(%rip), %rsi # 0x645f9
leaq -0x370(%rbp), %rdi
callq 0xd130
movq -0x430(%rbp), %rsi
movq -0x370(%rbp), %rcx
movq -0x368(%rbp), %r8
leaq -0x360(%rbp), %rdi
movl $0x60, %edx
callq 0x43180
jmp 0x4ad71
leaq 0x1989e(%rip), %rsi # 0x64616
leaq -0x3e0(%rbp), %rdi
callq 0xd130
movq -0x430(%rbp), %rsi
movq -0x3e0(%rbp), %rcx
movq -0x3d8(%rbp), %r8
leaq -0x3d0(%rbp), %rdi
movl $0x58, %edx
callq 0x43180
jmp 0x4adac
leaq -0x3d0(%rbp), %rdi
callq 0xa300
leaq -0x408(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x7320
jmp 0x4adcd
movq -0x430(%rbp), %rsi
leaq -0x428(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq -0x360(%rbp), %rcx
callq 0x43570
jmp 0x4aded
leaq -0x3e8(%rbp), %rdi
leaq -0x408(%rbp), %rsi
leaq -0x428(%rbp), %rdx
callq 0x5b5c0
jmp 0x4ae09
movq -0x440(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x22880
leaq -0x3e8(%rbp), %rdi
callq 0x228d0
leaq -0x408(%rbp), %rdi
callq 0x71f0
leaq -0x360(%rbp), %rdi
callq 0xa300
leaq -0x278(%rbp), %rdi
callq 0x7280
leaq -0x70(%rbp), %rdi
callq 0xa300
movq -0x438(%rbp), %rax
addq $0x480, %rsp # imm = 0x480
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x4ae97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x71f0
leaq -0x360(%rbp), %rdi
callq 0xa300
leaq -0x278(%rbp), %rdi
callq 0x7280
leaq -0x70(%rbp), %rdi
callq 0xa300
movq -0xe8(%rbp), %rdi
callq 0x75a0
nopw %cs:(%rax,%rax)
|
_ZN4flux6parser6Parser14asmDeclarationEv:
push rbp
mov rbp, rsp
sub rsp, 480h
mov [rbp+var_440], rdi
mov rax, rdi
mov [rbp+var_438], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rsi, [rbp+var_10]
mov [rbp+var_430], rsi
add rsi, 68h ; 'h'; flux::lexer::Token *
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenC2ERKS1_; flux::lexer::Token::Token(flux::lexer::Token const&)
lea rsi, aExpectedAfterA_0; "Expected '{' after 'asm'"
lea rdi, [rbp+var_E0]
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rsi, [rbp+var_430]
mov rcx, [rbp+var_E0]
mov r8, [rbp+var_D8]
lea rdi, [rbp+var_D0]
mov edx, 5Fh ; '_'
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
jmp short $+2
loc_4AB27:
lea rdi, [rbp+var_D0]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
lea rdi, [rbp+var_278]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
jmp short $+2
loc_4AB41:
mov [rbp+var_27C], 1
loc_4AB4B:
xor eax, eax
cmp [rbp+var_27C], 0
mov [rbp+var_441], al
jle short loc_4AB80
mov rdi, [rbp+var_430]
xor esi, esi
call _ZNK4flux6parser6Parser5checkENS_5lexer9TokenTypeE; flux::parser::Parser::check(flux::lexer::TokenType)
mov [rbp+var_442], al
jmp short $+2
loc_4AB72:
mov al, [rbp+var_442]
xor al, 0FFh
mov [rbp+var_441], al
loc_4AB80:
mov al, [rbp+var_441]
test al, 1
jnz short loc_4AB8F
jmp loc_4AD36
loc_4AB8F:
mov rdi, [rbp+var_430]
mov esi, 5Fh ; '_'
call _ZNK4flux6parser6Parser5checkENS_5lexer9TokenTypeE; flux::parser::Parser::check(flux::lexer::TokenType)
mov [rbp+var_443], al
jmp short $+2
loc_4ABA8:
mov al, [rbp+var_443]
test al, 1
jnz short loc_4ABB4
jmp short loc_4ABF3
loc_4ABB4:
mov eax, [rbp+var_27C]
add eax, 1
mov [rbp+var_27C], eax
jmp short loc_4AC39
mov rcx, rax
mov eax, edx
mov [rbp+var_E8], rcx
mov [rbp+var_EC], eax
jmp loc_4AEAF
mov rcx, rax
mov eax, edx
mov [rbp+var_E8], rcx
mov [rbp+var_EC], eax
jmp loc_4AEA3
loc_4ABF3:
mov rdi, [rbp+var_430]
mov esi, 60h ; '`'
call _ZNK4flux6parser6Parser5checkENS_5lexer9TokenTypeE; flux::parser::Parser::check(flux::lexer::TokenType)
mov [rbp+var_444], al
jmp short $+2
loc_4AC0C:
mov al, [rbp+var_444]
test al, 1
jnz short loc_4AC18
jmp short loc_4AC37
loc_4AC18:
mov eax, [rbp+var_27C]
add eax, 0FFFFFFFFh
mov [rbp+var_27C], eax
cmp [rbp+var_27C], 0
jnz short loc_4AC35
jmp loc_4AD36
loc_4AC35:
jmp short $+2
loc_4AC37:
jmp short $+2
loc_4AC39:
lea rdi, [rbp+var_268]; this
call __ZNSo5tellpEv; std::ostream::tellp(void)
mov [rbp+var_458], rdx
mov [rbp+var_450], rax
jmp short $+2
loc_4AC55:
mov rax, [rbp+var_458]
mov rcx, [rbp+var_450]
mov [rbp+var_290], rcx
mov [rbp+var_288], rax
lea rdi, [rbp+var_290]
call _ZNKSt4fposI11__mbstate_tEcvlEv; std::fpos<__mbstate_t>::operator long(void)
mov [rbp+var_460], rax
jmp short $+2
loc_4AC86:
mov rax, [rbp+var_460]
cmp rax, 0
jle short loc_4ACAA
lea rdi, [rbp+var_268]
lea rsi, asc_62182+1; " "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_4ACA8:
jmp short $+2
loc_4ACAA:
mov rdi, [rbp+var_430]
lea rax, [rbp+var_268]
mov [rbp+var_478], rax
add rdi, 8; this
call _ZNK4flux5lexer5Token6lexemeEv; flux::lexer::Token::lexeme(void)
mov [rbp+var_470], rdx
mov [rbp+var_468], rax
jmp short $+2
loc_4ACD8:
mov rdi, [rbp+var_478]
mov rax, [rbp+var_470]
mov rcx, [rbp+var_468]
mov [rbp+var_2A0], rcx
mov [rbp+var_298], rax
mov rsi, [rbp+var_2A0]
mov rdx, [rbp+var_298]
call _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St17basic_string_viewIS3_S4_E; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::string_view)
jmp short $+2
loc_4AD10:
mov rsi, [rbp+var_430]
lea rdi, [rbp+var_300]; this
call _ZN4flux6parser6Parser7advanceEv; flux::parser::Parser::advance(void)
jmp short $+2
loc_4AD25:
lea rdi, [rbp+var_300]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
jmp loc_4AB4B
loc_4AD36:
lea rsi, aExpectedAfterA_1; "Expected '}' after ASM block"
lea rdi, [rbp+var_370]
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rsi, [rbp+var_430]
mov rcx, [rbp+var_370]
mov r8, [rbp+var_368]
lea rdi, [rbp+var_360]
mov edx, 60h ; '`'
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
jmp short $+2
loc_4AD71:
lea rsi, aExpectedAfterA_2; "Expected ';' after ASM block"
lea rdi, [rbp+var_3E0]
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rsi, [rbp+var_430]
mov rcx, [rbp+var_3E0]
mov r8, [rbp+var_3D8]
lea rdi, [rbp+var_3D0]
mov edx, 58h ; 'X'
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
jmp short $+2
loc_4ADAC:
lea rdi, [rbp+var_3D0]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
lea rdi, [rbp+var_408]
lea rsi, [rbp+var_278]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_4ADCD:
mov rsi, [rbp+var_430]; flux::lexer::Token *
lea rdi, [rbp+var_428]; this
lea rdx, [rbp+var_70]; flux::lexer::Token *
lea rcx, [rbp+var_360]
call _ZNK4flux6parser6Parser9makeRangeERKNS_5lexer5TokenES5_; flux::parser::Parser::makeRange(flux::lexer::Token const&,flux::lexer::Token const&)
jmp short $+2
loc_4ADED:
lea rdi, [rbp+var_3E8]
lea rsi, [rbp+var_408]
lea rdx, [rbp+var_428]
call _ZSt11make_uniqueIN4flux6parser7AsmDeclEJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::AsmDecl,std::string,flux::common::SourceRange>(std::string,flux::common::SourceRange &&)
jmp short $+2
loc_4AE09:
mov rdi, [rbp+var_440]
lea rsi, [rbp+var_3E8]
call _ZNSt10unique_ptrIN4flux6parser4DeclESt14default_deleteIS2_EEC2INS1_7AsmDeclES3_IS7_EvEEOS_IT_T0_E; std::unique_ptr<flux::parser::Decl>::unique_ptr<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>,void>(std::unique_ptr&&<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>>)
lea rdi, [rbp+var_3E8]
call _ZNSt10unique_ptrIN4flux6parser7AsmDeclESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::AsmDecl>::~unique_ptr()
lea rdi, [rbp+var_408]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_360]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
lea rdi, [rbp+var_278]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
mov rax, [rbp+var_438]
add rsp, 480h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_E8], rcx
mov [rbp+var_EC], eax
jmp short loc_4AE97
mov rcx, rax
mov eax, edx
mov [rbp+var_E8], rcx
mov [rbp+var_EC], eax
lea rdi, [rbp+var_408]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_4AE97:
lea rdi, [rbp+var_360]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
loc_4AEA3:
lea rdi, [rbp+var_278]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
loc_4AEAF:
lea rdi, [rbp+var_70]; this
call _ZN4flux5lexer5TokenD2Ev; flux::lexer::Token::~Token()
mov rdi, [rbp+var_E8]
call __Unwind_Resume
|
flux::parser::Parser * flux::parser::Parser::asmDeclaration(flux::parser::Parser *this, _BYTE *a2)
{
long long v2; // rdx
long long v3; // rdx
char v5; // [rsp+3Fh] [rbp-441h]
_BYTE v6[32]; // [rsp+58h] [rbp-428h] BYREF
_BYTE v7[32]; // [rsp+78h] [rbp-408h] BYREF
_BYTE v8[8]; // [rsp+98h] [rbp-3E8h] BYREF
long long v9[2]; // [rsp+A0h] [rbp-3E0h] BYREF
_BYTE v10[96]; // [rsp+B0h] [rbp-3D0h] BYREF
long long v11[2]; // [rsp+110h] [rbp-370h] BYREF
_BYTE v12[96]; // [rsp+120h] [rbp-360h] BYREF
_BYTE v13[96]; // [rsp+180h] [rbp-300h] BYREF
long long v14; // [rsp+1E0h] [rbp-2A0h]
long long v15; // [rsp+1E8h] [rbp-298h]
_QWORD v16[2]; // [rsp+1F0h] [rbp-290h] BYREF
int v17; // [rsp+204h] [rbp-27Ch]
_BYTE v18[16]; // [rsp+208h] [rbp-278h] BYREF
_BYTE v19[380]; // [rsp+218h] [rbp-268h] BYREF
long long v20[2]; // [rsp+3A0h] [rbp-E0h] BYREF
_BYTE v21[96]; // [rsp+3B0h] [rbp-D0h] BYREF
_BYTE v22[96]; // [rsp+410h] [rbp-70h] BYREF
_BYTE *v23; // [rsp+470h] [rbp-10h]
flux::parser::Parser *v24; // [rsp+478h] [rbp-8h]
v24 = this;
v23 = a2;
flux::lexer::Token::Token((flux::lexer::Token *)v22, (const flux::lexer::Token *)(a2 + 104));
std::string_view::basic_string_view(v20, (long long)"Expected '{' after 'asm'");
flux::parser::Parser::consume((flux::parser::Parser *)v21, a2, 95, v20[0], v20[1]);
flux::lexer::Token::~Token((flux::lexer::Token *)v21);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v18);
v17 = 1;
while ( 1 )
{
v5 = 0;
if ( v17 > 0 )
v5 = ~flux::parser::Parser::check((long long)a2, 0);
if ( (v5 & 1) == 0 )
break;
if ( flux::parser::Parser::check((long long)a2, 95) )
{
++v17;
}
else if ( flux::parser::Parser::check((long long)a2, 96) && !--v17 )
{
break;
}
v16[0] = std::ostream::tellp((std::ostream *)v19);
v16[1] = v2;
if ( std::fpos<__mbstate_t>::operator long((long long)v16) > 0 )
std::operator<<<std::char_traits<char>>(v19, " ");
v14 = flux::lexer::Token::lexeme((flux::lexer::Token *)(a2 + 8));
v15 = v3;
std::operator<<<char,std::char_traits<char>>((long long)v19, v14, v3);
flux::parser::Parser::advance((flux::parser::Parser *)v13, (long long)a2);
flux::lexer::Token::~Token((flux::lexer::Token *)v13);
}
std::string_view::basic_string_view(v11, (long long)"Expected '}' after ASM block");
flux::parser::Parser::consume((flux::parser::Parser *)v12, a2, 96, v11[0], v11[1]);
std::string_view::basic_string_view(v9, (long long)"Expected ';' after ASM block");
flux::parser::Parser::consume((flux::parser::Parser *)v10, a2, 88, v9[0], v9[1]);
flux::lexer::Token::~Token((flux::lexer::Token *)v10);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(v7, v18);
flux::parser::Parser::makeRange(
(flux::parser::Parser *)v6,
(const flux::lexer::Token *)a2,
(const flux::lexer::Token *)v22,
(flux::lexer::Token *)v12);
std::make_unique<flux::parser::AsmDecl,std::string,flux::common::SourceRange>(v8, v7, v6);
std::unique_ptr<flux::parser::Decl>::unique_ptr<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>,void>(
(long long)this,
(long long)v8);
std::unique_ptr<flux::parser::AsmDecl>::~unique_ptr((long long)v8);
std::string::~string(v7);
flux::lexer::Token::~Token((flux::lexer::Token *)v12);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v18);
flux::lexer::Token::~Token((flux::lexer::Token *)v22);
return this;
}
|
asmDeclaration:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x480
MOV qword ptr [RBP + -0x440],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x438],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RSI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x430],RSI
ADD RSI,0x68
LEA RDI,[RBP + -0x70]
CALL 0x00115420
LEA RSI,[0x1645e0]
LEA RDI,[RBP + -0xe0]
CALL 0x0010d130
MOV RSI,qword ptr [RBP + -0x430]
MOV RCX,qword ptr [RBP + -0xe0]
MOV R8,qword ptr [RBP + -0xd8]
LAB_0014ab14:
LEA RDI,[RBP + -0xd0]
MOV EDX,0x5f
CALL 0x00143180
JMP 0x0014ab27
LAB_0014ab27:
LEA RDI,[RBP + -0xd0]
CALL 0x0010a300
LEA RDI,[RBP + -0x278]
CALL 0x00107240
JMP 0x0014ab41
LAB_0014ab41:
MOV dword ptr [RBP + -0x27c],0x1
LAB_0014ab4b:
XOR EAX,EAX
CMP dword ptr [RBP + -0x27c],0x0
MOV byte ptr [RBP + -0x441],AL
JLE 0x0014ab80
LAB_0014ab5c:
MOV RDI,qword ptr [RBP + -0x430]
XOR ESI,ESI
CALL 0x001417c0
MOV byte ptr [RBP + -0x442],AL
JMP 0x0014ab72
LAB_0014ab72:
MOV AL,byte ptr [RBP + -0x442]
XOR AL,0xff
MOV byte ptr [RBP + -0x441],AL
LAB_0014ab80:
MOV AL,byte ptr [RBP + -0x441]
TEST AL,0x1
JNZ 0x0014ab8f
JMP 0x0014ad36
LAB_0014ab8f:
MOV RDI,qword ptr [RBP + -0x430]
MOV ESI,0x5f
CALL 0x001417c0
MOV byte ptr [RBP + -0x443],AL
JMP 0x0014aba8
LAB_0014aba8:
MOV AL,byte ptr [RBP + -0x443]
TEST AL,0x1
JNZ 0x0014abb4
JMP 0x0014abf3
LAB_0014abb4:
MOV EAX,dword ptr [RBP + -0x27c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x27c],EAX
JMP 0x0014ac39
LAB_0014abf3:
MOV RDI,qword ptr [RBP + -0x430]
MOV ESI,0x60
CALL 0x001417c0
MOV byte ptr [RBP + -0x444],AL
JMP 0x0014ac0c
LAB_0014ac0c:
MOV AL,byte ptr [RBP + -0x444]
TEST AL,0x1
JNZ 0x0014ac18
JMP 0x0014ac37
LAB_0014ac18:
MOV EAX,dword ptr [RBP + -0x27c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x27c],EAX
CMP dword ptr [RBP + -0x27c],0x0
JNZ 0x0014ac35
JMP 0x0014ad36
LAB_0014ac35:
JMP 0x0014ac37
LAB_0014ac37:
JMP 0x0014ac39
LAB_0014ac39:
LEA RDI,[RBP + -0x268]
CALL 0x001072d0
MOV qword ptr [RBP + -0x458],RDX
MOV qword ptr [RBP + -0x450],RAX
JMP 0x0014ac55
LAB_0014ac55:
MOV RAX,qword ptr [RBP + -0x458]
MOV RCX,qword ptr [RBP + -0x450]
MOV qword ptr [RBP + -0x290],RCX
MOV qword ptr [RBP + -0x288],RAX
LEA RDI,[RBP + -0x290]
CALL 0x00110da0
MOV qword ptr [RBP + -0x460],RAX
JMP 0x0014ac86
LAB_0014ac86:
MOV RAX,qword ptr [RBP + -0x460]
CMP RAX,0x0
JLE 0x0014acaa
LEA RDI,[RBP + -0x268]
LEA RSI,[0x162183]
CALL 0x00107330
JMP 0x0014aca8
LAB_0014aca8:
JMP 0x0014acaa
LAB_0014acaa:
MOV RDI,qword ptr [RBP + -0x430]
LEA RAX,[RBP + -0x268]
MOV qword ptr [RBP + -0x478],RAX
ADD RDI,0x8
CALL 0x0012a860
MOV qword ptr [RBP + -0x470],RDX
MOV qword ptr [RBP + -0x468],RAX
JMP 0x0014acd8
LAB_0014acd8:
MOV RDI,qword ptr [RBP + -0x478]
MOV RAX,qword ptr [RBP + -0x470]
MOV RCX,qword ptr [RBP + -0x468]
MOV qword ptr [RBP + -0x2a0],RCX
MOV qword ptr [RBP + -0x298],RAX
MOV RSI,qword ptr [RBP + -0x2a0]
MOV RDX,qword ptr [RBP + -0x298]
CALL 0x001091b0
JMP 0x0014ad10
LAB_0014ad10:
MOV RSI,qword ptr [RBP + -0x430]
LEA RDI,[RBP + -0x300]
CALL 0x001417f0
JMP 0x0014ad25
LAB_0014ad25:
LEA RDI,[RBP + -0x300]
CALL 0x0010a300
JMP 0x0014ab4b
LAB_0014ad36:
LEA RSI,[0x1645f9]
LEA RDI,[RBP + -0x370]
CALL 0x0010d130
MOV RSI,qword ptr [RBP + -0x430]
MOV RCX,qword ptr [RBP + -0x370]
MOV R8,qword ptr [RBP + -0x368]
LEA RDI,[RBP + -0x360]
MOV EDX,0x60
CALL 0x00143180
JMP 0x0014ad71
LAB_0014ad71:
LEA RSI,[0x164616]
LEA RDI,[RBP + -0x3e0]
CALL 0x0010d130
MOV RSI,qword ptr [RBP + -0x430]
MOV RCX,qword ptr [RBP + -0x3e0]
MOV R8,qword ptr [RBP + -0x3d8]
LAB_0014ad99:
LEA RDI,[RBP + -0x3d0]
MOV EDX,0x58
CALL 0x00143180
JMP 0x0014adac
LAB_0014adac:
LEA RDI,[RBP + -0x3d0]
CALL 0x0010a300
LEA RDI,[RBP + -0x408]
LEA RSI,[RBP + -0x278]
CALL 0x00107320
JMP 0x0014adcd
LAB_0014adcd:
MOV RSI,qword ptr [RBP + -0x430]
LEA RDI,[RBP + -0x428]
LEA RDX,[RBP + -0x70]
LEA RCX,[RBP + -0x360]
CALL 0x00143570
JMP 0x0014aded
LAB_0014aded:
LEA RDI,[RBP + -0x3e8]
LEA RSI,[RBP + -0x408]
LEA RDX,[RBP + -0x428]
CALL 0x0015b5c0
LAB_0014ae07:
JMP 0x0014ae09
LAB_0014ae09:
MOV RDI,qword ptr [RBP + -0x440]
LEA RSI,[RBP + -0x3e8]
CALL 0x00122880
LEA RDI,[RBP + -0x3e8]
CALL 0x001228d0
LEA RDI,[RBP + -0x408]
CALL 0x001071f0
LEA RDI,[RBP + -0x360]
CALL 0x0010a300
LEA RDI,[RBP + -0x278]
CALL 0x00107280
LEA RDI,[RBP + -0x70]
CALL 0x0010a300
MOV RAX,qword ptr [RBP + -0x438]
ADD RSP,0x480
POP RBP
RET
|
/* flux::parser::Parser::asmDeclaration() */
unique_ptr<flux::parser::Decl,std::default_delete<flux::parser::Decl>> *
flux::parser::Parser::asmDeclaration(void)
{
byte bVar1;
long lVar2;
Parser *in_RSI;
unique_ptr<flux::parser::Decl,std::default_delete<flux::parser::Decl>> *in_RDI;
int1 auVar3 [16];
byte local_449;
Token local_430 [32];
SourceRange local_410 [32];
string local_3f0 [8];
int8 local_3e8;
int8 local_3e0;
Token local_3d8 [96];
int8 local_378;
int8 local_370;
Token local_368 [96];
Token local_308 [96];
int1 local_2a8 [16];
int1 local_298 [16];
int local_284;
stringstream local_280 [16];
ostream local_270 [392];
int8 local_e8;
int8 local_e0;
Token local_d8 [96];
Token local_78 [112];
lexer::Token::Token(local_78,(Token *)(in_RSI + 0x68));
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_e8,
"Expected \'{\' after \'asm\'");
/* try { // try from 0014ab14 to 0014ab3e has its CatchHandler @ 0014abc5 */
consume(local_d8,in_RSI,0x5f,local_e8,local_e0);
lexer::Token::~Token(local_d8);
std::__cxx11::stringstream::stringstream(local_280);
local_284 = 1;
while( true ) {
local_449 = 0;
if (0 < local_284) {
/* try { // try from 0014ab5c to 0014ad6e has its CatchHandler @ 0014abdc */
local_449 = check(in_RSI,0);
local_449 = local_449 ^ 0xff;
}
if ((local_449 & 1) == 0) break;
bVar1 = check(in_RSI,0x5f);
if ((bVar1 & 1) == 0) {
bVar1 = check(in_RSI,0x60);
if (((bVar1 & 1) != 0) && (local_284 = local_284 + -1, local_284 == 0)) break;
}
else {
local_284 = local_284 + 1;
}
auVar3 = std::ostream::tellp();
local_298 = auVar3;
lVar2 = std::fpos::operator_cast_to_long((fpos *)local_298);
if (0 < lVar2) {
std::operator<<(local_270," ");
}
auVar3 = lexer::Token::lexeme((Token *)(in_RSI + 8));
local_2a8 = auVar3;
std::operator<<(local_270,auVar3._0_8_,auVar3._8_8_);
advance();
lexer::Token::~Token(local_308);
}
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_378,
"Expected \'}\' after ASM block");
consume(local_368,in_RSI,0x60,local_378,local_370);
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_3e8,
"Expected \';\' after ASM block");
/* try { // try from 0014ad99 to 0014adca has its CatchHandler @ 0014ae65 */
consume(local_3d8,in_RSI,0x58,local_3e8,local_3e0);
lexer::Token::~Token(local_3d8);
std::__cxx11::stringstream::str();
/* try { // try from 0014adcd to 0014ae06 has its CatchHandler @ 0014ae79 */
makeRange(local_430,(Token *)in_RSI);
std::make_unique<flux::parser::AsmDecl,std::__cxx11::string,flux::common::SourceRange>
(local_3f0,local_410);
std::unique_ptr<flux::parser::Decl,std::default_delete<flux::parser::Decl>>::
unique_ptr<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>,void>
(in_RDI,(unique_ptr *)local_3f0);
std::unique_ptr<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>>::~unique_ptr
((unique_ptr<flux::parser::AsmDecl,std::default_delete<flux::parser::AsmDecl>> *)
local_3f0);
std::__cxx11::string::~string((string *)local_410);
lexer::Token::~Token(local_368);
std::__cxx11::stringstream::~stringstream(local_280);
lexer::Token::~Token(local_78);
return in_RDI;
}
|
|
5,013 |
flux::parser::Parser::asmDeclaration()
|
kvthweatt[P]FluxLang/src/parser/parser.cpp
|
std::unique_ptr<Decl> Parser::asmDeclaration() {
auto start = previous_; // 'asm' keyword
// Parse the ASM block
consume(lexer::TokenType::LEFT_BRACE, "Expected '{' after 'asm'");
// Collect the ASM code as a string
std::stringstream asmCode;
// Track nested braces
int braceLevel = 1;
// Continue until we find the matching closing brace
while (braceLevel > 0 && !check(lexer::TokenType::END_OF_FILE)) {
if (check(lexer::TokenType::LEFT_BRACE)) {
braceLevel++;
} else if (check(lexer::TokenType::RIGHT_BRACE)) {
braceLevel--;
if (braceLevel == 0) {
break; // Found the matching closing brace
}
}
// Add the current token's lexeme to the ASM code
// Add a space to preserve token separation
if (asmCode.tellp() > 0) {
asmCode << " ";
}
asmCode << current_.lexeme();
// Move to the next token
advance();
}
auto endToken = consume(lexer::TokenType::RIGHT_BRACE, "Expected '}' after ASM block");
consume(lexer::TokenType::SEMICOLON, "Expected ';' after ASM block");
return std::make_unique<AsmDecl>(
asmCode.str(),
makeRange(start, endToken)
);
}
|
O2
|
cpp
|
flux::parser::Parser::asmDeclaration():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
addq $0x68, %rsi
leaq 0x90(%rsp), %rdi
callq 0xa5ae
leaq 0xd627(%rip), %r8 # 0x24820
leaq 0x1d0(%rsp), %rdi
pushq $0x5f
popq %rdx
pushq $0x18
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x210(%rsp), %rdi
callq 0x60e0
leaq 0x230(%rsp), %rdi
callq 0x6180
leaq 0x240(%rsp), %r15
pushq $0x1
popq %rbx
leaq 0x1b0(%rsp), %r12
leaq 0xaf3c(%rip), %r13 # 0x2217f
leaq 0x170(%rsp), %rbp
movl 0x8(%r14), %eax
cmpl $0x5f, %eax
je 0x17265
cmpl $0x60, %eax
je 0x1725f
testl %eax, %eax
jne 0x17267
jmp 0x172a4
decl %ebx
jne 0x17267
jmp 0x172a4
incl %ebx
movq %r15, %rdi
callq 0x61f0
testq %rax, %rax
jle 0x1727f
movq %r15, %rdi
movq %r13, %rsi
callq 0x6220
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x6260
movq %rbp, %rdi
movq %r14, %rsi
callq 0x122ec
movq %r12, %rdi
callq 0x60e0
jmp 0x1724b
leaq 0xd58e(%rip), %r8 # 0x24839
leaq 0x30(%rsp), %rdi
pushq $0x60
popq %rdx
pushq $0x1c
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0xd591(%rip), %r8 # 0x24856
leaq 0x110(%rsp), %rdi
pushq $0x58
popq %rdx
pushq $0x1c
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x150(%rsp), %rdi
callq 0x60e0
leaq 0x248(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x6370
movups 0xa8(%rsp), %xmm0
leaq 0xf0(%rsp), %rdx
movaps %xmm0, (%rdx)
movups 0x58(%rsp), %xmm0
movaps %xmm0, 0x10(%rdx)
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x20174
movq (%rsp), %rax
movq 0x8(%rsp), %rbx
movq %rax, (%rbx)
andq $0x0, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x60e0
leaq 0x70(%rsp), %rdi
callq 0x60e0
leaq 0x230(%rsp), %rdi
callq 0x61c0
leaq 0xd0(%rsp), %rdi
callq 0x60e0
movq %rbx, %rax
addq $0x3b8, %rsp # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x60e0
jmp 0x1738b
jmp 0x17388
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x60e0
jmp 0x173a5
jmp 0x173a2
jmp 0x1739b
movq %rax, %rbx
jmp 0x173b2
jmp 0x173a2
movq %rax, %rbx
leaq 0x230(%rsp), %rdi
callq 0x61c0
leaq 0xd0(%rsp), %rdi
callq 0x60e0
movq %rbx, %rdi
callq 0x63e0
nop
|
_ZN4flux6parser6Parser14asmDeclarationEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 3B8h
mov r14, rsi
mov [rsp+3E8h+var_3E0], rdi
add rsi, 68h ; 'h'; flux::lexer::Token *
lea rdi, [rsp+3E8h+var_358]; this
call _ZN4flux5lexer5TokenC2ERKS1_; flux::lexer::Token::Token(flux::lexer::Token const&)
lea r8, aExpectedAfterA_0; "Expected '{' after 'asm'"
lea rdi, [rsp+3E8h+var_218]; this
push 5Fh ; '_'
pop rdx
push 18h
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+3E8h+var_1D8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea r15, [rsp+3E8h+var_1A8]
push 1
pop rbx
lea r12, [rsp+3E8h+var_238]
lea r13, asc_2217E+1; " "
lea rbp, [rsp+3E8h+var_278]
loc_1724B:
mov eax, [r14+8]
cmp eax, 5Fh ; '_'
jz short loc_17265
cmp eax, 60h ; '`'
jz short loc_1725F
test eax, eax
jnz short loc_17267
jmp short loc_172A4
loc_1725F:
dec ebx
jnz short loc_17267
jmp short loc_172A4
loc_17265:
inc ebx
loc_17267:
mov rdi, r15; this
call __ZNSo5tellpEv; std::ostream::tellp(void)
test rax, rax
jle short loc_1727F
mov rdi, r15
mov rsi, r13
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_1727F:
mov rdx, [r14+10h]
mov rsi, [r14+18h]
mov rdi, 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 rdi, rbp; this
mov rsi, r14
call _ZN4flux6parser6Parser7advanceEv; flux::parser::Parser::advance(void)
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_1724B
loc_172A4:
lea r8, aExpectedAfterA_1; "Expected '}' after ASM block"
lea rdi, [rsp+3E8h+var_3B8]; this
push 60h ; '`'
pop rdx
push 1Ch
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea r8, aExpectedAfterA_2; "Expected ';' after ASM block"
lea rdi, [rsp+3E8h+var_2D8]; this
push 58h ; 'X'
pop rdx
push 1Ch
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+3E8h+var_298]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rsi, [rsp+3E8h+var_1A0]
lea rdi, [rsp+3E8h+var_3D8]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
movups xmm0, [rsp+3E8h+var_340]
lea rdx, [rsp+3E8h+var_2F8]
movaps xmmword ptr [rdx], xmm0
movups xmm0, [rsp+3E8h+var_390]
movaps xmmword ptr [rdx+10h], xmm0
mov rdi, rsp
lea rsi, [rsp+3E8h+var_3D8]
call _ZSt11make_uniqueIN4flux6parser7AsmDeclEJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::AsmDecl,std::string,flux::common::SourceRange>(std::string,flux::common::SourceRange &&)
mov rax, [rsp+3E8h+var_3E8]
mov rbx, [rsp+3E8h+var_3E0]
mov [rbx], rax
and [rsp+3E8h+var_3E8], 0
lea rdi, [rsp+3E8h+var_3D8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3E8h+var_378]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+3E8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+3E8h+var_318]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 3B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_1738B
jmp short $+2
loc_17388:
mov rbx, rax
loc_1738B:
lea rdi, [rsp+arg_68]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_173A5
jmp short loc_173A2
jmp short $+2
loc_1739B:
mov rbx, rax
jmp short loc_173B2
jmp short $+2
loc_173A2:
mov rbx, rax
loc_173A5:
lea rdi, [rsp+arg_228]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
loc_173B2:
lea rdi, [rsp+arg_C8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
flux::parser::Parser * flux::parser::Parser::asmDeclaration(flux::parser::Parser *this, long long a2)
{
int v2; // ebx
int v3; // eax
flux::parser::Parser *v4; // rbx
long long v6; // [rsp+0h] [rbp-3E8h] BYREF
flux::parser::Parser *v7; // [rsp+8h] [rbp-3E0h]
_BYTE v8[32]; // [rsp+10h] [rbp-3D8h] BYREF
char v9[40]; // [rsp+30h] [rbp-3B8h] BYREF
__int128 v10; // [rsp+58h] [rbp-390h]
char v11[32]; // [rsp+70h] [rbp-378h] BYREF
char v12[24]; // [rsp+90h] [rbp-358h] BYREF
__int128 v13; // [rsp+A8h] [rbp-340h]
char v14[32]; // [rsp+D0h] [rbp-318h] BYREF
__int128 v15; // [rsp+F0h] [rbp-2F8h]
__int128 v16; // [rsp+100h] [rbp-2E8h]
char v17[64]; // [rsp+110h] [rbp-2D8h] BYREF
char v18[32]; // [rsp+150h] [rbp-298h] BYREF
char v19[64]; // [rsp+170h] [rbp-278h] BYREF
char v20[32]; // [rsp+1B0h] [rbp-238h] BYREF
char v21[64]; // [rsp+1D0h] [rbp-218h] BYREF
char v22[32]; // [rsp+210h] [rbp-1D8h] BYREF
_BYTE v23[16]; // [rsp+230h] [rbp-1B8h] BYREF
char v24[8]; // [rsp+240h] [rbp-1A8h] BYREF
char v25[416]; // [rsp+248h] [rbp-1A0h] BYREF
v7 = this;
flux::lexer::Token::Token((flux::lexer::Token *)v12, (const flux::lexer::Token *)(a2 + 104));
flux::parser::Parser::consume((flux::parser::Parser *)v21, a2, 95, 24LL, (long long)"Expected '{' after 'asm'");
std::string::~string(v22);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v23);
v2 = 1;
while ( 1 )
{
v3 = *(_DWORD *)(a2 + 8);
if ( v3 == 95 )
{
++v2;
goto LABEL_9;
}
if ( v3 == 96 )
break;
if ( !v3 )
goto LABEL_12;
LABEL_9:
if ( (long long)std::ostream::tellp((std::ostream *)v24) > 0 )
std::operator<<<std::char_traits<char>>(v24, " ");
std::__ostream_insert<char,std::char_traits<char>>(v24, *(_QWORD *)(a2 + 24), *(_QWORD *)(a2 + 16));
flux::parser::Parser::advance((flux::parser::Parser *)v19, a2);
std::string::~string(v20);
}
if ( --v2 )
goto LABEL_9;
LABEL_12:
flux::parser::Parser::consume((flux::parser::Parser *)v9, a2, 96, 28LL, (long long)"Expected '}' after ASM block");
flux::parser::Parser::consume((flux::parser::Parser *)v17, a2, 88, 28LL, (long long)"Expected ';' after ASM block");
std::string::~string(v18);
std::stringbuf::str(v8, v25);
v15 = v13;
v16 = v10;
std::make_unique<flux::parser::AsmDecl,std::string,flux::common::SourceRange>(&v6, v8);
v4 = v7;
*(_QWORD *)v7 = v6;
v6 = 0LL;
std::string::~string(v8);
std::string::~string(v11);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v23);
std::string::~string(v14);
return v4;
}
|
asmDeclaration:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x3b8
MOV R14,RSI
MOV qword ptr [RSP + 0x8],RDI
ADD RSI,0x68
LEA RDI,[RSP + 0x90]
CALL 0x0010a5ae
LAB_001171f2:
LEA R8,[0x124820]
LEA RDI,[RSP + 0x1d0]
PUSH 0x5f
POP RDX
PUSH 0x18
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x210]
CALL 0x001060e0
LAB_0011721c:
LEA RDI,[RSP + 0x230]
CALL 0x00106180
LEA R15,[RSP + 0x240]
PUSH 0x1
POP RBX
LEA R12,[RSP + 0x1b0]
LEA R13,[0x12217f]
LEA RBP,[RSP + 0x170]
LAB_0011724b:
MOV EAX,dword ptr [R14 + 0x8]
CMP EAX,0x5f
JZ 0x00117265
CMP EAX,0x60
JZ 0x0011725f
TEST EAX,EAX
JNZ 0x00117267
JMP 0x001172a4
LAB_0011725f:
DEC EBX
JNZ 0x00117267
JMP 0x001172a4
LAB_00117265:
INC EBX
LAB_00117267:
MOV RDI,R15
CALL 0x001061f0
TEST RAX,RAX
JLE 0x0011727f
LAB_00117274:
MOV RDI,R15
MOV RSI,R13
CALL 0x00106220
LAB_0011727f:
MOV RDX,qword ptr [R14 + 0x10]
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,R15
CALL 0x00106260
MOV RDI,RBP
MOV RSI,R14
CALL 0x001122ec
MOV RDI,R12
CALL 0x001060e0
JMP 0x0011724b
LAB_001172a4:
LEA R8,[0x124839]
LEA RDI,[RSP + 0x30]
PUSH 0x60
POP RDX
PUSH 0x1c
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LAB_001172be:
LEA R8,[0x124856]
LEA RDI,[RSP + 0x110]
PUSH 0x58
POP RDX
PUSH 0x1c
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x150]
CALL 0x001060e0
LEA RSI,[RSP + 0x248]
LAB_001172f0:
LEA RDI,[RSP + 0x10]
CALL 0x00106370
MOVUPS XMM0,xmmword ptr [RSP + 0xa8]
LEA RDX,[RSP + 0xf0]
MOVAPS xmmword ptr [RDX],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x58]
MOVAPS xmmword ptr [RDX + 0x10],XMM0
LAB_00117316:
MOV RDI,RSP
LEA RSI,[RSP + 0x10]
CALL 0x00120174
LAB_00117323:
MOV RAX,qword ptr [RSP]
MOV RBX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX],RAX
AND qword ptr [RSP],0x0
LEA RDI,[RSP + 0x10]
CALL 0x001060e0
LEA RDI,[RSP + 0x70]
CALL 0x001060e0
LEA RDI,[RSP + 0x230]
CALL 0x001061c0
LEA RDI,[RSP + 0xd0]
CALL 0x001060e0
MOV RAX,RBX
ADD RSP,0x3b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* flux::parser::Parser::asmDeclaration() */
int8 * flux::parser::Parser::asmDeclaration(void)
{
int iVar1;
long lVar2;
int iVar3;
long in_RSI;
int8 *in_RDI;
int8 local_3e8;
int8 *local_3e0;
SourceRange local_3d8 [32];
int1 local_3b8 [40];
int8 local_390;
int8 uStack_388;
string local_378 [32];
Token local_358 [24];
int8 local_340;
int8 uStack_338;
string local_318 [32];
int8 local_2f8;
int8 uStack_2f0;
int8 local_2e8;
int8 uStack_2e0;
int1 local_2d8 [64];
string local_298 [96];
string local_238 [32];
int1 local_218 [64];
string local_1d8 [32];
stringstream local_1b8 [16];
ostream local_1a8 [376];
local_3e0 = in_RDI;
lexer::Token::Token(local_358,(Token *)(in_RSI + 0x68));
/* try { // try from 001171f2 to 0011720e has its CatchHandler @ 0011739b */
consume(local_218);
std::__cxx11::string::~string(local_1d8);
/* try { // try from 0011721c to 00117228 has its CatchHandler @ 00117399 */
std::__cxx11::stringstream::stringstream(local_1b8);
iVar3 = 1;
do {
iVar1 = *(int *)(in_RSI + 8);
if (iVar1 == 0x5f) {
iVar3 = iVar3 + 1;
}
else {
if (iVar1 == 0x60) {
iVar3 = iVar3 + -1;
iVar1 = iVar3;
}
if (iVar1 == 0) {
/* try { // try from 001172a4 to 001172bd has its CatchHandler @ 00117397 */
consume(local_3b8);
/* try { // try from 001172be to 001172da has its CatchHandler @ 00117388 */
consume(local_2d8);
std::__cxx11::string::~string(local_298);
/* try { // try from 001172f0 to 001172f9 has its CatchHandler @ 00117386 */
std::__cxx11::stringbuf::str();
local_2f8 = local_340;
uStack_2f0 = uStack_338;
local_2e8 = local_390;
uStack_2e0 = uStack_388;
/* try { // try from 00117316 to 00117322 has its CatchHandler @ 00117377 */
std::make_unique<flux::parser::AsmDecl,std::__cxx11::string,flux::common::SourceRange>
((string *)&local_3e8,local_3d8);
*local_3e0 = local_3e8;
local_3e8 = 0;
std::__cxx11::string::~string((string *)local_3d8);
std::__cxx11::string::~string(local_378);
std::__cxx11::stringstream::~stringstream(local_1b8);
std::__cxx11::string::~string(local_318);
return local_3e0;
}
}
/* try { // try from 00117267 to 0011726e has its CatchHandler @ 001173a0 */
lVar2 = std::ostream::tellp();
if (0 < lVar2) {
/* try { // try from 00117274 to 00117299 has its CatchHandler @ 001173a2 */
std::operator<<(local_1a8," ");
}
std::__ostream_insert<char,std::char_traits<char>>
(local_1a8,*(char **)(in_RSI + 0x18),*(long *)(in_RSI + 0x10));
advance();
std::__cxx11::string::~string(local_238);
} while( true );
}
|
|
5,014 |
my_context_init
|
eloqsql/libmariadb/libmariadb/ma_context.c
|
int
my_context_init(struct my_context *c, size_t stack_size)
{
memset(c, 0, sizeof(*c));
if (!(c->stack_bot= malloc(stack_size)))
return -1; /* Out of memory */
c->stack_top= (void *)
(( ((intptr)c->stack_bot + stack_size) & ~(intptr)0xf) - 16);
memset(c->stack_top, 0, 16);
#ifdef HAVE_VALGRIND
c->valgrind_stack_id=
VALGRIND_STACK_REGISTER(c->stack_bot, c->stack_top);
#endif
return 0;
}
|
O0
|
c
|
my_context_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x13250
movq -0x18(%rbp), %rdi
callq 0x135b0
movq -0x10(%rbp), %rcx
movq %rax, 0x50(%rcx)
cmpq $0x0, %rax
jne 0x473e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47417
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
addq -0x18(%rbp), %rcx
andq $-0x10, %rcx
subq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x13250
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
my_context_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 58h ; 'X'
call _memset
mov rdi, [rbp+var_18]
call _malloc
mov rcx, [rbp+var_10]
mov [rcx+50h], rax
cmp rax, 0
jnz short loc_473E0
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_47417
loc_473E0:
mov rax, [rbp+var_10]
mov rcx, [rax+50h]
add rcx, [rbp+var_18]
and rcx, 0FFFFFFFFFFFFFFF0h
sub rcx, 10h
mov rax, [rbp+var_10]
mov [rax+48h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+48h]
xor esi, esi
mov edx, 10h
call _memset
mov [rbp+var_4], 0
loc_47417:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_context_init(long long a1, long long a2)
{
long long v2; // rax
memset(a1, 0LL, 88LL);
v2 = malloc(a2);
*(_QWORD *)(a1 + 80) = v2;
if ( v2 )
{
*(_QWORD *)(a1 + 72) = ((a2 + *(_QWORD *)(a1 + 80)) & 0xFFFFFFFFFFFFFFF0LL) - 16;
memset(*(_QWORD *)(a1 + 72), 0LL, 16LL);
return 0;
}
else
{
return (unsigned int)-1;
}
}
|
my_context_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x58
CALL 0x00113250
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001135b0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x50],RAX
CMP RAX,0x0
JNZ 0x001473e0
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00147417
LAB_001473e0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,qword ptr [RBP + -0x18]
AND RCX,-0x10
SUB RCX,0x10
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x48]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x00113250
MOV dword ptr [RBP + -0x4],0x0
LAB_00147417:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_context_init(void *param_1,size_t param_2)
{
void *pvVar1;
int4 local_c;
memset(param_1,0,0x58);
pvVar1 = malloc(param_2);
*(void **)((long)param_1 + 0x50) = pvVar1;
if (pvVar1 == (void *)0x0) {
local_c = 0xffffffff;
}
else {
*(size_t *)((long)param_1 + 0x48) =
(*(long *)((long)param_1 + 0x50) + param_2 & 0xfffffffffffffff0) - 0x10;
memset(*(void **)((long)param_1 + 0x48),0,0x10);
local_c = 0;
}
return local_c;
}
|
|
5,015 |
inline_mysql_mutex_init
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
}
|
O0
|
c
|
inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1d93ee(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_mutex_init_8:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
|
long long inline_mysql_mutex_init_8(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
|
inline_mysql_mutex_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a340
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
|
|
5,016 |
my_char_weight_put
|
eloqsql/strings/ctype-uca.c
|
static my_bool
my_char_weight_put(MY_UCA_WEIGHT_LEVEL *dst,
uint16 *to, size_t to_length, size_t *nweights,
my_wc_t *str, size_t len)
{
size_t count;
int rc= FALSE;
if (!to_length)
{
*nweights= 0;
return len > 0;
}
to_length--; /* Without trailing zero */
for (count= 0; len; )
{
size_t chlen;
const uint16 *from= NULL;
uint16 implicit_weights[3];
for (chlen= len; chlen > 1; chlen--)
{
const MY_CONTRACTION *cnt;
if (chlen <= MY_UCA_MAX_CONTRACTION &&
(cnt= my_uca_contraction_find(&dst->contractions, str, chlen)))
{
from= cnt->weight;
str+= chlen;
len-= chlen;
break;
}
}
if (!from)
{
from= my_char_weight_addr(dst, *str);
if (!from)
{
from= implicit_weights;
my_uca_implicit_weight_put(implicit_weights, *str, dst->levelno);
}
str++;
len--;
}
for ( ; from && *from && count < to_length; )
{
*to++= *from++;
count++;
}
if (count == to_length && from && * from)
rc= TRUE; /* All weights did not fit */
}
*to= 0;
*nweights= count;
return rc;
}
|
O3
|
c
|
my_char_weight_put:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x30(%rbp)
testq %rdx, %rdx
je 0x78a3c
movq %rcx, -0x68(%rbp)
testq %r9, %r9
je 0x78a4b
movq %rdi, -0x60(%rbp)
decq %rdx
xorl %ecx, %ecx
xorl %r13d, %r13d
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq %r9, -0x40(%rbp)
cmpq $0x2, %r9
jb 0x78920
movq -0x40(%rbp), %rbx
leaq (,%rbx,8), %r12
cmpq $0x6, %rbx
ja 0x78913
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
jle 0x78913
movq -0x60(%rbp), %rcx
movq 0x20(%rcx), %r15
imulq $0x58, %rax, %r14
addq %r15, %r14
leaq (,%rbx,8), %rax
movq %rax, -0x70(%rbp)
cmpq $0x6, %rbx
je 0x788eb
cmpq $0x0, (%r15,%r12)
jne 0x7890a
cmpb $0x0, 0x52(%r15)
jne 0x7890a
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x283a0
testl %eax, %eax
je 0x789c3
addq $0x58, %r15
cmpq %r14, %r15
jb 0x788de
decq %rbx
addq $-0x8, %r12
cmpq $0x1, %rbx
ja 0x788b0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rsi
cmpq %rcx, (%rsi)
jb 0x78958
movq 0x10(%rsi), %rcx
movl %eax, %edx
shrl $0x8, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x78958
movzbl %al, %eax
movq 0x8(%rsi), %rsi
movzbl (%rsi,%rdx), %edx
imull %eax, %edx
leaq (%rcx,%rdx,2), %r15
jmp 0x789a9
leaq -0x3400(%rax), %rcx
leaq -0x4e00(%rax), %rdx
xorl %esi, %esi
cmpq $0x51a6, %rdx # imm = 0x51A6
setae %sil
shll $0x7, %esi
orl $0xfffffb40, %esi # imm = 0xFFFFFB40
cmpq $0x19b6, %rcx # imm = 0x19B6
movl $0xfb80, %ecx # imm = 0xFB80
cmovbl %ecx, %esi
movl %eax, %ecx
shrl $0xf, %ecx
addl %esi, %ecx
movw %cx, -0x36(%rbp)
orl $0x8000, %eax # imm = 0x8000
movw %ax, -0x34(%rbp)
movw $0x0, -0x32(%rbp)
leaq -0x36(%rbp), %r15
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %r9
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
addq $0x8, -0x30(%rbp)
decq %r9
jmp 0x789e6
addq $0x30, %r15
movq -0x30(%rbp), %rax
leaq (%rax,%rbx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %r9
subq %rbx, %r9
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movzwl (%r15), %eax
testw %ax, %ax
sete %cl
cmpq %rdx, %r13
setae %r8b
orb %cl, %r8b
jne 0x78a1c
addq $0x2, %r15
movw %ax, (%rsi)
addq $0x2, %rsi
incq %r13
movzwl (%r15), %eax
testw %ax, %ax
je 0x78a1c
addq $0x2, %r15
cmpq %rdx, %r13
jb 0x78a00
testw %ax, %ax
movzbl %dil, %eax
movl $0x1, %ecx
cmovel %eax, %ecx
cmpq %rdx, %r13
cmovnel %eax, %ecx
testq %r9, %r9
jne 0x78892
jmp 0x78a50
movq $0x0, (%rcx)
testq %r9, %r9
setne %cl
jmp 0x78a5c
xorl %r13d, %r13d
xorl %ecx, %ecx
movw $0x0, (%rsi)
movq -0x68(%rbp), %rax
movq %r13, (%rax)
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_char_weight_put:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_30], r8
test rdx, rdx
jz loc_78A3C
mov [rbp+var_68], rcx
test r9, r9
jz loc_78A4B
mov [rbp+var_60], rdi
dec rdx
xor ecx, ecx
xor r13d, r13d
mov [rbp+var_48], rdx
loc_78892:
mov [rbp+var_50], rcx
mov [rbp+var_58], rsi
mov [rbp+var_40], r9
cmp r9, 2
jb short loc_78920
mov rbx, [rbp+var_40]
lea r12, ds:0[rbx*8]
loc_788B0:
cmp rbx, 6
ja short loc_78913
mov rax, [rbp+var_60]
mov rax, [rax+18h]
test rax, rax
jle short loc_78913
mov rcx, [rbp+var_60]
mov r15, [rcx+20h]
imul r14, rax, 58h ; 'X'
add r14, r15
lea rax, ds:0[rbx*8]
mov [rbp+var_70], rax
loc_788DE:
cmp rbx, 6
jz short loc_788EB
cmp qword ptr [r15+r12], 0
jnz short loc_7890A
loc_788EB:
cmp byte ptr [r15+52h], 0
jnz short loc_7890A
mov rdi, r15
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_70]
call _bcmp
test eax, eax
jz loc_789C3
loc_7890A:
add r15, 58h ; 'X'
cmp r15, r14
jb short loc_788DE
loc_78913:
dec rbx
add r12, 0FFFFFFFFFFFFFFF8h
cmp rbx, 1
ja short loc_788B0
loc_78920:
mov rax, [rbp+var_30]
mov rax, [rax]
mov ecx, eax
mov rsi, [rbp+var_60]
cmp [rsi], rcx
jb short loc_78958
mov rcx, [rsi+10h]
mov edx, eax
shr edx, 8
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_78958
movzx eax, al
mov rsi, [rsi+8]
movzx edx, byte ptr [rsi+rdx]
imul edx, eax
lea r15, [rcx+rdx*2]
jmp short loc_789A9
loc_78958:
lea rcx, [rax-3400h]
lea rdx, [rax-4E00h]
xor esi, esi
cmp rdx, 51A6h
setnb sil
shl esi, 7
or esi, 0FFFFFB40h
cmp rcx, 19B6h
mov ecx, 0FB80h
cmovb esi, ecx
mov ecx, eax
shr ecx, 0Fh
add ecx, esi
mov [rbp+var_36], cx
or eax, 8000h
mov [rbp+var_34], ax
mov [rbp+var_32], 0
lea r15, [rbp+var_36]
loc_789A9:
mov rsi, [rbp+var_58]
mov r9, [rbp+var_40]
mov rdi, [rbp+var_50]
mov rdx, [rbp+var_48]
add [rbp+var_30], 8
dec r9
jmp short loc_789E6
loc_789C3:
add r15, 30h ; '0'
mov rax, [rbp+var_30]
lea rax, [rax+rbx*8]
mov [rbp+var_30], rax
mov r9, [rbp+var_40]
sub r9, rbx
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
mov rdx, [rbp+var_48]
loc_789E6:
movzx eax, word ptr [r15]
test ax, ax
setz cl
cmp r13, rdx
setnb r8b
or r8b, cl
jnz short loc_78A1C
add r15, 2
loc_78A00:
mov [rsi], ax
add rsi, 2
inc r13
movzx eax, word ptr [r15]
test ax, ax
jz short loc_78A1C
add r15, 2
cmp r13, rdx
jb short loc_78A00
loc_78A1C:
test ax, ax
movzx eax, dil
mov ecx, 1
cmovz ecx, eax
cmp r13, rdx
cmovnz ecx, eax
test r9, r9
jnz loc_78892
jmp short loc_78A50
loc_78A3C:
mov qword ptr [rcx], 0
test r9, r9
setnz cl
jmp short loc_78A5C
loc_78A4B:
xor r13d, r13d
xor ecx, ecx
loc_78A50:
mov word ptr [rsi], 0
mov rax, [rbp+var_68]
mov [rax], r13
loc_78A5C:
mov eax, ecx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_char_weight_put(
_QWORD *a1,
_WORD *a2,
long long a3,
unsigned long long *a4,
long long *a5,
unsigned long long a6)
{
unsigned long long v6; // r13
unsigned long long v7; // rbx
long long v8; // r12
long long v9; // rax
unsigned long long v10; // r15
unsigned long long v11; // r14
long long v12; // rax
long long v13; // rdx
long long v14; // rcx
__int16 *v15; // r15
__int16 v16; // si
unsigned __int8 v17; // di
unsigned long long v18; // rdx
__int16 v19; // ax
__int16 *v20; // r15
unsigned long long *v22; // [rsp+8h] [rbp-68h]
_WORD *v24; // [rsp+18h] [rbp-58h]
unsigned __int8 v25; // [rsp+20h] [rbp-50h]
unsigned long long v26; // [rsp+28h] [rbp-48h]
unsigned long long v27; // [rsp+30h] [rbp-40h]
_WORD v28[3]; // [rsp+3Ah] [rbp-36h] BYREF
long long *v29; // [rsp+40h] [rbp-30h]
v29 = a5;
if ( a3 )
{
v22 = a4;
if ( a6 )
{
LOBYTE(a4) = 0;
v6 = 0LL;
v26 = a3 - 1;
do
{
v25 = (unsigned __int8)a4;
v24 = a2;
v27 = a6;
if ( a6 < 2 )
{
LABEL_15:
v12 = *v29;
if ( *a1 >= (unsigned long long)(unsigned int)*v29
&& (v13 = (unsigned int)v12 >> 8, (v14 = *(_QWORD *)(a1[2] + 8 * v13)) != 0) )
{
v15 = (__int16 *)(v14 + 2LL * (unsigned __int8)v12 * (unsigned int)*(unsigned __int8 *)(a1[1] + v13));
}
else
{
v16 = (((unsigned long long)(v12 - 19968) >= 0x51A6) << 7) | 0xFB40;
if ( (unsigned long long)(v12 - 13312) < 0x19B6 )
v16 = -1152;
v28[0] = v16 + ((unsigned int)v12 >> 15);
v28[1] = v12 | 0x8000;
v28[2] = 0;
v15 = v28;
}
a2 = v24;
v17 = v25;
v18 = v26;
++v29;
a6 = v27 - 1;
}
else
{
v7 = a6;
v8 = 8 * a6;
while ( 1 )
{
if ( v7 <= 6 )
{
v9 = a1[3];
if ( v9 > 0 )
break;
}
LABEL_14:
--v7;
v8 -= 8LL;
if ( v7 <= 1 )
goto LABEL_15;
}
v10 = a1[4];
v11 = v10 + 88 * v9;
while ( v7 != 6 && *(_QWORD *)(v10 + v8) || *(_BYTE *)(v10 + 82) || (unsigned int)bcmp(v10, v29, 8 * v7) )
{
v10 += 88LL;
if ( v10 >= v11 )
goto LABEL_14;
}
v15 = (__int16 *)(v10 + 48);
v29 += v7;
a6 = v27 - v7;
v17 = v25;
v18 = v26;
}
v19 = *v15;
if ( *v15 != 0 && v6 < v18 )
{
v20 = v15 + 1;
do
{
*a2++ = v19;
++v6;
v19 = *v20;
if ( !*v20 )
break;
++v20;
}
while ( v6 < v18 );
}
LODWORD(a4) = 1;
if ( !v19 )
LODWORD(a4) = v17;
if ( v6 != v18 )
LODWORD(a4) = v17;
}
while ( a6 );
}
else
{
v6 = 0LL;
LODWORD(a4) = 0;
}
*a2 = 0;
*v22 = v6;
}
else
{
*a4 = 0LL;
LOBYTE(a4) = a6 != 0;
}
return (unsigned int)a4;
}
|
my_char_weight_put:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x30],R8
TEST RDX,RDX
JZ 0x00178a3c
MOV qword ptr [RBP + -0x68],RCX
TEST R9,R9
JZ 0x00178a4b
MOV qword ptr [RBP + -0x60],RDI
DEC RDX
XOR ECX,ECX
XOR R13D,R13D
MOV qword ptr [RBP + -0x48],RDX
LAB_00178892:
MOV qword ptr [RBP + -0x50],RCX
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x40],R9
CMP R9,0x2
JC 0x00178920
MOV RBX,qword ptr [RBP + -0x40]
LEA R12,[RBX*0x8]
LAB_001788b0:
CMP RBX,0x6
JA 0x00178913
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x18]
TEST RAX,RAX
JLE 0x00178913
MOV RCX,qword ptr [RBP + -0x60]
MOV R15,qword ptr [RCX + 0x20]
IMUL R14,RAX,0x58
ADD R14,R15
LEA RAX,[RBX*0x8]
MOV qword ptr [RBP + -0x70],RAX
LAB_001788de:
CMP RBX,0x6
JZ 0x001788eb
CMP qword ptr [R15 + R12*0x1],0x0
JNZ 0x0017890a
LAB_001788eb:
CMP byte ptr [R15 + 0x52],0x0
JNZ 0x0017890a
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x001283a0
TEST EAX,EAX
JZ 0x001789c3
LAB_0017890a:
ADD R15,0x58
CMP R15,R14
JC 0x001788de
LAB_00178913:
DEC RBX
ADD R12,-0x8
CMP RBX,0x1
JA 0x001788b0
LAB_00178920:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV ECX,EAX
MOV RSI,qword ptr [RBP + -0x60]
CMP qword ptr [RSI],RCX
JC 0x00178958
MOV RCX,qword ptr [RSI + 0x10]
MOV EDX,EAX
SHR EDX,0x8
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x00178958
MOVZX EAX,AL
MOV RSI,qword ptr [RSI + 0x8]
MOVZX EDX,byte ptr [RSI + RDX*0x1]
IMUL EDX,EAX
LEA R15,[RCX + RDX*0x2]
JMP 0x001789a9
LAB_00178958:
LEA RCX,[RAX + -0x3400]
LEA RDX,[RAX + -0x4e00]
XOR ESI,ESI
CMP RDX,0x51a6
SETNC SIL
SHL ESI,0x7
OR ESI,0xfffffb40
CMP RCX,0x19b6
MOV ECX,0xfb80
CMOVC ESI,ECX
MOV ECX,EAX
SHR ECX,0xf
ADD ECX,ESI
MOV word ptr [RBP + -0x36],CX
OR EAX,0x8000
MOV word ptr [RBP + -0x34],AX
MOV word ptr [RBP + -0x32],0x0
LEA R15,[RBP + -0x36]
LAB_001789a9:
MOV RSI,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
ADD qword ptr [RBP + -0x30],0x8
DEC R9
JMP 0x001789e6
LAB_001789c3:
ADD R15,0x30
MOV RAX,qword ptr [RBP + -0x30]
LEA RAX,[RAX + RBX*0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV R9,qword ptr [RBP + -0x40]
SUB R9,RBX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
LAB_001789e6:
MOVZX EAX,word ptr [R15]
TEST AX,AX
SETZ CL
CMP R13,RDX
SETNC R8B
OR R8B,CL
JNZ 0x00178a1c
ADD R15,0x2
LAB_00178a00:
MOV word ptr [RSI],AX
ADD RSI,0x2
INC R13
MOVZX EAX,word ptr [R15]
TEST AX,AX
JZ 0x00178a1c
ADD R15,0x2
CMP R13,RDX
JC 0x00178a00
LAB_00178a1c:
TEST AX,AX
MOVZX EAX,DIL
MOV ECX,0x1
CMOVZ ECX,EAX
CMP R13,RDX
CMOVNZ ECX,EAX
TEST R9,R9
JNZ 0x00178892
JMP 0x00178a50
LAB_00178a3c:
MOV qword ptr [RCX],0x0
TEST R9,R9
SETNZ CL
JMP 0x00178a5c
LAB_00178a4b:
XOR R13D,R13D
XOR ECX,ECX
LAB_00178a50:
MOV word ptr [RSI],0x0
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],R13
LAB_00178a5c:
MOV EAX,ECX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_char_weight_put(ulong *param_1,short *param_2,long param_3,ulong *param_4,ulong *param_5,
ulong param_6)
{
ushort uVar1;
short sVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
ulong uVar9;
void *pvVar10;
void *__s1;
short *psVar11;
short local_3e;
ushort local_3c;
int2 local_3a;
ulong *local_38;
if (param_3 == 0) {
*param_4 = 0;
uVar7 = CONCAT71((int7)((ulong)param_4 >> 8),param_6 != 0);
}
else {
if (param_6 == 0) {
uVar9 = 0;
uVar7 = 0;
}
else {
uVar5 = param_3 - 1;
uVar9 = 0;
uVar4 = 0;
local_38 = param_5;
do {
if (1 < param_6) {
lVar8 = param_6 * 8;
uVar7 = param_6;
do {
if ((uVar7 < 7) && (0 < (long)param_1[3])) {
__s1 = (void *)param_1[4];
pvVar10 = (void *)(param_1[3] * 0x58 + (long)__s1);
do {
if ((((uVar7 == 6) || (*(long *)((long)__s1 + lVar8) == 0)) &&
(*(char *)((long)__s1 + 0x52) == '\0')) &&
(iVar3 = bcmp(__s1,local_38,uVar7 * 8), iVar3 == 0)) {
psVar11 = (short *)((long)__s1 + 0x30);
local_38 = local_38 + uVar7;
param_6 = param_6 - uVar7;
goto LAB_001789e6;
}
__s1 = (void *)((long)__s1 + 0x58);
} while (__s1 < pvVar10);
}
uVar7 = uVar7 - 1;
lVar8 = lVar8 + -8;
} while (1 < uVar7);
}
uVar7 = *local_38;
if (*param_1 < (uVar7 & 0xffffffff)) {
LAB_00178958:
uVar1 = (ushort)(0x51a5 < uVar7 - 0x4e00) << 7 | 0xfb40;
if (uVar7 - 0x3400 < 0x19b6) {
uVar1 = 0xfb80;
}
local_3e = (short)(uVar7 >> 0xf) + uVar1;
local_3c = (ushort)uVar7 | 0x8000;
local_3a = 0;
psVar11 = &local_3e;
}
else {
uVar6 = uVar7 >> 8 & 0xffffff;
lVar8 = *(long *)(param_1[2] + uVar6 * 8);
if (lVar8 == 0) goto LAB_00178958;
psVar11 = (short *)(lVar8 + (ulong)((uint)*(byte *)(param_1[1] + uVar6) *
((uint)uVar7 & 0xff)) * 2);
}
local_38 = local_38 + 1;
param_6 = param_6 - 1;
LAB_001789e6:
sVar2 = *psVar11;
if (uVar9 < uVar5 && sVar2 != 0) {
do {
psVar11 = psVar11 + 1;
*param_2 = sVar2;
param_2 = param_2 + 1;
uVar9 = uVar9 + 1;
sVar2 = *psVar11;
if (sVar2 == 0) break;
} while (uVar9 < uVar5);
}
uVar7 = 1;
if (sVar2 == 0) {
uVar7 = uVar4;
}
if (uVar9 != uVar5) {
uVar7 = uVar4;
}
uVar4 = uVar7;
} while (param_6 != 0);
}
*param_2 = 0;
*param_4 = uVar9;
}
return uVar7 & 0xffffffff;
}
|
|
5,017 |
qh_newfacet
|
aimrt_mujoco_sim/_deps/qhull-src/src/libqhull_r/poly_r.c
|
facetT *qh_newfacet(qhT *qh) {
facetT *facet;
void **freelistp; /* used if !qh_NOmem by qh_memalloc_() */
qh_memalloc_(qh, (int)sizeof(facetT), freelistp, facet, facetT);
memset((char *)facet, (size_t)0, sizeof(facetT));
if (qh->facet_id == qh->tracefacet_id)
qh->tracefacet= facet;
facet->id= qh->facet_id++;
facet->neighbors= qh_setnew(qh, qh->hull_dim);
#if !qh_COMPUTEfurthest
facet->furthestdist= 0.0;
#endif
#if qh_MAXoutside
if (qh->FORCEoutput && qh->APPROXhull)
facet->maxoutside= qh->MINoutside;
else
facet->maxoutside= qh->DISTround; /* same value as test for QH7082 */
#endif
facet->simplicial= True;
facet->good= True;
facet->newfacet= True;
trace4((qh, qh->ferr, 4055, "qh_newfacet: created facet f%d\n", facet->id));
return(facet);
}
|
O0
|
c
|
qh_newfacet:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x78, %esi
callq 0x4fc130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x49430
movq 0x10(%rsp), %rax
movl 0xa18(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x9c4(%rcx), %eax
jne 0x4f6bf7
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x9c8(%rax)
movq 0x10(%rsp), %rax
movl 0xa18(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xa18(%rax)
movq 0x8(%rsp), %rax
movl %ecx, 0x6c(%rax)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x278(%rax), %esi
callq 0x4fa1e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4f6c6e
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
je 0x4f6c6e
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x4f6c85
movq 0x10(%rsp), %rax
movsd 0x6f8(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
andl $0xffffdfff, %ecx # imm = 0xFFFFDFFF
orl $0x2000, %ecx # imm = 0x2000
movl %ecx, 0x70(%rax)
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
andl $0xfff7ffff, %ecx # imm = 0xFFF7FFFF
orl $0x80000, %ecx # imm = 0x80000
movl %ecx, 0x70(%rax)
movq 0x8(%rsp), %rax
movl 0x70(%rax), %ecx
andl $0xfffffbff, %ecx # imm = 0xFFFFFBFF
orl $0x400, %ecx # imm = 0x400
movl %ecx, 0x70(%rax)
movq 0x10(%rsp), %rax
cmpl $0x4, 0x88(%rax)
jl 0x4f6d05
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x978(%rax), %rsi
movq 0x8(%rsp), %rax
movl 0x6c(%rax), %r8d
movl $0xfd7, %edx # imm = 0xFD7
leaq 0x508ba(%rip), %rcx # 0x5475b8
movb $0x0, %al
callq 0x4fdcb0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
qh_newfacet:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]
mov esi, 78h ; 'x'
call qh_memalloc
mov [rsp+18h+var_10], rax
mov rdi, [rsp+18h+var_10]
xor esi, esi
mov edx, 78h ; 'x'
call _memset
mov rax, [rsp+18h+var_8]
mov eax, [rax+0A18h]
mov rcx, [rsp+18h+var_8]
cmp eax, [rcx+9C4h]
jnz short loc_4F6BF7
mov rcx, [rsp+18h+var_10]
mov rax, [rsp+18h+var_8]
mov [rax+9C8h], rcx
loc_4F6BF7:
mov rax, [rsp+18h+var_8]
mov ecx, [rax+0A18h]
mov edx, ecx
add edx, 1
mov [rax+0A18h], edx
mov rax, [rsp+18h+var_10]
mov [rax+6Ch], ecx
mov rdi, [rsp+18h+var_8]
mov rax, [rsp+18h+var_8]
mov esi, [rax+278h]
call qh_setnew
mov rcx, rax
mov rax, [rsp+18h+var_10]
mov [rax+50h], rcx
mov rax, [rsp+18h+var_10]
xorps xmm0, xmm0
movsd qword ptr [rax], xmm0
mov rax, [rsp+18h+var_8]
cmp dword ptr [rax+60h], 0
jz short loc_4F6C6E
mov rax, [rsp+18h+var_8]
cmp dword ptr [rax+14h], 0
jz short loc_4F6C6E
mov rax, [rsp+18h+var_8]
movsd xmm0, qword ptr [rax+18h]
mov rax, [rsp+18h+var_10]
movsd qword ptr [rax+8], xmm0
jmp short loc_4F6C85
loc_4F6C6E:
mov rax, [rsp+18h+var_8]
movsd xmm0, qword ptr [rax+6F8h]
mov rax, [rsp+18h+var_10]
movsd qword ptr [rax+8], xmm0
loc_4F6C85:
mov rax, [rsp+18h+var_10]
mov ecx, [rax+70h]
and ecx, 0FFFFDFFFh
or ecx, 2000h
mov [rax+70h], ecx
mov rax, [rsp+18h+var_10]
mov ecx, [rax+70h]
and ecx, 0FFF7FFFFh
or ecx, 80000h
mov [rax+70h], ecx
mov rax, [rsp+18h+var_10]
mov ecx, [rax+70h]
and ecx, 0FFFFFBFFh
or ecx, 400h
mov [rax+70h], ecx
mov rax, [rsp+18h+var_8]
cmp dword ptr [rax+88h], 4
jl short loc_4F6D05
mov rdi, [rsp+18h+var_8]
mov rax, [rsp+18h+var_8]
mov rsi, [rax+978h]
mov rax, [rsp+18h+var_10]
mov r8d, [rax+6Ch]
mov edx, 0FD7h
lea rcx, aQhNewfacetCrea; "qh_newfacet: created facet f%d\n"
mov al, 0
call qh_fprintf
loc_4F6D05:
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
|
long long qh_newfacet(long long a1)
{
int v1; // ecx
long long v2; // rdx
int v3; // r9d
long long v5; // [rsp+8h] [rbp-10h]
v5 = qh_memalloc(a1, 120LL);
memset(v5, 0LL, 120LL);
if ( *(_DWORD *)(a1 + 2584) == *(_DWORD *)(a1 + 2500) )
*(_QWORD *)(a1 + 2504) = v5;
v1 = *(_DWORD *)(a1 + 2584);
v2 = (unsigned int)(v1 + 1);
*(_DWORD *)(a1 + 2584) = v2;
*(_DWORD *)(v5 + 108) = v1;
*(_QWORD *)(v5 + 80) = qh_setnew(a1, *(unsigned int *)(a1 + 632), v2);
*(_QWORD *)v5 = 0LL;
if ( *(_DWORD *)(a1 + 96) && *(_DWORD *)(a1 + 20) )
*(_QWORD *)(v5 + 8) = *(_QWORD *)(a1 + 24);
else
*(_QWORD *)(v5 + 8) = *(_QWORD *)(a1 + 1784);
*(_DWORD *)(v5 + 112) = *(_DWORD *)(v5 + 112) & 0xFFFFDFFF | 0x2000;
*(_DWORD *)(v5 + 112) = *(_DWORD *)(v5 + 112) & 0xFFF7FFFF | 0x80000;
*(_DWORD *)(v5 + 112) = *(_DWORD *)(v5 + 112) & 0xFFFFFBFF | 0x400;
if ( *(int *)(a1 + 136) >= 4 )
qh_fprintf(
a1,
*(_QWORD *)(a1 + 2424),
4055,
(unsigned int)"qh_newfacet: created facet f%d\n",
*(_DWORD *)(v5 + 108),
v3);
return v5;
}
|
Material:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
ADD RAX,0x2228
RET
|
/* mjCDef::Material() */
mjCDef * __thiscall mjCDef::Material(mjCDef *this)
{
return this + 0x2228;
}
|
|
5,018 |
mysql_stmt_execute_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_execute_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_execute,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_stmt_execute_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x38(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rbx
callq 0x3324d
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_execute_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+38h]
mov rax, [rax+480h]
mov rbx, [rax+28h]
call mysql_stmt_execute
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_execute_start_internal(long long *a1)
{
long long v1; // rdi
_DWORD *v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_execute(v1);
v2[2] = result;
*v2 = 0;
return result;
}
|
mysql_stmt_execute_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0013324d
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_execute_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_execute();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
5,019 |
ma_block_get_status
|
eloqsql/storage/maria/ma_state.c
|
my_bool _ma_block_get_status(void* param, my_bool concurrent_insert)
{
MARIA_HA *info=(MARIA_HA*) param;
DBUG_ENTER("_ma_block_get_status");
DBUG_PRINT("enter", ("concurrent_insert %d", concurrent_insert));
info->row_base_length= info->s->base_length;
info->row_flag= info->s->base.default_row_flag;
DBUG_ASSERT(!concurrent_insert ||
info->lock.type == TL_WRITE_CONCURRENT_INSERT);
if (concurrent_insert || !info->autocommit)
{
info->row_flag|= ROW_FLAG_TRANSID;
info->row_base_length+= TRANSID_SIZE;
}
else
{
DBUG_ASSERT(info->lock.type != TL_WRITE_CONCURRENT_INSERT);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_block_get_status:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movl 0x7c4(%rcx), %eax
movq %rax, 0x610(%rdi)
movl 0x418(%rcx), %ecx
movl %ecx, 0x618(%rdi)
testb %sil, %sil
je 0x39af2
orl $0x1, %ecx
movl %ecx, 0x618(%rdi)
addq $0x6, %rax
movq %rax, 0x610(%rdi)
jmp 0x39afb
cmpb $0x0, 0x688(%rdi)
je 0x39adc
xorl %eax, %eax
popq %rbp
retq
|
_ma_block_get_status:
push rbp
mov rbp, rsp
mov rcx, [rdi]
mov eax, [rcx+7C4h]
mov [rdi+610h], rax
mov ecx, [rcx+418h]
mov [rdi+618h], ecx
test sil, sil
jz short loc_39AF2
loc_39ADC:
or ecx, 1
mov [rdi+618h], ecx
add rax, 6
mov [rdi+610h], rax
jmp short loc_39AFB
loc_39AF2:
cmp byte ptr [rdi+688h], 0
jz short loc_39ADC
loc_39AFB:
xor eax, eax
pop rbp
retn
|
long long ma_block_get_status(long long *a1, char a2)
{
long long v2; // rcx
long long v3; // rax
int v4; // ecx
v2 = *a1;
v3 = *(unsigned int *)(*a1 + 1988);
a1[194] = v3;
v4 = *(_DWORD *)(v2 + 1048);
*((_DWORD *)a1 + 390) = v4;
if ( a2 || !*((_BYTE *)a1 + 1672) )
{
*((_DWORD *)a1 + 390) = v4 | 1;
a1[194] = v3 + 6;
}
return 0LL;
}
|
_ma_block_get_status:
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI]
MOV EAX,dword ptr [RCX + 0x7c4]
MOV qword ptr [RDI + 0x610],RAX
MOV ECX,dword ptr [RCX + 0x418]
MOV dword ptr [RDI + 0x618],ECX
TEST SIL,SIL
JZ 0x00139af2
LAB_00139adc:
OR ECX,0x1
MOV dword ptr [RDI + 0x618],ECX
ADD RAX,0x6
MOV qword ptr [RDI + 0x610],RAX
JMP 0x00139afb
LAB_00139af2:
CMP byte ptr [RDI + 0x688],0x0
JZ 0x00139adc
LAB_00139afb:
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_block_get_status(long *param_1,char param_2)
{
uint uVar1;
ulong uVar2;
uVar2 = (ulong)*(uint *)(*param_1 + 0x7c4);
param_1[0xc2] = uVar2;
uVar1 = *(uint *)(*param_1 + 0x418);
*(uint *)(param_1 + 0xc3) = uVar1;
if ((param_2 != '\0') || ((char)param_1[0xd1] == '\0')) {
*(uint *)(param_1 + 0xc3) = uVar1 | 1;
param_1[0xc2] = uVar2 + 6;
}
return 0;
}
|
|
5,020 |
my_charlen_utf8mb3
|
eloqsql/strings/ctype-utf8.c
|
static
int my_charlen_utf8mb3(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_charlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0xcb6e3
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0xcb6e1
movl $0x1, %eax
testb %cl, %cl
jns 0xcb6e3
cmpb $-0x3e, %cl
jae 0xcb6e5
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0xcb705
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0xcb6e3
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0xcb6e3
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0xcb6e3
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0xcb6e1
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0xcb6e3
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0xcb6e3
|
my_charlen_utf8mb3:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_CB6E3
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_CB6E1
mov eax, 1
test cl, cl
jns short loc_CB6E3
cmp cl, 0C2h
jnb short loc_CB6E5
loc_CB6E1:
xor eax, eax
loc_CB6E3:
pop rbp
retn
loc_CB6E5:
cmp cl, 0DFh
ja short loc_CB705
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja short loc_CB6E3
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp short loc_CB6E3
loc_CB705:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_CB6E3
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_CB6E1
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_CB6E3
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_CB6E3
|
long long my_charlen_utf8mb3(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( (unsigned __int8)*a2 > 0xEFu )
return 0LL;
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) <= a3 )
{
v5 = a2[1];
if ( v5 > -65 )
return 0LL;
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v5 >= 0xA0u);
}
}
}
else
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
}
}
return result;
}
|
my_charlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001cb6e3
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x001cb6e1
MOV EAX,0x1
TEST CL,CL
JNS 0x001cb6e3
CMP CL,0xc2
JNC 0x001cb6e5
LAB_001cb6e1:
XOR EAX,EAX
LAB_001cb6e3:
POP RBP
RET
LAB_001cb6e5:
CMP CL,0xdf
JA 0x001cb705
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x001cb6e3
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x001cb6e3
LAB_001cb705:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x001cb6e3
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cb6e1
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x001cb6e3
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x001cb6e3
|
int my_charlen_utf8mb3(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
if (param_3 <= param_2) {
return -0x65;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return -0x66;
}
return (uint)((char)param_2[1] < -0x40) * 2;
}
if (param_3 < param_2 + 3) {
return -0x67;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (uint)(0x9f < param_2[1]) * 3;
}
}
}
return 0;
}
|
|
5,021 |
my_instr_simple
|
eloqsql/strings/ctype-simple.c
|
uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
}
|
O0
|
c
|
my_instr_simple:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x559de
cmpq $0x0, -0x30(%rbp)
jne 0x55876
cmpl $0x0, 0x10(%rbp)
je 0x5586a
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x559e5
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x558ad
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x559dc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x48(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x559d7
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x55959
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x60(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x68(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x55957
jmp 0x558ab
jmp 0x55908
cmpl $0x0, 0x10(%rbp)
jbe 0x559ce
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0x10(%rbp)
jbe 0x559cc
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x38(%rbp), %rax
subl 0xc(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x559ce
movl $0x2, -0x4(%rbp)
jmp 0x559e5
jmp 0x558ad
jmp 0x559de
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_instr_simple:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_0]
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 [rbp+var_38], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
ja loc_559DE
cmp [rbp+var_30], 0
jnz short loc_55876
cmp [rbp+arg_0], 0
jz short loc_5586A
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
loc_5586A:
mov [rbp+var_4], 1
jmp loc_559E5
loc_55876:
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_30]
add rax, rcx
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_58], rax
loc_558AB:
jmp short $+2
loc_558AD:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_50]
jz loc_559DC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_40]
mov rdx, rcx
add rdx, 1
mov [rbp+var_40], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_48]
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jnz loc_559D7
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_68], rax
loc_55908:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_58]
jz short loc_55959
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_60]
mov rdx, rcx
add rdx, 1
mov [rbp+var_60], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_68]
mov rsi, rdx
add rsi, 1
mov [rbp+var_68], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_55957
jmp loc_558AB
loc_55957:
jmp short loc_55908
loc_55959:
cmp [rbp+arg_0], 0
jbe short loc_559CE
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
sub rax, rcx
sub rax, 1
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+4], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+8], ecx
cmp [rbp+arg_0], 1
jbe short loc_559CC
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+0Ch], ecx
mov rax, [rbp+var_38]
mov eax, [rax+4]
add rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+10h]
mov rax, [rbp+var_38]
sub ecx, [rax+0Ch]
mov rax, [rbp+var_38]
mov [rax+14h], ecx
loc_559CC:
jmp short $+2
loc_559CE:
mov [rbp+var_4], 2
jmp short loc_559E5
loc_559D7:
jmp loc_558AD
loc_559DC:
jmp short $+2
loc_559DE:
mov [rbp+var_4], 0
loc_559E5:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
unsigned int a7)
{
unsigned __int8 *v7; // rcx
unsigned __int8 *v8; // rcx
unsigned __int8 *v9; // rdx
unsigned __int8 *v11; // [rsp+0h] [rbp-68h]
unsigned __int8 *v12; // [rsp+8h] [rbp-60h]
unsigned __int8 *v13; // [rsp+10h] [rbp-58h]
long long v14; // [rsp+18h] [rbp-50h]
unsigned __int8 *v15; // [rsp+28h] [rbp-40h]
if ( a5 > a3 )
return 0;
if ( a5 )
{
v15 = a2;
v14 = (long long)&a2[a3 - a5 + 1];
v13 = &a4[a5];
LABEL_7:
while ( v15 != (unsigned __int8 *)v14 )
{
v7 = v15++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v7) == *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a4) )
{
v12 = v15;
v11 = a4 + 1;
while ( v11 != v13 )
{
v8 = v12++;
v9 = v11++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v8) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v9) )
goto LABEL_7;
}
if ( a7 )
{
*a6 = 0;
a6[1] = (_DWORD)v15 - (_DWORD)a2 - 1;
a6[2] = a6[1];
if ( a7 > 1 )
{
a6[3] = a6[1];
a6[4] = a5 + a6[1];
a6[5] = a6[4] - a6[3];
}
}
return 2;
}
}
return 0;
}
if ( a7 )
{
*a6 = 0;
a6[1] = 0;
a6[2] = 0;
}
return 1;
}
|
my_instr_simple:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x10]
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 qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x001559de
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00155876
CMP dword ptr [RBP + 0x10],0x0
JZ 0x0015586a
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
LAB_0015586a:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001559e5
LAB_00155876:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
LAB_001558ab:
JMP 0x001558ad
LAB_001558ad:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x50]
JZ 0x001559dc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x40],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x48]
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JNZ 0x001559d7
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
LAB_00155908:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x58]
JZ 0x00155959
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x68]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x68],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00155957
JMP 0x001558ab
LAB_00155957:
JMP 0x00155908
LAB_00155959:
CMP dword ptr [RBP + 0x10],0x0
JBE 0x001559ce
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SUB RAX,0x1
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
CMP dword ptr [RBP + 0x10],0x1
JBE 0x001559cc
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
ADD RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
SUB ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x14],ECX
LAB_001559cc:
JMP 0x001559ce
LAB_001559ce:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001559e5
LAB_001559d7:
JMP 0x001558ad
LAB_001559dc:
JMP 0x001559de
LAB_001559de:
MOV dword ptr [RBP + -0x4],0x0
LAB_001559e5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,uint param_7)
{
byte bVar1;
byte bVar2;
byte *pbVar3;
byte *local_70;
byte *local_68;
byte *local_48;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
}
return 1;
}
local_48 = param_2;
while (local_48 != param_2 + (param_3 - param_5) + 1) {
pbVar3 = local_48 + 1;
bVar1 = *local_48;
local_48 = pbVar3;
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4)) {
local_70 = param_4 + 1;
local_68 = pbVar3;
do {
if (local_70 == param_4 + param_5) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = ((int)pbVar3 - (int)param_2) + -1;
param_6[2] = param_6[1];
if (1 < param_7) {
param_6[3] = param_6[1];
param_6[4] = param_6[1] + (int)param_5;
param_6[5] = param_6[4] - param_6[3];
}
}
return 2;
}
bVar1 = *local_68;
bVar2 = *local_70;
local_70 = local_70 + 1;
local_68 = local_68 + 1;
} while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2));
}
}
}
return 0;
}
|
|
5,022 |
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
void Next() {
int stride = *this->_size;
++this->_size;
this->_indices += stride;
this->_weights += stride;
if (_duWeights) _duWeights += stride;
if (_dvWeights) _dvWeights += stride;
if (_duuWeights) _duuWeights += stride;
if (_duvWeights) _duvWeights += stride;
if (_dvvWeights) _dvvWeights += stride;
}
|
O0
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next():
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rcx
movl (%rcx), %ecx
movl %ecx, -0xc(%rbp)
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %edx
movq 0x8(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %edx
movq 0x10(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x18(%rax)
je 0x154cdc
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x18(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x154d00
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x20(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x154d24
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x28(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x154d48
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x30(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x154d6c
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x38(%rax), %rcx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
popq %rbp
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIdE4NextEv:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rcx, [rax]
mov ecx, [rcx]
mov [rbp+var_C], ecx
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov edx, [rbp+var_C]
mov rcx, [rax+8]
movsxd rdx, edx
shl rdx, 2
add rcx, rdx
mov [rax+8], rcx
mov edx, [rbp+var_C]
mov rcx, [rax+10h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+10h], rcx
cmp qword ptr [rax+18h], 0
jz short loc_154CDC
mov rax, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, [rax+18h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+18h], rcx
loc_154CDC:
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_154D00
mov rax, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, [rax+20h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+20h], rcx
loc_154D00:
mov rax, [rbp+var_18]
cmp qword ptr [rax+28h], 0
jz short loc_154D24
mov rax, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, [rax+28h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+28h], rcx
loc_154D24:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 0
jz short loc_154D48
mov rax, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, [rax+30h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+30h], rcx
loc_154D48:
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jz short loc_154D6C
mov rax, [rbp+var_18]
mov edx, [rbp+var_C]
mov rcx, [rax+38h]
movsxd rdx, edx
shl rdx, 3
add rcx, rdx
mov [rax+38h], rcx
loc_154D6C:
pop rbp
retn
|
int ** OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next(int **a1)
{
int **result; // rax
int v2; // [rsp+Ch] [rbp-Ch]
v2 = *(*a1)++;
a1[1] += v2;
a1[2] += 2 * v2;
if ( a1[3] )
a1[3] += 2 * v2;
if ( a1[4] )
a1[4] += 2 * v2;
if ( a1[5] )
a1[5] += 2 * v2;
if ( a1[6] )
a1[6] += 2 * v2;
result = a1;
if ( a1[7] )
{
result = a1;
a1[7] += 2 * v2;
}
return result;
}
| |||
5,023 |
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
void Next() {
int stride = *this->_size;
++this->_size;
this->_indices += stride;
this->_weights += stride;
if (_duWeights) _duWeights += stride;
if (_dvWeights) _dvWeights += stride;
if (_duuWeights) _duuWeights += stride;
if (_duvWeights) _duvWeights += stride;
if (_dvvWeights) _dvvWeights += stride;
}
|
O2
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next():
movq (%rdi), %rdx
movq 0x18(%rdi), %rcx
movslq (%rdx), %rax
addq $0x4, %rdx
movq %rdx, (%rdi)
leaq (,%rax,4), %rdx
addq %rdx, 0x8(%rdi)
leaq (,%rax,8), %rdx
addq %rdx, 0x10(%rdi)
testq %rcx, %rcx
je 0x831ee
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x18(%rdi)
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x831ff
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x20(%rdi)
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x83210
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x28(%rdi)
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x83221
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x30(%rdi)
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x83232
leaq (%rcx,%rax,8), %rax
movq %rax, 0x38(%rdi)
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIdE4NextEv:
mov rdx, [rdi]
mov rcx, [rdi+18h]
movsxd rax, dword ptr [rdx]
add rdx, 4
mov [rdi], rdx
lea rdx, ds:0[rax*4]
add [rdi+8], rdx
lea rdx, ds:0[rax*8]
add [rdi+10h], rdx
test rcx, rcx
jz short loc_831EE
lea rcx, [rcx+rax*8]
mov [rdi+18h], rcx
loc_831EE:
mov rcx, [rdi+20h]
test rcx, rcx
jz short loc_831FF
lea rcx, [rcx+rax*8]
mov [rdi+20h], rcx
loc_831FF:
mov rcx, [rdi+28h]
test rcx, rcx
jz short loc_83210
lea rcx, [rcx+rax*8]
mov [rdi+28h], rcx
loc_83210:
mov rcx, [rdi+30h]
test rcx, rcx
jz short loc_83221
lea rcx, [rcx+rax*8]
mov [rdi+30h], rcx
loc_83221:
mov rcx, [rdi+38h]
test rcx, rcx
jz short locret_83232
lea rax, [rcx+rax*8]
mov [rdi+38h], rax
locret_83232:
retn
|
int * OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next(int **a1)
{
int *v1; // rcx
int *result; // rax
int *v3; // rcx
int *v4; // rcx
int *v5; // rcx
int *v6; // rcx
v1 = a1[3];
result = (int *)*(*a1)++;
a1[1] += (long long)result;
a1[2] += 2 * (_QWORD)result;
if ( v1 )
a1[3] = &v1[2 * (_QWORD)result];
v3 = a1[4];
if ( v3 )
a1[4] = &v3[2 * (_QWORD)result];
v4 = a1[5];
if ( v4 )
a1[5] = &v4[2 * (_QWORD)result];
v5 = a1[6];
if ( v5 )
a1[6] = &v5[2 * (_QWORD)result];
v6 = a1[7];
if ( v6 )
{
result = &v6[2 * (_QWORD)result];
a1[7] = result;
}
return result;
}
|
Next:
MOV RDX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x18]
MOVSXD RAX,dword ptr [RDX]
ADD RDX,0x4
MOV qword ptr [RDI],RDX
LEA RDX,[RAX*0x4]
ADD qword ptr [RDI + 0x8],RDX
LEA RDX,[RAX*0x8]
ADD qword ptr [RDI + 0x10],RDX
TEST RCX,RCX
JZ 0x001831ee
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x18],RCX
LAB_001831ee:
MOV RCX,qword ptr [RDI + 0x20]
TEST RCX,RCX
JZ 0x001831ff
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x20],RCX
LAB_001831ff:
MOV RCX,qword ptr [RDI + 0x28]
TEST RCX,RCX
JZ 0x00183210
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x28],RCX
LAB_00183210:
MOV RCX,qword ptr [RDI + 0x30]
TEST RCX,RCX
JZ 0x00183221
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x30],RCX
LAB_00183221:
MOV RCX,qword ptr [RDI + 0x38]
TEST RCX,RCX
JZ 0x00183232
LEA RAX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x38],RAX
LAB_00183232:
RET
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next() */
void __thiscall
OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next(LimitStencilReal<double> *this)
{
long lVar1;
lVar1 = (long)**(int **)this;
*(int **)this = *(int **)this + 1;
*(long *)(this + 8) = *(long *)(this + 8) + lVar1 * 4;
*(long *)(this + 0x10) = *(long *)(this + 0x10) + lVar1 * 8;
if (*(long *)(this + 0x18) != 0) {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + lVar1 * 8;
}
if (*(long *)(this + 0x20) != 0) {
*(long *)(this + 0x20) = *(long *)(this + 0x20) + lVar1 * 8;
}
if (*(long *)(this + 0x28) != 0) {
*(long *)(this + 0x28) = *(long *)(this + 0x28) + lVar1 * 8;
}
if (*(long *)(this + 0x30) != 0) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + lVar1 * 8;
}
if (*(long *)(this + 0x38) != 0) {
*(long *)(this + 0x38) = *(long *)(this + 0x38) + lVar1 * 8;
}
return;
}
|
|
5,024 |
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
void Next() {
int stride = *this->_size;
++this->_size;
this->_indices += stride;
this->_weights += stride;
if (_duWeights) _duWeights += stride;
if (_dvWeights) _dvWeights += stride;
if (_duuWeights) _duuWeights += stride;
if (_duvWeights) _duvWeights += stride;
if (_dvvWeights) _dvvWeights += stride;
}
|
O3
|
c
|
OpenSubdiv::v3_6_0::Far::LimitStencilReal<float>::Next():
movq (%rdi), %rdx
movq 0x18(%rdi), %rcx
movslq (%rdx), %rax
addq $0x4, %rdx
movq %rdx, (%rdi)
leaq (,%rax,4), %rdx
addq %rdx, 0x8(%rdi)
leaq (,%rax,8), %rdx
addq %rdx, 0x10(%rdi)
testq %rcx, %rcx
je 0x72d66
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x18(%rdi)
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x72d77
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x20(%rdi)
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0x72d88
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x28(%rdi)
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x72d99
leaq (%rcx,%rax,8), %rcx
movq %rcx, 0x30(%rdi)
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x72daa
leaq (%rcx,%rax,8), %rax
movq %rax, 0x38(%rdi)
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Far16LimitStencilRealIdE4NextEv:
mov rdx, [rdi]
mov rcx, [rdi+18h]
movsxd rax, dword ptr [rdx]
add rdx, 4
mov [rdi], rdx
lea rdx, ds:0[rax*4]
add [rdi+8], rdx
lea rdx, ds:0[rax*8]
add [rdi+10h], rdx
test rcx, rcx
jz short loc_72D66
lea rcx, [rcx+rax*8]
mov [rdi+18h], rcx
loc_72D66:
mov rcx, [rdi+20h]
test rcx, rcx
jz short loc_72D77
lea rcx, [rcx+rax*8]
mov [rdi+20h], rcx
loc_72D77:
mov rcx, [rdi+28h]
test rcx, rcx
jz short loc_72D88
lea rcx, [rcx+rax*8]
mov [rdi+28h], rcx
loc_72D88:
mov rcx, [rdi+30h]
test rcx, rcx
jz short loc_72D99
lea rcx, [rcx+rax*8]
mov [rdi+30h], rcx
loc_72D99:
mov rcx, [rdi+38h]
test rcx, rcx
jz short locret_72DAA
lea rax, [rcx+rax*8]
mov [rdi+38h], rax
locret_72DAA:
retn
|
int * OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next(int **a1)
{
int *v1; // rcx
int *result; // rax
int *v3; // rcx
int *v4; // rcx
int *v5; // rcx
int *v6; // rcx
v1 = a1[3];
result = (int *)*(*a1)++;
a1[1] += (long long)result;
a1[2] += 2 * (_QWORD)result;
if ( v1 )
a1[3] = &v1[2 * (_QWORD)result];
v3 = a1[4];
if ( v3 )
a1[4] = &v3[2 * (_QWORD)result];
v4 = a1[5];
if ( v4 )
a1[5] = &v4[2 * (_QWORD)result];
v5 = a1[6];
if ( v5 )
a1[6] = &v5[2 * (_QWORD)result];
v6 = a1[7];
if ( v6 )
{
result = &v6[2 * (_QWORD)result];
a1[7] = result;
}
return result;
}
|
Next:
MOV RDX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x18]
MOVSXD RAX,dword ptr [RDX]
ADD RDX,0x4
MOV qword ptr [RDI],RDX
LEA RDX,[RAX*0x4]
ADD qword ptr [RDI + 0x8],RDX
LEA RDX,[RAX*0x8]
ADD qword ptr [RDI + 0x10],RDX
TEST RCX,RCX
JZ 0x00172d66
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x18],RCX
LAB_00172d66:
MOV RCX,qword ptr [RDI + 0x20]
TEST RCX,RCX
JZ 0x00172d77
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x20],RCX
LAB_00172d77:
MOV RCX,qword ptr [RDI + 0x28]
TEST RCX,RCX
JZ 0x00172d88
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x28],RCX
LAB_00172d88:
MOV RCX,qword ptr [RDI + 0x30]
TEST RCX,RCX
JZ 0x00172d99
LEA RCX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x30],RCX
LAB_00172d99:
MOV RCX,qword ptr [RDI + 0x38]
TEST RCX,RCX
JZ 0x00172daa
LEA RAX,[RCX + RAX*0x8]
MOV qword ptr [RDI + 0x38],RAX
LAB_00172daa:
RET
|
/* OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next() */
void __thiscall
OpenSubdiv::v3_6_0::Far::LimitStencilReal<double>::Next(LimitStencilReal<double> *this)
{
long lVar1;
lVar1 = (long)**(int **)this;
*(int **)this = *(int **)this + 1;
*(long *)(this + 8) = *(long *)(this + 8) + lVar1 * 4;
*(long *)(this + 0x10) = *(long *)(this + 0x10) + lVar1 * 8;
if (*(long *)(this + 0x18) != 0) {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + lVar1 * 8;
}
if (*(long *)(this + 0x20) != 0) {
*(long *)(this + 0x20) = *(long *)(this + 0x20) + lVar1 * 8;
}
if (*(long *)(this + 0x28) != 0) {
*(long *)(this + 0x28) = *(long *)(this + 0x28) + lVar1 * 8;
}
if (*(long *)(this + 0x30) != 0) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + lVar1 * 8;
}
if (*(long *)(this + 0x38) != 0) {
*(long *)(this + 0x38) = *(long *)(this + 0x38) + lVar1 * 8;
}
return;
}
|
|
5,025 |
mi_find_writepos
|
eloqsql/storage/myisam/mi_dynrec.c
|
static int _mi_find_writepos(MI_INFO *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MI_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_mi_find_writepos");
if (info->s->state.dellink != HA_OFFSET_ERROR &&
!info->append_insert_at_end)
{
/* Deleted blocks exists; Get last used block */
*filepos=info->s->state.dellink;
block_info.second_read=0;
info->rec_cache.seek_not_done=1;
if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
my_errno=HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(-1);
}
info->s->state.dellink=block_info.next_filepos;
info->state->del--;
info->state->empty-= block_info.block_len;
*length= block_info.block_len;
}
else
{
/* No deleted blocks; Allocate a new block */
*filepos=info->state->data_file_length;
if ((tmp= reclength + 3 + MY_TEST(reclength >= (65520 - 3))) <
info->s->base.min_block_length)
tmp= info->s->base.min_block_length;
else
tmp= ((tmp+MI_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
if (info->state->data_file_length >
(info->s->base.max_data_file_length - tmp))
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(-1);
}
if (tmp > MI_MAX_BLOCK_LENGTH)
tmp=MI_MAX_BLOCK_LENGTH;
*length= tmp;
info->state->data_file_length+= tmp;
info->s->state.split++;
info->update|=HA_STATE_WRITE_AT_END;
}
DBUG_RETURN(0);
}
|
O3
|
c
|
mi_find_writepos:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq (%rdi), %rax
movq 0x58(%rax), %rax
cmpq $-0x1, %rax
je 0x79e9a
cmpb $0x0, 0x33a(%r14)
je 0x79f16
movq 0x8(%r14), %rax
movq 0x28(%rax), %rax
movq %rax, (%rdx)
cmpq $0xffed, %rsi # imm = 0xFFED
sbbq $-0x1, %rsi
leaq 0x3(%rsi), %rax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x160(%rcx), %rdi
addq $0x6, %rsi
andq $-0x4, %rsi
cmpq %rdi, %rax
cmovbq %rdi, %rsi
movq 0x110(%rcx), %rax
subq %rsi, %rax
cmpq %rax, 0x28(%rdx)
jbe 0x79eee
callq 0xa1b22
movl $0x87, (%rax)
jmp 0x79f51
movl $0xfffffc, %eax # imm = 0xFFFFFC
cmpq %rax, %rsi
cmovbq %rsi, %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rcx
addq %rax, 0x28(%rcx)
movq (%r14), %rax
incq 0x50(%rax)
orb $0x1, 0x1d1(%r14)
jmp 0x79f7e
movq %rax, (%rdx)
leaq -0x70(%rbp), %rdi
movl $0x0, 0x50(%rdi)
movl $0x1, 0x300(%r14)
movl 0x1c0(%r14), %esi
movq (%r14), %rax
movq 0x58(%rax), %rdx
callq 0x78413
testb $0x4, %al
jne 0x79f58
callq 0xa1b22
movl $0x7f, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x79f80
movq -0x30(%rbp), %rax
movq (%r14), %rcx
movq %rax, 0x58(%rcx)
movq 0x8(%r14), %rax
decq 0x8(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%r14), %rcx
subq %rax, 0x10(%rcx)
movq -0x48(%rbp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x79f98
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29270
nopl (%rax)
|
_mi_find_writepos:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov rbx, rcx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rax, [rdi]
mov rax, [rax+58h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_79E9A
cmp byte ptr [r14+33Ah], 0
jz short loc_79F16
loc_79E9A:
mov rax, [r14+8]
mov rax, [rax+28h]
mov [rdx], rax
cmp rsi, 0FFEDh
sbb rsi, 0FFFFFFFFFFFFFFFFh
lea rax, [rsi+3]
mov rcx, [r14]
mov rdx, [r14+8]
mov rdi, [rcx+160h]
add rsi, 6
and rsi, 0FFFFFFFFFFFFFFFCh
cmp rax, rdi
cmovb rsi, rdi
mov rax, [rcx+110h]
sub rax, rsi
cmp [rdx+28h], rax
jbe short loc_79EEE
call _my_thread_var
mov dword ptr [rax], 87h
jmp short loc_79F51
loc_79EEE:
mov eax, 0FFFFFCh
cmp rsi, rax
cmovb rax, rsi
mov [rbx], rax
mov rcx, [r14+8]
add [rcx+28h], rax
mov rax, [r14]
inc qword ptr [rax+50h]
or byte ptr [r14+1D1h], 1
jmp short loc_79F7E
loc_79F16:
mov [rdx], rax
lea rdi, [rbp+var_70]
mov dword ptr [rdi+50h], 0
mov dword ptr [r14+300h], 1
mov esi, [r14+1C0h]
mov rax, [r14]
mov rdx, [rax+58h]
call _mi_get_block_info
test al, 4
jnz short loc_79F58
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_79F51:
mov eax, 0FFFFFFFFh
jmp short loc_79F80
loc_79F58:
mov rax, [rbp+var_30]
mov rcx, [r14]
mov [rcx+58h], rax
mov rax, [r14+8]
dec qword ptr [rax+8]
mov rax, [rbp+var_48]
mov rcx, [r14+8]
sub [rcx+10h], rax
mov rax, [rbp+var_48]
mov [rbx], rax
loc_79F7E:
xor eax, eax
loc_79F80:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_79F98
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_79F98:
call ___stack_chk_fail
|
long long mi_find_writepos(_QWORD *a1, unsigned long long a2, _QWORD *a3, long long *a4)
{
long long v6; // rax
unsigned long long v7; // rsi
unsigned long long v8; // rax
long long v9; // rcx
long long v10; // rdx
unsigned long long v11; // rdi
const char *v12; // rsi
long long v13; // rax
unsigned long long v14; // rsi
_BYTE v16[40]; // [rsp+0h] [rbp-70h] BYREF
long long v17; // [rsp+28h] [rbp-48h]
long long v18; // [rsp+40h] [rbp-30h]
int v19; // [rsp+50h] [rbp-20h]
unsigned long long v20; // [rsp+58h] [rbp-18h]
v20 = __readfsqword(0x28u);
v6 = *(_QWORD *)(*a1 + 88LL);
if ( v6 == -1 || *((_BYTE *)a1 + 826) )
{
*a3 = *(_QWORD *)(a1[1] + 40LL);
v7 = a2 - ((a2 < 0xFFED) - 1LL);
v8 = v7 + 3;
v9 = *a1;
v10 = a1[1];
v11 = *(_QWORD *)(*a1 + 352LL);
v12 = (const char *)((v7 + 6) & 0xFFFFFFFFFFFFFFFCLL);
if ( v8 < v11 )
v12 = *(const char **)(*a1 + 352LL);
if ( *(_QWORD *)(v10 + 40) > *(_QWORD *)(v9 + 272) - (_QWORD)v12 )
{
*(_DWORD *)my_thread_var(v11, v12) = 135;
return 0xFFFFFFFFLL;
}
v13 = 16777212LL;
if ( (unsigned long long)v12 < 0xFFFFFC )
v13 = (long long)v12;
*a4 = v13;
*(_QWORD *)(a1[1] + 40LL) += v13;
++*(_QWORD *)(*a1 + 80LL);
*((_BYTE *)a1 + 465) |= 1u;
}
else
{
*a3 = v6;
v19 = 0;
*((_DWORD *)a1 + 192) = 1;
v14 = *((unsigned int *)a1 + 112);
if ( (mi_get_block_info((long long)v16, v14, *(_QWORD *)(*a1 + 88LL)) & 4) == 0 )
{
*(_DWORD *)my_thread_var(v16, (const char *)v14) = 127;
return 0xFFFFFFFFLL;
}
*(_QWORD *)(*a1 + 88LL) = v18;
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= v17;
*a4 = v17;
}
return 0LL;
}
|
_mi_find_writepos:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RCX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x58]
CMP RAX,-0x1
JZ 0x00179e9a
CMP byte ptr [R14 + 0x33a],0x0
JZ 0x00179f16
LAB_00179e9a:
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RDX],RAX
CMP RSI,0xffed
SBB RSI,-0x1
LEA RAX,[RSI + 0x3]
MOV RCX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RCX + 0x160]
ADD RSI,0x6
AND RSI,-0x4
CMP RAX,RDI
CMOVC RSI,RDI
MOV RAX,qword ptr [RCX + 0x110]
SUB RAX,RSI
CMP qword ptr [RDX + 0x28],RAX
JBE 0x00179eee
CALL 0x001a1b22
MOV dword ptr [RAX],0x87
JMP 0x00179f51
LAB_00179eee:
MOV EAX,0xfffffc
CMP RSI,RAX
CMOVC RAX,RSI
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [R14 + 0x8]
ADD qword ptr [RCX + 0x28],RAX
MOV RAX,qword ptr [R14]
INC qword ptr [RAX + 0x50]
OR byte ptr [R14 + 0x1d1],0x1
JMP 0x00179f7e
LAB_00179f16:
MOV qword ptr [RDX],RAX
LEA RDI,[RBP + -0x70]
MOV dword ptr [RDI + 0x50],0x0
MOV dword ptr [R14 + 0x300],0x1
MOV ESI,dword ptr [R14 + 0x1c0]
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX + 0x58]
CALL 0x00178413
TEST AL,0x4
JNZ 0x00179f58
CALL 0x001a1b22
MOV dword ptr [RAX],0x7f
LAB_00179f51:
MOV EAX,0xffffffff
JMP 0x00179f80
LAB_00179f58:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [R14]
MOV qword ptr [RCX + 0x58],RAX
MOV RAX,qword ptr [R14 + 0x8]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [R14 + 0x8]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBX],RAX
LAB_00179f7e:
XOR EAX,EAX
LAB_00179f80:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x00179f98
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_00179f98:
CALL 0x00129270
|
int8 _mi_find_writepos(long *param_1,ulong param_2,long *param_3,ulong *param_4)
{
int4 *puVar1;
ulong uVar2;
int8 uVar3;
long lVar4;
ulong uVar5;
long in_FS_OFFSET;
int1 local_78 [40];
ulong local_50;
int8 local_38;
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 0x58) == -1) || (*(char *)((long)param_1 + 0x33a) != '\0')) {
*param_3 = *(long *)(param_1[1] + 0x28);
lVar4 = (param_2 + 1) - (ulong)(param_2 < 0xffed);
uVar2 = *(ulong *)(*param_1 + 0x160);
uVar5 = lVar4 + 6U & 0xfffffffffffffffc;
if (lVar4 + 3U < uVar2) {
uVar5 = uVar2;
}
if (*(ulong *)(param_1[1] + 0x28) <= *(long *)(*param_1 + 0x110) - uVar5) {
uVar2 = 0xfffffc;
if (uVar5 < 0xfffffc) {
uVar2 = uVar5;
}
*param_4 = uVar2;
*(long *)(param_1[1] + 0x28) = *(long *)(param_1[1] + 0x28) + uVar2;
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + 1;
*(byte *)((long)param_1 + 0x1d1) = *(byte *)((long)param_1 + 0x1d1) | 1;
LAB_00179f7e:
uVar3 = 0;
goto LAB_00179f80;
}
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x87;
}
else {
*param_3 = *(long *)(*param_1 + 0x58);
local_28 = 0;
*(int4 *)(param_1 + 0x60) = 1;
uVar2 = _mi_get_block_info(local_78,(int)param_1[0x38],*(int8 *)(*param_1 + 0x58));
if ((uVar2 & 4) != 0) {
*(int8 *)(*param_1 + 0x58) = local_38;
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - local_50;
*param_4 = local_50;
goto LAB_00179f7e;
}
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0x7f;
}
uVar3 = 0xffffffff;
LAB_00179f80:
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,026 |
int_token(char const*, unsigned int)
|
eloqsql/sql/sql_lex.cc
|
static inline uint int_token(const char *str,uint length)
{
if (length < long_len) // quick normal case
return NUM;
bool neg=0;
if (*str == '+') // Remove sign and pre-zeros
{
str++; length--;
}
else if (*str == '-')
{
str++; length--;
neg=1;
}
while (*str == '0' && length)
{
str++; length --;
}
if (length < long_len)
return NUM;
uint smaller,bigger;
const char *cmp;
if (neg)
{
if (length == long_len)
{
cmp= signed_long_str + 1;
smaller= NUM; // If <= signed_long_str
bigger= LONG_NUM; // If >= signed_long_str
}
else if (length < signed_longlong_len)
return LONG_NUM;
else if (length > signed_longlong_len)
return DECIMAL_NUM;
else
{
cmp= signed_longlong_str + 1;
smaller= LONG_NUM; // If <= signed_longlong_str
bigger=DECIMAL_NUM;
}
}
else
{
if (length == long_len)
{
cmp= long_str;
smaller=NUM;
bigger=LONG_NUM;
}
else if (length < longlong_len)
return LONG_NUM;
else if (length > longlong_len)
{
if (length > unsigned_longlong_len)
return DECIMAL_NUM;
cmp=unsigned_longlong_str;
smaller=ULONGLONG_NUM;
bigger=DECIMAL_NUM;
}
else
{
cmp=longlong_str;
smaller=LONG_NUM;
bigger= ULONGLONG_NUM;
}
}
while (*cmp && *cmp++ == *str++) ;
return ((uchar) str[-1] <= (uchar) cmp[-1]) ? smaller : bigger;
}
|
O0
|
cpp
|
int_token(char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jae 0x5859fd
movl $0x11c, -0x4(%rbp) # imm = 0x11C
jmp 0x585c03
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x585a24
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x585a4b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x585a49
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movb $0x1, -0x15(%rbp)
jmp 0x585a4b
jmp 0x585a4d
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x29(%rbp)
jne 0x585a68
cmpl $0x0, -0x14(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x585a71
jmp 0x585a88
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x585a4d
cmpl $0xa, -0x14(%rbp)
jae 0x585a9a
movl $0x11c, -0x4(%rbp) # imm = 0x11C
jmp 0x585c03
testb $0x1, -0x15(%rbp)
je 0x585b0f
cmpl $0xa, -0x14(%rbp)
jne 0x585ac5
movq 0xe5dbf3(%rip), %rax # 0x13e36a0
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl $0x11c, -0x1c(%rbp) # imm = 0x11C
movl $0x11a, -0x20(%rbp) # imm = 0x11A
jmp 0x585b0a
cmpl $0x13, -0x14(%rbp)
jae 0x585ad7
movl $0x11a, -0x4(%rbp) # imm = 0x11A
jmp 0x585c03
cmpl $0x13, -0x14(%rbp)
jbe 0x585ae9
movl $0x116, -0x4(%rbp) # imm = 0x116
jmp 0x585c03
movq 0xe5dbb8(%rip), %rax # 0x13e36a8
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl $0x11a, -0x1c(%rbp) # imm = 0x11A
movl $0x116, -0x20(%rbp) # imm = 0x116
jmp 0x585b08
jmp 0x585b0a
jmp 0x585b94
cmpl $0xa, -0x14(%rbp)
jne 0x585b30
movq 0xe5db94(%rip), %rax # 0x13e36b0
movq %rax, -0x28(%rbp)
movl $0x11c, -0x1c(%rbp) # imm = 0x11C
movl $0x11a, -0x20(%rbp) # imm = 0x11A
jmp 0x585b92
cmpl $0x13, -0x14(%rbp)
jae 0x585b42
movl $0x11a, -0x4(%rbp) # imm = 0x11A
jmp 0x585c03
cmpl $0x13, -0x14(%rbp)
jbe 0x585b75
cmpl $0x14, -0x14(%rbp)
jbe 0x585b5a
movl $0x116, -0x4(%rbp) # imm = 0x116
jmp 0x585c03
movq 0xe5db57(%rip), %rax # 0x13e36b8
movq %rax, -0x28(%rbp)
movl $0x11e, -0x1c(%rbp) # imm = 0x11E
movl $0x116, -0x20(%rbp) # imm = 0x116
jmp 0x585b8e
movq 0xe5db44(%rip), %rax # 0x13e36c0
movq %rax, -0x28(%rbp)
movl $0x11a, -0x1c(%rbp) # imm = 0x11A
movl $0x11e, -0x20(%rbp) # imm = 0x11E
jmp 0x585b90
jmp 0x585b92
jmp 0x585b94
jmp 0x585b96
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x2a(%rbp)
je 0x585bd0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x585bd9
jmp 0x585bdb
jmp 0x585b96
movq -0x10(%rbp), %rax
movzbl -0x1(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
cmpl %ecx, %eax
jg 0x585bf7
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x585bfd
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
_ZL9int_tokenPKcj:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
cmp [rbp+var_14], 0Ah
jnb short loc_5859FD
mov [rbp+var_4], 11Ch
jmp loc_585C03
loc_5859FD:
mov [rbp+var_15], 0
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_585A24
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
add eax, 0FFFFFFFFh
mov [rbp+var_14], eax
jmp short loc_585A4B
loc_585A24:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_585A49
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
add eax, 0FFFFFFFFh
mov [rbp+var_14], eax
mov [rbp+var_15], 1
loc_585A49:
jmp short $+2
loc_585A4B:
jmp short $+2
loc_585A4D:
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 30h ; '0'
mov [rbp+var_29], al
jnz short loc_585A68
cmp [rbp+var_14], 0
setnz al
mov [rbp+var_29], al
loc_585A68:
mov al, [rbp+var_29]
test al, 1
jnz short loc_585A71
jmp short loc_585A88
loc_585A71:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov eax, [rbp+var_14]
add eax, 0FFFFFFFFh
mov [rbp+var_14], eax
jmp short loc_585A4D
loc_585A88:
cmp [rbp+var_14], 0Ah
jnb short loc_585A9A
mov [rbp+var_4], 11Ch
jmp loc_585C03
loc_585A9A:
test [rbp+var_15], 1
jz short loc_585B0F
cmp [rbp+var_14], 0Ah
jnz short loc_585AC5
mov rax, cs:_ZL15signed_long_str; signed_long_str
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_1C], 11Ch
mov [rbp+var_20], 11Ah
jmp short loc_585B0A
loc_585AC5:
cmp [rbp+var_14], 13h
jnb short loc_585AD7
mov [rbp+var_4], 11Ah
jmp loc_585C03
loc_585AD7:
cmp [rbp+var_14], 13h
jbe short loc_585AE9
mov [rbp+var_4], 116h
jmp loc_585C03
loc_585AE9:
mov rax, cs:_ZL19signed_longlong_str; signed_longlong_str
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_1C], 11Ah
mov [rbp+var_20], 116h
jmp short $+2
loc_585B08:
jmp short $+2
loc_585B0A:
jmp loc_585B94
loc_585B0F:
cmp [rbp+var_14], 0Ah
jnz short loc_585B30
mov rax, cs:_ZL8long_str; long_str
mov [rbp+var_28], rax
mov [rbp+var_1C], 11Ch
mov [rbp+var_20], 11Ah
jmp short loc_585B92
loc_585B30:
cmp [rbp+var_14], 13h
jnb short loc_585B42
mov [rbp+var_4], 11Ah
jmp loc_585C03
loc_585B42:
cmp [rbp+var_14], 13h
jbe short loc_585B75
cmp [rbp+var_14], 14h
jbe short loc_585B5A
mov [rbp+var_4], 116h
jmp loc_585C03
loc_585B5A:
mov rax, cs:_ZL21unsigned_longlong_str; unsigned_longlong_str
mov [rbp+var_28], rax
mov [rbp+var_1C], 11Eh
mov [rbp+var_20], 116h
jmp short loc_585B8E
loc_585B75:
mov rax, cs:_ZL12longlong_str; longlong_str
mov [rbp+var_28], rax
mov [rbp+var_1C], 11Ah
mov [rbp+var_20], 11Eh
loc_585B8E:
jmp short $+2
loc_585B90:
jmp short $+2
loc_585B92:
jmp short $+2
loc_585B94:
jmp short $+2
loc_585B96:
mov rcx, [rbp+var_28]
xor eax, eax
cmp byte ptr [rcx], 0
mov [rbp+var_2A], al
jz short loc_585BD0
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
movsx ecx, byte ptr [rcx]
cmp eax, ecx
setz al
mov [rbp+var_2A], al
loc_585BD0:
mov al, [rbp+var_2A]
test al, 1
jnz short loc_585BD9
jmp short loc_585BDB
loc_585BD9:
jmp short loc_585B96
loc_585BDB:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax-1]
mov rcx, [rbp+var_28]
movzx ecx, byte ptr [rcx-1]
cmp eax, ecx
jg short loc_585BF7
mov eax, [rbp+var_1C]
mov [rbp+var_30], eax
jmp short loc_585BFD
loc_585BF7:
mov eax, [rbp+var_20]
mov [rbp+var_30], eax
loc_585BFD:
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
loc_585C03:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long int_token(const char *a1, unsigned int a2)
{
char *v2; // rax
const char *v3; // rcx
bool v6; // [rsp+6h] [rbp-2Ah]
bool v7; // [rsp+7h] [rbp-29h]
char *v8; // [rsp+8h] [rbp-28h]
unsigned int v9; // [rsp+10h] [rbp-20h]
unsigned int v10; // [rsp+14h] [rbp-1Ch]
char v11; // [rsp+1Bh] [rbp-15h]
unsigned int v12; // [rsp+1Ch] [rbp-14h]
const char *v13; // [rsp+20h] [rbp-10h]
v13 = a1;
v12 = a2;
if ( a2 >= 0xA )
{
v11 = 0;
if ( *a1 == 43 )
{
v13 = a1 + 1;
v12 = a2 - 1;
}
else if ( *a1 == 45 )
{
v13 = a1 + 1;
v12 = a2 - 1;
v11 = 1;
}
while ( 1 )
{
v7 = 0;
if ( *v13 == 48 )
v7 = v12 != 0;
if ( !v7 )
break;
++v13;
--v12;
}
if ( v12 >= 0xA )
{
if ( (v11 & 1) != 0 )
{
if ( v12 == 10 )
{
v8 = signed_long_str[0] + 1;
v10 = 284;
v9 = 282;
}
else
{
if ( v12 < 0x13 )
return 282;
if ( v12 > 0x13 )
return 278;
v8 = signed_longlong_str[0] + 1;
v10 = 282;
v9 = 278;
}
}
else if ( v12 == 10 )
{
v8 = long_str[0];
v10 = 284;
v9 = 282;
}
else
{
if ( v12 < 0x13 )
return 282;
if ( v12 <= 0x13 )
{
v8 = longlong_str[0];
v10 = 282;
v9 = 286;
}
else
{
if ( v12 > 0x14 )
return 278;
v8 = unsigned_longlong_str[0];
v10 = 286;
v9 = 278;
}
}
do
{
v6 = 0;
if ( *v8 )
{
v2 = v8++;
v3 = v13++;
v6 = *v2 == *v3;
}
}
while ( v6 );
if ( *((unsigned __int8 *)v13 - 1) > (int)(unsigned __int8)*(v8 - 1) )
return v9;
else
return v10;
}
else
{
return 284;
}
}
else
{
return 284;
}
}
|
__cxx_global_var_init.4:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1f0df38]
MOV ESI,0x10
CALL 0x0058cc10
POP RBP
RET
|
void __cxx_global_var_init_4(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_INTERVAL_DAY,0x10);
return;
}
|
|
5,027 |
inline_mysql_file_pread
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_pread:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x21c144(%rip), %rax # 0x289300
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x6, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6d2cf
leaq 0x21c0fa(%rip), %rax # 0x289300
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xbf320
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x6d27a
cmpq $0x0, -0x38(%rbp)
jne 0x6d25f
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x6d26a
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x6d26a
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x6d2a7
cmpq $-0x1, -0x38(%rbp)
je 0x6d28e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x6d299
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x6d299
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x21c052(%rip), %rax # 0x289300
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d2f3
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xbf320
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
|
inline_mysql_file_pread_4:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 6
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_6D2CF
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_6D27A
cmp [rbp+var_38], 0
jnz short loc_6D25F
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_6D26A
loc_6D25F:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_6D26A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_6D2A7
loc_6D27A:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_6D28E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_6D299
loc_6D28E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_6D299:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_6D2A7:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_6D2F3
loc_6D2CF:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_6D2F3:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long inline_mysql_file_pread_4(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 6LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pread(v16, v15, v14, v13, a7);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pread(v16, v15, v14, v13, a7);
}
}
|
inline_mysql_file_pread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x389300]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x6
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0016d2cf
LEA RAX,[0x389300]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001bf320
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x0016d27a
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0016d25f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0016d26a
LAB_0016d25f:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0016d26a
LAB_0016d26a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0016d2a7
LAB_0016d27a:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x0016d28e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0016d299
LAB_0016d28e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0016d299
LAB_0016d299:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_0016d2a7:
LEA RAX,[0x389300]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016d2f3
LAB_0016d2cf:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001bf320
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016d2f3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pread
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,6);
if (local_48 == 0) {
local_10 = my_pread(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pread(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
|
|
5,028 |
mi_decrement_open_count
|
eloqsql/storage/myisam/mi_locking.c
|
int _mi_decrement_open_count(MI_INFO *info)
{
uchar buff[2];
register MYISAM_SHARE *share=info->s;
int lock_error=0,write_error=0;
if (share->global_changed)
{
uint old_lock=info->lock_type;
share->global_changed=0;
lock_error= my_disable_locking ? 0 : mi_lock_database(info,F_WRLCK);
/* Its not fatal even if we couldn't get the lock ! */
if (share->state.open_count > 0)
{
share->state.open_count--;
mi_int2store(buff,share->state.open_count);
write_error= (mysql_file_pwrite(share->kfile, buff, sizeof(buff),
sizeof(share->state.header),
MYF(MY_NABP)) != 0);
}
if (!lock_error && !my_disable_locking)
lock_error=mi_lock_database(info,old_lock);
}
return MY_TEST(lock_error || write_error);
}
|
O0
|
c
|
mi_decrement_open_count:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x380(%rax)
je 0xb901c
movq -0x8(%rbp), %rax
movl 0x1f4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x380(%rax)
leaq 0xbd54f3(%rip), %rax # 0xc8e448
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb8f64
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb8f75
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xb7890
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xec(%rax)
jbe 0xb8ff9
movq -0x18(%rbp), %rax
movl 0xec(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xec(%rax)
movq -0x18(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0x9(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
movl 0x350(%rax), %edx
leaq -0xa(%rbp), %rcx
leaq 0xa2aba(%rip), %rdi # 0x15ba86
movl $0x28c, %esi # imm = 0x28C
movl $0x2, %r8d
movl $0x18, %r9d
movq $0x4, (%rsp)
callq 0xb8d90
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xb901a
leaq 0xbd5442(%rip), %rax # 0xc8e448
cmpb $0x0, (%rax)
jne 0xb901a
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xb7890
movl %eax, -0x1c(%rbp)
jmp 0xb901c
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2d(%rbp)
jne 0xb9031
cmpl $0x0, -0x20(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_mi_decrement_open_count:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
mov [rbp+var_20], 0
mov rax, [rbp+var_18]
cmp byte ptr [rax+380h], 0
jz loc_B901C
mov rax, [rbp+var_8]
mov eax, [rax+1F4h]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov byte ptr [rax+380h], 0
lea rax, my_disable_locking
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_B8F64
xor eax, eax
mov [rbp+var_2C], eax
jmp short loc_B8F75
loc_B8F64:
mov rdi, [rbp+var_8]
mov esi, 1
call mi_lock_database
mov [rbp+var_2C], eax
loc_B8F75:
mov eax, [rbp+var_2C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
cmp dword ptr [rax+0ECh], 0
jbe short loc_B8FF9
mov rax, [rbp+var_18]
mov ecx, [rax+0ECh]
add ecx, 0FFFFFFFFh
mov [rax+0ECh], ecx
mov rax, [rbp+var_18]
mov eax, [rax+0ECh]
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
mov [rbp+var_9], al
mov eax, [rbp+var_28]
shr eax, 8
mov [rbp+var_A], al
mov rax, [rbp+var_18]
mov edx, [rax+350h]
lea rcx, [rbp+var_A]
lea rdi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 28Ch
mov r8d, 2
mov r9d, 18h
mov [rsp+40h+var_40], 4
call inline_mysql_file_pwrite_1
cmp rax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_20], eax
loc_B8FF9:
cmp [rbp+var_1C], 0
jnz short loc_B901A
lea rax, my_disable_locking
cmp byte ptr [rax], 0
jnz short loc_B901A
mov rdi, [rbp+var_8]
mov esi, [rbp+var_24]
call mi_lock_database
mov [rbp+var_1C], eax
loc_B901A:
jmp short $+2
loc_B901C:
mov al, 1
cmp [rbp+var_1C], 0
mov [rbp+var_2D], al
jnz short loc_B9031
cmp [rbp+var_20], 0
setnz al
mov [rbp+var_2D], al
loc_B9031:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
add rsp, 40h
pop rbp
retn
|
_BOOL8 mi_decrement_open_count(_DWORD *a1)
{
__int16 v1; // kr00_2
bool v3; // [rsp+13h] [rbp-2Dh]
int v4; // [rsp+14h] [rbp-2Ch]
unsigned int v5; // [rsp+1Ch] [rbp-24h]
BOOL v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
long long v8; // [rsp+28h] [rbp-18h]
_BYTE v9[2]; // [rsp+36h] [rbp-Ah] BYREF
_DWORD *v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v8 = *(_QWORD *)a1;
v7 = 0;
v6 = 0;
if ( *(_BYTE *)(*(_QWORD *)a1 + 896LL) )
{
v5 = v10[125];
*(_BYTE *)(v8 + 896) = 0;
if ( my_disable_locking )
v4 = 0;
else
v4 = mi_lock_database(v10, (_BYTE *)&dword_0 + 1);
v7 = v4;
if ( *(_DWORD *)(v8 + 236) )
{
v1 = --*(_DWORD *)(v8 + 236);
v9[0] = HIBYTE(v1);
v9[1] = v1;
v6 = inline_mysql_file_pwrite_1(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x28Cu,
*(_DWORD *)(v8 + 848),
(long long)v9,
2LL,
24LL,
4LL) != 0;
}
if ( !v4 && !my_disable_locking )
v7 = mi_lock_database(v10, (const char *)v5);
}
v3 = 1;
if ( !v7 )
return v6;
return v3;
}
|
_mi_decrement_open_count:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x380],0x0
JZ 0x001b901c
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1f4]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x380],0x0
LEA RAX,[0xd8e448]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001b8f64
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001b8f75
LAB_001b8f64:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x001b7890
MOV dword ptr [RBP + -0x2c],EAX
LAB_001b8f75:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0xec],0x0
JBE 0x001b8ff9
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0xec]
ADD ECX,-0x1
MOV dword ptr [RAX + 0xec],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xec]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x9],AL
MOV EAX,dword ptr [RBP + -0x28]
SHR EAX,0x8
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0x350]
LEA RCX,[RBP + -0xa]
LEA RDI,[0x25ba86]
MOV ESI,0x28c
MOV R8D,0x2
MOV R9D,0x18
MOV qword ptr [RSP],0x4
CALL 0x001b8d90
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x20],EAX
LAB_001b8ff9:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x001b901a
LEA RAX,[0xd8e448]
CMP byte ptr [RAX],0x0
JNZ 0x001b901a
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x24]
CALL 0x001b7890
MOV dword ptr [RBP + -0x1c],EAX
LAB_001b901a:
JMP 0x001b901c
LAB_001b901c:
MOV AL,0x1
CMP dword ptr [RBP + -0x1c],0x0
MOV byte ptr [RBP + -0x2d],AL
JNZ 0x001b9031
CMP dword ptr [RBP + -0x20],0x0
SETNZ AL
MOV byte ptr [RBP + -0x2d],AL
LAB_001b9031:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
ADD RSP,0x40
POP RBP
RET
|
bool _mi_decrement_open_count(long *param_1)
{
int4 uVar1;
long lVar2;
bool bVar3;
int local_34;
int local_24;
int1 local_12;
int1 local_11;
long *local_10;
lVar2 = *param_1;
local_24 = 0;
bVar3 = false;
if (*(char *)(lVar2 + 0x380) != '\0') {
uVar1 = *(int4 *)((long)param_1 + 500);
*(int1 *)(lVar2 + 0x380) = 0;
local_10 = param_1;
if (my_disable_locking == '\0') {
local_34 = mi_lock_database(param_1,1);
}
else {
local_34 = 0;
}
local_24 = local_34;
if (*(int *)(lVar2 + 0xec) != 0) {
*(int *)(lVar2 + 0xec) = *(int *)(lVar2 + 0xec) + -1;
local_11 = (int1)*(int4 *)(lVar2 + 0xec);
local_12 = (int1)((uint)*(int4 *)(lVar2 + 0xec) >> 8);
lVar2 = inline_mysql_file_pwrite
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_locking.c",
0x28c,*(int4 *)(lVar2 + 0x350),&local_12,2,0x18,4);
bVar3 = lVar2 != 0;
}
if ((local_34 == 0) && (my_disable_locking == '\0')) {
local_24 = mi_lock_database(local_10,uVar1);
}
}
return local_24 != 0 || bVar3;
}
|
|
5,029 |
my_get_err_msg
|
eloqsql/mysys/my_error.c
|
const char *my_get_err_msg(uint nr)
{
const char *format;
struct my_err_head *meh_p;
/* Search for the range this error is in. */
for (meh_p= my_errmsgs_list; meh_p; meh_p= meh_p->meh_next)
if (nr <= meh_p->meh_last)
break;
/*
If we found the range this error number is in, get the format string.
If the string is empty, or a NULL pointer, or if we're out of return,
we return NULL.
*/
if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
!*format)
return NULL;
return format;
}
|
O3
|
c
|
my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x2eeb80(%rip), %r14 # 0x36f740
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0x80bf6
cmpl %ebx, 0x14(%r14)
jb 0x80bc2
cmpl %ebx, 0x10(%r14)
ja 0x80bf4
movl %ebx, %edi
callq *0x8(%r14)
subl 0x10(%r14), %ebx
movq (%rax,%rbx,8), %rcx
testq %rcx, %rcx
je 0x80bf4
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rcx, %rax
jmp 0x80bf6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_get_err_msg:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
lea r14, my_errmsgs_list
xor eax, eax
loc_80BC2:
mov r14, [r14]
test r14, r14
jz short loc_80BF6
cmp [r14+14h], ebx
jb short loc_80BC2
cmp [r14+10h], ebx
ja short loc_80BF4
mov edi, ebx
call qword ptr [r14+8]
sub ebx, [r14+10h]
mov rcx, [rax+rbx*8]
test rcx, rcx
jz short loc_80BF4
xor eax, eax
cmp byte ptr [rcx], 0
cmovnz rax, rcx
jmp short loc_80BF6
loc_80BF4:
xor eax, eax
loc_80BF6:
pop rbx
pop r14
pop rbp
retn
|
_BYTE * my_get_err_msg(unsigned int a1)
{
long long **v1; // r14
_BYTE *result; // rax
_BYTE *v3; // rcx
v1 = &my_errmsgs_list;
result = 0LL;
while ( 1 )
{
v1 = (long long **)*v1;
if ( !v1 )
break;
if ( *((_DWORD *)v1 + 5) >= a1 )
{
if ( *((_DWORD *)v1 + 4) > a1 )
return 0LL;
v3 = *(_BYTE **)(((long long ( *)(_QWORD))v1[1])(a1) + 8LL * (a1 - *((_DWORD *)v1 + 4)));
if ( !v3 )
return 0LL;
result = 0LL;
if ( *v3 )
return v3;
return result;
}
}
return result;
}
|
my_get_err_msg:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
LEA R14,[0x46f740]
XOR EAX,EAX
LAB_00180bc2:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x00180bf6
CMP dword ptr [R14 + 0x14],EBX
JC 0x00180bc2
CMP dword ptr [R14 + 0x10],EBX
JA 0x00180bf4
MOV EDI,EBX
CALL qword ptr [R14 + 0x8]
SUB EBX,dword ptr [R14 + 0x10]
MOV RCX,qword ptr [RAX + RBX*0x8]
TEST RCX,RCX
JZ 0x00180bf4
XOR EAX,EAX
CMP byte ptr [RCX],0x0
CMOVNZ RAX,RCX
JMP 0x00180bf6
LAB_00180bf4:
XOR EAX,EAX
LAB_00180bf6:
POP RBX
POP R14
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
char *pcVar1;
long lVar2;
int **ppuVar3;
ppuVar3 = &my_errmsgs_list;
do {
ppuVar3 = (int **)*ppuVar3;
if (ppuVar3 == (int **)0x0) {
return (char *)0x0;
}
} while (*(uint *)((long)ppuVar3 + 0x14) < param_1);
if (*(uint *)(ppuVar3 + 2) <= param_1) {
lVar2 = (*(code *)ppuVar3[1])(param_1);
pcVar1 = *(char **)(lVar2 + (ulong)(param_1 - *(int *)(ppuVar3 + 2)) * 8);
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\0') {
return (char *)0x0;
}
return pcVar1;
}
}
return (char *)0x0;
}
|
|
5,030 |
maria_ftparser_call_deinitializer
|
eloqsql/storage/maria/ma_ft_parser.c
|
void maria_ftparser_call_deinitializer(MARIA_HA *info)
{
uint i, j, keys= info->s->state.header.keys;
free_root(&info->ft_memroot, MYF(0));
if (! info->ftparser_param)
return;
for (i= 0; i < keys; i++)
{
MARIA_KEYDEF *keyinfo= &info->s->keyinfo[i];
for (j=0; j < MAX_PARAM_NR; j++)
{
MYSQL_FTPARSER_PARAM *ftparser_param=
&info->ftparser_param[keyinfo->ftkey_nr*MAX_PARAM_NR + j];
if (keyinfo->flag & HA_FULLTEXT && ftparser_param->mysql_add_word)
{
if (keyinfo->parser->deinit)
keyinfo->parser->deinit(ftparser_param);
ftparser_param->mysql_add_word= 0;
}
else
break;
}
}
}
|
O3
|
c
|
maria_ftparser_call_deinitializer:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movb 0x12(%rax), %r14b
addq $0x328, %rdi # imm = 0x328
xorl %esi, %esi
callq 0x9ee8f
cmpq $0x0, 0x368(%rbx)
setne %al
testb %r14b, %r14b
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x602da
movzbl %r14b, %eax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
movq (%rbx), %rax
imulq $0x118, %r12, %r13 # imm = 0x118
addq 0x570(%rax), %r13
movb $0x1, %r15b
xorl %eax, %eax
testb $-0x80, 0xa2(%r13)
je 0x602d1
movl 0xbc(%r13), %ecx
leal (%rax,%rcx,2), %r14d
shlq $0x6, %r14
addq 0x368(%rbx), %r14
cmpq $0x0, 0x8(%r14)
je 0x602d1
movq 0xd0(%r13), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x602b8
movq %r14, %rdi
callq *%rax
movq $0x0, 0x8(%r14)
movl $0x1, %eax
testb $0x1, %r15b
movl $0x0, %r15d
jne 0x6027c
incq %r12
cmpq -0x30(%rbp), %r12
jne 0x60266
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
|
maria_ftparser_call_deinitializer:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rax, [rdi]
mov r14b, [rax+12h]
add rdi, 328h
xor esi, esi
call free_root
cmp qword ptr [rbx+368h], 0
setnz al
test r14b, r14b
setnz cl
and cl, al
cmp cl, 1
jnz short loc_602DA
movzx eax, r14b
mov [rbp+var_30], rax
xor r12d, r12d
loc_60266:
mov rax, [rbx]
imul r13, r12, 118h
add r13, [rax+570h]
mov r15b, 1
xor eax, eax
loc_6027C:
test byte ptr [r13+0A2h], 80h
jz short loc_602D1
mov ecx, [r13+0BCh]
lea r14d, [rax+rcx*2]
shl r14, 6
add r14, [rbx+368h]
cmp qword ptr [r14+8], 0
jz short loc_602D1
mov rax, [r13+0D0h]
mov rax, [rax+18h]
test rax, rax
jz short loc_602B8
mov rdi, r14
call rax
loc_602B8:
mov qword ptr [r14+8], 0
mov eax, 1
test r15b, 1
mov r15d, 0
jnz short loc_6027C
loc_602D1:
inc r12
cmp r12, [rbp+var_30]
jnz short loc_60266
loc_602DA:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char maria_ftparser_call_deinitializer(_QWORD *a1)
{
unsigned __int8 v1; // r14
int v2; // eax
long long v3; // r12
long long v4; // r13
char v5; // r15
unsigned long long v6; // r14
void ( *v7)(unsigned long long); // rax
bool v8; // zf
long long v10; // [rsp+0h] [rbp-30h]
v1 = *(_BYTE *)(*a1 + 18LL);
free_root(a1 + 101, 0LL);
LOBYTE(v2) = a1[109] != 0LL;
if ( ((unsigned __int8)v2 & (v1 != 0)) == 1 )
{
v10 = v1;
v3 = 0LL;
do
{
v4 = *(_QWORD *)(*a1 + 1392LL) + 280 * v3;
v5 = 1;
v2 = 0;
do
{
if ( *(char *)(v4 + 162) >= 0 )
break;
v6 = a1[109] + ((unsigned long long)(unsigned int)(v2 + 2 * *(_DWORD *)(v4 + 188)) << 6);
if ( !*(_QWORD *)(v6 + 8) )
break;
v7 = *(void ( **)(unsigned long long))(*(_QWORD *)(v4 + 208) + 24LL);
if ( v7 )
v7(v6);
*(_QWORD *)(v6 + 8) = 0LL;
v2 = 1;
v8 = (v5 & 1) == 0;
v5 = 0;
}
while ( !v8 );
++v3;
}
while ( v3 != v10 );
}
return v2;
}
|
maria_ftparser_call_deinitializer:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV R14B,byte ptr [RAX + 0x12]
ADD RDI,0x328
XOR ESI,ESI
CALL 0x0019ee8f
CMP qword ptr [RBX + 0x368],0x0
SETNZ AL
TEST R14B,R14B
SETNZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x001602da
MOVZX EAX,R14B
MOV qword ptr [RBP + -0x30],RAX
XOR R12D,R12D
LAB_00160266:
MOV RAX,qword ptr [RBX]
IMUL R13,R12,0x118
ADD R13,qword ptr [RAX + 0x570]
MOV R15B,0x1
XOR EAX,EAX
LAB_0016027c:
TEST byte ptr [R13 + 0xa2],0x80
JZ 0x001602d1
MOV ECX,dword ptr [R13 + 0xbc]
LEA R14D,[RAX + RCX*0x2]
SHL R14,0x6
ADD R14,qword ptr [RBX + 0x368]
CMP qword ptr [R14 + 0x8],0x0
JZ 0x001602d1
MOV RAX,qword ptr [R13 + 0xd0]
MOV RAX,qword ptr [RAX + 0x18]
TEST RAX,RAX
JZ 0x001602b8
MOV RDI,R14
CALL RAX
LAB_001602b8:
MOV qword ptr [R14 + 0x8],0x0
MOV EAX,0x1
TEST R15B,0x1
MOV R15D,0x0
JNZ 0x0016027c
LAB_001602d1:
INC R12
CMP R12,qword ptr [RBP + -0x30]
JNZ 0x00160266
LAB_001602da:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void maria_ftparser_call_deinitializer(long *param_1)
{
byte bVar1;
code *pcVar2;
bool bVar3;
int iVar4;
ulong uVar5;
long lVar6;
long lVar7;
bool bVar8;
bVar1 = *(byte *)(*param_1 + 0x12);
free_root(param_1 + 0x65,0);
if (bVar1 != 0 && param_1[0x6d] != 0) {
uVar5 = 0;
do {
lVar6 = uVar5 * 0x118 + *(long *)(*param_1 + 0x570);
iVar4 = 0;
bVar3 = true;
do {
bVar8 = bVar3;
if ((*(byte *)(lVar6 + 0xa2) & 0x80) == 0) break;
lVar7 = (ulong)(uint)(iVar4 + *(int *)(lVar6 + 0xbc) * 2) * 0x40 + param_1[0x6d];
if (*(long *)(lVar7 + 8) == 0) break;
pcVar2 = *(code **)(*(long *)(lVar6 + 0xd0) + 0x18);
if (pcVar2 != (code *)0x0) {
(*pcVar2)(lVar7);
}
*(int8 *)(lVar7 + 8) = 0;
iVar4 = 1;
bVar3 = false;
} while (bVar8);
uVar5 = uVar5 + 1;
} while (uVar5 != bVar1);
}
return;
}
|
|
5,031 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object()
|
monkey531[P]llama/common/json.hpp
|
bool end_object()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_object());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_object():
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x46a58
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x46a74
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x6a97d(%rip), %rdi # 0xb13dc
leaq 0x648f8(%rip), %rdx # 0xab35e
leaq 0x6b969(%rip), %rcx # 0xb23d6
movl $0x1aeb, %esi # imm = 0x1AEB
jmp 0x46a8e
leaq 0x6a961(%rip), %rdi # 0xb13dc
leaq 0x648dc(%rip), %rdx # 0xab35e
leaq 0x6b8fb(%rip), %rcx # 0xb2384
movl $0x1aec, %esi # imm = 0x1AEC
xorl %eax, %eax
callq 0x23f60
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10end_objectEv:
push rax
mov rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_46A58
mov rcx, [rax-8]
cmp byte ptr [rcx], 1
jnz short loc_46A74
add rax, 0FFFFFFFFFFFFFFF8h
mov [rdi+10h], rax
mov al, 1
pop rcx
retn
loc_46A58:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1AEBh
jmp short loc_46A8E
loc_46A74:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
mov esi, 1AECh
loc_46A8E:
xor eax, eax
call _ggml_abort
nop
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_object(
long long a1)
{
long long v1; // rax
long long v3; // rsi
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v1 )
{
v3 = 6891LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6891LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
}
else
{
if ( **(_BYTE **)(v1 - 8) == 1 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
return 1;
}
v3 = 6892LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
6892LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_object()");
}
return nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v3);
}
|
end_object:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x00146a58
MOV RCX,qword ptr [RAX + -0x8]
CMP byte ptr [RCX],0x1
JNZ 0x00146a74
ADD RAX,-0x8
MOV qword ptr [RDI + 0x10],RAX
MOV AL,0x1
POP RCX
RET
LAB_00146a58:
LEA RDI,[0x1b13dc]
LEA RDX,[0x1ab35e]
LEA RCX,[0x1b23d6]
MOV ESI,0x1aeb
JMP 0x00146a8e
LAB_00146a74:
LEA RDI,[0x1b13dc]
LEA RDX,[0x1ab35e]
LEA RCX,[0x1b2384]
MOV ESI,0x1aec
LAB_00146a8e:
XOR EAX,EAX
CALL 0x00123f60
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_object() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_object(json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long lVar1;
char *pcVar2;
int8 uVar3;
lVar1 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar1) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1aeb;
}
else {
if (**(char **)(lVar1 + -8) == '\x01') {
*(long *)(this + 0x10) = lVar1 + -8;
return CONCAT71((int7)((ulong)(lVar1 + -8) >> 8),1);
}
pcVar2 = "ref_stack.back()->is_object()";
uVar3 = 0x1aec;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
5,032 |
my_thread_destroy_common_mutex
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_destroy_common_mutex(void)
{
mysql_mutex_destroy(&THR_LOCK_open);
mysql_mutex_destroy(&THR_LOCK_lock);
mysql_mutex_destroy(&THR_LOCK_myisam);
mysql_mutex_destroy(&THR_LOCK_myisam_mmap);
mysql_mutex_destroy(&THR_LOCK_heap);
mysql_mutex_destroy(&THR_LOCK_net);
mysql_mutex_destroy(&THR_LOCK_charset);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_destroy(&LOCK_localtime_r);
#endif
}
|
O3
|
c
|
my_thread_destroy_common_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xb6a3ef(%rip), %rbx # 0xc10660
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa628f
leaq 0x2e7f47(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a3ca(%rip), %rdi # 0xc10660
callq 0x2a0e0
leaq 0xb6a406(%rip), %rbx # 0xc106a8
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa62c0
leaq 0x2e7f16(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a3e1(%rip), %rdi # 0xc106a8
callq 0x2a0e0
leaq 0xb6a41d(%rip), %rbx # 0xc106f0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa62f1
leaq 0x2e7ee5(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a3f8(%rip), %rdi # 0xc106f0
callq 0x2a0e0
leaq 0xb6a434(%rip), %rbx # 0xc10738
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa6322
leaq 0x2e7eb4(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a40f(%rip), %rdi # 0xc10738
callq 0x2a0e0
leaq 0xb6a44b(%rip), %rbx # 0xc10780
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa6353
leaq 0x2e7e83(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a426(%rip), %rdi # 0xc10780
callq 0x2a0e0
leaq 0xb6a462(%rip), %rbx # 0xc107c8
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa6384
leaq 0x2e7e52(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a43d(%rip), %rdi # 0xc107c8
callq 0x2a0e0
leaq 0xb6a479(%rip), %rbx # 0xc10810
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa63b5
leaq 0x2e7e21(%rip), %rax # 0x38e1c8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6a454(%rip), %rdi # 0xc10810
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a0e0
|
my_thread_destroy_common_mutex:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, THR_LOCK_open
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A628F
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A628F:
lea rdi, THR_LOCK_open
call _pthread_mutex_destroy
lea rbx, THR_LOCK_lock
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A62C0
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A62C0:
lea rdi, THR_LOCK_lock
call _pthread_mutex_destroy
lea rbx, THR_LOCK_myisam
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A62F1
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A62F1:
lea rdi, THR_LOCK_myisam
call _pthread_mutex_destroy
lea rbx, THR_LOCK_myisam_mmap
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A6322
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A6322:
lea rdi, THR_LOCK_myisam_mmap
call _pthread_mutex_destroy
lea rbx, THR_LOCK_heap
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A6353
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A6353:
lea rdi, THR_LOCK_heap
call _pthread_mutex_destroy
lea rbx, THR_LOCK_net
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A6384
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A6384:
lea rdi, THR_LOCK_net
call _pthread_mutex_destroy
lea rbx, THR_LOCK_charset
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A63B5
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A63B5:
lea rdi, THR_LOCK_charset
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_destroy
|
long long my_thread_destroy_common_mutex()
{
long long v0; // rdi
long long v1; // rdi
long long v2; // rdi
long long v3; // rdi
long long v4; // rdi
long long v5; // rdi
long long v6; // rdi
v0 = THR_LOCK_open[8];
if ( v0 )
{
((void ( *)(long long))PSI_server[9])(v0);
THR_LOCK_open[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_open);
v1 = THR_LOCK_lock[8];
if ( v1 )
{
((void ( *)(long long))PSI_server[9])(v1);
THR_LOCK_lock[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_lock);
v2 = THR_LOCK_myisam[8];
if ( v2 )
{
((void ( *)(long long))PSI_server[9])(v2);
THR_LOCK_myisam[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_myisam);
v3 = THR_LOCK_myisam_mmap[8];
if ( v3 )
{
((void ( *)(long long))PSI_server[9])(v3);
THR_LOCK_myisam_mmap[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_myisam_mmap);
v4 = THR_LOCK_heap[8];
if ( v4 )
{
((void ( *)(long long))PSI_server[9])(v4);
THR_LOCK_heap[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_heap);
v5 = THR_LOCK_net[8];
if ( v5 )
{
((void ( *)(long long))PSI_server[9])(v5);
THR_LOCK_net[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_net);
v6 = THR_LOCK_charset[8];
if ( v6 )
{
((void ( *)(long long))PSI_server[9])(v6);
THR_LOCK_charset[8] = 0LL;
}
return pthread_mutex_destroy(THR_LOCK_charset);
}
|
my_thread_destroy_common_mutex:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0xd10660]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a628f
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a628f:
LEA RDI,[0xd10660]
CALL 0x0012a0e0
LEA RBX,[0xd106a8]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a62c0
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a62c0:
LEA RDI,[0xd106a8]
CALL 0x0012a0e0
LEA RBX,[0xd106f0]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a62f1
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a62f1:
LEA RDI,[0xd106f0]
CALL 0x0012a0e0
LEA RBX,[0xd10738]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a6322
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a6322:
LEA RDI,[0xd10738]
CALL 0x0012a0e0
LEA RBX,[0xd10780]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a6353
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a6353:
LEA RDI,[0xd10780]
CALL 0x0012a0e0
LEA RBX,[0xd107c8]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a6384
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a6384:
LEA RDI,[0xd107c8]
CALL 0x0012a0e0
LEA RBX,[0xd10810]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a63b5
LEA RAX,[0x48e1c8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a63b5:
LEA RDI,[0xd10810]
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0012a0e0
|
void my_thread_destroy_common_mutex(void)
{
if (THR_LOCK_open._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_open._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_open);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_lock._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_lock);
if (THR_LOCK_myisam._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_myisam._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_myisam);
if (THR_LOCK_myisam_mmap._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_myisam_mmap._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_myisam_mmap);
if (THR_LOCK_heap._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_heap._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_heap);
if (THR_LOCK_net._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_net._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_net);
if (THR_LOCK_charset._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_charset._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_charset);
return;
}
|
|
5,033 |
PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::apply(void (*)(PFS_user*))
|
eloqsql/storage/perfschema/pfs_buffer_container.h
|
void apply(function_type fct)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
if (pfs->m_lock.is_populated())
{
fct(pfs);
}
pfs++;
}
}
}
}
|
O0
|
c
|
PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::apply(void (*)(PFS_user*)):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0x342fc
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x342ec
movq -0x20(%rbp), %rdi
callq 0x34410
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34430
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x342ea
movq -0x28(%rbp), %rdi
addq $0x7e0, %rdi # imm = 0x7E0
callq 0x2d950
testb $0x1, %al
jne 0x342d0
jmp 0x342da
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x9c0, %rax # imm = 0x9C0
movq %rax, -0x28(%rbp)
jmp 0x342b0
jmp 0x342ec
jmp 0x342ee
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3426f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN29PFS_buffer_scalable_containerI8PFS_userLi128ELi128E14PFS_user_array18PFS_user_allocatorE5applyEPFvPS0_E:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_14], 0
loc_3426F:
cmp [rbp+var_14], 80h
jnb loc_342FC
mov rax, [rbp+var_38]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8+0A8h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_342EC
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI8PFS_userE9get_firstEv; PFS_buffer_default_array<PFS_user>::get_first(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI8PFS_userE8get_lastEv; PFS_buffer_default_array<PFS_user>::get_last(void)
mov [rbp+var_30], rax
loc_342B0:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_342EA
mov rdi, [rbp+var_28]
add rdi, 7E0h; this
call _ZN8pfs_lock12is_populatedEv; pfs_lock::is_populated(void)
test al, 1
jnz short loc_342D0
jmp short loc_342DA
loc_342D0:
mov rax, [rbp+var_10]
mov rdi, [rbp+var_28]
call rax
loc_342DA:
mov rax, [rbp+var_28]
add rax, 9C0h
mov [rbp+var_28], rax
jmp short loc_342B0
loc_342EA:
jmp short $+2
loc_342EC:
jmp short $+2
loc_342EE:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_3426F
loc_342FC:
add rsp, 40h
pop rbp
retn
|
long long PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::apply(
long long a1,
unsigned int *a2)
{
long long result; // rax
unsigned long long last; // [rsp+10h] [rbp-30h]
unsigned long long first; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
result = a1;
for ( i = 0; i < 0x80; ++i )
{
v5 = *(_QWORD *)(a1 + 8LL * i + 168);
if ( v5 )
{
first = PFS_buffer_default_array<PFS_user>::get_first(v5);
last = PFS_buffer_default_array<PFS_user>::get_last(v5);
while ( first < last )
{
if ( pfs_lock::is_populated((pfs_lock *)(first + 2016), a2) )
((void ( *)(unsigned long long))a2)(first);
first += 2496LL;
}
}
result = i + 1;
}
return result;
}
|
apply:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_0013426f:
CMP dword ptr [RBP + -0x14],0x80
JNC 0x001342fc
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001342ec
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00134410
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00134430
MOV qword ptr [RBP + -0x30],RAX
LAB_001342b0:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001342ea
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x7e0
CALL 0x0012d950
TEST AL,0x1
JNZ 0x001342d0
JMP 0x001342da
LAB_001342d0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
LAB_001342da:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x9c0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001342b0
LAB_001342ea:
JMP 0x001342ec
LAB_001342ec:
JMP 0x001342ee
LAB_001342ee:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0013426f
LAB_001342fc:
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_user, 128, 128, PFS_user_array, PFS_user_allocator>::apply(void
(*)(PFS_user*)) */
void __thiscall
PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::apply
(PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator> *this,
_func_void_PFS_user_ptr *param_1)
{
PFS_buffer_default_array<PFS_user> *this_00;
PFS_user *pPVar1;
ulong uVar2;
PFS_user *local_30;
uint local_1c;
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
this_00 = *(PFS_buffer_default_array<PFS_user> **)(this + (ulong)local_1c * 8 + 0xa8);
if (this_00 != (PFS_buffer_default_array<PFS_user> *)0x0) {
local_30 = (PFS_user *)PFS_buffer_default_array<PFS_user>::get_first(this_00);
pPVar1 = (PFS_user *)PFS_buffer_default_array<PFS_user>::get_last(this_00);
for (; local_30 < pPVar1; local_30 = local_30 + 0x9c0) {
uVar2 = pfs_lock::is_populated((pfs_lock *)(local_30 + 0x7e0));
if ((uVar2 & 1) != 0) {
(*param_1)(local_30);
}
}
}
}
return;
}
|
|
5,034 |
main
|
eloqsql/unittest/mysys/thr_template.c
|
int main(int argc __attribute__((unused)), char **argv)
{
MY_INIT(argv[0]);
if (argv[1] && *argv[1])
DBUG_SET_INITIAL(argv[1]);
pthread_mutex_init(&mutex, 0);
#define CYCLES 30000
#define THREADS 30
diag("N CPUs: %d", my_getncpus());
do_tests();
pthread_mutex_destroy(&mutex);
my_end(0);
return exit_status();
}
|
O3
|
c
|
main:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rsi), %rax
leaq 0x341683(%rip), %rcx # 0x366e80
movq %rax, (%rcx)
callq 0x268dc
leaq 0x3413c4(%rip), %rbx # 0x366bd0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x244b0
callq 0x28604
leaq 0x379b6(%rip), %rdi # 0x5d1d8
movl %eax, %esi
xorl %eax, %eax
callq 0x25dd7
callq 0x25b9a
movq %rbx, %rdi
callq 0x24370
xorl %edi, %edi
callq 0x26a77
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2649b
|
main:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rsi]
lea rcx, my_progname
mov [rcx], rax
call my_init
lea rbx, mutex
mov rdi, rbx
xor esi, esi
call _pthread_mutex_init
call my_getncpus
lea rdi, aNCpusD; "N CPUs: %d"
mov esi, eax
xor eax, eax
call diag
call do_tests
mov rdi, rbx
call _pthread_mutex_destroy
xor edi, edi
call my_end
add rsp, 8
pop rbx
pop rbp
jmp exit_status
|
int main(int argc, const char **argv, const char **envp)
{
int v3; // eax
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
my_progname = *argv;
my_init(argc, argv, envp);
pthread_mutex_init(&mutex, 0LL);
v3 = my_getncpus();
diag((unsigned int)"N CPUs: %d", v3, v4, v5, v6, v7);
do_tests();
pthread_mutex_destroy(&mutex);
my_end(0LL);
return exit_status();
}
|
main:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RSI]
LEA RCX,[0x466e80]
MOV qword ptr [RCX],RAX
CALL 0x001268dc
LEA RBX,[0x466bd0]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001244b0
CALL 0x00128604
LEA RDI,[0x15d1d8]
MOV ESI,EAX
XOR EAX,EAX
CALL 0x00125dd7
CALL 0x00125b9a
MOV RDI,RBX
CALL 0x00124370
XOR EDI,EDI
CALL 0x00126a77
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0012649b
|
void main(int8 param_1,int8 *param_2)
{
int4 uVar1;
my_progname = *param_2;
my_init();
pthread_mutex_init((pthread_mutex_t *)mutex,(pthread_mutexattr_t *)0x0);
uVar1 = my_getncpus();
diag("N CPUs: %d",uVar1);
do_tests();
pthread_mutex_destroy((pthread_mutex_t *)mutex);
my_end(0);
exit_status();
return;
}
|
|
5,035 |
dbuf_printf
|
bluesky950520[P]quickjs/cutils.c
|
int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
const char *fmt, ...)
{
va_list ap;
char buf[128];
int len;
va_start(ap, fmt);
len = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (len < (int)sizeof(buf)) {
/* fast case */
return dbuf_put(s, (uint8_t *)buf, len);
} else {
if (dbuf_realloc(s, s->size + len + 1))
return -1;
va_start(ap, fmt);
vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
fmt, ap);
va_end(ap);
s->size += len;
}
return 0;
}
|
O0
|
c
|
dbuf_printf:
subq $0x178, %rsp # imm = 0x178
testb %al, %al
je 0x1e78c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x168(%rsp)
movq %rsi, 0x160(%rsp)
leaq 0x140(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x180(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0xc0(%rsp), %rdi
movq 0x160(%rsp), %rdx
leaq 0x140(%rsp), %rcx
movl $0x80, %esi
callq 0xe190
movl %eax, 0xbc(%rsp)
leaq 0x140(%rsp), %rax
cmpl $0x80, 0xbc(%rsp)
jge 0x1e83f
movq 0x168(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movslq 0xbc(%rsp), %rdx
callq 0x1e550
movl %eax, 0x174(%rsp)
jmp 0x1e913
movq 0x168(%rsp), %rdi
movq 0x168(%rsp), %rax
movq 0x8(%rax), %rsi
movslq 0xbc(%rsp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x1e3f0
cmpl $0x0, %eax
je 0x1e87c
movl $0xffffffff, 0x174(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e913
leaq 0x140(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x180(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x168(%rsp), %rax
movq (%rax), %rdi
movq 0x168(%rsp), %rax
addq 0x8(%rax), %rdi
movq 0x168(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x168(%rsp), %rax
subq 0x8(%rax), %rsi
movq 0x160(%rsp), %rdx
leaq 0x140(%rsp), %rcx
callq 0xe190
leaq 0x140(%rsp), %rax
movslq 0xbc(%rsp), %rcx
movq 0x168(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x174(%rsp)
movl 0x174(%rsp), %eax
addq $0x178, %rsp # imm = 0x178
retq
nopw %cs:(%rax,%rax)
|
dbuf_printf:
sub rsp, 178h
test al, al
jz short loc_1E78C
movaps [rsp+178h+var_148], xmm0
movaps [rsp+178h+var_138], xmm1
movaps [rsp+178h+var_128], xmm2
movaps [rsp+178h+var_118], xmm3
movaps [rsp+178h+var_108], xmm4
movaps [rsp+178h+var_F8], xmm5
movaps [rsp+178h+var_E8], xmm6
movaps [rsp+178h+var_D8], xmm7
loc_1E78C:
mov [rsp+178h+var_150], r9
mov [rsp+178h+var_158], r8
mov [rsp+178h+var_160], rcx
mov [rsp+178h+var_168], rdx
mov [rsp+178h+var_10], rdi
mov [rsp+178h+var_18], rsi
lea rax, [rsp+178h+var_38]
mov rcx, rsp
mov [rax+10h], rcx
lea rcx, [rsp+178h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rdi, [rsp+178h+var_B8]
mov rdx, [rsp+178h+var_18]
lea rcx, [rsp+178h+var_38]
mov esi, 80h
call _vsnprintf
mov [rsp+178h+var_BC], eax
lea rax, [rsp+178h+var_38]
cmp [rsp+178h+var_BC], 80h
jge short loc_1E83F
mov rdi, [rsp+178h+var_10]
lea rsi, [rsp+178h+var_B8]
movsxd rdx, [rsp+178h+var_BC]
call dbuf_put
mov [rsp+178h+var_4], eax
jmp loc_1E913
loc_1E83F:
mov rdi, [rsp+178h+var_10]
mov rax, [rsp+178h+var_10]
mov rsi, [rax+8]
movsxd rax, [rsp+178h+var_BC]
add rsi, rax
add rsi, 1
call dbuf_realloc
cmp eax, 0
jz short loc_1E87C
mov [rsp+178h+var_4], 0FFFFFFFFh
jmp loc_1E913
loc_1E87C:
lea rax, [rsp+178h+var_38]
mov rcx, rsp
mov [rax+10h], rcx
lea rcx, [rsp+178h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov rax, [rsp+178h+var_10]
mov rdi, [rax]
mov rax, [rsp+178h+var_10]
add rdi, [rax+8]
mov rax, [rsp+178h+var_10]
mov rsi, [rax+10h]
mov rax, [rsp+178h+var_10]
sub rsi, [rax+8]
mov rdx, [rsp+178h+var_18]
lea rcx, [rsp+178h+var_38]
call _vsnprintf
lea rax, [rsp+178h+var_38]
movsxd rcx, [rsp+178h+var_BC]
mov rax, [rsp+178h+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov [rsp+178h+var_4], 0
loc_1E913:
mov eax, [rsp+178h+var_4]
add rsp, 178h
retn
|
long long dbuf_printf(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_QWORD v16[6]; // [rsp+0h] [rbp-178h] BYREF
__m128 v17; // [rsp+30h] [rbp-148h]
__m128 v18; // [rsp+40h] [rbp-138h]
__m128 v19; // [rsp+50h] [rbp-128h]
__m128 v20; // [rsp+60h] [rbp-118h]
__m128 v21; // [rsp+70h] [rbp-108h]
__m128 v22; // [rsp+80h] [rbp-F8h]
__m128 v23; // [rsp+90h] [rbp-E8h]
__m128 v24; // [rsp+A0h] [rbp-D8h]
int v25; // [rsp+BCh] [rbp-BCh]
_BYTE v26[128]; // [rsp+C0h] [rbp-B8h] BYREF
int v27; // [rsp+140h] [rbp-38h] BYREF
int v28; // [rsp+144h] [rbp-34h]
char *v29; // [rsp+148h] [rbp-30h]
_QWORD *v30; // [rsp+150h] [rbp-28h]
long long v31; // [rsp+160h] [rbp-18h]
_QWORD *v32; // [rsp+168h] [rbp-10h]
v17 = a7;
v18 = a8;
v19 = a9;
v20 = a10;
v21 = a11;
v22 = a12;
v23 = a13;
v24 = a14;
v16[5] = a6;
v16[4] = a5;
v16[3] = a4;
v16[2] = a3;
v32 = a1;
v31 = a2;
v30 = v16;
v29 = &a15;
v28 = 48;
v27 = 16;
v25 = vsnprintf(v26, 128LL, a2, &v27);
if ( v25 >= 128 )
{
if ( (unsigned int)dbuf_realloc((long long)v32, v25 + v32[1] + 1LL) )
{
return (unsigned int)-1;
}
else
{
v30 = v16;
v29 = &a15;
v28 = 48;
v27 = 16;
vsnprintf(v32[1] + *v32, v32[2] - v32[1], v31, &v27);
v32[1] += v25;
return 0;
}
}
else
{
return (unsigned int)dbuf_put(v32, (long long)v26, v25);
}
}
|
dbuf_printf:
SUB RSP,0x178
TEST AL,AL
JZ 0x0011e78c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_0011e78c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x168],RDI
MOV qword ptr [RSP + 0x160],RSI
LEA RAX,[RSP + 0x140]
MOV RCX,RSP
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x180]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RDI,[RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0x160]
LEA RCX,[RSP + 0x140]
MOV ESI,0x80
CALL 0x0010e190
MOV dword ptr [RSP + 0xbc],EAX
LEA RAX,[RSP + 0x140]
CMP dword ptr [RSP + 0xbc],0x80
JGE 0x0011e83f
MOV RDI,qword ptr [RSP + 0x168]
LEA RSI,[RSP + 0xc0]
MOVSXD RDX,dword ptr [RSP + 0xbc]
CALL 0x0011e550
MOV dword ptr [RSP + 0x174],EAX
JMP 0x0011e913
LAB_0011e83f:
MOV RDI,qword ptr [RSP + 0x168]
MOV RAX,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RAX + 0x8]
MOVSXD RAX,dword ptr [RSP + 0xbc]
ADD RSI,RAX
ADD RSI,0x1
CALL 0x0011e3f0
CMP EAX,0x0
JZ 0x0011e87c
MOV dword ptr [RSP + 0x174],0xffffffff
JMP 0x0011e913
LAB_0011e87c:
LEA RAX,[RSP + 0x140]
MOV RCX,RSP
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x180]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV RAX,qword ptr [RSP + 0x168]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x168]
ADD RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x168]
SUB RSI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RSP + 0x160]
LEA RCX,[RSP + 0x140]
CALL 0x0010e190
LEA RAX,[RSP + 0x140]
MOVSXD RCX,dword ptr [RSP + 0xbc]
MOV RAX,qword ptr [RSP + 0x168]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RSP + 0x174],0x0
LAB_0011e913:
MOV EAX,dword ptr [RSP + 0x174]
ADD RSP,0x178
RET
|
int4
dbuf_printf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,long *param_9
,char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
int iVar1;
int1 auStack_178 [16];
int8 local_168;
int8 local_160;
int8 local_158;
int8 local_150;
int8 local_148;
int8 local_138;
int8 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int local_bc;
char local_b8 [128];
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
char *local_18;
long *local_10;
int4 local_4;
local_28 = auStack_178;
if (in_AL != '\0') {
local_148 = param_1;
local_138 = param_2;
local_128 = param_3;
local_118 = param_4;
local_108 = param_5;
local_f8 = param_6;
local_e8 = param_7;
local_d8 = param_8;
}
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_168 = param_11;
local_160 = param_12;
local_158 = param_13;
local_150 = param_14;
local_18 = param_10;
local_10 = param_9;
local_bc = vsnprintf(local_b8,0x80,param_10,&local_38);
if (local_bc < 0x80) {
local_4 = dbuf_put(local_10,local_b8,(long)local_bc);
}
else {
iVar1 = dbuf_realloc(local_10,local_10[1] + (long)local_bc + 1);
if (iVar1 == 0) {
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_28 = auStack_178;
vsnprintf((char *)(*local_10 + local_10[1]),local_10[2] - local_10[1],local_18,&local_38);
local_10[1] = (long)local_bc + local_10[1];
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
}
return local_4;
}
|
|
5,036 |
dbuf_printf
|
bluesky950520[P]quickjs/cutils.c
|
int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
const char *fmt, ...)
{
va_list ap;
char buf[128];
int len;
va_start(ap, fmt);
len = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (len < (int)sizeof(buf)) {
/* fast case */
return dbuf_put(s, (uint8_t *)buf, len);
} else {
if (dbuf_realloc(s, s->size + len + 1))
return -1;
va_start(ap, fmt);
vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
fmt, ap);
va_end(ap);
s->size += len;
}
return 0;
}
|
O1
|
c
|
dbuf_printf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x1b582
movaps %xmm0, 0xd0(%rsp)
movaps %xmm1, 0xe0(%rsp)
movaps %xmm2, 0xf0(%rsp)
movaps %xmm3, 0x100(%rsp)
movaps %xmm4, 0x110(%rsp)
movaps %xmm5, 0x120(%rsp)
movaps %xmm6, 0x130(%rsp)
movaps %xmm7, 0x140(%rsp)
movabsq $0x3000000010, %r12 # imm = 0x3000000010
movq %rsp, %rcx
movq %r12, (%rcx)
leaq 0x190(%rsp), %r13
movq %r13, 0x8(%rcx)
movq %r15, 0x10(%rcx)
leaq 0x20(%rsp), %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0xe190
cmpl $0x7f, %eax
jg 0x1b5cb
movslq %eax, %rdx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b422
jmp 0x1b618
movq 0x8(%rbx), %rcx
movl %eax, %ebp
leaq (%rcx,%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x1b375
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1b618
movq %rsp, %rcx
movq %r15, 0x10(%rcx)
movq %r13, 0x8(%rcx)
movq %r12, (%rcx)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rsi
movq (%rbx), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r14, %rdx
callq 0xe190
addq %rbp, 0x8(%rbx)
xorl %eax, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
dbuf_printf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 158h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+188h+var_E8]
mov [r15+10h], rdx
mov [r15+18h], rcx
mov [r15+20h], r8
mov [r15+28h], r9
test al, al
jz short loc_1B582
movaps [rsp+188h+var_B8], xmm0
movaps [rsp+188h+var_A8], xmm1
movaps [rsp+188h+var_98], xmm2
movaps [rsp+188h+var_88], xmm3
movaps [rsp+188h+var_78], xmm4
movaps [rsp+188h+var_68], xmm5
movaps [rsp+188h+var_58], xmm6
movaps [rsp+188h+var_48], xmm7
loc_1B582:
mov r12, 3000000010h
mov rcx, rsp
mov [rcx], r12
lea r13, [rsp+188h+arg_0]
mov [rcx+8], r13
mov [rcx+10h], r15
lea rdi, [rsp+188h+var_168]
mov esi, 80h
mov rdx, r14
call _vsnprintf
cmp eax, 7Fh
jg short loc_1B5CB
movsxd rdx, eax
lea rsi, [rsp+188h+var_168]
mov rdi, rbx
call dbuf_put
jmp short loc_1B618
loc_1B5CB:
mov rcx, [rbx+8]
mov ebp, eax
lea rsi, [rcx+rbp]
inc rsi
mov rdi, rbx
call dbuf_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_1B618
mov rcx, rsp
mov [rcx+10h], r15
mov [rcx+8], r13
mov [rcx], r12
mov rax, [rbx+8]
mov rsi, [rbx+10h]
mov rdi, [rbx]
add rdi, rax
sub rsi, rax
mov rdx, r14
call _vsnprintf
add [rbx+8], rbp
xor eax, eax
loc_1B618:
add rsp, 158h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long dbuf_printf(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
int v15; // eax
long long result; // rax
long long v17; // rbp
int v18; // ecx
long long v19; // r8
long long v20; // r9
long long v21; // [rsp+0h] [rbp-188h] BYREF
char *v22; // [rsp+8h] [rbp-180h]
_BYTE *v23; // [rsp+10h] [rbp-178h]
_BYTE v24[128]; // [rsp+20h] [rbp-168h] BYREF
_BYTE v25[16]; // [rsp+A0h] [rbp-E8h] BYREF
long long v26; // [rsp+B0h] [rbp-D8h]
long long v27; // [rsp+B8h] [rbp-D0h]
long long v28; // [rsp+C0h] [rbp-C8h]
long long v29; // [rsp+C8h] [rbp-C0h]
__m128 v30; // [rsp+D0h] [rbp-B8h]
__m128 v31; // [rsp+E0h] [rbp-A8h]
__m128 v32; // [rsp+F0h] [rbp-98h]
__m128 v33; // [rsp+100h] [rbp-88h]
__m128 v34; // [rsp+110h] [rbp-78h]
__m128 v35; // [rsp+120h] [rbp-68h]
__m128 v36; // [rsp+130h] [rbp-58h]
__m128 v37; // [rsp+140h] [rbp-48h]
v30 = a7;
v31 = a8;
v32 = a9;
v33 = a10;
v34 = a11;
v35 = a12;
v36 = a13;
v37 = a14;
v26 = a3;
v27 = a4;
v28 = a5;
v29 = a6;
v21 = 0x3000000010LL;
v22 = &a15;
v23 = v25;
v15 = ((long long ( *)(_BYTE *, long long, long long, long long *))vsnprintf)(v24, 128LL, a2, &v21);
if ( v15 <= 127 )
return dbuf_put(a1, (long long)v24, v15);
v17 = (unsigned int)v15;
v18 = dbuf_realloc((long long)a1, a1[1] + (unsigned int)v15 + 1LL);
result = 0xFFFFFFFFLL;
if ( !v18 )
{
v23 = v25;
v22 = &a15;
v21 = 0x3000000010LL;
((void ( *)(_QWORD, _QWORD, long long, long long *, long long, long long))vsnprintf)(
a1[1] + *a1,
a1[2] - a1[1],
a2,
&v21,
v19,
v20);
a1[1] += v17;
return 0LL;
}
return result;
}
| |||
5,037 |
dbuf_printf
|
bluesky950520[P]quickjs/cutils.c
|
int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
const char *fmt, ...)
{
va_list ap;
char buf[128];
int len;
va_start(ap, fmt);
len = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (len < (int)sizeof(buf)) {
/* fast case */
return dbuf_put(s, (uint8_t *)buf, len);
} else {
if (dbuf_realloc(s, s->size + len + 1))
return -1;
va_start(ap, fmt);
vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
fmt, ap);
va_end(ap);
s->size += len;
}
return 0;
}
|
O2
|
c
|
dbuf_printf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x15de3
movaps %xmm0, 0xd0(%rsp)
movaps %xmm1, 0xe0(%rsp)
movaps %xmm2, 0xf0(%rsp)
movaps %xmm3, 0x100(%rsp)
movaps %xmm4, 0x110(%rsp)
movaps %xmm5, 0x120(%rsp)
movaps %xmm6, 0x130(%rsp)
movaps %xmm7, 0x140(%rsp)
movabsq $0x3000000010, %r12 # imm = 0x3000000010
movq %rsp, %rcx
movq %r12, (%rcx)
leaq 0x190(%rsp), %r13
movq %r13, 0x8(%rcx)
movq %r15, 0x10(%rcx)
leaq 0x20(%rsp), %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0xe1a0
cmpl $0x7f, %eax
jg 0x15e2c
movslq %eax, %rdx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x15c88
jmp 0x15e77
movq 0x8(%rbx), %rcx
movl %eax, %ebp
leaq (%rcx,%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x15bdf
testl %eax, %eax
je 0x15e4a
pushq $-0x1
popq %rax
jmp 0x15e77
movq %rsp, %rcx
movq %r15, 0x10(%rcx)
movq %r13, 0x8(%rcx)
movq %r12, (%rcx)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rsi
movq (%rbx), %rdi
addq %rax, %rdi
subq %rax, %rsi
movq %r14, %rdx
callq 0xe1a0
addq %rbp, 0x8(%rbx)
xorl %eax, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
dbuf_printf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 158h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+188h+var_E8]
mov [r15+10h], rdx
mov [r15+18h], rcx
mov [r15+20h], r8
mov [r15+28h], r9
test al, al
jz short loc_15DE3
movaps [rsp+188h+var_B8], xmm0
movaps [rsp+188h+var_A8], xmm1
movaps [rsp+188h+var_98], xmm2
movaps [rsp+188h+var_88], xmm3
movaps [rsp+188h+var_78], xmm4
movaps [rsp+188h+var_68], xmm5
movaps [rsp+188h+var_58], xmm6
movaps [rsp+188h+var_48], xmm7
loc_15DE3:
mov r12, 3000000010h
mov rcx, rsp
mov [rcx], r12
lea r13, [rsp+188h+arg_0]
mov [rcx+8], r13
mov [rcx+10h], r15
lea rdi, [rsp+188h+var_168]
mov esi, 80h
mov rdx, r14
call _vsnprintf
cmp eax, 7Fh
jg short loc_15E2C
movsxd rdx, eax
lea rsi, [rsp+188h+var_168]
mov rdi, rbx
call dbuf_put
jmp short loc_15E77
loc_15E2C:
mov rcx, [rbx+8]
mov ebp, eax
lea rsi, [rcx+rbp]
inc rsi
mov rdi, rbx
call dbuf_realloc
test eax, eax
jz short loc_15E4A
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_15E77
loc_15E4A:
mov rcx, rsp
mov [rcx+10h], r15
mov [rcx+8], r13
mov [rcx], r12
mov rax, [rbx+8]
mov rsi, [rbx+10h]
mov rdi, [rbx]
add rdi, rax
sub rsi, rax
mov rdx, r14
call _vsnprintf
add [rbx+8], rbp
xor eax, eax
loc_15E77:
add rsp, 158h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long dbuf_printf(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
int v15; // eax
long long v17; // rbp
long long v18; // r8
long long v19; // r9
long long v20; // [rsp+0h] [rbp-188h] BYREF
char *v21; // [rsp+8h] [rbp-180h]
_BYTE *v22; // [rsp+10h] [rbp-178h]
_BYTE v23[128]; // [rsp+20h] [rbp-168h] BYREF
_BYTE v24[16]; // [rsp+A0h] [rbp-E8h] BYREF
long long v25; // [rsp+B0h] [rbp-D8h]
long long v26; // [rsp+B8h] [rbp-D0h]
long long v27; // [rsp+C0h] [rbp-C8h]
long long v28; // [rsp+C8h] [rbp-C0h]
__m128 v29; // [rsp+D0h] [rbp-B8h]
__m128 v30; // [rsp+E0h] [rbp-A8h]
__m128 v31; // [rsp+F0h] [rbp-98h]
__m128 v32; // [rsp+100h] [rbp-88h]
__m128 v33; // [rsp+110h] [rbp-78h]
__m128 v34; // [rsp+120h] [rbp-68h]
__m128 v35; // [rsp+130h] [rbp-58h]
__m128 v36; // [rsp+140h] [rbp-48h]
v29 = a7;
v30 = a8;
v31 = a9;
v32 = a10;
v33 = a11;
v34 = a12;
v35 = a13;
v36 = a14;
v25 = a3;
v26 = a4;
v27 = a5;
v28 = a6;
v20 = 0x3000000010LL;
v21 = &a15;
v22 = v24;
v15 = ((long long ( *)(_BYTE *, long long, long long, long long *))vsnprintf)(v23, 128LL, a2, &v20);
if ( v15 <= 127 )
return dbuf_put(a1, (long long)v23, v15);
v17 = (unsigned int)v15;
if ( (unsigned int)dbuf_realloc((long long)a1, a1[1] + (unsigned int)v15 + 1LL) )
return -1LL;
v22 = v24;
v21 = &a15;
v20 = 0x3000000010LL;
((void ( *)(_QWORD, _QWORD, long long, long long *, long long, long long))vsnprintf)(
a1[1] + *a1,
a1[2] - a1[1],
a2,
&v20,
v18,
v19);
a1[1] += v17;
return 0LL;
}
|
dbuf_printf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x158
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0xa0]
MOV qword ptr [R15 + 0x10],RDX
MOV qword ptr [R15 + 0x18],RCX
MOV qword ptr [R15 + 0x20],R8
MOV qword ptr [R15 + 0x28],R9
TEST AL,AL
JZ 0x00115de3
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVAPS xmmword ptr [RSP + 0xe0],XMM1
MOVAPS xmmword ptr [RSP + 0xf0],XMM2
MOVAPS xmmword ptr [RSP + 0x100],XMM3
MOVAPS xmmword ptr [RSP + 0x110],XMM4
MOVAPS xmmword ptr [RSP + 0x120],XMM5
MOVAPS xmmword ptr [RSP + 0x130],XMM6
MOVAPS xmmword ptr [RSP + 0x140],XMM7
LAB_00115de3:
MOV R12,0x3000000010
MOV RCX,RSP
MOV qword ptr [RCX],R12
LEA R13,[RSP + 0x190]
MOV qword ptr [RCX + 0x8],R13
MOV qword ptr [RCX + 0x10],R15
LEA RDI,[RSP + 0x20]
MOV ESI,0x80
MOV RDX,R14
CALL 0x0010e1a0
CMP EAX,0x7f
JG 0x00115e2c
MOVSXD RDX,EAX
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00115c88
JMP 0x00115e77
LAB_00115e2c:
MOV RCX,qword ptr [RBX + 0x8]
MOV EBP,EAX
LEA RSI,[RCX + RBP*0x1]
INC RSI
MOV RDI,RBX
CALL 0x00115bdf
TEST EAX,EAX
JZ 0x00115e4a
PUSH -0x1
POP RAX
JMP 0x00115e77
LAB_00115e4a:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],R15
MOV qword ptr [RCX + 0x8],R13
MOV qword ptr [RCX],R12
MOV RAX,qword ptr [RBX + 0x8]
MOV RSI,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX]
ADD RDI,RAX
SUB RSI,RAX
MOV RDX,R14
CALL 0x0010e1a0
ADD qword ptr [RBX + 0x8],RBP
XOR EAX,EAX
LAB_00115e77:
ADD RSP,0x158
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
dbuf_printf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,long *param_9
,char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
uint uVar1;
int iVar2;
int8 uVar3;
int8 local_188;
int1 *local_180;
int1 *local_178;
char local_168 [128];
int1 local_e8 [16];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_188 = 0x3000000010;
local_180 = &stack0x00000008;
local_178 = local_e8;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
uVar1 = vsnprintf(local_168,0x80,param_10,&local_188);
if ((int)uVar1 < 0x80) {
uVar3 = dbuf_put(param_9,local_168,(long)(int)uVar1);
}
else {
iVar2 = dbuf_realloc(param_9,param_9[1] + (ulong)uVar1 + 1);
if (iVar2 == 0) {
local_188 = 0x3000000010;
local_180 = &stack0x00000008;
local_178 = local_e8;
vsnprintf((char *)(*param_9 + param_9[1]),param_9[2] - param_9[1],param_10,&local_188);
param_9[1] = param_9[1] + (ulong)uVar1;
uVar3 = 0;
}
else {
uVar3 = 0xffffffffffffffff;
}
}
return uVar3;
}
|
|
5,038 |
str2int
|
eloqsql/strings/str2int.c
|
char *str2int(register const char *src, register int radix, long int lower,
long int upper, long int *val)
{
int sign; /* is number negative (+1) or positive (-1) */
int n; /* number of digits yet to be converted */
long limit; /* "largest" possible valid input */
long scale; /* the amount to multiply next digit by */
long sofar; /* the running value */
register int d; /* (negative of) next digit */
char *start;
int digits[32]; /* Room for numbers */
/* Make sure *val is sensible in case of error */
*val = 0;
/* Check that the radix is in the range 2..36 */
#ifndef DBUG_OFF
if (radix < 2 || radix > 36) {
errno=EDOM;
return NullS;
}
#endif
/* The basic problem is: how do we handle the conversion of
a number without resorting to machine-specific code to
check for overflow? Obviously, we have to ensure that
no calculation can overflow. We are guaranteed that the
"lower" and "upper" arguments are valid machine integers.
On sign-and-magnitude, twos-complement, and ones-complement
machines all, if +|n| is representable, so is -|n|, but on
twos complement machines the converse is not true. So the
"maximum" representable number has a negative representative.
Limit is set to MY_MIN(-|lower|,-|upper|); this is the "largest"
number we are concerned with. */
/* Calculate Limit using Scale as a scratch variable */
if ((limit = lower) > 0) limit = -limit;
if ((scale = upper) > 0) scale = -scale;
if (scale < limit) limit = scale;
/* Skip leading spaces and check for a sign.
Note: because on a 2s complement machine MinLong is a valid
integer but |MinLong| is not, we have to keep the current
converted value (and the scale!) as *negative* numbers,
so the sign is the opposite of what you might expect.
*/
while (my_isspace(&my_charset_latin1,*src)) src++;
sign = -1;
if (*src == '+') src++; else
if (*src == '-') src++, sign = 1;
/* Skip leading zeros so that we never compute a power of radix
in scale that we won't have a need for. Otherwise sticking
enough 0s in front of a number could cause the multiplication
to overflow when it neededn't.
*/
start=(char*) src;
while (*src == '0') src++;
/* Move over the remaining digits. We have to convert from left
to left in order to avoid overflow. Answer is after last digit.
*/
for (n = 0; (digits[n]=char_val(*src)) < radix && n < 20; n++,src++) ;
/* Check that there is at least one digit */
if (start == src) {
errno=EDOM;
return NullS;
}
/* The invariant we want to maintain is that src is just
to the right of n digits, we've converted k digits to
sofar, scale = -radix**k, and scale < sofar < 0. Now
if the final number is to be within the original
Limit, we must have (to the left)*scale+sofar >= Limit,
or (to the left)*scale >= Limit-sofar, i.e. the digits
to the left of src must form an integer <= (Limit-sofar)/(scale).
In particular, this is true of the next digit. In our
incremental calculation of Limit,
IT IS VITAL that (-|N|)/(-|D|) = |N|/|D|
*/
for (sofar = 0, scale = -1; --n >= 1;)
{
if ((long) -(d=digits[n]) < limit) {
errno=ERANGE;
return NullS;
}
limit = (limit+d)/radix, sofar += d*scale; scale *= radix;
}
if (n == 0)
{
if ((long) -(d=digits[n]) < limit) /* get last digit */
{
errno=ERANGE;
return NullS;
}
sofar+=d*scale;
}
/* Now it might still happen that sofar = -32768 or its equivalent,
so we can't just multiply by the sign and check that the result
is in the range lower..upper. All of this caution is a right
pain in the neck. If only there were a standard routine which
says generate thus and such a signal on integer overflow...
But not enough machines can do it *SIGH*.
*/
if (sign < 0)
{
if (sofar < -LONG_MAX || (sofar= -sofar) > upper)
{
errno=ERANGE;
return NullS;
}
}
else if (sofar < lower)
{
errno=ERANGE;
return NullS;
}
*val = sofar;
errno=0; /* indicate that all went well */
return (char*) src;
}
|
O0
|
c
|
str2int:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jle 0x801a1
xorl %eax, %eax
subq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jle 0x801b9
xorl %eax, %eax
subq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jge 0x801cb
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x801cd
leaq 0x1ffc5c(%rip), %rax # 0x27fe30
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x801fa
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x801cd
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x8021b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8023c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x8023a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x8023c
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x8025e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x80244
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x8028f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x8028f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xe4(%rbp)
jmp 0x8030e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x802bc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x802bc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0xe8(%rbp)
jmp 0x80302
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x802e9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x802e9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0xec(%rbp)
jmp 0x802f6
movl $0x7f, %eax
movl %eax, -0xec(%rbp)
jmp 0x802f6
movl -0xec(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %ecx
movslq -0x38(%rbp), %rax
movl %ecx, -0xe0(%rbp,%rax,4)
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0xed(%rbp)
jge 0x80339
cmpl $0x14, -0x38(%rbp)
setl %al
movb %al, -0xed(%rbp)
movb -0xed(%rbp), %al
testb $0x1, %al
jne 0x80345
jmp 0x80361
jmp 0x80347
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x80265
movq -0x60(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x80383
callq 0x25040
movl $0x21, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x804d0
movq $0x0, -0x50(%rbp)
movq $-0x1, -0x48(%rbp)
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0x1, %eax
jl 0x8040b
movslq -0x38(%rbp), %rax
movl -0xe0(%rbp,%rax,4), %ecx
movl %ecx, -0x54(%rbp)
xorl %eax, %eax
subl %ecx, %eax
cltq
cmpq -0x40(%rbp), %rax
jge 0x803d3
callq 0x25040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x804d0
movq -0x40(%rbp), %rax
movslq -0x54(%rbp), %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movslq -0x54(%rbp), %rax
imulq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rax
imulq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x80393
cmpl $0x0, -0x38(%rbp)
jne 0x80454
movslq -0x38(%rbp), %rax
movl -0xe0(%rbp,%rax,4), %ecx
movl %ecx, -0x54(%rbp)
xorl %eax, %eax
subl %ecx, %eax
cltq
cmpq -0x40(%rbp), %rax
jge 0x80443
callq 0x25040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x804d0
movslq -0x54(%rbp), %rax
imulq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x80491
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, -0x50(%rbp)
jl 0x8047a
xorl %eax, %eax
subq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq -0x28(%rbp), %rax
jle 0x8048f
callq 0x25040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x804d0
jmp 0x804b2
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x804b0
callq 0x25040
movl $0x22, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x804d0
jmp 0x804b2
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
callq 0x25040
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
|
str2int:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_30]
mov qword ptr [rax], 0
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
cmp rax, 0
jle short loc_801A1
xor eax, eax
sub rax, [rbp+var_40]
mov [rbp+var_40], rax
loc_801A1:
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
cmp rax, 0
jle short loc_801B9
xor eax, eax
sub rax, [rbp+var_48]
mov [rbp+var_48], rax
loc_801B9:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
jge short loc_801CB
mov rax, [rbp+var_48]
mov [rbp+var_40], rax
loc_801CB:
jmp short $+2
loc_801CD:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_801FA
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_801CD
loc_801FA:
mov [rbp+var_34], 0FFFFFFFFh
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_8021B
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_8023C
loc_8021B:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_8023A
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
mov [rbp+var_34], 1
loc_8023A:
jmp short $+2
loc_8023C:
mov rax, [rbp+var_10]
mov [rbp+var_60], rax
loc_80244:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jnz short loc_8025E
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_80244
loc_8025E:
mov [rbp+var_38], 0
loc_80265:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jl short loc_8028F
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 39h ; '9'
jg short loc_8028F
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 30h ; '0'
mov [rbp+var_E4], eax
jmp short loc_8030E
loc_8028F:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 41h ; 'A'
jl short loc_802BC
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Ah ; 'Z'
jg short loc_802BC
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_E8], eax
jmp short loc_80302
loc_802BC:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 61h ; 'a'
jl short loc_802E9
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Ah ; 'z'
jg short loc_802E9
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_EC], eax
jmp short loc_802F6
loc_802E9:
mov eax, 7Fh
mov [rbp+var_EC], eax
jmp short $+2
loc_802F6:
mov eax, [rbp+var_EC]
mov [rbp+var_E8], eax
loc_80302:
mov eax, [rbp+var_E8]
mov [rbp+var_E4], eax
loc_8030E:
mov ecx, [rbp+var_E4]
movsxd rax, [rbp+var_38]
mov [rbp+rax*4+var_E0], ecx
xor eax, eax
cmp ecx, [rbp+var_14]
mov [rbp+var_ED], al
jge short loc_80339
cmp [rbp+var_38], 14h
setl al
mov [rbp+var_ED], al
loc_80339:
mov al, [rbp+var_ED]
test al, 1
jnz short loc_80345
jmp short loc_80361
loc_80345:
jmp short $+2
loc_80347:
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_80265
loc_80361:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_10]
jnz short loc_80383
call ___errno_location
mov dword ptr [rax], 21h ; '!'
mov [rbp+var_8], 0
jmp loc_804D0
loc_80383:
mov [rbp+var_50], 0
mov [rbp+var_48], 0FFFFFFFFFFFFFFFFh
loc_80393:
mov eax, [rbp+var_38]
add eax, 0FFFFFFFFh
mov [rbp+var_38], eax
cmp eax, 1
jl short loc_8040B
movsxd rax, [rbp+var_38]
mov ecx, [rbp+rax*4+var_E0]
mov [rbp+var_54], ecx
xor eax, eax
sub eax, ecx
cdqe
cmp rax, [rbp+var_40]
jge short loc_803D3
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp loc_804D0
loc_803D3:
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_54]
add rax, rcx
movsxd rcx, [rbp+var_14]
cqo
idiv rcx
mov [rbp+var_40], rax
movsxd rax, [rbp+var_54]
imul rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_50], rax
movsxd rax, [rbp+var_14]
imul rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short loc_80393
loc_8040B:
cmp [rbp+var_38], 0
jnz short loc_80454
movsxd rax, [rbp+var_38]
mov ecx, [rbp+rax*4+var_E0]
mov [rbp+var_54], ecx
xor eax, eax
sub eax, ecx
cdqe
cmp rax, [rbp+var_40]
jge short loc_80443
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp loc_804D0
loc_80443:
movsxd rax, [rbp+var_54]
imul rax, [rbp+var_48]
add rax, [rbp+var_50]
mov [rbp+var_50], rax
loc_80454:
cmp [rbp+var_34], 0
jge short loc_80491
mov rax, 8000000000000001h
cmp [rbp+var_50], rax
jl short loc_8047A
xor eax, eax
sub rax, [rbp+var_50]
mov [rbp+var_50], rax
cmp rax, [rbp+var_28]
jle short loc_8048F
loc_8047A:
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp short loc_804D0
loc_8048F:
jmp short loc_804B2
loc_80491:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_20]
jge short loc_804B0
call ___errno_location
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0
jmp short loc_804D0
loc_804B0:
jmp short $+2
loc_804B2:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
call ___errno_location
mov dword ptr [rax], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_804D0:
mov rax, [rbp+var_8]
add rsp, 0F0h
pop rbp
retn
|
_BYTE * str2int(_BYTE *a1, int a2, long long a3, long long a4, long long *a5)
{
bool v6; // [rsp+3h] [rbp-EDh]
int v7; // [rsp+4h] [rbp-ECh]
int v8; // [rsp+8h] [rbp-E8h]
int v9; // [rsp+Ch] [rbp-E4h]
_DWORD v10[32]; // [rsp+10h] [rbp-E0h]
_BYTE *v11; // [rsp+90h] [rbp-60h]
int v12; // [rsp+9Ch] [rbp-54h]
long long v13; // [rsp+A0h] [rbp-50h]
long long i; // [rsp+A8h] [rbp-48h]
long long v15; // [rsp+B0h] [rbp-40h]
int v16; // [rsp+B8h] [rbp-38h]
int v17; // [rsp+BCh] [rbp-34h]
long long *v18; // [rsp+C0h] [rbp-30h]
long long v19; // [rsp+C8h] [rbp-28h]
long long v20; // [rsp+D0h] [rbp-20h]
int v21; // [rsp+DCh] [rbp-14h]
_BYTE *v22; // [rsp+E0h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
*a5 = 0LL;
v15 = v20;
if ( v20 > 0 )
v15 = -v15;
i = v19;
if ( v19 > 0 )
i = -i;
if ( i < v15 )
v15 = i;
while ( (*(_BYTE *)(*(_QWORD *)&my_charset_latin1[16] + (unsigned __int8)*v22 + 1LL) & 8) != 0 )
++v22;
v17 = -1;
if ( *v22 == 43 )
{
++v22;
}
else if ( *v22 == 45 )
{
++v22;
v17 = 1;
}
v11 = v22;
while ( *v22 == 48 )
++v22;
v16 = 0;
while ( 1 )
{
if ( (char)*v22 < 48 || (char)*v22 > 57 )
{
if ( (char)*v22 < 65 || (char)*v22 > 90 )
{
v7 = (char)*v22 < 97 || (char)*v22 > 122 ? 127 : (char)*v22 - 97 + 10;
v8 = v7;
}
else
{
v8 = (char)*v22 - 65 + 10;
}
v9 = v8;
}
else
{
v9 = (char)*v22 - 48;
}
v10[v16] = v9;
v6 = 0;
if ( v9 < v21 )
v6 = v16 < 20;
if ( !v6 )
break;
++v16;
++v22;
}
if ( v11 != v22 )
{
v13 = 0LL;
for ( i = -1LL; --v16 >= 1; i *= v21 )
{
v12 = v10[v16];
if ( -v12 < v15 )
goto LABEL_49;
v15 = (v12 + v15) / v21;
v13 += i * v12;
}
if ( !v16 )
{
v12 = v10[0];
if ( -v10[0] < v15 )
goto LABEL_49;
v13 += i * v12;
}
if ( v17 < 0 )
{
if ( v13 == 0x8000000000000000LL )
goto LABEL_49;
v13 = -v13;
if ( v13 > v19 )
goto LABEL_49;
LABEL_50:
*v18 = v13;
*(_DWORD *)__errno_location() = 0;
return v22;
}
if ( v13 >= v20 )
goto LABEL_50;
LABEL_49:
*(_DWORD *)__errno_location() = 34;
return 0LL;
}
*(_DWORD *)__errno_location() = 33;
return 0LL;
}
|
str2int:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JLE 0x001801a1
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
LAB_001801a1:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JLE 0x001801b9
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
LAB_001801b9:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x001801cb
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
LAB_001801cb:
JMP 0x001801cd
LAB_001801cd:
LEA RAX,[0x37fe30]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001801fa
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001801cd
LAB_001801fa:
MOV dword ptr [RBP + -0x34],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x0018021b
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0018023c
LAB_0018021b:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x0018023a
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x34],0x1
LAB_0018023a:
JMP 0x0018023c
LAB_0018023c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x60],RAX
LAB_00180244:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JNZ 0x0018025e
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00180244
LAB_0018025e:
MOV dword ptr [RBP + -0x38],0x0
LAB_00180265:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JL 0x0018028f
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x39
JG 0x0018028f
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x30
MOV dword ptr [RBP + -0xe4],EAX
JMP 0x0018030e
LAB_0018028f:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x41
JL 0x001802bc
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5a
JG 0x001802bc
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x41
ADD EAX,0xa
MOV dword ptr [RBP + -0xe8],EAX
JMP 0x00180302
LAB_001802bc:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x61
JL 0x001802e9
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7a
JG 0x001802e9
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
SUB EAX,0x61
ADD EAX,0xa
MOV dword ptr [RBP + -0xec],EAX
JMP 0x001802f6
LAB_001802e9:
MOV EAX,0x7f
MOV dword ptr [RBP + -0xec],EAX
JMP 0x001802f6
LAB_001802f6:
MOV EAX,dword ptr [RBP + -0xec]
MOV dword ptr [RBP + -0xe8],EAX
LAB_00180302:
MOV EAX,dword ptr [RBP + -0xe8]
MOV dword ptr [RBP + -0xe4],EAX
LAB_0018030e:
MOV ECX,dword ptr [RBP + -0xe4]
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + RAX*0x4 + -0xe0],ECX
XOR EAX,EAX
CMP ECX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0xed],AL
JGE 0x00180339
CMP dword ptr [RBP + -0x38],0x14
SETL AL
MOV byte ptr [RBP + -0xed],AL
LAB_00180339:
MOV AL,byte ptr [RBP + -0xed]
TEST AL,0x1
JNZ 0x00180345
JMP 0x00180361
LAB_00180345:
JMP 0x00180347
LAB_00180347:
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00180265
LAB_00180361:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x00180383
CALL 0x00125040
MOV dword ptr [RAX],0x21
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001804d0
LAB_00180383:
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],-0x1
LAB_00180393:
MOV EAX,dword ptr [RBP + -0x38]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x1
JL 0x0018040b
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + RAX*0x4 + -0xe0]
MOV dword ptr [RBP + -0x54],ECX
XOR EAX,EAX
SUB EAX,ECX
CDQE
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x001803d3
CALL 0x00125040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001804d0
LAB_001803d3:
MOV RAX,qword ptr [RBP + -0x40]
MOVSXD RCX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x14]
CQO
IDIV RCX
MOV qword ptr [RBP + -0x40],RAX
MOVSXD RAX,dword ptr [RBP + -0x54]
IMUL RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOVSXD RAX,dword ptr [RBP + -0x14]
IMUL RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00180393
LAB_0018040b:
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x00180454
MOVSXD RAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + RAX*0x4 + -0xe0]
MOV dword ptr [RBP + -0x54],ECX
XOR EAX,EAX
SUB EAX,ECX
CDQE
CMP RAX,qword ptr [RBP + -0x40]
JGE 0x00180443
CALL 0x00125040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001804d0
LAB_00180443:
MOVSXD RAX,dword ptr [RBP + -0x54]
IMUL RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
LAB_00180454:
CMP dword ptr [RBP + -0x34],0x0
JGE 0x00180491
MOV RAX,-0x7fffffffffffffff
CMP qword ptr [RBP + -0x50],RAX
JL 0x0018047a
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,qword ptr [RBP + -0x28]
JLE 0x0018048f
LAB_0018047a:
CALL 0x00125040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001804d0
LAB_0018048f:
JMP 0x001804b2
LAB_00180491:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x20]
JGE 0x001804b0
CALL 0x00125040
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001804d0
LAB_001804b0:
JMP 0x001804b2
LAB_001804b2:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
CALL 0x00125040
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001804d0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xf0
POP RBP
RET
|
byte * str2int(byte *param_1,int param_2,long param_3,long param_4,long *param_5)
{
int *piVar1;
int local_f4;
int local_f0;
int local_ec;
int aiStack_e8 [32];
byte *local_68;
int local_5c;
long local_58;
long local_50;
long local_48;
int local_40;
int local_3c;
long *local_38;
long local_30;
long local_28;
int local_1c;
byte *local_18;
byte *local_10;
*param_5 = 0;
local_48 = param_3;
if (0 < param_3) {
local_48 = -param_3;
}
local_50 = param_4;
if (0 < param_4) {
local_50 = -param_4;
}
local_18 = param_1;
if (local_50 < local_48) {
local_48 = local_50;
}
while ((PTR_ctype_latin1_0037fe70[(ulong)*local_18 + 1] & 8) != 0) {
local_18 = local_18 + 1;
}
local_3c = -1;
if (*local_18 == 0x2b) {
local_18 = local_18 + 1;
}
else if (*local_18 == 0x2d) {
local_18 = local_18 + 1;
local_3c = 1;
}
local_68 = local_18;
for (; *local_18 == 0x30; local_18 = local_18 + 1) {
}
local_40 = 0;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
while( true ) {
if (((char)*local_18 < '0') || ('9' < (char)*local_18)) {
if (((char)*local_18 < 'A') || ('Z' < (char)*local_18)) {
if (((char)*local_18 < 'a') || ('z' < (char)*local_18)) {
local_f4 = 0x7f;
}
else {
local_f4 = (char)*local_18 + -0x57;
}
local_f0 = local_f4;
}
else {
local_f0 = (char)*local_18 + -0x37;
}
local_ec = local_f0;
}
else {
local_ec = (char)*local_18 + -0x30;
}
aiStack_e8[local_40] = local_ec;
if (local_1c <= local_ec || 0x13 < local_40) break;
local_40 = local_40 + 1;
local_18 = local_18 + 1;
}
if (local_68 == local_18) {
piVar1 = __errno_location();
*piVar1 = 0x21;
local_10 = (byte *)0x0;
}
else {
local_58 = 0;
local_50 = -1;
while (local_40 = local_40 + -1, 0 < local_40) {
local_5c = aiStack_e8[local_40];
if (-local_5c < local_48) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
local_48 = (local_48 + local_5c) / (long)local_1c;
local_58 = local_5c * local_50 + local_58;
local_50 = local_1c * local_50;
}
if (local_40 == 0) {
local_5c = aiStack_e8[0];
if (-aiStack_e8[0] < local_48) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
local_58 = aiStack_e8[0] * local_50 + local_58;
}
if (local_3c < 0) {
if ((local_58 < -0x7fffffffffffffff) || (local_58 = -local_58, local_30 < local_58)) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
}
else if (local_58 < local_28) {
piVar1 = __errno_location();
*piVar1 = 0x22;
return (byte *)0x0;
}
*local_38 = local_58;
piVar1 = __errno_location();
*piVar1 = 0;
local_10 = local_18;
}
return local_10;
}
|
|
5,039 |
mi_pack_get_block_info
|
eloqsql/storage/myisam/mi_packrec.c
|
uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info, uchar **rec_buff_p,
File file, my_off_t filepos)
{
uchar *header=info->header;
uint head_length, UNINIT_VAR(ref_length);
if (file >= 0)
{
ref_length=myisam->s->pack.ref_length;
/*
We can't use mysql_file_pread() here because mi_read_rnd_pack_record
assumes position is ok
*/
mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, header, ref_length, MYF(MY_NABP)))
return BLOCK_FATAL_ERROR;
DBUG_DUMP("header",(uchar*) header,ref_length);
}
head_length= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
head_length+= read_pack_length((uint) myisam->s->pack.version,
header + head_length, &info->blob_len);
/*
Ensure that the record buffer is big enough for the compressed
record plus all expanded blobs. [We do not have an extra buffer
for the resulting blobs. Sigh.]
*/
if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
rec_buff_p)))
return BLOCK_FATAL_ERROR; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p + info->rec_len;
bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
myisam->blob_length=info->blob_len;
}
info->filepos=filepos+head_length;
if (file > 0)
{
info->offset=MY_MIN(info->rec_len, ref_length - head_length);
memcpy(*rec_buff_p, header + head_length, info->offset);
}
return 0;
}
|
O3
|
c
|
mi_pack_get_block_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
testl %r8d, %r8d
movq %r9, -0x48(%rbp)
js 0x818b7
movq %r9, %r15
movq %rcx, -0x30(%rbp)
movq (%r14), %rax
movl 0x240(%rax), %r13d
leaq 0x3047e0(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x81a19
movl %r12d, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0ba4
leaq 0x3047a9(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %r13, -0x38(%rbp)
jne 0x81a2c
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa09a4
movq %rax, %r13
movl $0x20, %r15d
testq %r13, %r13
movq -0x30(%rbp), %rcx
jne 0x81a07
jmp 0x818bb
movq %rax, -0x38(%rbp)
movzbl (%rbx), %esi
cmpq $0xfd, %rsi
ja 0x818d3
movl $0x1, %r15d
movq -0x38(%rbp), %rdi
jmp 0x81916
cmpl $0xfe, %esi
movq -0x38(%rbp), %rdi
jne 0x818eb
movzwl 0x1(%rbx), %esi
movl $0x3, %r15d
jmp 0x81916
movq (%r14), %rax
cmpb $0x1, 0x244(%rax)
jne 0x8190d
movzwl 0x1(%rbx), %eax
movzbl 0x3(%rbx), %esi
shll $0x10, %esi
orq %rax, %rsi
movl $0x4, %r15d
jmp 0x81916
movl 0x1(%rbx), %esi
movl $0x5, %r15d
movq %rsi, 0x18(%rbx)
movq (%r14), %rdx
cmpl $0x0, 0x188(%rdx)
je 0x819cc
movl %r15d, %edi
movzbl (%rbx,%rdi), %eax
cmpq $0xfd, %rax
ja 0x81942
movl $0x1, -0x30(%rbp)
jmp 0x81984
cmpl $0xfe, %eax
jne 0x81957
movzwl 0x1(%rbx,%rdi), %eax
movl $0x3, -0x30(%rbp)
jmp 0x81984
cmpb $0x1, 0x244(%rdx)
jne 0x81979
movzwl 0x1(%rbx,%rdi), %edx
movzbl 0x3(%rbx,%rdi), %eax
shll $0x10, %eax
orq %rdx, %rax
movl $0x4, -0x30(%rbp)
jmp 0x81984
movl 0x1(%rbx,%rdi), %eax
movl $0x5, -0x30(%rbp)
movq %rax, 0x30(%rbx)
addq %rax, %rsi
movq %r14, %rdi
movq %rcx, %rdx
movq %rcx, %r13
callq 0x7fb5d
testq %rax, %rax
je 0x81a01
movq (%r13), %rax
addq 0x18(%rbx), %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x18(%rcx)
addq 0x30(%rbx), %rax
addl -0x30(%rbp), %r15d
movq %rax, 0x20(%rcx)
movq 0x30(%rbx), %rax
movq %rax, 0x1b8(%r14)
movq %r13, %rcx
movq -0x38(%rbp), %rdi
movl %r15d, %eax
movq -0x48(%rbp), %rdx
addq %rax, %rdx
movq %rdx, 0x38(%rbx)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x81a07
movq 0x18(%rbx), %rdx
subl %eax, %edi
cmpq %rdi, %rdx
cmovael %edi, %edx
movl %edx, 0x54(%rbx)
movq (%rcx), %rdi
addq %rax, %rbx
movq %rbx, %rsi
callq 0x29080
jmp 0x81a07
movl $0x20, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x2e459
jmp 0x81860
movq %rax, %r15
leaq 0x3045da(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x59f78(%rip), %rdx # 0xdb9b8
movq %r15, %rdi
movq %r13, %rsi
movl $0x566, %ecx # imm = 0x566
callq *0x210(%rax)
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa09a4
movq %r13, %rcx
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
cmoveq %rcx, %rsi
leaq 0x304596(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x818a2
|
_mi_pack_get_block_info:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov rbx, rdx
mov [rbp+var_40], rsi
mov r14, rdi
test r8d, r8d
mov [rbp+var_48], r9
js loc_818B7
mov r15, r9
mov [rbp+var_30], rcx
mov rax, [r14]
mov r13d, [rax+240h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_81A19
mov edi, r12d
mov rsi, r15
xor edx, edx
xor ecx, ecx
call my_seek
loc_81860:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_38], r13
jnz loc_81A2C
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov r13, rax
loc_818A2:
mov r15d, 20h ; ' '
test r13, r13
mov rcx, [rbp+var_30]
jnz loc_81A07
jmp short loc_818BB
loc_818B7:
mov [rbp+var_38], rax
loc_818BB:
movzx esi, byte ptr [rbx]
cmp rsi, 0FDh
ja short loc_818D3
mov r15d, 1
mov rdi, [rbp+var_38]
jmp short loc_81916
loc_818D3:
cmp esi, 0FEh
mov rdi, [rbp+var_38]
jnz short loc_818EB
movzx esi, word ptr [rbx+1]
mov r15d, 3
jmp short loc_81916
loc_818EB:
mov rax, [r14]
cmp byte ptr [rax+244h], 1
jnz short loc_8190D
movzx eax, word ptr [rbx+1]
movzx esi, byte ptr [rbx+3]
shl esi, 10h
or rsi, rax
mov r15d, 4
jmp short loc_81916
loc_8190D:
mov esi, [rbx+1]
mov r15d, 5
loc_81916:
mov [rbx+18h], rsi
mov rdx, [r14]
cmp dword ptr [rdx+188h], 0
jz loc_819CC
mov edi, r15d
movzx eax, byte ptr [rbx+rdi]
cmp rax, 0FDh
ja short loc_81942
mov dword ptr [rbp+var_30], 1
jmp short loc_81984
loc_81942:
cmp eax, 0FEh
jnz short loc_81957
movzx eax, word ptr [rbx+rdi+1]
mov dword ptr [rbp+var_30], 3
jmp short loc_81984
loc_81957:
cmp byte ptr [rdx+244h], 1
jnz short loc_81979
movzx edx, word ptr [rbx+rdi+1]
movzx eax, byte ptr [rbx+rdi+3]
shl eax, 10h
or rax, rdx
mov dword ptr [rbp+var_30], 4
jmp short loc_81984
loc_81979:
mov eax, [rbx+rdi+1]
mov dword ptr [rbp+var_30], 5
loc_81984:
mov [rbx+30h], rax
add rsi, rax
mov rdi, r14
mov rdx, rcx
mov r13, rcx
call mi_alloc_rec_buff
test rax, rax
jz short loc_81A01
mov rax, [r13+0]
add rax, [rbx+18h]
mov rcx, [rbp+var_40]
mov [rcx+18h], rax
add rax, [rbx+30h]
add r15d, dword ptr [rbp+var_30]
mov [rcx+20h], rax
mov rax, [rbx+30h]
mov [r14+1B8h], rax
mov rcx, r13
mov rdi, [rbp+var_38]
loc_819CC:
mov eax, r15d
mov rdx, [rbp+var_48]
add rdx, rax
mov [rbx+38h], rdx
xor r15d, r15d
test r12d, r12d
jle short loc_81A07
mov rdx, [rbx+18h]
sub edi, eax
cmp rdx, rdi
cmovnb edx, edi
mov [rbx+54h], edx
mov rdi, [rcx]
add rbx, rax
mov rsi, rbx
call _memcpy
jmp short loc_81A07
loc_81A01:
mov r15d, 20h ; ' '
loc_81A07:
mov eax, r15d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_81A19:
mov rdi, rax
mov esi, r12d
mov rdx, r15
call _mi_pack_get_block_info_cold_1
jmp loc_81860
loc_81A2C:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r13
mov ecx, 566h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov rcx, r13
mov r13, rax
xor esi, esi
test rax, rax
cmovz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_818A2
|
long long mi_pack_get_block_info(
long long *a1,
long long a2,
unsigned __int8 *a3,
_QWORD *a4,
long long a5,
long long a6)
{
long long v6; // rax
unsigned int v7; // r12d
long long v11; // r13
long long v12; // rax
long long v13; // rax
long long v14; // r13
unsigned int v15; // r15d
unsigned long long v16; // rsi
unsigned int v17; // r15d
int v18; // edi
unsigned long long v19; // rax
_QWORD *v20; // r13
long long v21; // rax
long long v22; // rcx
long long v23; // rax
unsigned long long v24; // rdx
unsigned long long v25; // rdi
long long v27; // r15
long long v28; // rax
long long v29; // rcx
long long v30; // rsi
_BYTE v31[72]; // [rsp+0h] [rbp-90h] BYREF
long long v32; // [rsp+48h] [rbp-48h]
long long v33; // [rsp+50h] [rbp-40h]
long long v34; // [rsp+58h] [rbp-38h]
_QWORD *v35; // [rsp+60h] [rbp-30h]
v7 = a5;
v33 = a2;
v32 = a6;
if ( (int)a5 < 0 )
{
v34 = v6;
}
else
{
v35 = a4;
v11 = *(unsigned int *)(*a1 + 576);
v12 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, (unsigned int)a5, 8LL);
if ( v12 )
mi_pack_get_block_info_cold_1(v12, v7, a6);
else
my_seek(v7, a6, 0LL, 0LL);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, v7, 6LL);
v34 = v11;
if ( v13 )
{
v27 = v13;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v13,
v11,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
1382LL);
v28 = my_read(v7, a3, v11, 4LL);
v29 = v11;
v14 = v28;
v30 = 0LL;
if ( !v28 )
v30 = v29;
((void ( *)(long long, long long))PSI_server[67])(v27, v30);
}
else
{
v14 = my_read(v7, a3, v11, 4LL);
}
v15 = 32;
a4 = v35;
if ( v14 )
return v15;
}
v16 = *a3;
if ( v16 > 0xFD )
{
v18 = v34;
if ( (_DWORD)v16 == 254 )
{
v16 = *(unsigned __int16 *)(a3 + 1);
v17 = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v16 = *(unsigned __int16 *)(a3 + 1) | (unsigned long long)(a3[3] << 16);
v17 = 4;
}
else
{
v16 = *(unsigned int *)(a3 + 1);
v17 = 5;
}
}
else
{
v17 = 1;
v18 = v34;
}
*((_QWORD *)a3 + 3) = v16;
if ( *(_DWORD *)(*a1 + 392) )
{
v19 = a3[v17];
if ( v19 > 0xFD )
{
if ( (_DWORD)v19 == 254 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1];
LODWORD(v35) = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1] | (unsigned long long)(a3[v17 + 3] << 16);
LODWORD(v35) = 4;
}
else
{
v19 = *(unsigned int *)&a3[v17 + 1];
LODWORD(v35) = 5;
}
}
else
{
LODWORD(v35) = 1;
}
*((_QWORD *)a3 + 6) = v19;
v20 = a4;
if ( !mi_alloc_rec_buff(a1, v19 + v16, a4, (long long)a4, a5, a6) )
return 32;
v21 = *((_QWORD *)a3 + 3) + *v20;
v22 = v33;
*(_QWORD *)(v33 + 24) = v21;
v17 += (unsigned int)v35;
*(_QWORD *)(v22 + 32) = *((_QWORD *)a3 + 6) + v21;
a1[55] = *((_QWORD *)a3 + 6);
a4 = v20;
v18 = v34;
}
v23 = v17;
*((_QWORD *)a3 + 7) = v17 + v32;
v15 = 0;
if ( (int)v7 > 0 )
{
v24 = *((_QWORD *)a3 + 3);
v25 = (unsigned int)(v18 - v23);
if ( v24 >= v25 )
v24 = (unsigned int)v25;
*((_DWORD *)a3 + 21) = v24;
memcpy(*a4, &a3[v23], v24);
}
return v15;
}
|
_mi_pack_get_block_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV RBX,RDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
TEST R8D,R8D
MOV qword ptr [RBP + -0x48],R9
JS 0x001818b7
MOV R15,R9
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [R14]
MOV R13D,dword ptr [RAX + 0x240]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00181a19
MOV EDI,R12D
MOV RSI,R15
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0ba4
LAB_00181860:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x38],R13
JNZ 0x00181a2c
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a09a4
MOV R13,RAX
LAB_001818a2:
MOV R15D,0x20
TEST R13,R13
MOV RCX,qword ptr [RBP + -0x30]
JNZ 0x00181a07
JMP 0x001818bb
LAB_001818b7:
MOV qword ptr [RBP + -0x38],RAX
LAB_001818bb:
MOVZX ESI,byte ptr [RBX]
CMP RSI,0xfd
JA 0x001818d3
MOV R15D,0x1
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x00181916
LAB_001818d3:
CMP ESI,0xfe
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x001818eb
MOVZX ESI,word ptr [RBX + 0x1]
MOV R15D,0x3
JMP 0x00181916
LAB_001818eb:
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x0018190d
MOVZX EAX,word ptr [RBX + 0x1]
MOVZX ESI,byte ptr [RBX + 0x3]
SHL ESI,0x10
OR RSI,RAX
MOV R15D,0x4
JMP 0x00181916
LAB_0018190d:
MOV ESI,dword ptr [RBX + 0x1]
MOV R15D,0x5
LAB_00181916:
MOV qword ptr [RBX + 0x18],RSI
MOV RDX,qword ptr [R14]
CMP dword ptr [RDX + 0x188],0x0
JZ 0x001819cc
MOV EDI,R15D
MOVZX EAX,byte ptr [RBX + RDI*0x1]
CMP RAX,0xfd
JA 0x00181942
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00181984
LAB_00181942:
CMP EAX,0xfe
JNZ 0x00181957
MOVZX EAX,word ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x3
JMP 0x00181984
LAB_00181957:
CMP byte ptr [RDX + 0x244],0x1
JNZ 0x00181979
MOVZX EDX,word ptr [RBX + RDI*0x1 + 0x1]
MOVZX EAX,byte ptr [RBX + RDI*0x1 + 0x3]
SHL EAX,0x10
OR RAX,RDX
MOV dword ptr [RBP + -0x30],0x4
JMP 0x00181984
LAB_00181979:
MOV EAX,dword ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x5
LAB_00181984:
MOV qword ptr [RBX + 0x30],RAX
ADD RSI,RAX
MOV RDI,R14
MOV RDX,RCX
MOV R13,RCX
CALL 0x0017fb5d
TEST RAX,RAX
JZ 0x00181a01
MOV RAX,qword ptr [R13]
ADD RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX + 0x18],RAX
ADD RAX,qword ptr [RBX + 0x30]
ADD R15D,dword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x20],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x1b8],RAX
MOV RCX,R13
MOV RDI,qword ptr [RBP + -0x38]
LAB_001819cc:
MOV EAX,R15D
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV qword ptr [RBX + 0x38],RDX
XOR R15D,R15D
TEST R12D,R12D
JLE 0x00181a07
MOV RDX,qword ptr [RBX + 0x18]
SUB EDI,EAX
CMP RDX,RDI
CMOVNC EDX,EDI
MOV dword ptr [RBX + 0x54],EDX
MOV RDI,qword ptr [RCX]
ADD RBX,RAX
MOV RSI,RBX
CALL 0x00129080
JMP 0x00181a07
LAB_00181a01:
MOV R15D,0x20
LAB_00181a07:
MOV EAX,R15D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00181a19:
MOV RDI,RAX
MOV ESI,R12D
MOV RDX,R15
CALL 0x0012e459
JMP 0x00181860
LAB_00181a2c:
MOV R15,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1db9b8]
MOV RDI,R15
MOV RSI,R13
MOV ECX,0x566
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a09a4
MOV RCX,R13
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RCX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x001818a2
|
int8
_mi_pack_get_block_info
(long *param_1,long param_2,byte *param_3,long *param_4,int param_5,long param_6)
{
ulong in_RAX;
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 local_98 [72];
long local_50;
long local_48;
ulong local_40;
long *local_38;
local_50 = param_6;
local_48 = param_2;
local_40 = in_RAX;
if (-1 < param_5) {
uVar4 = (ulong)*(uint *)(*param_1 + 0x240);
local_38 = param_4;
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,8);
if (lVar1 == 0) {
my_seek(param_5,param_6,0,0);
}
else {
_mi_pack_get_block_info_cold_1(lVar1,param_5,param_6);
}
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,6);
local_40 = uVar4;
if (lVar1 == 0) {
lVar2 = my_read(param_5,param_3,uVar4,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,uVar4,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
0x566);
lVar2 = my_read(param_5,param_3,uVar4,4);
uVar6 = 0;
if (lVar2 == 0) {
uVar6 = uVar4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar6);
}
param_4 = local_38;
if (lVar2 != 0) {
return 0x20;
}
}
uVar4 = (ulong)*param_3;
if (uVar4 < 0xfe) {
uVar6 = 1;
}
else if (*param_3 == 0xfe) {
uVar4 = (ulong)*(ushort *)(param_3 + 1);
uVar6 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar4 = (ulong)*(uint3 *)(param_3 + 1);
uVar6 = 4;
}
else {
uVar4 = (ulong)*(uint *)(param_3 + 1);
uVar6 = 5;
}
iVar5 = (int)local_40;
*(ulong *)(param_3 + 0x18) = uVar4;
if (*(int *)(*param_1 + 0x188) != 0) {
uVar3 = (ulong)param_3[uVar6];
if (uVar3 < 0xfe) {
local_38 = (long *)CONCAT44(local_38._4_4_,1);
}
else if (param_3[uVar6] == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,3);
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)CONCAT12(param_3[uVar6 + 3],*(int2 *)(param_3 + uVar6 + 1));
local_38 = (long *)CONCAT44(local_38._4_4_,4);
}
else {
uVar3 = (ulong)*(uint *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,5);
}
*(ulong *)(param_3 + 0x30) = uVar3;
lVar1 = mi_alloc_rec_buff(param_1,uVar4 + uVar3,param_4);
if (lVar1 == 0) {
return 0x20;
}
lVar1 = *param_4;
lVar2 = *(long *)(param_3 + 0x18);
*(long *)(local_48 + 0x18) = lVar1 + lVar2;
uVar6 = (ulong)(uint)((int)uVar6 + (int)local_38);
*(long *)(local_48 + 0x20) = lVar1 + lVar2 + *(long *)(param_3 + 0x30);
param_1[0x37] = *(long *)(param_3 + 0x30);
iVar5 = (int)local_40;
}
*(ulong *)(param_3 + 0x38) = local_50 + uVar6;
if (0 < param_5) {
uVar3 = (ulong)(uint)(iVar5 - (int)uVar6);
uVar4 = *(ulong *)(param_3 + 0x18) & 0xffffffff;
if (uVar3 <= *(ulong *)(param_3 + 0x18)) {
uVar4 = uVar3;
}
*(int *)(param_3 + 0x54) = (int)uVar4;
memcpy((void *)*param_4,param_3 + uVar6,uVar4);
}
return 0;
}
|
|
5,040 |
my_thread_destroy_internal_mutex
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_destroy_internal_mutex(void)
{
mysql_mutex_destroy(&THR_LOCK_threads);
mysql_mutex_destroy(&THR_LOCK_malloc);
mysql_cond_destroy(&THR_COND_threads);
}
|
O3
|
c
|
my_thread_destroy_internal_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x33ecb8(%rip), %rbx # 0x3657d0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x26b36
leaq 0x2c7cf8(%rip), %rax # 0x2ee820
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0x33ec93(%rip), %rdi # 0x3657d0
callq 0x24310
leaq 0x33eccf(%rip), %rbx # 0x365818
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x26b67
leaq 0x2c7cc7(%rip), %rax # 0x2ee820
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0x33ecaa(%rip), %rdi # 0x365818
callq 0x24310
leaq 0x33ece6(%rip), %rax # 0x365860
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x26b95
leaq 0x33ecd6(%rip), %rdi # 0x365860
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24540
callq 0x249a8
jmp 0x26b83
|
my_thread_destroy_internal_mutex:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, THR_LOCK_threads
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_26B36
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_26B36:
lea rdi, THR_LOCK_threads
call _pthread_mutex_destroy
lea rbx, THR_LOCK_malloc
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_26B67
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_26B67:
lea rdi, THR_LOCK_malloc
call _pthread_mutex_destroy
lea rax, THR_COND_threads
mov rdi, [rax+30h]
test rdi, rdi
jnz short loc_26B95
loc_26B83:
lea rdi, THR_COND_threads
add rsp, 8
pop rbx
pop rbp
jmp _pthread_cond_destroy
loc_26B95:
call my_thread_destroy_internal_mutex_cold_1
jmp short loc_26B83
|
long long my_thread_destroy_internal_mutex()
{
long long v0; // rdi
long long v1; // rdi
v0 = THR_LOCK_threads[8];
if ( v0 )
{
(*((void ( **)(long long))PSI_server[0] + 9))(v0);
THR_LOCK_threads[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_threads);
v1 = THR_LOCK_malloc[8];
if ( v1 )
{
(*((void ( **)(long long))PSI_server[0] + 9))(v1);
THR_LOCK_malloc[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_malloc);
if ( THR_COND_threads[6] )
my_thread_destroy_internal_mutex_cold_1();
return pthread_cond_destroy(THR_COND_threads);
}
|
my_thread_destroy_internal_mutex:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0x4657d0]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x00126b36
LEA RAX,[0x3ee820]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_00126b36:
LEA RDI,[0x4657d0]
CALL 0x00124310
LEA RBX,[0x465818]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x00126b67
LEA RAX,[0x3ee820]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_00126b67:
LEA RDI,[0x465818]
CALL 0x00124310
LEA RAX,[0x465860]
MOV RDI,qword ptr [RAX + 0x30]
TEST RDI,RDI
JNZ 0x00126b95
LAB_00126b83:
LEA RDI,[0x465860]
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00124540
LAB_00126b95:
CALL 0x001249a8
JMP 0x00126b83
|
void my_thread_destroy_internal_mutex(void)
{
if (THR_LOCK_threads._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_threads._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_threads);
if (THR_LOCK_malloc._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_malloc._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_malloc);
if (THR_COND_threads._48_8_ != 0) {
my_thread_destroy_internal_mutex_cold_1();
}
pthread_cond_destroy((pthread_cond_t *)THR_COND_threads);
return;
}
|
|
5,041 |
minja::Value::to_int() const
|
monkey531[P]llama/common/minja.hpp
|
int64_t to_int() const {
if (is_null()) return 0;
if (is_boolean()) return get<bool>() ? 1 : 0;
if (is_number()) return static_cast<int64_t>(get<double>());
if (is_string()) {
try {
return std::stol(get<std::string>());
} catch (const std::exception &) {
return 0;
}
}
return 0;
}
|
O2
|
cpp
|
minja::Value::to_int() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x66168
testb %al, %al
je 0x84c03
xorl %ebx, %ebx
jmp 0x84c5b
movb 0x40(%rbx), %al
cmpb $0x4, %al
jne 0x84c17
movq %rbx, %rdi
callq 0x664fc
movzbl %al, %ebx
jmp 0x84c5b
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x84c2e
movq %rbx, %rdi
callq 0x65a9a
cvttsd2si %xmm0, %rbx
jmp 0x84c5b
cmpb $0x3, %al
jne 0x84bff
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x665b2
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x84c9b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25478
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25478
jmp 0x84c7e
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x84c96
callq 0x24400
callq 0x25080
jmp 0x84bff
callq 0x251e0
|
_ZNK5minja5Value6to_intEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_84C03
loc_84BFF:
xor ebx, ebx
jmp short loc_84C5B
loc_84C03:
mov al, [rbx+40h]
cmp al, 4
jnz short loc_84C17
mov rdi, rbx
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
movzx ebx, al
jmp short loc_84C5B
loc_84C17:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_84C2E
mov rdi, rbx
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
cvttsd2si rbx, xmm0
jmp short loc_84C5B
loc_84C2E:
cmp al, 3
jnz short loc_84BFF
lea rdi, [rsp+38h+var_30]
mov rsi, rbx
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+38h+var_30]
push 0Ah
pop rdx
xor esi, esi
call _ZNSt7__cxx114stolERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stol(std::string const&,ulong *,int)
mov rbx, rax
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_84C5B:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_84C7E
mov r14, rdx
mov rbx, rax
loc_84C7E:
mov rdi, rbx; void *
cmp r14d, 1
jnz short loc_84C96
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_84BFF
loc_84C96:
call __Unwind_Resume
|
long long minja::Value::to_int(minja::Value *this, double a2)
{
long long v2; // rbx
char v3; // al
_BYTE v5[48]; // [rsp+8h] [rbp-30h] BYREF
if ( !minja::Value::is_null(this) )
{
v3 = *((_BYTE *)this + 64);
if ( v3 == 4 )
return (unsigned __int8)minja::Value::get<bool>(this);
if ( (unsigned __int8)(v3 - 5) <= 2u )
{
minja::Value::get<double>(this);
return (unsigned int)(int)a2;
}
if ( v3 == 3 )
{
minja::Value::get<std::string>((long long)v5, this);
v2 = std::stol(v5, 0LL, 10LL);
std::string::~string(v5);
return v2;
}
}
return 0LL;
}
|
to_int:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CALL 0x00166168
TEST AL,AL
JZ 0x00184c03
LAB_00184bff:
XOR EBX,EBX
JMP 0x00184c5b
LAB_00184c03:
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
JNZ 0x00184c17
MOV RDI,RBX
CALL 0x001664fc
MOVZX EBX,AL
JMP 0x00184c5b
LAB_00184c17:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x00184c2e
MOV RDI,RBX
CALL 0x00165a9a
CVTTSD2SI RBX,XMM0
JMP 0x00184c5b
LAB_00184c2e:
CMP AL,0x3
JNZ 0x00184bff
LAB_00184c32:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
CALL 0x001665b2
LAB_00184c3f:
LEA RDI,[RSP + 0x8]
PUSH 0xa
POP RDX
XOR ESI,ESI
CALL 0x00184c9b
LAB_00184c4e:
MOV RBX,RAX
LEA RDI,[RSP + 0x8]
CALL 0x00125478
LAB_00184c5b:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* minja::Value::to_int() const */
ulong __thiscall minja::Value::to_int(Value *this)
{
Value VVar1;
char cVar2;
bool bVar3;
ulong uVar4;
double dVar5;
string local_30 [32];
cVar2 = is_null(this);
if (cVar2 == '\0') {
VVar1 = this[0x40];
if (VVar1 == (Value)0x4) {
bVar3 = get<bool>(this);
return (ulong)bVar3;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar5 = get<double>(this);
return (long)dVar5;
}
if (VVar1 == (Value)0x3) {
/* try { // try from 00184c32 to 00184c3e has its CatchHandler @ 00184c78 */
get<std::__cxx11::string>();
/* try { // try from 00184c3f to 00184c4d has its CatchHandler @ 00184c66 */
uVar4 = std::__cxx11::stol(local_30,(ulong *)0x0,10);
std::__cxx11::string::~string(local_30);
return uVar4;
}
}
return 0;
}
|
|
5,042 |
ttt::game::Game::get_player(ttt::game::Sign) const
|
vsennov[P]tictactoe-course/src/core/game.cpp
|
const IPlayer *Game::get_player(Sign sign) const {
switch (sign) {
case Sign::X:
return m_x_player;
case Sign::O:
return m_o_player;
default:
return 0;
}
}
|
O0
|
cpp
|
ttt::game::Game::get_player(ttt::game::Sign) const:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x2db9
jmp 0x2daf
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x2dc7
jmp 0x2dd5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ddd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ddd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZNK3ttt4game4Game10get_playerENS0_4SignE:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov eax, [rbp+var_14]
mov [rbp+var_18], eax
test eax, eax
jz short loc_2DB9
jmp short $+2
loc_2DAF:
mov eax, [rbp+var_18]
sub eax, 1
jz short loc_2DC7
jmp short loc_2DD5
loc_2DB9:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_8], rax
jmp short loc_2DDD
loc_2DC7:
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov [rbp+var_8], rax
jmp short loc_2DDD
loc_2DD5:
mov [rbp+var_8], 0
loc_2DDD:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long ttt::game::Game::get_player(long long a1, int a2)
{
if ( !a2 )
return *(_QWORD *)(a1 + 16);
if ( a2 == 1 )
return *(_QWORD *)(a1 + 24);
return 0LL;
}
|
get_player:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x18],EAX
TEST EAX,EAX
JZ 0x00102db9
JMP 0x00102daf
LAB_00102daf:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
JZ 0x00102dc7
JMP 0x00102dd5
LAB_00102db9:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00102ddd
LAB_00102dc7:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00102ddd
LAB_00102dd5:
MOV qword ptr [RBP + -0x8],0x0
LAB_00102ddd:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
/* ttt::game::Game::get_player(ttt::game::Sign) const */
int8 __thiscall ttt::game::Game::get_player(Game *this,int param_2)
{
int8 local_10;
if (param_2 == 0) {
local_10 = *(int8 *)(this + 0x10);
}
else if (param_2 == 1) {
local_10 = *(int8 *)(this + 0x18);
}
else {
local_10 = 0;
}
return local_10;
}
|
|
5,043 |
evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&)
|
corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline Result datacopy(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto data = state.analysis.baseline->eof_data();
const auto& mem_index = stack.pop();
const auto& data_index = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, mem_index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto dst = static_cast<size_t>(mem_index);
// TODO why?
const auto src = data.size() < data_index ? data.size() : static_cast<size_t>(data_index);
const auto s = static_cast<size_t>(size);
const auto copy_size = std::min(s, data.size() - src);
if (const auto cost = copy_cost(s); (gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
if (copy_size > 0)
std::memcpy(&state.memory[dst], &data[src], copy_size);
if (s - copy_size > 0)
std::memset(&state.memory[dst + copy_size], 0, s - copy_size);
return {EVMC_SUCCESS, gas_left};
}
|
O0
|
cpp
|
evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1f8(%rax), %rdi
callq 0x6f830
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x20(%rbp), %rdi
callq 0x68460
testb $0x1, %al
jne 0x6fa77
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fbc2
movq -0x40(%rbp), %rdi
callq 0x68550
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e5d0
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x69080
testb $0x1, %al
jne 0x6faa4
jmp 0x6fab6
leaq -0x38(%rbp), %rdi
callq 0x3e5d0
movq %rax, -0x90(%rbp)
jmp 0x6fac6
movq -0x48(%rbp), %rdi
callq 0x68550
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
callq 0x68550
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3e5d0
subq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3a680
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x692b0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x6fb3f
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6fbc2
cmpq $0x0, -0x78(%rbp)
jbe 0x6fb7e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x58(%rbp), %rsi
callq 0x60120
movq %rax, -0x98(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x694e0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
movq -0x78(%rbp), %rdx
callq 0x230a0
movq -0x70(%rbp), %rax
subq -0x78(%rbp), %rax
cmpq $0x0, %rax
jbe 0x6fbb3
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x58(%rbp), %rsi
addq -0x78(%rbp), %rsi
callq 0x60120
movq %rax, %rdi
movq -0x70(%rbp), %rdx
subq -0x78(%rbp), %rdx
xorl %esi, %esi
callq 0x231c0
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN6evmone5instr4core8datacopyENS_8StackTopElRNS_14ExecutionStateE:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov rax, [rbp+var_28]
mov rdi, [rax+1F8h]; this
call _ZNK6evmone8baseline12CodeAnalysis8eof_dataEv; evmone::baseline::CodeAnalysis::eof_data(void)
mov [rbp+var_38], rax
mov [rbp+var_30], rdx
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_40], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_48], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_50], rax
mov rsi, [rbp+var_28]
add rsi, 8
mov rdx, [rbp+var_40]
mov rcx, [rbp+var_50]
lea rdi, [rbp+var_20]
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, 1
jnz short loc_6FA77
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_6FBC2
loc_6FA77:
mov rdi, [rbp+var_40]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_58], rax
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEE4sizeEv; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::size(void)
mov [rbp+var_68], rax
mov rsi, [rbp+var_48]
lea rdi, [rbp+var_68]
call _ZN4intxltILj256EmvEEbRKT0_RKNS_4uintIXT_EEE; intx::operator<<256u,ulong,void>(ulong const&,intx::uint<256u> const&)
test al, 1
jnz short loc_6FAA4
jmp short loc_6FAB6
loc_6FAA4:
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEE4sizeEv; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::size(void)
mov [rbp+var_90], rax
jmp short loc_6FAC6
loc_6FAB6:
mov rdi, [rbp+var_48]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_90], rax
loc_6FAC6:
mov rax, [rbp+var_90]
mov [rbp+var_60], rax
mov rdi, [rbp+var_50]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_70], rax
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEE4sizeEv; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::size(void)
sub rax, [rbp+var_60]
mov [rbp+var_80], rax
lea rdi, [rbp+var_70]
lea rsi, [rbp+var_80]; unsigned __int64
call _ZSt3minImERKT_S2_S2_; std::min<ulong>(ulong const&,ulong const&)
mov rax, [rax]
mov [rbp+var_78], rax
mov rdi, [rbp+var_70]; this
call _ZN6evmone9copy_costEm; evmone::copy_cost(ulong)
mov [rbp+var_88], rax
mov rcx, [rbp+var_88]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jge short loc_6FB3F
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_6FBC2
loc_6FB3F:
cmp [rbp+var_78], 0
jbe short loc_6FB7E
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_58]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov [rbp+var_98], rax
mov rsi, [rbp+var_60]
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIhN4evmc11byte_traitsIhEEEixEm; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::operator[](ulong)
mov rdi, [rbp+var_98]
mov rsi, rax
mov rdx, [rbp+var_78]
call _memcpy
loc_6FB7E:
mov rax, [rbp+var_70]
sub rax, [rbp+var_78]
cmp rax, 0
jbe short loc_6FBB3
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_58]
add rsi, [rbp+var_78]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov rdi, rax
mov rdx, [rbp+var_70]
sub rdx, [rbp+var_78]
xor esi, esi
call _memset
loc_6FBB3:
mov [rbp+var_10], 0
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_6FBC2:
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long evmone::instr::core::datacopy(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v8; // [rsp+8h] [rbp-98h]
long long v9; // [rsp+10h] [rbp-90h]
unsigned long long v10; // [rsp+18h] [rbp-88h]
unsigned long long v11; // [rsp+20h] [rbp-80h] BYREF
evmone *v12; // [rsp+28h] [rbp-78h]
evmone *v13; // [rsp+30h] [rbp-70h] BYREF
long long v14; // [rsp+38h] [rbp-68h] BYREF
long long v15; // [rsp+40h] [rbp-60h]
long long v16; // [rsp+48h] [rbp-58h]
long long v17; // [rsp+50h] [rbp-50h]
long long v18; // [rsp+58h] [rbp-48h]
long long v19; // [rsp+60h] [rbp-40h]
_QWORD v20[2]; // [rsp+68h] [rbp-38h] BYREF
long long v21; // [rsp+78h] [rbp-28h]
long long v22; // [rsp+80h] [rbp-20h] BYREF
long long v23; // [rsp+88h] [rbp-18h] BYREF
unsigned int v24; // [rsp+90h] [rbp-10h]
long long v25; // [rsp+98h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20[0] = evmone::baseline::CodeAnalysis::eof_data(*(evmone::baseline::CodeAnalysis **)(a3 + 504));
v20[1] = v3;
v19 = evmone::StackTop::pop((evmone::StackTop *)&v23);
v18 = evmone::StackTop::pop((evmone::StackTop *)&v23);
v17 = evmone::StackTop::pop((evmone::StackTop *)&v23);
if ( (evmone::check_memory((long long)&v22, v21 + 8, v19, v17) & 1) != 0 )
{
v16 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v19);
v14 = std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::size((long long)v20);
if ( intx::operator<<256u,unsigned long,void>(&v14, v18) )
v9 = std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::size((long long)v20);
else
v9 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v18);
v15 = v9;
v13 = (evmone *)intx::uint<256u>::operator unsigned long<unsigned long,void>(v17);
v4 = std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::size((long long)v20);
v11 = v4 - v15;
v12 = (evmone *)*std::min<unsigned long>(&v13, &v11);
v10 = evmone::copy_cost(v13);
v22 -= v10;
if ( v22 >= 0 )
{
if ( v12 )
{
v8 = evmone::Memory::operator[](v21 + 8, v16);
v5 = std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::operator[]((long long)v20, v15);
memcpy(v8, v5, v12);
}
if ( v13 != v12 )
{
v6 = evmone::Memory::operator[](v21 + 8, (long long)v12 + v16);
memset(v6, 0LL, v13 - v12);
}
v24 = 0;
v25 = v22;
}
else
{
v24 = 3;
v25 = v22;
}
}
else
{
v24 = 3;
v25 = v22;
}
return v24;
}
|
datacopy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x1f8]
CALL 0x0016f830
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x30],RDX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x40],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x50],RAX
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x8
MOV RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x50]
LEA RDI,[RBP + -0x20]
CALL 0x00168460
TEST AL,0x1
JNZ 0x0016fa77
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016fbc2
LAB_0016fa77:
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00168550
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0013e5d0
MOV qword ptr [RBP + -0x68],RAX
MOV RSI,qword ptr [RBP + -0x48]
LEA RDI,[RBP + -0x68]
CALL 0x00169080
TEST AL,0x1
JNZ 0x0016faa4
JMP 0x0016fab6
LAB_0016faa4:
LEA RDI,[RBP + -0x38]
CALL 0x0013e5d0
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0016fac6
LAB_0016fab6:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00168550
MOV qword ptr [RBP + -0x90],RAX
LAB_0016fac6:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00168550
MOV qword ptr [RBP + -0x70],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0013e5d0
SUB RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x80],RAX
LEA RDI,[RBP + -0x70]
LEA RSI,[RBP + -0x80]
CALL 0x0013a680
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x001692b0
MOV qword ptr [RBP + -0x88],RAX
MOV RCX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JGE 0x0016fb3f
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016fbc2
LAB_0016fb3f:
CMP qword ptr [RBP + -0x78],0x0
JBE 0x0016fb7e
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x58]
CALL 0x00160120
MOV qword ptr [RBP + -0x98],RAX
MOV RSI,qword ptr [RBP + -0x60]
LEA RDI,[RBP + -0x38]
CALL 0x001694e0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x001230a0
LAB_0016fb7e:
MOV RAX,qword ptr [RBP + -0x70]
SUB RAX,qword ptr [RBP + -0x78]
CMP RAX,0x0
JBE 0x0016fbb3
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,qword ptr [RBP + -0x78]
CALL 0x00160120
MOV RDI,RAX
MOV RDX,qword ptr [RBP + -0x70]
SUB RDX,qword ptr [RBP + -0x78]
XOR ESI,ESI
CALL 0x001231c0
LAB_0016fbb3:
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016fbc2:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
/* evmone::instr::core::datacopy(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::datacopy(int8 param_1,long param_2,long param_3)
{
bool bVar1;
ulong uVar2;
long lVar3;
ulong *puVar4;
void *pvVar5;
void *__src;
int1 auVar6 [16];
ulong local_98;
ulong local_88;
ulong local_80;
ulong local_78;
ulong local_70;
ulong local_68;
ulong local_60;
uint *local_58;
uint *local_50;
uint *local_48;
basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> local_40 [16];
long local_30;
long local_28;
int8 local_20;
uint local_18;
long local_10;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_40 = (basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> [16])
baseline::CodeAnalysis::eof_data(*(CodeAnalysis **)(param_3 + 0x1f8));
local_48 = (uint *)StackTop::pop((StackTop *)&local_20);
local_50 = (uint *)StackTop::pop((StackTop *)&local_20);
local_58 = (uint *)StackTop::pop((StackTop *)&local_20);
uVar2 = check_memory(&local_28,(Memory *)(local_30 + 8),local_48,local_58);
if ((uVar2 & 1) == 0) {
local_18 = 3;
local_10 = local_28;
}
else {
local_60 = intx::uint::operator_cast_to_unsigned_long(local_48);
local_70 = std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::size
(local_40);
bVar1 = intx::operator<(&local_70,local_50);
if (bVar1) {
local_98 = std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::size
(local_40);
}
else {
local_98 = intx::uint::operator_cast_to_unsigned_long(local_50);
}
local_68 = local_98;
local_78 = intx::uint::operator_cast_to_unsigned_long(local_58);
lVar3 = std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::size(local_40);
local_88 = lVar3 - local_68;
puVar4 = std::min<unsigned_long>(&local_78,&local_88);
local_80 = *puVar4;
lVar3 = copy_cost(local_78);
local_28 = local_28 - lVar3;
if (local_28 < 0) {
local_18 = 3;
local_10 = local_28;
}
else {
if (local_80 != 0) {
pvVar5 = (void *)Memory::operator[]((Memory *)(local_30 + 8),local_60);
__src = (void *)std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::
operator[](local_40,local_68);
memcpy(pvVar5,__src,local_80);
}
if (local_78 != local_80) {
pvVar5 = (void *)Memory::operator[]((Memory *)(local_30 + 8),local_60 + local_80);
memset(pvVar5,0,local_78 - local_80);
}
local_18 = 0;
local_10 = local_28;
}
}
auVar6._4_4_ = 0;
auVar6._0_4_ = local_18;
auVar6._8_8_ = local_10;
return auVar6;
}
|
|
5,044 |
ma_bitmap_reset_full_page_bits
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page,
uint page_count)
{
ulonglong bitmap_page;
uint offset, bit_start, bit_count, tmp, byte_offset;
uchar *data;
DBUG_ENTER("_ma_bitmap_reset_full_page_bits");
DBUG_PRINT("enter", ("page: %lu page_count: %u", (ulong) page, page_count));
mysql_mutex_assert_owner(&info->s->bitmap.bitmap_lock);
bitmap_page= page - page % bitmap->pages_covered;
DBUG_ASSERT(page != bitmap_page);
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(1);
/* Find page number from start of bitmap */
offset= (uint) (page - bitmap->page - 1);
/* Clear bits from 'page * 3' -> '(page + page_count) * 3' */
bit_start= offset * 3;
bit_count= page_count * 3;
byte_offset= bit_start/8;
data= bitmap->map + byte_offset;
offset= bit_start & 7;
tmp= (255 << offset); /* Bits to keep */
if (bit_count + offset < 8)
{
/* Only clear bits between 'offset' and 'offset+bit_count-1' */
tmp^= (255 << (offset + bit_count));
}
*data&= ~tmp;
set_if_smaller(bitmap->full_head_size, byte_offset);
set_if_smaller(bitmap->full_tail_size, byte_offset);
if ((int) (bit_count-= (8 - offset)) > 0)
{
uint fill;
data++;
/*
-1 is here to avoid one 'if' statement and to let the following code
handle the last byte
*/
if ((fill= (bit_count - 1) / 8))
{
bzero(data, fill);
data+= fill;
}
bit_count-= fill * 8; /* Bits left to clear */
tmp= (1 << bit_count) - 1;
*data&= ~tmp;
}
set_if_smaller(info->s->state.first_bitmap_with_space, bitmap_page);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_bitmap_reset_full_page_bits:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
jmp 0x615c9
jmp 0x615cb
jmp 0x615cd
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
movq -0x60(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x30(%rbp)
jmp 0x615f3
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x61625
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x612f0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x61625
jmp 0x6161c
movb $0x1, -0x1(%rbp)
jmp 0x61793
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
movl %eax, -0x34(%rbp)
imull $0x3, -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
imull $0x3, -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x44(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movl $0xff, %eax
shll %cl, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl $0x8, %eax
jae 0x61695
movl -0x34(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl $0xff, %eax
shll %cl, %eax
xorl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
xorl $-0x1, %edx
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x44(%rbp), %eax
jbe 0x616bc
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x616be
jmp 0x616c0
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0x44(%rbp), %eax
jbe 0x616d6
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x616d8
movl $0x8, %ecx
subl -0x34(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jle 0x61759
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movl -0x3c(%rbp), %eax
subl $0x1, %eax
shrl $0x3, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x6172a
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
movl -0x54(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %ecx
shll $0x3, %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
xorl $-0x1, %edx
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
jmp 0x6175b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rax
cmpq -0x30(%rbp), %rax
jbe 0x61781
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xd0(%rax)
jmp 0x61783
movq -0x18(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x6178d
jmp 0x6178f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
_ma_bitmap_reset_full_page_bits:
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_24], ecx
jmp short $+2
loc_615C9:
jmp short $+2
loc_615CB:
jmp short $+2
loc_615CD:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
xor edx, edx
div qword ptr [rcx+138h]
mov rax, [rbp+var_60]
sub rax, rdx
mov [rbp+var_30], rax
jmp short $+2
loc_615F3:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
cmp rax, [rcx+10h]
jz short loc_61625
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
call _ma_change_bitmap_page
movsx eax, al
cmp eax, 0
jz short loc_61625
jmp short $+2
loc_6161C:
mov [rbp+var_1], 1
jmp loc_61793
loc_61625:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, [rcx+10h]
sub rax, 1
mov [rbp+var_34], eax
imul eax, [rbp+var_34], 3
mov [rbp+var_38], eax
imul eax, [rbp+var_24], 3
mov [rbp+var_3C], eax
mov eax, [rbp+var_38]
shr eax, 3
mov [rbp+var_44], eax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov ecx, [rbp+var_44]
add rax, rcx
mov [rbp+var_50], rax
mov eax, [rbp+var_38]
and eax, 7
mov [rbp+var_34], eax
mov ecx, [rbp+var_34]
mov eax, 0FFh
shl eax, cl
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
add eax, [rbp+var_34]
cmp eax, 8
jnb short loc_61695
mov ecx, [rbp+var_34]
add ecx, [rbp+var_3C]
mov eax, 0FFh
shl eax, cl
xor eax, [rbp+var_40]
mov [rbp+var_40], eax
loc_61695:
mov edx, [rbp+var_40]
xor edx, 0FFFFFFFFh
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
and ecx, edx
mov [rax], cl
mov rax, [rbp+var_18]
mov eax, [rax+28h]
cmp eax, [rbp+var_44]
jbe short loc_616BC
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
mov [rax+28h], ecx
loc_616BC:
jmp short $+2
loc_616BE:
jmp short $+2
loc_616C0:
mov rax, [rbp+var_18]
mov eax, [rax+2Ch]
cmp eax, [rbp+var_44]
jbe short loc_616D6
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
mov [rax+2Ch], ecx
loc_616D6:
jmp short $+2
loc_616D8:
mov ecx, 8
sub ecx, [rbp+var_34]
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
cmp eax, 0
jle short loc_61759
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov eax, [rbp+var_3C]
sub eax, 1
shr eax, 3
mov [rbp+var_54], eax
cmp eax, 0
jz short loc_6172A
mov rdi, [rbp+var_50]
mov eax, [rbp+var_54]
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_54]
mov rax, [rbp+var_50]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
loc_6172A:
mov ecx, [rbp+var_54]
shl ecx, 3
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
mov ecx, [rbp+var_3C]
mov eax, 1
shl eax, cl
sub eax, 1
mov [rbp+var_40], eax
mov edx, [rbp+var_40]
xor edx, 0FFFFFFFFh
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
and ecx, edx
mov [rax], cl
loc_61759:
jmp short $+2
loc_6175B:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+0D0h]
cmp rax, [rbp+var_30]
jbe short loc_61781
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+0D0h], rcx
loc_61781:
jmp short $+2
loc_61783:
mov rax, [rbp+var_18]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_6178D:
jmp short $+2
loc_6178F:
mov [rbp+var_1], 0
loc_61793:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
|
char ma_bitmap_reset_full_page_bits(long long *a1, long long a2, unsigned long long a3, int a4)
{
unsigned int v5; // [rsp+Ch] [rbp-54h]
_BYTE *v6; // [rsp+10h] [rbp-50h]
_BYTE *v7; // [rsp+10h] [rbp-50h]
unsigned int v8; // [rsp+1Ch] [rbp-44h]
int v9; // [rsp+20h] [rbp-40h]
int v10; // [rsp+24h] [rbp-3Ch]
int v11; // [rsp+24h] [rbp-3Ch]
int v12; // [rsp+2Ch] [rbp-34h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14; // [rsp+30h] [rbp-30h]
int v16; // [rsp+40h] [rbp-20h]
v16 = a3;
v14 = a3 - a3 % *(_QWORD *)(a2 + 312);
if ( v14 != *(_QWORD *)(a2 + 16) && ma_change_bitmap_page(a1, a2, v14) )
return 1;
v12 = v16 - *(_DWORD *)(a2 + 16) - 1;
v10 = 3 * a4;
v8 = (unsigned int)(3 * v12) >> 3;
v6 = (_BYTE *)(v8 + *(_QWORD *)(a2 + 8));
v13 = (3 * (_BYTE)v12) & 7;
v9 = 255 << v13;
if ( (unsigned int)(v13 + 3 * a4) < 8 )
v9 ^= 255 << (v10 + v13);
*v6 &= ~(_BYTE)v9;
if ( *(_DWORD *)(a2 + 40) > v8 )
*(_DWORD *)(a2 + 40) = v8;
if ( *(_DWORD *)(a2 + 44) > v8 )
*(_DWORD *)(a2 + 44) = v8;
v11 = v10 - (8 - v13);
if ( v11 > 0 )
{
v7 = v6 + 1;
v5 = (unsigned int)(v11 - 1) >> 3;
if ( v5 )
{
memset(v7, 0LL, v5);
v7 += v5;
}
*v7 &= ~((1 << (v11 - 8 * v5)) - 1);
}
if ( *(_QWORD *)(*a1 + 208) > v14 )
*(_QWORD *)(*a1 + 208) = v14;
*(_BYTE *)(a2 + 32) = 1;
return 0;
}
|
_ma_bitmap_reset_full_page_bits:
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 dword ptr [RBP + -0x24],ECX
JMP 0x001615c9
LAB_001615c9:
JMP 0x001615cb
LAB_001615cb:
JMP 0x001615cd
LAB_001615cd:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
MOV RAX,qword ptr [RBP + -0x60]
SUB RAX,RDX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001615f3
LAB_001615f3:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x00161625
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001612f0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00161625
JMP 0x0016161c
LAB_0016161c:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00161793
LAB_00161625:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RCX + 0x10]
SUB RAX,0x1
MOV dword ptr [RBP + -0x34],EAX
IMUL EAX,dword ptr [RBP + -0x34],0x3
MOV dword ptr [RBP + -0x38],EAX
IMUL EAX,dword ptr [RBP + -0x24],0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x38]
SHR EAX,0x3
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x44]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x38]
AND EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV ECX,dword ptr [RBP + -0x34]
MOV EAX,0xff
SHL EAX,CL
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,dword ptr [RBP + -0x34]
CMP EAX,0x8
JNC 0x00161695
MOV ECX,dword ptr [RBP + -0x34]
ADD ECX,dword ptr [RBP + -0x3c]
MOV EAX,0xff
SHL EAX,CL
XOR EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x40],EAX
LAB_00161695:
MOV EDX,dword ptr [RBP + -0x40]
XOR EDX,0xffffffff
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
AND ECX,EDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x28]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x001616bc
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x28],ECX
LAB_001616bc:
JMP 0x001616be
LAB_001616be:
JMP 0x001616c0
LAB_001616c0:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x2c]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x001616d6
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x2c],ECX
LAB_001616d6:
JMP 0x001616d8
LAB_001616d8:
MOV ECX,0x8
SUB ECX,dword ptr [RBP + -0x34]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JLE 0x00161759
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
SHR EAX,0x3
MOV dword ptr [RBP + -0x54],EAX
CMP EAX,0x0
JZ 0x0016172a
MOV RDI,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_0016172a:
MOV ECX,dword ptr [RBP + -0x54]
SHL ECX,0x3
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV EAX,0x1
SHL EAX,CL
SUB EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
MOV EDX,dword ptr [RBP + -0x40]
XOR EDX,0xffffffff
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
AND ECX,EDX
MOV byte ptr [RAX],CL
LAB_00161759:
JMP 0x0016175b
LAB_0016175b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xd0]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00161781
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0xd0],RCX
LAB_00161781:
JMP 0x00161783
LAB_00161783:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x0016178d
LAB_0016178d:
JMP 0x0016178f
LAB_0016178f:
MOV byte ptr [RBP + -0x1],0x0
LAB_00161793:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int1 _ma_bitmap_reset_full_page_bits(long *param_1,long param_2,ulong param_3,int param_4)
{
char cVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
byte *local_58;
byte local_48;
uVar4 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
if ((uVar4 != *(ulong *)(param_2 + 0x10)) &&
(cVar1 = _ma_change_bitmap_page(param_1,param_2,uVar4), cVar1 != '\0')) {
return 1;
}
uVar2 = (((int)param_3 - (int)*(int8 *)(param_2 + 0x10)) + -1) * 3;
param_4 = param_4 * 3;
uVar3 = uVar2 >> 3;
local_58 = (byte *)(*(long *)(param_2 + 8) + (ulong)uVar3);
uVar2 = uVar2 & 7;
local_48 = (byte)(0xff << (sbyte)uVar2);
if (param_4 + uVar2 < 8) {
local_48 = (byte)(0xff << ((sbyte)uVar2 + (char)param_4 & 0x1fU)) ^ local_48;
}
*local_58 = *local_58 & (local_48 ^ 0xff);
if (uVar3 < *(uint *)(param_2 + 0x28)) {
*(uint *)(param_2 + 0x28) = uVar3;
}
if (uVar3 < *(uint *)(param_2 + 0x2c)) {
*(uint *)(param_2 + 0x2c) = uVar3;
}
param_4 = param_4 - (8 - uVar2);
if (0 < param_4) {
local_58 = local_58 + 1;
uVar3 = param_4 - 1U >> 3;
if (uVar3 != 0) {
memset(local_58,0,(ulong)uVar3);
local_58 = local_58 + uVar3;
}
*local_58 = *local_58 & ((char)(1 << ((char)param_4 + (char)uVar3 * -8 & 0x1fU)) - 1U ^ 0xff);
}
if (uVar4 < *(ulong *)(*param_1 + 0xd0)) {
*(ulong *)(*param_1 + 0xd0) = uVar4;
}
*(int1 *)(param_2 + 0x20) = 1;
return 0;
}
|
|
5,045 |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/./json.hpp
|
std::string exception_message(const token_type expected, const std::string& context)
{
std::string error_msg = "syntax error ";
if (!context.empty())
{
error_msg += concat("while parsing ", context, ' ');
}
error_msg += "- ";
if (last_token == token_type::parse_error)
{
error_msg += concat(m_lexer.get_error_message(), "; last read: '",
m_lexer.get_token_string(), '\'');
}
else
{
error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
}
if (expected != token_type::uninitialized)
{
error_msg += concat("; expected ", lexer_t::token_type_name(expected));
}
return error_msg;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0xa1d30(%rip), %rsi # 0xcad7f
leaq 0xa1d36(%rip), %rdx # 0xcad8c
callq 0x237c2
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x290e2
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addq $0xf, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1dbc0
leaq 0xa1cfe(%rip), %rsi # 0xcad8d
leaq 0x8(%rsp), %rdi
callq 0x1d920
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1d470
leaq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x1e070
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d470
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x290e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
leaq 0xa1cb3(%rip), %rsi # 0xcad9c
movq %rbx, %rdi
callq 0x1d920
movl 0x20(%r14), %edi
cmpl $0xe, %edi
jne 0x29185
movq 0x98(%r14), %rax
addq $0x28, %r14
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x28d70
leaq 0x2f(%rsp), %r8
movb $0x27, (%r8)
leaq 0xa1c74(%rip), %rdx # 0xcad9f
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rcx
callq 0x2e260
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d470
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2916c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x291ff
movq 0x48(%rsp), %rsi
jmp 0x291f7
callq 0x2e322
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x1d550
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1dbc0
leaq 0xa1bef(%rip), %rsi # 0xcadae
leaq 0x8(%rsp), %rdi
callq 0x1d920
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1d920
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d470
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x291ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
testl %ebp, %ebp
je 0x2927f
movl %ebp, %edi
callq 0x2e322
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x1d550
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1dbc0
leaq 0xa1b7b(%rip), %rsi # 0xcadba
leaq 0x8(%rsp), %rdi
callq 0x1d920
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1d920
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d470
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2927f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x292d8
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x292b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0x292b6
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29301
movq 0x48(%rsp), %rsi
jmp 0x292f9
jmp 0x292d1
jmp 0x292d8
jmp 0x292e7
movq %rax, %r14
jmp 0x29301
jmp 0x292d8
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x292f4
jmp 0x29301
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x29301
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x29315
movq (%r12), %rsi
incq %rsi
callq 0x1d160
movq %r14, %rdi
callq 0x1d8e0
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE17exception_messageENS1_10lexer_baseISF_E10token_typeERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rcx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
lea rsi, aSyntaxError; "syntax error "
lea rdx, aSyntaxError+0Dh; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [r15+8]
test rsi, rsi
jz short loc_290E2
lea r13, [rsp+88h+var_70]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
add rsi, 0Fh
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aWhileParsing; "while parsing "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rdi, [rsp+88h+var_80]
mov esi, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r13
jz short loc_290E2
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_290E2:
lea rsi, asc_CAD9C; "- "
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov edi, [r14+20h]
cmp edi, 0Eh
jnz loc_29185
mov rax, [r14+98h]
add r14, 28h ; '('
mov [rsp+88h+var_58], rax
lea rdi, [rsp+88h+var_50]
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(void)
lea r8, [rsp+88h+var_59]
mov byte ptr [r8], 27h ; '''
lea rdx, aLastRead; "; last read: '"
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_58]
lea rcx, [rsp+88h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJPKcRA15_S9_S8_cEEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(char const*,char const(&)[15],std::string,char &&)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2916C
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2916C:
lea rax, [rsp+88h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz loc_291FF
mov rsi, [rsp+88h+var_40]
jmp short loc_291F7
loc_29185:
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aUnexpected; "unexpected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_291FF
mov rsi, [rsp+88h+var_70]
loc_291F7:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_291FF:
test ebp, ebp
jz short loc_2927F
mov edi, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aExpected; "; expected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_2927F
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2927F:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_292D8
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_292B6
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_292B6
mov r14, rax
loc_292B6:
lea rax, [rsp+arg_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_29301
mov rsi, [rsp+arg_40]
jmp short loc_292F9
jmp short loc_292D1
jmp short loc_292D8
jmp short loc_292E7
loc_292D1:
mov r14, rax
jmp short loc_29301
jmp short $+2
loc_292D8:
mov r14, rax
mov rdi, [rsp+arg_0]
cmp rdi, r15
jnz short loc_292F4
jmp short loc_29301
loc_292E7:
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_29301
loc_292F4:
mov rsi, [rsp+arg_10]
loc_292F9:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_29301:
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_29315
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_29315:
mov rdi, r14
call __Unwind_Resume
|
_QWORD * nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::exception_message(
_QWORD *a1,
long long a2,
unsigned int a3,
_QWORD *a4)
{
long long v8; // rsi
void *v9; // rdi
long long v10; // rsi
long long v11; // r14
long long v12; // rax
long long v13; // r14
long long v14; // rax
void *v16; // [rsp+8h] [rbp-80h] BYREF
long long v17; // [rsp+10h] [rbp-78h]
_QWORD v18[2]; // [rsp+18h] [rbp-70h] BYREF
char v19; // [rsp+2Fh] [rbp-59h] BYREF
long long v20; // [rsp+30h] [rbp-58h] BYREF
_QWORD v21[2]; // [rsp+38h] [rbp-50h] BYREF
long long v22; // [rsp+48h] [rbp-40h] BYREF
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "syntax error ", (long long)"");
v8 = a4[1];
if ( v8 )
{
v16 = v18;
v17 = 0LL;
LOBYTE(v18[0]) = 0;
std::string::reserve(&v16, v8 + 15);
std::string::append(&v16, "while parsing ");
std::string::append(&v16, *a4, a4[1]);
std::string::push_back(&v16, 32LL);
std::string::append(a1, v16, v17);
if ( v16 != v18 )
operator delete(v16, v18[0] + 1LL);
}
std::string::append(a1, "- ");
if ( *(_DWORD *)(a2 + 32) == 14 )
{
v20 = *(_QWORD *)(a2 + 152);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
(long long)v21,
a2 + 40);
v19 = 39;
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(
&v16,
&v20,
"; last read: '",
v21,
&v19);
std::string::append(a1, v16, v17);
if ( v16 != v18 )
operator delete(v16, v18[0] + 1LL);
v9 = (void *)v21[0];
if ( (long long *)v21[0] != &v22 )
{
v10 = v22;
LABEL_11:
operator delete(v9, v10 + 1);
}
}
else
{
v11 = ((long long (*)(void))nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name)();
v16 = v18;
v17 = 0LL;
LOBYTE(v18[0]) = 0;
v12 = strlen(v11);
std::string::reserve(&v16, v12 + 11);
std::string::append(&v16, "unexpected ");
std::string::append(&v16, v11);
std::string::append(a1, v16, v17);
v9 = v16;
if ( v16 != v18 )
{
v10 = v18[0];
goto LABEL_11;
}
}
if ( a3 )
{
v13 = nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name(a3);
v16 = v18;
v17 = 0LL;
LOBYTE(v18[0]) = 0;
v14 = strlen(v13);
std::string::reserve(&v16, v14 + 11);
std::string::append(&v16, "; expected ");
std::string::append(&v16, v13);
std::string::append(a1, v16, v17);
if ( v16 != v18 )
operator delete(v16, v18[0] + 1LL);
}
return a1;
}
|
exception_message:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RCX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
LEA RSI,[0x1cad7f]
LEA RDX,[0x1cad8c]
CALL 0x001237c2
MOV RSI,qword ptr [R15 + 0x8]
TEST RSI,RSI
JZ 0x001290e2
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
ADD RSI,0xf
LAB_0012907e:
LEA RDI,[RSP + 0x8]
CALL 0x0011dbc0
LEA RSI,[0x1cad8d]
LEA RDI,[RSP + 0x8]
CALL 0x0011d920
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x0011d470
LEA RDI,[RSP + 0x8]
MOV ESI,0x20
CALL 0x0011e070
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001290c3:
MOV RDI,RBX
CALL 0x0011d470
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x001290e2
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011d160
LAB_001290e2:
LEA RSI,[0x1cad9c]
MOV RDI,RBX
CALL 0x0011d920
MOV EDI,dword ptr [R14 + 0x20]
CMP EDI,0xe
JNZ 0x00129185
MOV RAX,qword ptr [R14 + 0x98]
ADD R14,0x28
MOV qword ptr [RSP + 0x30],RAX
LAB_0012910e:
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x00128d70
LEA R8,[RSP + 0x2f]
MOV byte ptr [R8],0x27
LAB_00129124:
LEA RDX,[0x1cad9f]
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x30]
LEA RCX,[RSP + 0x38]
CALL 0x0012e260
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00129149:
MOV RDI,RBX
CALL 0x0011d470
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012916c
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011d160
LAB_0012916c:
LEA RAX,[RSP + 0x48]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001291ff
MOV RSI,qword ptr [RSP + 0x48]
JMP 0x001291f7
LAB_00129185:
CALL 0x0012e322
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x0011d550
LEA RSI,[RAX + 0xb]
LAB_001291ae:
LEA RDI,[RSP + 0x8]
CALL 0x0011dbc0
LEA RSI,[0x1cadae]
LEA RDI,[RSP + 0x8]
CALL 0x0011d920
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011d920
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001291e0:
MOV RDI,RBX
CALL 0x0011d470
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001291ff
MOV RSI,qword ptr [RSP + 0x18]
LAB_001291f7:
INC RSI
CALL 0x0011d160
LAB_001291ff:
TEST EBP,EBP
JZ 0x0012927f
MOV EDI,EBP
CALL 0x0012e322
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x0011d550
LEA RSI,[RAX + 0xb]
LAB_0012922e:
LEA RDI,[RSP + 0x8]
CALL 0x0011dbc0
LEA RSI,[0x1cadba]
LEA RDI,[RSP + 0x8]
CALL 0x0011d920
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011d920
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00129260:
MOV RDI,RBX
CALL 0x0011d470
LAB_00129268:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0012927f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011d160
LAB_0012927f:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >
>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type, std::__cxx11::string const&) */
long * nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::exception_message(long *param_1,long param_2,int param_3,ulong *param_4)
{
char *pcVar1;
long *local_80;
int8 local_78;
int1 local_70;
int7 uStack_6f;
int1 local_59;
int8 local_58;
long *local_50 [2];
long local_40 [2];
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"syntax error ","");
if (param_4[1] != 0) {
local_78 = 0;
local_70 = 0;
/* try { // try from 0012907e to 001290b8 has its CatchHandler @ 001292e7 */
local_80 = (long *)&local_70;
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80,*param_4);
std::__cxx11::string::push_back((char)&local_80);
/* try { // try from 001290c3 to 001290ca has its CatchHandler @ 001292cf */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
/* try { // try from 001290e2 to 001290f0 has its CatchHandler @ 001292d1 */
std::__cxx11::string::append((char *)param_1);
if (*(int *)(param_2 + 0x20) == 0xe) {
local_58 = *(int8 *)(param_2 + 0x98);
/* try { // try from 0012910e to 0012911a has its CatchHandler @ 001292cb */
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get_token_string();
local_59 = 0x27;
/* try { // try from 00129124 to 0012913e has its CatchHandler @ 001292b3 */
concat<std::__cxx11::string,char_const*,char_const(&)[15],std::__cxx11::string,char>
((char **)&local_80,(char *)&local_58,(string *)"; last read: \'",(char *)local_50);
/* try { // try from 00129149 to 00129150 has its CatchHandler @ 00129293 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
if (local_50[0] == local_40) goto LAB_001291ff;
}
else {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name();
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 001291ae to 001291d5 has its CatchHandler @ 001292d6 */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 001291e0 to 001291e7 has its CatchHandler @ 00129291 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 == (long *)&local_70) goto LAB_001291ff;
local_40[0] = CONCAT71(uStack_6f,local_70);
local_50[0] = local_80;
}
operator_delete(local_50[0],local_40[0] + 1);
LAB_001291ff:
if (param_3 != 0) {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(param_3);
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 0012922e to 00129255 has its CatchHandler @ 001292d8 */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 00129260 to 00129267 has its CatchHandler @ 001292cd */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
return param_1;
}
|
|
5,046 |
mi_ck_write_btree
|
eloqsql/storage/myisam/mi_write.c
|
int _mi_ck_write_btree(register MI_INFO *info, uint keynr, uchar *key,
uint key_length)
{
int error;
uint comp_flag;
MI_KEYDEF *keyinfo=info->s->keyinfo+keynr;
my_off_t *root=&info->s->state.key_root[keynr];
DBUG_ENTER("_mi_ck_write_btree");
if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
comp_flag=SEARCH_BIGGER; /* Put after same key */
else if (keyinfo->flag & (HA_NOSAME|HA_FULLTEXT))
{
comp_flag=SEARCH_FIND | SEARCH_UPDATE | SEARCH_INSERT; /* No duplicates */
if (keyinfo->flag & HA_NULL_ARE_EQUAL)
comp_flag|= SEARCH_NULL_ARE_EQUAL;
}
else
comp_flag=SEARCH_SAME; /* Keys in rec-pos order */
error=_mi_ck_real_write_btree(info, keyinfo, key, key_length,
root, comp_flag);
if (info->ft1_to_ft2)
{
if (!error)
error= _mi_ft_convert_to_ft2(info, keynr, key);
delete_dynamic(info->ft1_to_ft2);
my_free(info->ft1_to_ft2);
info->ft1_to_ft2=0;
}
DBUG_RETURN(error);
}
|
O0
|
c
|
mi_ck_write_btree:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0xc7519
movl $0x8, -0x24(%rbp)
jmp 0xc755a
movq -0x30(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x81, %eax
cmpl $0x0, %eax
je 0xc7551
movl $0x20041, -0x24(%rbp) # imm = 0x20041
movq -0x30(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
je 0xc754f
movl -0x24(%rbp), %eax
orl $0x8000, %eax # imm = 0x8000
movl %eax, -0x24(%rbp)
jmp 0xc7558
movl $0x4, -0x24(%rbp)
jmp 0xc755a
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0xc75e0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xc75cf
cmpl $0x0, -0x20(%rbp)
jne 0xc75a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xa4d70
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xdc530
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xf5590
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
jmp 0xc75d1
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
|
_mi_ck_write_btree:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_C]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_C]
shl rcx, 3
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Ah]
and eax, 200h
cmp eax, 0
jz short loc_C7519
mov [rbp+var_24], 8
jmp short loc_C755A
loc_C7519:
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Ah]
and eax, 81h
cmp eax, 0
jz short loc_C7551
mov [rbp+var_24], 20041h
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Ah]
and eax, 800h
cmp eax, 0
jz short loc_C754F
mov eax, [rbp+var_24]
or eax, 8000h
mov [rbp+var_24], eax
loc_C754F:
jmp short loc_C7558
loc_C7551:
mov [rbp+var_24], 4
loc_C7558:
jmp short $+2
loc_C755A:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_1C]
mov r8, [rbp+var_38]
mov r9d, [rbp+var_24]
call _mi_ck_real_write_btree
mov [rbp+var_20], eax
mov rax, [rbp+var_8]
cmp qword ptr [rax+88h], 0
jz short loc_C75CF
cmp [rbp+var_20], 0
jnz short loc_C75A0
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call _mi_ft_convert_to_ft2
mov [rbp+var_20], eax
loc_C75A0:
mov rax, [rbp+var_8]
mov rdi, [rax+88h]
call delete_dynamic
mov rax, [rbp+var_8]
mov rdi, [rax+88h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+88h], 0
loc_C75CF:
jmp short $+2
loc_C75D1:
mov eax, [rbp+var_20]
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
add rsp, 40h
pop rbp
retn
|
long long mi_ck_write_btree(_QWORD *a1, unsigned int a2, unsigned __int8 *a3, unsigned int a4)
{
long long v5; // [rsp+10h] [rbp-30h]
unsigned int v6; // [rsp+1Ch] [rbp-24h]
unsigned int v7; // [rsp+20h] [rbp-20h]
v5 = 112LL * a2 + *(_QWORD *)(*a1 + 536LL);
if ( (*(_WORD *)(v5 + 10) & 0x200) != 0 )
{
v6 = 8;
}
else if ( (*(_WORD *)(v5 + 10) & 0x81) != 0 )
{
v6 = 131137;
if ( (*(_WORD *)(v5 + 10) & 0x800) != 0 )
v6 = 163905;
}
else
{
v6 = 4;
}
v7 = mi_ck_real_write_btree(a1, v5, a3, a4, 8LL * a2 + *(_QWORD *)(*a1 + 152LL), v6);
if ( a1[17] )
{
if ( !v7 )
v7 = mi_ft_convert_to_ft2(a1, a2, a3);
delete_dynamic(a1[17]);
my_free(a1[17]);
a1[17] = 0LL;
}
return v7;
}
|
_mi_ck_write_btree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0xc]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x200
CMP EAX,0x0
JZ 0x001c7519
MOV dword ptr [RBP + -0x24],0x8
JMP 0x001c755a
LAB_001c7519:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x81
CMP EAX,0x0
JZ 0x001c7551
MOV dword ptr [RBP + -0x24],0x20041
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x800
CMP EAX,0x0
JZ 0x001c754f
MOV EAX,dword ptr [RBP + -0x24]
OR EAX,0x8000
MOV dword ptr [RBP + -0x24],EAX
LAB_001c754f:
JMP 0x001c7558
LAB_001c7551:
MOV dword ptr [RBP + -0x24],0x4
LAB_001c7558:
JMP 0x001c755a
LAB_001c755a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
MOV R8,qword ptr [RBP + -0x38]
MOV R9D,dword ptr [RBP + -0x24]
CALL 0x001c75e0
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x88],0x0
JZ 0x001c75cf
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x001c75a0
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001a4d70
MOV dword ptr [RBP + -0x20],EAX
LAB_001c75a0:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x001dc530
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x001f5590
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],0x0
LAB_001c75cf:
JMP 0x001c75d1
LAB_001c75d1:
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD RSP,0x40
POP RBP
RET
|
int _mi_ck_write_btree(long *param_1,uint param_2,int8 param_3,int4 param_4)
{
long lVar1;
int4 local_2c;
int local_28;
lVar1 = *(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70;
if ((*(ushort *)(lVar1 + 10) & 0x200) == 0) {
if ((*(ushort *)(lVar1 + 10) & 0x81) == 0) {
local_2c = 4;
}
else {
local_2c = 0x20041;
if ((*(ushort *)(lVar1 + 10) & 0x800) != 0) {
local_2c = 0x28041;
}
}
}
else {
local_2c = 8;
}
local_28 = _mi_ck_real_write_btree
(param_1,lVar1,param_3,param_4,
*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8,local_2c);
if (param_1[0x11] != 0) {
if (local_28 == 0) {
local_28 = _mi_ft_convert_to_ft2(param_1,param_2,param_3);
}
delete_dynamic(param_1[0x11]);
my_free(param_1[0x11]);
param_1[0x11] = 0;
}
return local_28;
}
|
|
5,047 |
ma_base_info_write
|
eloqsql/storage/maria/ma_open.c
|
uint _ma_base_info_write(File file, MARIA_BASE_INFO *base)
{
uchar buff[MARIA_BASE_INFO_SIZE], *ptr=buff;
bmove(ptr, maria_uuid, MY_UUID_SIZE);
ptr+= MY_UUID_SIZE;
mi_sizestore(ptr,base->keystart); ptr+= 8;
mi_sizestore(ptr,base->max_data_file_length); ptr+= 8;
mi_sizestore(ptr,base->max_key_file_length); ptr+= 8;
mi_rowstore(ptr,base->records); ptr+= 8;
mi_rowstore(ptr,base->reloc); ptr+= 8;
mi_int4store(ptr,base->mean_row_length); ptr+= 4;
mi_int4store(ptr,base->reclength); ptr+= 4;
mi_int4store(ptr,base->pack_reclength); ptr+= 4;
mi_int4store(ptr,base->min_pack_length); ptr+= 4;
mi_int4store(ptr,base->max_pack_length); ptr+= 4;
mi_int4store(ptr,base->min_block_length); ptr+= 4;
mi_int2store(ptr,base->fields); ptr+= 2;
mi_int2store(ptr,base->fixed_not_null_fields); ptr+= 2;
mi_int2store(ptr,base->fixed_not_null_fields_length); ptr+= 2;
mi_int2store(ptr,base->max_field_lengths); ptr+= 2;
mi_int2store(ptr,base->pack_fields); ptr+= 2;
mi_int2store(ptr,base->extra_options) ptr+= 2;
mi_int2store(ptr,base->null_bytes); ptr+= 2;
mi_int2store(ptr,base->original_null_bytes); ptr+= 2;
mi_int2store(ptr,base->field_offsets); ptr+= 2;
mi_int2store(ptr,base->language); ptr+= 2;
mi_int2store(ptr,base->block_size); ptr+= 2;
*ptr++= base->rec_reflength;
*ptr++= base->key_reflength;
*ptr++= base->keys;
*ptr++= base->auto_key;
*ptr++= base->born_transactional;
*ptr++= base->compression_algorithm;
mi_int2store(ptr,base->pack_bytes); ptr+= 2;
mi_int2store(ptr,base->blobs); ptr+= 2;
mi_int2store(ptr,base->max_key_block_length); ptr+= 2;
mi_int2store(ptr,base->max_key_length); ptr+= 2;
mi_int2store(ptr,base->extra_alloc_bytes); ptr+= 2;
*ptr++= base->extra_alloc_procent;
mi_int3store(ptr, base->s3_block_size); ptr+= 3;
bzero(ptr,13); ptr+= 13; /* extra */
DBUG_ASSERT((ptr - buff) == MARIA_BASE_INFO_SIZE);
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
}
|
O3
|
c
|
ma_base_info_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq 0x395c99(%rip), %rax # 0x402bd0
movaps (%rax), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq (%rsi), %rax
bswapq %rax
movq %rax, -0x90(%rbp)
movq 0x8(%rsi), %rax
bswapq %rax
movq %rax, -0x88(%rbp)
movq 0x10(%rsi), %rax
bswapq %rax
movq %rax, -0x80(%rbp)
movq 0x20(%rsi), %rax
bswapq %rax
movq %rax, -0x78(%rbp)
movq 0x28(%rsi), %rax
bswapq %rax
movq %rax, -0x70(%rbp)
movl 0x30(%rsi), %eax
bswapl %eax
movl %eax, -0x68(%rbp)
movl 0x38(%rsi), %eax
bswapl %eax
movl %eax, -0x64(%rbp)
movl 0x40(%rsi), %eax
bswapl %eax
movl %eax, -0x60(%rbp)
movl 0x48(%rsi), %eax
bswapl %eax
movl %eax, -0x5c(%rbp)
movl 0x50(%rsi), %eax
bswapl %eax
movl %eax, -0x58(%rbp)
movl 0x58(%rsi), %eax
bswapl %eax
movl %eax, -0x54(%rbp)
movzwl 0x68(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x50(%rbp)
movzwl 0x6c(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x4e(%rbp)
movzwl 0x70(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x4c(%rbp)
movzwl 0x74(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x4a(%rbp)
movzwl 0x78(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x48(%rbp)
movzwl 0xc8(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x46(%rbp)
movzwl 0x9c(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x44(%rbp)
movzwl 0x98(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x42(%rbp)
movzwl 0xa0(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x40(%rbp)
movzwl 0xcc(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x3e(%rbp)
movzwl 0xbc(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x3c(%rbp)
movdqu 0x80(%rsi), %xmm0
pand 0x786ed(%rip), %xmm0 # 0xe5740
packuswb %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, -0x3a(%rbp)
movb 0xec(%rsi), %al
movb %al, -0x36(%rbp)
movb 0xd0(%rsi), %al
movb %al, -0x35(%rbp)
movzwl 0x94(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x34(%rbp)
movzwl 0x90(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x32(%rbp)
movzwl 0xa4(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x30(%rbp)
movzwl 0xa8(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x2e(%rbp)
movzwl 0xac(%rsi), %eax
rolw $0x8, %ax
movl %edi, %ebx
movw %ax, -0x2c(%rbp)
movb 0xb0(%rsi), %al
movb %al, -0x2a(%rbp)
movq 0x60(%rsi), %rax
movl %eax, %ecx
rolw $0x8, %cx
movw %cx, -0x28(%rbp)
shrl $0x10, %eax
movb %al, -0x29(%rbp)
xorl %eax, %eax
movq %rax, -0x21(%rbp)
movq %rax, -0x26(%rbp)
leaq 0x31f2db(%rip), %rax # 0x38c3c8
movq (%rax), %rax
leaq -0xf0(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x6d149
leaq -0xa0(%rbp), %rsi
movl $0x87, %edx
movl $0x4, %ecx
movl %ebx, %edi
callq 0x30b3a
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %cl
movq %fs:0x28, %rdx
cmpq -0x18(%rbp), %rdx
jne 0x6d169
movb %cl, %al
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0xa0(%rbp), %rdx
leaq -0xa8(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rcx
callq 0x2e2a9
movq (%r14), %rcx
jmp 0x6d124
callq 0x2a240
|
_ma_base_info_write:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_18], rax
lea rax, maria_uuid
movaps xmm0, xmmword ptr [rax]
movaps [rbp+var_A0], xmm0
mov rax, [rsi]
bswap rax
mov [rbp+var_90], rax
mov rax, [rsi+8]
bswap rax
mov [rbp+var_88], rax
mov rax, [rsi+10h]
bswap rax
mov [rbp+var_80], rax
mov rax, [rsi+20h]
bswap rax
mov [rbp+var_78], rax
mov rax, [rsi+28h]
bswap rax
mov [rbp+var_70], rax
mov eax, [rsi+30h]
bswap eax
mov [rbp+var_68], eax
mov eax, [rsi+38h]
bswap eax
mov [rbp+var_64], eax
mov eax, [rsi+40h]
bswap eax
mov [rbp+var_60], eax
mov eax, [rsi+48h]
bswap eax
mov [rbp+var_5C], eax
mov eax, [rsi+50h]
bswap eax
mov [rbp+var_58], eax
mov eax, [rsi+58h]
bswap eax
mov [rbp+var_54], eax
movzx eax, word ptr [rsi+68h]
rol ax, 8
mov [rbp+var_50], ax
movzx eax, word ptr [rsi+6Ch]
rol ax, 8
mov [rbp+var_4E], ax
movzx eax, word ptr [rsi+70h]
rol ax, 8
mov [rbp+var_4C], ax
movzx eax, word ptr [rsi+74h]
rol ax, 8
mov [rbp+var_4A], ax
movzx eax, word ptr [rsi+78h]
rol ax, 8
mov [rbp+var_48], ax
movzx eax, word ptr [rsi+0C8h]
rol ax, 8
mov [rbp+var_46], ax
movzx eax, word ptr [rsi+9Ch]
rol ax, 8
mov [rbp+var_44], ax
movzx eax, word ptr [rsi+98h]
rol ax, 8
mov [rbp+var_42], ax
movzx eax, word ptr [rsi+0A0h]
rol ax, 8
mov [rbp+var_40], ax
movzx eax, word ptr [rsi+0CCh]
rol ax, 8
mov [rbp+var_3E], ax
movzx eax, word ptr [rsi+0BCh]
rol ax, 8
mov [rbp+var_3C], ax
movdqu xmm0, xmmword ptr [rsi+80h]
pand xmm0, cs:xmmword_E5740
packuswb xmm0, xmm0
packuswb xmm0, xmm0
movd [rbp+var_3A], xmm0
mov al, [rsi+0ECh]
mov [rbp+var_36], al
mov al, [rsi+0D0h]
mov [rbp+var_35], al
movzx eax, word ptr [rsi+94h]
rol ax, 8
mov [rbp+var_34], ax
movzx eax, word ptr [rsi+90h]
rol ax, 8
mov [rbp+var_32], ax
movzx eax, word ptr [rsi+0A4h]
rol ax, 8
mov [rbp+var_30], ax
movzx eax, word ptr [rsi+0A8h]
rol ax, 8
mov [rbp+var_2E], ax
movzx eax, word ptr [rsi+0ACh]
rol ax, 8
mov ebx, edi
mov [rbp+var_2C], ax
mov al, [rsi+0B0h]
mov [rbp+var_2A], al
mov rax, [rsi+60h]
mov ecx, eax
rol cx, 8
mov [rbp+var_28], cx
shr eax, 10h
mov [rbp+var_29], al
xor eax, eax
mov [rbp+var_21], rax
mov [rbp-26h], rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_F0]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_6D149
lea rsi, [rbp+var_A0]
mov edx, 87h
mov ecx, 4
mov edi, ebx
call my_write
mov rcx, rax
loc_6D124:
xor eax, eax
test rcx, rcx
setnz cl
mov rdx, fs:28h
cmp rdx, [rbp+var_18]
jnz short loc_6D169
mov al, cl
add rsp, 0E0h
pop rbx
pop r14
pop rbp
retn
loc_6D149:
lea rdx, [rbp+var_A0]
lea r14, [rbp+var_A8]
mov rdi, rax
mov esi, ebx
mov rcx, r14
call _ma_base_info_write_cold_1
mov rcx, [r14]
jmp short loc_6D124
loc_6D169:
call ___stack_chk_fail
|
bool ma_base_info_write(unsigned int a1, const __m128i *a2)
{
__m128i v2; // xmm0
__m128i v3; // xmm0
long long v4; // rax
long long v5; // rax
long long v6; // rcx
_BYTE v9[72]; // [rsp+0h] [rbp-F0h] BYREF
long long v10; // [rsp+48h] [rbp-A8h] BYREF
__int128 v11; // [rsp+50h] [rbp-A0h] BYREF
unsigned long long v12; // [rsp+60h] [rbp-90h]
unsigned long long v13; // [rsp+68h] [rbp-88h]
unsigned long long v14; // [rsp+70h] [rbp-80h]
unsigned long long v15; // [rsp+78h] [rbp-78h]
unsigned long long v16; // [rsp+80h] [rbp-70h]
unsigned __int32 v17; // [rsp+88h] [rbp-68h]
unsigned __int32 v18; // [rsp+8Ch] [rbp-64h]
unsigned __int32 v19; // [rsp+90h] [rbp-60h]
unsigned __int32 v20; // [rsp+94h] [rbp-5Ch]
unsigned __int32 v21; // [rsp+98h] [rbp-58h]
unsigned __int32 v22; // [rsp+9Ch] [rbp-54h]
__int16 v23; // [rsp+A0h] [rbp-50h]
__int16 v24; // [rsp+A2h] [rbp-4Eh]
__int16 v25; // [rsp+A4h] [rbp-4Ch]
__int16 v26; // [rsp+A6h] [rbp-4Ah]
__int16 v27; // [rsp+A8h] [rbp-48h]
__int16 v28; // [rsp+AAh] [rbp-46h]
__int16 v29; // [rsp+ACh] [rbp-44h]
__int16 v30; // [rsp+AEh] [rbp-42h]
__int16 v31; // [rsp+B0h] [rbp-40h]
__int16 v32; // [rsp+B2h] [rbp-3Eh]
__int16 v33; // [rsp+B4h] [rbp-3Ch]
int v34; // [rsp+B6h] [rbp-3Ah]
__int8 v35; // [rsp+BAh] [rbp-36h]
__int8 v36; // [rsp+BBh] [rbp-35h]
__int16 v37; // [rsp+BCh] [rbp-34h]
__int16 v38; // [rsp+BEh] [rbp-32h]
__int16 v39; // [rsp+C0h] [rbp-30h]
__int16 v40; // [rsp+C2h] [rbp-2Eh]
__int16 v41; // [rsp+C4h] [rbp-2Ch]
__int8 v42; // [rsp+C6h] [rbp-2Ah]
char v43; // [rsp+C7h] [rbp-29h]
__int16 v44; // [rsp+C8h] [rbp-28h]
_BYTE v45[13]; // [rsp+CAh] [rbp-26h] BYREF
unsigned long long v46; // [rsp+D8h] [rbp-18h]
v46 = __readfsqword(0x28u);
v11 = maria_uuid;
v12 = _byteswap_uint64(a2->m128i_i64[0]);
v13 = _byteswap_uint64(a2->m128i_u64[1]);
v14 = _byteswap_uint64(a2[1].m128i_u64[0]);
v15 = _byteswap_uint64(a2[2].m128i_u64[0]);
v16 = _byteswap_uint64(a2[2].m128i_u64[1]);
v17 = _byteswap_ulong(a2[3].m128i_u32[0]);
v18 = _byteswap_ulong(a2[3].m128i_u32[2]);
v19 = _byteswap_ulong(a2[4].m128i_u32[0]);
v20 = _byteswap_ulong(a2[4].m128i_u32[2]);
v21 = _byteswap_ulong(a2[5].m128i_u32[0]);
v22 = _byteswap_ulong(a2[5].m128i_u32[2]);
v23 = __ROL2__(a2[6].m128i_i16[4], 8);
v24 = __ROL2__(a2[6].m128i_i16[6], 8);
v25 = __ROL2__(a2[7].m128i_i16[0], 8);
v26 = __ROL2__(a2[7].m128i_i16[2], 8);
v27 = __ROL2__(a2[7].m128i_i16[4], 8);
v28 = __ROL2__(a2[12].m128i_i16[4], 8);
v29 = __ROL2__(a2[9].m128i_i16[6], 8);
v30 = __ROL2__(a2[9].m128i_i16[4], 8);
v31 = __ROL2__(a2[10].m128i_i16[0], 8);
v32 = __ROL2__(a2[12].m128i_i16[6], 8);
v33 = __ROL2__(a2[11].m128i_i16[6], 8);
v2 = _mm_and_si128(_mm_loadu_si128(a2 + 8), (__m128i)xmmword_E5740);
v3 = _mm_packus_epi16(v2, v2);
v34 = _mm_cvtsi128_si32(_mm_packus_epi16(v3, v3));
v35 = a2[14].m128i_i8[12];
v36 = a2[13].m128i_i8[0];
v37 = __ROL2__(a2[9].m128i_i16[2], 8);
v38 = __ROL2__(a2[9].m128i_i16[0], 8);
v39 = __ROL2__(a2[10].m128i_i16[2], 8);
v40 = __ROL2__(a2[10].m128i_i16[4], 8);
v41 = __ROL2__(a2[10].m128i_i16[6], 8);
v42 = a2[11].m128i_i8[0];
v4 = a2[6].m128i_i64[0];
v44 = __ROL2__(v4, 8);
v43 = BYTE2(v4);
memset(v45, 0, sizeof(v45));
v5 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, a1, 7LL);
if ( v5 )
{
ma_base_info_write_cold_1(v5, a1, (long long)&v11, &v10);
v6 = v10;
}
else
{
v6 = my_write(a1, (long long)&v11, 135LL, 4LL);
}
return v6 != 0;
}
|
_ma_base_info_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x502bd0]
MOVAPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOV RAX,qword ptr [RSI]
BSWAP RAX
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RSI + 0x8]
BSWAP RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RSI + 0x10]
BSWAP RAX
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RSI + 0x20]
BSWAP RAX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RSI + 0x28]
BSWAP RAX
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RSI + 0x30]
BSWAP EAX
MOV dword ptr [RBP + -0x68],EAX
MOV EAX,dword ptr [RSI + 0x38]
BSWAP EAX
MOV dword ptr [RBP + -0x64],EAX
MOV EAX,dword ptr [RSI + 0x40]
BSWAP EAX
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,dword ptr [RSI + 0x48]
BSWAP EAX
MOV dword ptr [RBP + -0x5c],EAX
MOV EAX,dword ptr [RSI + 0x50]
BSWAP EAX
MOV dword ptr [RBP + -0x58],EAX
MOV EAX,dword ptr [RSI + 0x58]
BSWAP EAX
MOV dword ptr [RBP + -0x54],EAX
MOVZX EAX,word ptr [RSI + 0x68]
ROL AX,0x8
MOV word ptr [RBP + -0x50],AX
MOVZX EAX,word ptr [RSI + 0x6c]
ROL AX,0x8
MOV word ptr [RBP + -0x4e],AX
MOVZX EAX,word ptr [RSI + 0x70]
ROL AX,0x8
MOV word ptr [RBP + -0x4c],AX
MOVZX EAX,word ptr [RSI + 0x74]
ROL AX,0x8
MOV word ptr [RBP + -0x4a],AX
MOVZX EAX,word ptr [RSI + 0x78]
ROL AX,0x8
MOV word ptr [RBP + -0x48],AX
MOVZX EAX,word ptr [RSI + 0xc8]
ROL AX,0x8
MOV word ptr [RBP + -0x46],AX
MOVZX EAX,word ptr [RSI + 0x9c]
ROL AX,0x8
MOV word ptr [RBP + -0x44],AX
MOVZX EAX,word ptr [RSI + 0x98]
ROL AX,0x8
MOV word ptr [RBP + -0x42],AX
MOVZX EAX,word ptr [RSI + 0xa0]
ROL AX,0x8
MOV word ptr [RBP + -0x40],AX
MOVZX EAX,word ptr [RSI + 0xcc]
ROL AX,0x8
MOV word ptr [RBP + -0x3e],AX
MOVZX EAX,word ptr [RSI + 0xbc]
ROL AX,0x8
MOV word ptr [RBP + -0x3c],AX
MOVDQU XMM0,xmmword ptr [RSI + 0x80]
PAND XMM0,xmmword ptr [0x001e5740]
PACKUSWB XMM0,XMM0
PACKUSWB XMM0,XMM0
MOVD dword ptr [RBP + -0x3a],XMM0
MOV AL,byte ptr [RSI + 0xec]
MOV byte ptr [RBP + -0x36],AL
MOV AL,byte ptr [RSI + 0xd0]
MOV byte ptr [RBP + -0x35],AL
MOVZX EAX,word ptr [RSI + 0x94]
ROL AX,0x8
MOV word ptr [RBP + -0x34],AX
MOVZX EAX,word ptr [RSI + 0x90]
ROL AX,0x8
MOV word ptr [RBP + -0x32],AX
MOVZX EAX,word ptr [RSI + 0xa4]
ROL AX,0x8
MOV word ptr [RBP + -0x30],AX
MOVZX EAX,word ptr [RSI + 0xa8]
ROL AX,0x8
MOV word ptr [RBP + -0x2e],AX
MOVZX EAX,word ptr [RSI + 0xac]
ROL AX,0x8
MOV EBX,EDI
MOV word ptr [RBP + -0x2c],AX
MOV AL,byte ptr [RSI + 0xb0]
MOV byte ptr [RBP + -0x2a],AL
MOV RAX,qword ptr [RSI + 0x60]
MOV ECX,EAX
ROL CX,0x8
MOV word ptr [RBP + -0x28],CX
SHR EAX,0x10
MOV byte ptr [RBP + -0x29],AL
XOR EAX,EAX
MOV qword ptr [RBP + -0x21],RAX
MOV qword ptr [RBP + -0x26],RAX
LEA RAX,[0x48c3c8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xf0]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0016d149
LEA RSI,[RBP + -0xa0]
MOV EDX,0x87
MOV ECX,0x4
MOV EDI,EBX
CALL 0x00130b3a
MOV RCX,RAX
LAB_0016d124:
XOR EAX,EAX
TEST RCX,RCX
SETNZ CL
MOV RDX,qword ptr FS:[0x28]
CMP RDX,qword ptr [RBP + -0x18]
JNZ 0x0016d169
MOV AL,CL
ADD RSP,0xe0
POP RBX
POP R14
POP RBP
RET
LAB_0016d149:
LEA RDX,[RBP + -0xa0]
LEA R14,[RBP + -0xa8]
MOV RDI,RAX
MOV ESI,EBX
MOV RCX,R14
CALL 0x0012e2a9
MOV RCX,qword ptr [R14]
JMP 0x0016d124
LAB_0016d169:
CALL 0x0012a240
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
bool _ma_base_info_write(int4 param_1,ulong *param_2)
{
uint uVar1;
ulong uVar2;
char cVar3;
short sVar7;
short sVar8;
short sVar9;
long lVar10;
long in_FS_OFFSET;
ushort uVar11;
short sVar12;
ushort uVar15;
ushort uVar16;
ushort uVar17;
ushort uVar18;
ushort uVar19;
ushort uVar20;
ushort uVar21;
int1 local_f8 [72];
long local_b0;
int8 local_a8 [2];
ulong local_98;
ulong local_90;
ulong local_88;
ulong local_80;
ulong local_78;
uint local_70;
uint local_6c;
uint local_68;
uint local_64;
uint local_60;
uint local_5c;
ushort local_58;
ushort local_56;
ushort local_54;
ushort local_52;
ushort local_50;
ushort local_4e;
ushort local_4c;
ushort local_4a;
ushort local_48;
ushort local_46;
ushort local_44;
int4 local_42;
int1 local_3e;
int1 local_3d;
ushort local_3c;
ushort local_3a;
ushort local_38;
ushort local_36;
ushort local_34;
int1 local_32;
int1 local_31;
ushort local_30;
int5 uStack_2e;
int3 local_29;
int5 uStack_26;
long local_20;
char cVar4;
char cVar5;
char cVar6;
int4 uVar13;
int6 uVar14;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_a8[0] = maria_uuid._0_8_;
local_a8[1] = maria_uuid._8_8_;
uVar2 = *param_2;
local_98 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar2 = param_2[1];
local_90 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar2 = param_2[2];
local_88 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar2 = param_2[4];
local_80 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar2 = param_2[5];
local_78 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar1 = (uint)param_2[6];
local_70 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar1 = (uint)param_2[7];
local_6c = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar1 = (uint)param_2[8];
local_68 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar1 = (uint)param_2[9];
local_64 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar1 = (uint)param_2[10];
local_60 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar1 = (uint)param_2[0xb];
local_5c = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
local_58 = (ushort)param_2[0xd] << 8 | (ushort)param_2[0xd] >> 8;
local_56 = *(ushort *)((long)param_2 + 0x6c) << 8 | *(ushort *)((long)param_2 + 0x6c) >> 8;
local_54 = (ushort)param_2[0xe] << 8 | (ushort)param_2[0xe] >> 8;
local_52 = *(ushort *)((long)param_2 + 0x74) << 8 | *(ushort *)((long)param_2 + 0x74) >> 8;
local_50 = (ushort)param_2[0xf] << 8 | (ushort)param_2[0xf] >> 8;
local_4e = (ushort)param_2[0x19] << 8 | (ushort)param_2[0x19] >> 8;
local_4c = *(ushort *)((long)param_2 + 0x9c) << 8 | *(ushort *)((long)param_2 + 0x9c) >> 8;
local_4a = (ushort)param_2[0x13] << 8 | (ushort)param_2[0x13] >> 8;
local_48 = (ushort)param_2[0x14] << 8 | (ushort)param_2[0x14] >> 8;
local_46 = *(ushort *)((long)param_2 + 0xcc) << 8 | *(ushort *)((long)param_2 + 0xcc) >> 8;
local_44 = *(ushort *)((long)param_2 + 0xbc) << 8 | *(ushort *)((long)param_2 + 0xbc) >> 8;
uVar11 = (ushort)param_2[0x10] & _DAT_001e5740;
uVar15 = *(ushort *)((long)param_2 + 0x82) & _UNK_001e5742;
uVar16 = *(ushort *)((long)param_2 + 0x84) & _UNK_001e5744;
uVar17 = *(ushort *)((long)param_2 + 0x86) & _UNK_001e5746;
uVar18 = (ushort)param_2[0x11] & _UNK_001e5748;
uVar19 = *(ushort *)((long)param_2 + 0x8a) & _UNK_001e574a;
uVar20 = *(ushort *)((long)param_2 + 0x8c) & _UNK_001e574c;
uVar21 = *(ushort *)((long)param_2 + 0x8e) & _UNK_001e574e;
cVar3 = (0 < (short)uVar11) * ((short)uVar11 < 0x100) * (char)uVar11 - (0xff < (short)uVar11);
sVar12 = CONCAT11((0 < (short)uVar15) * ((short)uVar15 < 0x100) * (char)uVar15 -
(0xff < (short)uVar15),cVar3);
cVar4 = (0 < (short)uVar16) * ((short)uVar16 < 0x100) * (char)uVar16 - (0xff < (short)uVar16);
uVar13 = CONCAT13((0 < (short)uVar17) * ((short)uVar17 < 0x100) * (char)uVar17 -
(0xff < (short)uVar17),CONCAT12(cVar4,sVar12));
cVar5 = (0 < (short)uVar18) * ((short)uVar18 < 0x100) * (char)uVar18 - (0xff < (short)uVar18);
uVar14 = CONCAT15((0 < (short)uVar19) * ((short)uVar19 < 0x100) * (char)uVar19 -
(0xff < (short)uVar19),CONCAT14(cVar5,uVar13));
cVar6 = (0 < (short)uVar20) * ((short)uVar20 < 0x100) * (char)uVar20 - (0xff < (short)uVar20);
sVar7 = (short)((uint)uVar13 >> 0x10);
sVar8 = (short)((uint6)uVar14 >> 0x20);
sVar9 = (short)(CONCAT17((0 < (short)uVar21) * ((short)uVar21 < 0x100) * (char)uVar21 -
(0xff < (short)uVar21),CONCAT16(cVar6,uVar14)) >> 0x30);
local_42 = CONCAT13((0 < sVar9) * (sVar9 < 0x100) * cVar6 - (0xff < sVar9),
CONCAT12((0 < sVar8) * (sVar8 < 0x100) * cVar5 - (0xff < sVar8),
CONCAT11((0 < sVar7) * (sVar7 < 0x100) * cVar4 - (0xff < sVar7),
(0 < sVar12) * (sVar12 < 0x100) * cVar3 - (0xff < sVar12))))
;
local_3e = *(int1 *)((long)param_2 + 0xec);
local_3d = (int1)param_2[0x1a];
local_3c = *(ushort *)((long)param_2 + 0x94) << 8 | *(ushort *)((long)param_2 + 0x94) >> 8;
local_3a = (ushort)param_2[0x12] << 8 | (ushort)param_2[0x12] >> 8;
local_38 = *(ushort *)((long)param_2 + 0xa4) << 8 | *(ushort *)((long)param_2 + 0xa4) >> 8;
local_36 = (ushort)param_2[0x15] << 8 | (ushort)param_2[0x15] >> 8;
local_34 = *(ushort *)((long)param_2 + 0xac) << 8 | *(ushort *)((long)param_2 + 0xac) >> 8;
local_32 = (int1)param_2[0x16];
uVar11 = (ushort)param_2[0xc];
local_30 = uVar11 << 8 | uVar11 >> 8;
local_31 = (int1)(param_2[0xc] >> 0x10);
uStack_26 = 0;
uStack_2e = 0;
local_29 = 0;
lVar10 = (**(code **)(PSI_server + 0x158))(local_f8,param_1,7);
if (lVar10 == 0) {
local_b0 = my_write(param_1,local_a8,0x87,4);
}
else {
_ma_base_info_write_cold_1(lVar10,param_1,local_a8,&local_b0);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return local_b0 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,048 |
get_key_cache_statistics
|
eloqsql/mysys/mf_keycache.c
|
void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->get_stats(keycache->keycache_cb,
partition_no, key_cache_stats);
pthread_mutex_unlock(&keycache->op_lock);
}
}
|
O0
|
c
|
get_key_cache_statistics:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe47b4
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a220
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
get_key_cache_statistics:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_E47B4
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+48h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call rax
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_E47B4:
add rsp, 20h
pop rbp
retn
|
long long get_key_cache_statistics(long long a1, unsigned int a2, long long a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 16) + 72LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
|
get_key_cache_statistics:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e47b4
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a220
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a1f0
LAB_001e47b4:
ADD RSP,0x20
POP RBP
RET
|
void get_key_cache_statistics(long param_1,int4 param_2,int8 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x48))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
}
return;
}
|
|
5,049 |
JS_ToStringInternal
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_ToStringInternal(JSContext *ctx, JSValue val, BOOL is_ToPropertyKey)
{
uint32_t tag;
char buf[32];
size_t len;
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_STRING:
return js_dup(val);
case JS_TAG_INT:
len = i32toa(buf, JS_VALUE_GET_INT(val));
return js_new_string8_len(ctx, buf, len);
case JS_TAG_BOOL:
return JS_AtomToString(ctx, JS_VALUE_GET_BOOL(val) ?
JS_ATOM_true : JS_ATOM_false);
case JS_TAG_NULL:
return JS_AtomToString(ctx, JS_ATOM_null);
case JS_TAG_UNDEFINED:
return JS_AtomToString(ctx, JS_ATOM_undefined);
case JS_TAG_EXCEPTION:
return JS_EXCEPTION;
case JS_TAG_OBJECT:
{
JSValue val1, ret;
val1 = JS_ToPrimitive(ctx, val, HINT_STRING);
if (JS_IsException(val1))
return val1;
ret = JS_ToStringInternal(ctx, val1, is_ToPropertyKey);
JS_FreeValue(ctx, val1);
return ret;
}
break;
case JS_TAG_FUNCTION_BYTECODE:
return js_new_string8(ctx, "[function bytecode]");
case JS_TAG_SYMBOL:
if (is_ToPropertyKey) {
return js_dup(val);
} else {
return JS_ThrowTypeError(ctx, "cannot convert symbol to string");
}
case JS_TAG_FLOAT64:
return js_dtoa(ctx, JS_VALUE_GET_FLOAT64(val), 0, JS_DTOA_TOSTRING);
case JS_TAG_BIG_INT:
return js_bigint_to_string(ctx, val);
case JS_TAG_UNINITIALIZED:
return js_new_string8(ctx, "[uninitialized]");
default:
return js_new_string8(ctx, "[unsupported type]");
}
}
|
O1
|
c
|
JS_ToStringInternal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %r15
leal 0x9(%rdx), %ecx
cmpl $0x10, %ecx
ja 0x27078
movq %rdx, %r14
movq %rsi, %rbx
movl %r14d, %eax
leaq 0x740d8(%rip), %rdx # 0x9afd0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0xa, %ecx
callq 0x3d6d0
jmp 0x2708c
xorl %ebx, %ebx
xorl %ecx, %ecx
movq %rax, %r14
jmp 0x2709f
testl %ebp, %ebp
je 0x270b6
movq %rbx, (%rsp)
cmpl $-0x9, %eax
jb 0x2700d
movq (%rsp), %rax
incl (%rax)
jmp 0x2700d
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b1d9
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
jmp 0x27087
movq %rbx, %xmm0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x270d3
jmp 0x2708c
cmpl $0x1, %ebx
movl $0x3, %esi
sbbl $0x0, %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x1fb46
jmp 0x2708c
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rbx
jmp 0x2703f
leaq 0x766c4(%rip), %rsi # 0x9d66e
movq %r15, %rdi
movl $0x13, %edx
jmp 0x27087
movq %rbx, (%rsp)
cmpl $-0x9, %eax
jb 0x26fc6
movq (%rsp), %rax
incl (%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3d3c3
movq %rax, %rbx
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x2700d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x26ec9
movq %rax, %r12
movq %rdx, %r13
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ccb2
movq %r12, %rbx
movq %r13, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
jmp 0x2709f
leaq 0x7667c(%rip), %rsi # 0x9d6a2
movq %r15, %rdi
movl $0xf, %edx
jmp 0x27087
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq 0x230(%rax), %rbx
movq 0x4(%rbx), %rcx
movq %rcx, %rdx
shrq $0x3e, %rdx
cmpl $0x1, %edx
sete %dl
negl %ecx
setno %cl
orb %dl, %cl
jne 0x27060
movq 0x178(%rax), %rbx
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movq $-0x7, %r14
jmp 0x2709f
leaq 0x76633(%rip), %rsi # 0x9d6b2
movq %r15, %rdi
movl $0x12, %edx
callq 0x1f5c9
movq %rax, %rbx
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x765c5(%rip), %rsi # 0x9d682
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %r14d
xorl %ecx, %ecx
jmp 0x2709f
|
JS_ToStringInternal:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov r15, rdi
lea ecx, [rdx+9]; switch 17 cases
cmp ecx, 10h
ja def_26EFF; jumptable 0000000000026EFF default case, cases -6--3,5
mov r14, rdx
mov rbx, rsi
mov eax, r14d
lea rdx, jpt_26EFF
movsxd rcx, ds:(jpt_26EFF - 9AFD0h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_26F01:
mov rdi, r15; jumptable 0000000000026EFF case -9
mov rsi, rbx
mov rdx, r14
mov ecx, 0Ah
call js_bigint_to_string1
jmp loc_2708C
loc_26F19:
xor ebx, ebx; jumptable 0000000000026EFF case 6
xor ecx, ecx
mov r14, rax
jmp loc_2709F
loc_26F25:
test ebp, ebp; jumptable 0000000000026EFF case -8
jz loc_270B6
loc_26F2D:
mov [rsp+58h+var_58], rbx; jumptable 0000000000026EFF case -7
cmp eax, 0FFFFFFF7h
jb loc_2700D
mov rax, [rsp+58h+var_58]
inc dword ptr [rax]
jmp loc_2700D
loc_26F45:
mov r14, rsp; jumptable 0000000000026EFF case 0
mov rdi, r14
mov esi, ebx
call i32toa
mov rdi, r15
mov rsi, r14
mov edx, eax
jmp loc_27087
loc_26F5F:
movq xmm0, rbx; jumptable 0000000000026EFF case 7
mov rdi, r15
xor esi, esi
xor edx, edx
call js_dtoa
jmp loc_2708C
loc_26F75:
cmp ebx, 1; jumptable 0000000000026EFF case 1
mov esi, 3
sbb esi, 0
mov rdi, r15
mov edx, 1
call __JS_AtomToValue
jmp loc_2708C
loc_26F92:
mov rax, [r15+18h]; jumptable 0000000000026EFF case 2
mov rax, [rax+68h]
mov rbx, [rax+8]
jmp loc_2703F
loc_26FA3:
lea rsi, aFunctionByteco; jumptable 0000000000026EFF case -2
mov rdi, r15
mov edx, 13h
jmp loc_27087
loc_26FB7:
mov [rsp+58h+var_58], rbx; jumptable 0000000000026EFF case -1
cmp eax, 0FFFFFFF7h
jb short loc_26FC6
mov rax, [rsp+58h+var_58]
inc dword ptr [rax]
loc_26FC6:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
xor ecx, ecx
call JS_ToPrimitiveFree
mov rbx, rax
mov r14, rdx
cmp r14d, 6
jz short loc_2700D
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov ecx, ebp
call JS_ToStringInternal
mov r12, rax
mov r13, rdx
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov rbx, r12
mov r14, r13
loc_2700D:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
jmp loc_2709F
loc_2701F:
lea rsi, aUninitialized; jumptable 0000000000026EFF case 4
mov rdi, r15
mov edx, 0Fh
jmp short loc_27087
loc_27030:
mov rax, [r15+18h]; jumptable 0000000000026EFF case 3
mov rax, [rax+68h]
mov rbx, [rax+230h]
loc_2703F:
mov rcx, [rbx+4]
mov rdx, rcx
shr rdx, 3Eh
cmp edx, 1
setz dl
neg ecx
setno cl
or cl, dl
jnz short loc_27060
mov rbx, [rax+178h]
loc_27060:
inc dword ptr [rbx]
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov r14, 0FFFFFFFFFFFFFFF9h
jmp short loc_2709F
def_26EFF:
lea rsi, aUnsupportedTyp; jumptable 0000000000026EFF default case, cases -6--3,5
mov rdi, r15
mov edx, 12h
loc_27087:
call js_new_string8_len
loc_2708C:
mov rbx, rax
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
loc_2709F:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_270B6:
lea rsi, aCannotConvertS; "cannot convert symbol to string"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14d, 6
xor ecx, ecx
jmp short loc_2709F
|
unsigned long long JS_ToStringInternal(
long long a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // rbx
long long v16; // rax
unsigned long long v17; // rcx
unsigned int v18; // eax
const char *v19; // rsi
unsigned int v20; // edx
_QWORD *v21; // rax
long long v22; // rax
long long v23; // rdx
long long v24; // r14
long long v25; // r12
char v27[88]; // [rsp+0h] [rbp-58h] BYREF
v15 = a2;
switch ( (int)a3 )
{
case -9:
v16 = js_bigint_to_string1(a1, a2, a3, 10LL);
goto LABEL_24;
case -8:
if ( a4 )
goto LABEL_5;
LODWORD(v15) = 0;
JS_ThrowTypeError(
a1,
(long long)"cannot convert symbol to string",
a3,
(unsigned int)(a3 + 9),
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v27[0]);
v17 = 0LL;
return v17 | (unsigned int)v15;
case -7:
LABEL_5:
*(_QWORD *)v27 = a2;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++**(_DWORD **)v27;
goto LABEL_16;
case -2:
v19 = "[function bytecode]";
v20 = 19;
goto LABEL_23;
case -1:
*(_QWORD *)v27 = a2;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++**(_DWORD **)v27;
v22 = JS_ToPrimitiveFree(a1, a2, a3, 0LL);
v15 = v22;
v24 = v23;
if ( (_DWORD)v23 != 6 )
{
v25 = JS_ToStringInternal(a1, v22, v23, a4);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v15, v24);
v15 = v25;
}
LABEL_16:
v17 = v15 & 0xFFFFFFFF00000000LL;
return v17 | (unsigned int)v15;
case 0:
v18 = i32toa(v27, a2);
v19 = v27;
v20 = v18;
goto LABEL_23;
case 1:
v16 = _JS_AtomToValue(a1, (((unsigned int)a2 | 0x300000000uLL) - 1) >> 32, 1);
goto LABEL_24;
case 2:
v21 = *(_QWORD **)(*(_QWORD *)(a1 + 24) + 104LL);
v15 = v21[1];
goto LABEL_19;
case 3:
v21 = *(_QWORD **)(*(_QWORD *)(a1 + 24) + 104LL);
v15 = v21[70];
LABEL_19:
if ( !((*(_QWORD *)(v15 + 4) >> 62 == 1) | !__OFSUB__(-(int)*(_QWORD *)(v15 + 4), 1)) )
v15 = v21[47];
++*(_DWORD *)v15;
v17 = v15 & 0xFFFFFFFF00000000LL;
return v17 | (unsigned int)v15;
case 4:
v19 = "[uninitialized]";
v20 = 15;
goto LABEL_23;
case 6:
LODWORD(v15) = 0;
v17 = 0LL;
return v17 | (unsigned int)v15;
case 7:
v16 = js_dtoa(a1, 0LL, 0LL, *(double *)&a2);
goto LABEL_24;
default:
v19 = "[unsupported type]";
v20 = 18;
LABEL_23:
v16 = js_new_string8_len(a1, (long long)v19, v20);
LABEL_24:
LODWORD(v15) = v16;
v17 = v16 & 0xFFFFFFFF00000000LL;
return v17 | (unsigned int)v15;
}
}
|
JS_ToStringInternal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R15,RDI
LEA ECX,[RDX + 0x9]
CMP ECX,0x10
JA 0x00127078
MOV R14,RDX
MOV RBX,RSI
MOV EAX,R14D
LEA RDX,[0x19afd0]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_fffffff7:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,0xa
CALL 0x0013d6d0
JMP 0x0012708c
caseD_6:
XOR EBX,EBX
XOR ECX,ECX
MOV R14,RAX
JMP 0x0012709f
caseD_fffffff8:
TEST EBP,EBP
JZ 0x001270b6
caseD_fffffff9:
MOV qword ptr [RSP],RBX
CMP EAX,-0x9
JC 0x0012700d
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
JMP 0x0012700d
caseD_0:
MOV R14,RSP
MOV RDI,R14
MOV ESI,EBX
CALL 0x0011b1d9
MOV RDI,R15
MOV RSI,R14
MOV EDX,EAX
JMP 0x00127087
caseD_7:
MOVQ XMM0,RBX
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001270d3
JMP 0x0012708c
caseD_1:
CMP EBX,0x1
MOV ESI,0x3
SBB ESI,0x0
MOV RDI,R15
MOV EDX,0x1
CALL 0x0011fb46
JMP 0x0012708c
caseD_2:
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RBX,qword ptr [RAX + 0x8]
JMP 0x0012703f
caseD_fffffffe:
LEA RSI,[0x19d66e]
MOV RDI,R15
MOV EDX,0x13
JMP 0x00127087
caseD_ffffffff:
MOV qword ptr [RSP],RBX
CMP EAX,-0x9
JC 0x00126fc6
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
LAB_00126fc6:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
XOR ECX,ECX
CALL 0x0013d3c3
MOV RBX,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x0012700d
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,EBP
CALL 0x00126ec9
MOV R12,RAX
MOV R13,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011ccb2
MOV RBX,R12
MOV R14,R13
LAB_0012700d:
MOV RCX,-0x100000000
AND RCX,RBX
JMP 0x0012709f
caseD_4:
LEA RSI,[0x19d6a2]
MOV RDI,R15
MOV EDX,0xf
JMP 0x00127087
caseD_3:
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RBX,qword ptr [RAX + 0x230]
LAB_0012703f:
MOV RCX,qword ptr [RBX + 0x4]
MOV RDX,RCX
SHR RDX,0x3e
CMP EDX,0x1
SETZ DL
NEG ECX
SETNO CL
OR CL,DL
JNZ 0x00127060
MOV RBX,qword ptr [RAX + 0x178]
LAB_00127060:
INC dword ptr [RBX]
MOV RCX,-0x100000000
AND RCX,RBX
MOV R14,-0x7
JMP 0x0012709f
caseD_fffffffa:
LEA RSI,[0x19d6b2]
MOV RDI,R15
MOV EDX,0x12
LAB_00127087:
CALL 0x0011f5c9
LAB_0012708c:
MOV RBX,RAX
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
LAB_0012709f:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001270b6:
LEA RSI,[0x19d682]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x00121953
MOV R14D,0x6
XOR ECX,ECX
JMP 0x0012709f
|
/* WARNING: Removing unreachable block (ram,0x00127059) */
int1 [16] JS_ToStringInternal(long param_1,int *param_2,ulong param_3,int param_4)
{
uint uVar1;
int1 auVar2 [16];
int4 uVar3;
ulong uVar4;
int *piVar5;
char *pcVar6;
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int *local_58 [5];
auVar7._8_8_ = param_3;
auVar7._0_8_ = param_2;
auVar8._8_8_ = param_3;
auVar8._0_8_ = param_2;
pcVar6 = (char *)local_58;
uVar1 = (uint)param_3;
if (0x10 < uVar1 + 9) {
switchD_00126eff_caseD_fffffffa:
pcVar6 = "[unsupported type]";
uVar3 = 0x12;
goto LAB_00127087;
}
switch(uVar1) {
case 0:
uVar3 = i32toa(local_58,(ulong)param_2 & 0xffffffff);
goto LAB_00127087;
case 1:
auVar8 = __JS_AtomToValue(param_1,3 - (uint)((int)param_2 == 0),1);
break;
case 2:
piVar5 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 8);
goto LAB_0012703f;
case 3:
piVar5 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x230);
LAB_0012703f:
*piVar5 = *piVar5 + 1;
uVar4 = (ulong)piVar5 & 0xffffffff00000000;
auVar8._8_8_ = 0xfffffffffffffff9;
auVar8._0_8_ = piVar5;
goto LAB_0012709f;
case 4:
pcVar6 = "[uninitialized]";
uVar3 = 0xf;
LAB_00127087:
auVar8 = js_new_string8_len(param_1,pcVar6,uVar3);
break;
case 6:
auVar2._8_8_ = 0;
auVar2._0_8_ = param_3 & 0xffffffff;
auVar8 = auVar2 << 0x40;
uVar4 = 0;
goto LAB_0012709f;
case 7:
auVar8 = js_dtoa(param_2,param_1,0,0);
break;
case 0xfffffff7:
auVar8 = js_bigint_to_string1(param_1,param_2,param_3,10);
break;
case 0xfffffff8:
if (param_4 == 0) {
JS_ThrowTypeError(param_1,"cannot convert symbol to string");
auVar8 = ZEXT816(6) << 0x40;
uVar4 = 0;
goto LAB_0012709f;
}
case 0xfffffff9:
if (0xfffffff6 < uVar1) {
*param_2 = *param_2 + 1;
auVar8 = auVar7;
}
LAB_0012700d:
uVar4 = auVar8._0_8_ & 0xffffffff00000000;
goto LAB_0012709f;
default:
goto switchD_00126eff_caseD_fffffffa;
case 0xfffffffe:
pcVar6 = "[function bytecode]";
uVar3 = 0x13;
goto LAB_00127087;
case 0xffffffff:
if (0xfffffff6 < uVar1) {
*param_2 = *param_2 + 1;
}
local_58[0] = param_2;
auVar8 = JS_ToPrimitiveFree(param_1,param_2,param_3,0);
if (auVar8._8_4_ != 6) {
auVar7 = JS_ToStringInternal(param_1,auVar8._0_8_,auVar8._8_8_,param_4);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar8._0_8_,auVar8._8_8_);
auVar8 = auVar7;
}
goto LAB_0012700d;
}
uVar4 = auVar8._0_8_ & 0xffffffff00000000;
LAB_0012709f:
auVar9._0_8_ = auVar8._0_8_ & 0xffffffff | uVar4;
auVar9._8_8_ = auVar8._8_8_;
return auVar9;
}
|
|
5,050 |
JS_ToStringInternal
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_ToStringInternal(JSContext *ctx, JSValue val, BOOL is_ToPropertyKey)
{
uint32_t tag;
char buf[32];
size_t len;
tag = JS_VALUE_GET_NORM_TAG(val);
switch(tag) {
case JS_TAG_STRING:
return js_dup(val);
case JS_TAG_INT:
len = i32toa(buf, JS_VALUE_GET_INT(val));
return js_new_string8_len(ctx, buf, len);
case JS_TAG_BOOL:
return JS_AtomToString(ctx, JS_VALUE_GET_BOOL(val) ?
JS_ATOM_true : JS_ATOM_false);
case JS_TAG_NULL:
return JS_AtomToString(ctx, JS_ATOM_null);
case JS_TAG_UNDEFINED:
return JS_AtomToString(ctx, JS_ATOM_undefined);
case JS_TAG_EXCEPTION:
return JS_EXCEPTION;
case JS_TAG_OBJECT:
{
JSValue val1, ret;
val1 = JS_ToPrimitive(ctx, val, HINT_STRING);
if (JS_IsException(val1))
return val1;
ret = JS_ToStringInternal(ctx, val1, is_ToPropertyKey);
JS_FreeValue(ctx, val1);
return ret;
}
break;
case JS_TAG_FUNCTION_BYTECODE:
return js_new_string8(ctx, "[function bytecode]");
case JS_TAG_SYMBOL:
if (is_ToPropertyKey) {
return js_dup(val);
} else {
return JS_ThrowTypeError(ctx, "cannot convert symbol to string");
}
case JS_TAG_FLOAT64:
return js_dtoa(ctx, JS_VALUE_GET_FLOAT64(val), 0, JS_DTOA_TOSTRING);
case JS_TAG_BIG_INT:
return js_bigint_to_string(ctx, val);
case JS_TAG_UNINITIALIZED:
return js_new_string8(ctx, "[uninitialized]");
default:
return js_new_string8(ctx, "[unsupported type]");
}
}
|
O3
|
c
|
JS_ToStringInternal:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leal 0x9(%rdx), %eax
cmpl $0x10, %eax
ja 0x276d3
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x76a6c(%rip), %rcx # 0x9dfb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0xa, %ecx
callq 0x3ee3b
jmp 0x275c2
movl %r14d, %r14d
xorl %ebx, %ebx
jmp 0x2778c
testl %ebp, %ebp
je 0x27773
incl (%rbx)
jmp 0x27712
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ba8d
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1fcd9
jmp 0x275c2
movq %rbx, %xmm0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x27790
jmp 0x275c2
cmpl $0x1, %ebx
movl $0x3, %esi
sbbl $0x0, %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x20277
movq %rax, %rbx
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x2771f
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rbx
jmp 0x2769a
xorl %ebx, %ebx
movq %r15, %rdi
movl $0x13, %esi
xorl %edx, %edx
callq 0x20686
testq %rax, %rax
je 0x2770c
movdqu 0x79031(%rip), %xmm0 # 0xa063e
movdqu %xmm0, 0x18(%rax)
movl $0x5d65646f, 0x27(%rax) # imm = 0x5D65646F
movb $0x0, 0x2b(%rax)
jmp 0x27700
incl (%rbx)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3e9e9
movq %rax, %r13
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x27736
movq %r13, %rbx
movq %r12, %r14
jmp 0x27712
xorl %ebx, %ebx
movq %r15, %rdi
movl $0xf, %esi
xorl %edx, %edx
callq 0x20686
testq %rax, %rax
je 0x2770c
movabsq $0x5d64657a696c6169, %rcx # imm = 0x5D64657A696C6169
movq %rcx, 0x1f(%rax)
movabsq $0x6974696e696e755b, %rcx # imm = 0x6974696E696E755B
movq %rcx, 0x18(%rax)
movb $0x0, 0x27(%rax)
jmp 0x27700
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq 0x230(%rax), %rbx
movq 0x4(%rbx), %rcx
movq %rcx, %rdx
shrq $0x3e, %rdx
cmpl $0x1, %edx
sete %dl
negl %ecx
setno %cl
orb %dl, %cl
jne 0x276bb
movq 0x178(%rax), %rbx
incl (%rbx)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movq $-0x7, %r14
jmp 0x2771f
xorl %ebx, %ebx
movq %r15, %rdi
movl $0x12, %esi
xorl %edx, %edx
callq 0x20686
testq %rax, %rax
je 0x2770c
movdqu 0x78f91(%rip), %xmm0 # 0xa0682
movdqu %xmm0, 0x18(%rax)
movw $0x5d65, 0x28(%rax) # imm = 0x5D65
movb $0x0, 0x2a(%rax)
movq $-0x7, %r14
movq %rax, %rbx
jmp 0x27712
movl $0x6, %r14d
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x27518
movq %rax, %rbx
movq %rdx, %r14
cmpl $-0x9, %r12d
jb 0x27712
movq 0x18(%r15), %rdi
movl (%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r13)
cmpl $0x1, %eax
jg 0x27712
movq %r13, %rsi
movq %r12, %rdx
callq 0x20d90
jmp 0x27712
leaq 0x78ed8(%rip), %rsi # 0xa0652
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2214f
movl $0x6, %r14d
xorl %ecx, %ecx
jmp 0x2771f
|
JS_ToStringInternal:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
lea eax, [rdx+9]; switch 17 cases
cmp eax, 10h
ja def_2754B; jumptable 000000000002754B default case, cases -6--3,5
mov ebp, ecx
mov r14, rdx
mov rbx, rsi
lea rcx, jpt_2754B
movsxd rax, ds:(jpt_2754B - 9DFB0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2754D:
mov rdi, r15; jumptable 000000000002754B case -9
mov rsi, rbx
mov rdx, r14
mov ecx, 0Ah
call js_bigint_to_string1
jmp short loc_275C2
loc_27562:
mov r14d, r14d; jumptable 000000000002754B case 6
xor ebx, ebx
jmp loc_2778C
loc_2756C:
test ebp, ebp; jumptable 000000000002754B case -8
jz loc_27773
loc_27574:
inc dword ptr [rbx]; jumptable 000000000002754B case -7
jmp loc_27712
loc_2757B:
mov r14, rsp; jumptable 000000000002754B case 0
mov rdi, r14
mov esi, ebx
call i32toa
mov rdi, r15
mov rsi, r14
mov edx, eax
call js_new_string8_len
jmp short loc_275C2
loc_27597:
movq xmm0, rbx; jumptable 000000000002754B case 7
mov rdi, r15
xor esi, esi
xor edx, edx
call js_dtoa
jmp short loc_275C2
loc_275AA:
cmp ebx, 1; jumptable 000000000002754B case 1
mov esi, 3
sbb esi, 0
mov rdi, r15
mov edx, 1
call __JS_AtomToValue
loc_275C2:
mov rbx, rax
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp loc_2771F
loc_275DA:
mov rax, [r15+18h]; jumptable 000000000002754B case 2
mov rax, [rax+68h]
mov rbx, [rax+8]
jmp loc_2769A
loc_275EB:
xor ebx, ebx; jumptable 000000000002754B case -2
mov rdi, r15
mov esi, 13h
xor edx, edx
call js_alloc_string
test rax, rax
jz loc_2770C
movdqu xmm0, cs:xmmword_A063E
movdqu xmmword ptr [rax+18h], xmm0
mov dword ptr [rax+27h], 5D65646Fh
mov byte ptr [rax+2Bh], 0
jmp loc_27700
loc_27622:
inc dword ptr [rbx]; jumptable 000000000002754B case -1
mov rdi, r15
mov rsi, rbx
mov rdx, r14
xor ecx, ecx
call JS_ToPrimitiveFree
mov r13, rax
mov r12, rdx
cmp r12d, 6
jnz loc_27736
mov rbx, r13
mov r14, r12
jmp loc_27712
loc_2764F:
xor ebx, ebx; jumptable 000000000002754B case 4
mov rdi, r15
mov esi, 0Fh
xor edx, edx
call js_alloc_string
test rax, rax
jz loc_2770C
mov rcx, 5D64657A696C6169h
mov [rax+1Fh], rcx
mov rcx, 6974696E696E755Bh
mov [rax+18h], rcx
mov byte ptr [rax+27h], 0
jmp short loc_27700
loc_2768B:
mov rax, [r15+18h]; jumptable 000000000002754B case 3
mov rax, [rax+68h]
mov rbx, [rax+230h]
loc_2769A:
mov rcx, [rbx+4]
mov rdx, rcx
shr rdx, 3Eh
cmp edx, 1
setz dl
neg ecx
setno cl
or cl, dl
jnz short loc_276BB
mov rbx, [rax+178h]
loc_276BB:
inc dword ptr [rbx]
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov r14, 0FFFFFFFFFFFFFFF9h
jmp short loc_2771F
def_2754B:
xor ebx, ebx; jumptable 000000000002754B default case, cases -6--3,5
mov rdi, r15
mov esi, 12h
xor edx, edx
call js_alloc_string
test rax, rax
jz short loc_2770C
movdqu xmm0, cs:xmmword_A0682
movdqu xmmword ptr [rax+18h], xmm0
mov word ptr [rax+28h], 5D65h
mov byte ptr [rax+2Ah], 0
loc_27700:
mov r14, 0FFFFFFFFFFFFFFF9h
mov rbx, rax
jmp short loc_27712
loc_2770C:
mov r14d, 6
loc_27712:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
loc_2771F:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_27736:
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov ecx, ebp
call JS_ToStringInternal
mov rbx, rax
mov r14, rdx
cmp r12d, 0FFFFFFF7h
jb short loc_27712
mov rdi, [r15+18h]
mov eax, [r13+0]
lea ecx, [rax-1]
mov [r13+0], ecx
cmp eax, 1
jg short loc_27712
mov rsi, r13
mov rdx, r12
call js_free_value_rt
jmp short loc_27712
loc_27773:
lea rsi, aCannotConvertS; "cannot convert symbol to string"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14d, 6
loc_2778C:
xor ecx, ecx
jmp short loc_2771F
|
unsigned long long JS_ToStringInternal(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // ebp
long long v15; // rbx
long long v16; // rax
int v17; // eax
unsigned long long v18; // rcx
_QWORD *v19; // rax
char *v20; // rax
long long v21; // rax
long long v22; // rdx
_QWORD *v23; // r13
long long v24; // r12
long long v26; // r8
long long v27; // r9
long long v28; // rdi
int v29; // eax
long long v30; // rcx
char v31[88]; // [rsp+0h] [rbp-58h] BYREF
v14 = a4;
v15 = (long long)a2;
switch ( (int)a3 )
{
case -9:
v16 = js_bigint_to_string1(a1, a2, a3, 10LL);
goto LABEL_9;
case -8:
if ( (_DWORD)a4 )
goto LABEL_5;
LODWORD(v15) = 0;
JS_ThrowTypeError(
a1,
(long long)"cannot convert symbol to string",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v31[0]);
goto LABEL_30;
case -7:
LABEL_5:
++*a2;
goto LABEL_24;
case -2:
v15 = 0LL;
v20 = (char *)js_alloc_string(a1, 19LL, 0);
if ( !v20 )
goto LABEL_24;
*(__m128i *)(v20 + 24) = _mm_loadu_si128(&xmmword_A063E);
strcpy(v20 + 39, "ode]");
break;
case -1:
++*a2;
v21 = JS_ToPrimitiveFree(a1, a2, a3, 0LL);
v23 = (_QWORD *)v21;
v24 = v22;
if ( (_DWORD)v22 == 6 )
{
v15 = v21;
}
else
{
v15 = JS_ToStringInternal(a1, v21, v22, v14);
if ( (unsigned int)v24 >= 0xFFFFFFF7 )
{
v28 = *(_QWORD *)(a1 + 24);
v29 = *(_DWORD *)v23;
v30 = (unsigned int)(*(_DWORD *)v23 - 1);
*(_DWORD *)v23 = v30;
if ( v29 <= 1 )
js_free_value_rt(v28, v23, v24, v30, v26, v27);
}
}
goto LABEL_24;
case 0:
v17 = i32toa(v31, (signed int)a2);
v16 = js_new_string8_len(a1, (long long)v31, v17);
goto LABEL_9;
case 1:
v16 = _JS_AtomToValue(a1, (((unsigned int)a2 | 0x300000000uLL) - 1) >> 32, 1);
goto LABEL_9;
case 2:
v19 = *(_QWORD **)(*(_QWORD *)(a1 + 24) + 104LL);
v15 = v19[1];
goto LABEL_18;
case 3:
v19 = *(_QWORD **)(*(_QWORD *)(a1 + 24) + 104LL);
v15 = v19[70];
LABEL_18:
if ( !((*(_QWORD *)(v15 + 4) >> 62 == 1) | !__OFSUB__(-(int)*(_QWORD *)(v15 + 4), 1)) )
v15 = v19[47];
++*(_DWORD *)v15;
v18 = v15 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v15;
case 4:
v15 = 0LL;
v20 = (char *)js_alloc_string(a1, 15LL, 0);
if ( !v20 )
goto LABEL_24;
strcpy(v20 + 24, "[uninitialized]");
break;
case 6:
LODWORD(v15) = 0;
LABEL_30:
v18 = 0LL;
return v18 | (unsigned int)v15;
case 7:
v16 = js_dtoa(a1, 0LL, 0LL, *(double *)&a2);
LABEL_9:
LODWORD(v15) = v16;
v18 = v16 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v15;
default:
v15 = 0LL;
v20 = (char *)js_alloc_string(a1, 18LL, 0);
if ( !v20 )
goto LABEL_24;
*(__m128i *)(v20 + 24) = _mm_loadu_si128(&xmmword_A0682);
strcpy(v20 + 40, "e]");
break;
}
v15 = (long long)v20;
LABEL_24:
v18 = v15 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v15;
}
|
JS_ToStringInternal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDI
LEA EAX,[RDX + 0x9]
CMP EAX,0x10
JA 0x001276d3
MOV EBP,ECX
MOV R14,RDX
MOV RBX,RSI
LEA RCX,[0x19dfb0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_fffffff7:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,0xa
CALL 0x0013ee3b
JMP 0x001275c2
caseD_6:
MOV R14D,R14D
XOR EBX,EBX
JMP 0x0012778c
caseD_fffffff8:
TEST EBP,EBP
JZ 0x00127773
caseD_fffffff9:
INC dword ptr [RBX]
JMP 0x00127712
caseD_0:
MOV R14,RSP
MOV RDI,R14
MOV ESI,EBX
CALL 0x0011ba8d
MOV RDI,R15
MOV RSI,R14
MOV EDX,EAX
CALL 0x0011fcd9
JMP 0x001275c2
caseD_7:
MOVQ XMM0,RBX
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00127790
JMP 0x001275c2
caseD_1:
CMP EBX,0x1
MOV ESI,0x3
SBB ESI,0x0
MOV RDI,R15
MOV EDX,0x1
CALL 0x00120277
LAB_001275c2:
MOV RBX,RAX
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x0012771f
caseD_2:
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RBX,qword ptr [RAX + 0x8]
JMP 0x0012769a
caseD_fffffffe:
XOR EBX,EBX
MOV RDI,R15
MOV ESI,0x13
XOR EDX,EDX
CALL 0x00120686
TEST RAX,RAX
JZ 0x0012770c
MOVDQU XMM0,xmmword ptr [0x001a063e]
MOVDQU xmmword ptr [RAX + 0x18],XMM0
MOV dword ptr [RAX + 0x27],0x5d65646f
MOV byte ptr [RAX + 0x2b],0x0
JMP 0x00127700
caseD_ffffffff:
INC dword ptr [RBX]
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
XOR ECX,ECX
CALL 0x0013e9e9
MOV R13,RAX
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00127736
MOV RBX,R13
MOV R14,R12
JMP 0x00127712
caseD_4:
XOR EBX,EBX
MOV RDI,R15
MOV ESI,0xf
XOR EDX,EDX
CALL 0x00120686
TEST RAX,RAX
JZ 0x0012770c
MOV RCX,0x5d64657a696c6169
MOV qword ptr [RAX + 0x1f],RCX
MOV RCX,0x6974696e696e755b
MOV qword ptr [RAX + 0x18],RCX
MOV byte ptr [RAX + 0x27],0x0
JMP 0x00127700
caseD_3:
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV RBX,qword ptr [RAX + 0x230]
LAB_0012769a:
MOV RCX,qword ptr [RBX + 0x4]
MOV RDX,RCX
SHR RDX,0x3e
CMP EDX,0x1
SETZ DL
NEG ECX
SETNO CL
OR CL,DL
JNZ 0x001276bb
MOV RBX,qword ptr [RAX + 0x178]
LAB_001276bb:
INC dword ptr [RBX]
MOV RCX,-0x100000000
AND RCX,RBX
MOV R14,-0x7
JMP 0x0012771f
caseD_fffffffa:
XOR EBX,EBX
MOV RDI,R15
MOV ESI,0x12
XOR EDX,EDX
CALL 0x00120686
TEST RAX,RAX
JZ 0x0012770c
MOVDQU XMM0,xmmword ptr [0x001a0682]
MOVDQU xmmword ptr [RAX + 0x18],XMM0
MOV word ptr [RAX + 0x28],0x5d65
MOV byte ptr [RAX + 0x2a],0x0
LAB_00127700:
MOV R14,-0x7
MOV RBX,RAX
JMP 0x00127712
LAB_0012770c:
MOV R14D,0x6
LAB_00127712:
MOV RCX,-0x100000000
AND RCX,RBX
LAB_0012771f:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00127736:
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV ECX,EBP
CALL 0x00127518
MOV RBX,RAX
MOV R14,RDX
CMP R12D,-0x9
JC 0x00127712
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R13]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R13],ECX
CMP EAX,0x1
JG 0x00127712
MOV RSI,R13
MOV RDX,R12
CALL 0x00120d90
JMP 0x00127712
LAB_00127773:
LEA RSI,[0x1a0652]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x0012214f
MOV R14D,0x6
LAB_0012778c:
XOR ECX,ECX
JMP 0x0012771f
|
/* WARNING: Removing unreachable block (ram,0x001276b4) */
int1 [16] JS_ToStringInternal(long param_1,int *param_2,ulong param_3,int param_4)
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
int4 uVar4;
long lVar5;
ulong uVar6;
int8 uVar7;
int *piVar8;
uint uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int1 auStack_58 [40];
auVar10._8_8_ = param_3;
auVar10._0_8_ = param_2;
switch((int)param_3) {
case 0:
uVar4 = i32toa(auStack_58,(ulong)param_2 & 0xffffffff);
auVar10 = js_new_string8_len(param_1,auStack_58,uVar4);
break;
case 1:
auVar10 = __JS_AtomToValue(param_1,3 - (uint)((int)param_2 == 0),1);
break;
case 2:
piVar8 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 8);
goto LAB_0012769a;
case 3:
piVar8 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x230);
LAB_0012769a:
*piVar8 = *piVar8 + 1;
uVar6 = (ulong)piVar8 & 0xffffffff00000000;
auVar10._8_8_ = 0xfffffffffffffff9;
auVar10._0_8_ = piVar8;
goto LAB_0012771f;
case 4:
lVar5 = js_alloc_string(param_1,0xf,0);
if (lVar5 == 0) goto LAB_0012770c;
*(int8 *)(lVar5 + 0x1f) = 0x5d64657a696c6169;
*(int8 *)(lVar5 + 0x18) = 0x6974696e696e755b;
*(int1 *)(lVar5 + 0x27) = 0;
LAB_00127700:
auVar10._8_8_ = 0xfffffffffffffff9;
auVar10._0_8_ = lVar5;
LAB_00127712:
uVar6 = auVar10._0_8_ & 0xffffffff00000000;
goto LAB_0012771f;
case 6:
param_3 = param_3 & 0xffffffff;
LAB_0012778c:
auVar3._8_8_ = 0;
auVar3._0_8_ = param_3;
auVar10 = auVar3 << 0x40;
uVar6 = 0;
goto LAB_0012771f;
case 7:
auVar10 = js_dtoa(param_2,param_1,0,0);
break;
case -9:
auVar10 = js_bigint_to_string1(param_1,param_2,param_3,10);
break;
case -8:
if (param_4 == 0) {
JS_ThrowTypeError(param_1,"cannot convert symbol to string");
param_3 = 6;
goto LAB_0012778c;
}
case -7:
*param_2 = *param_2 + 1;
goto LAB_00127712;
default:
lVar5 = js_alloc_string(param_1,0x12,0);
uVar7 = s__unsupported_type__001a0682._8_8_;
if (lVar5 != 0) {
*(int8 *)(lVar5 + 0x18) = s__unsupported_type__001a0682._0_8_;
*(int8 *)(lVar5 + 0x20) = uVar7;
*(int2 *)(lVar5 + 0x28) = 0x5d65;
*(int1 *)(lVar5 + 0x2a) = 0;
goto LAB_00127700;
}
LAB_0012770c:
auVar10 = ZEXT816(6) << 0x40;
goto LAB_00127712;
case -2:
lVar5 = js_alloc_string(param_1,0x13,0);
uVar7 = s__function_bytecode__001a063e._8_8_;
if (lVar5 == 0) goto LAB_0012770c;
*(int8 *)(lVar5 + 0x18) = s__function_bytecode__001a063e._0_8_;
*(int8 *)(lVar5 + 0x20) = uVar7;
*(int4 *)(lVar5 + 0x27) = 0x5d65646f;
*(int1 *)(lVar5 + 0x2b) = 0;
goto LAB_00127700;
case -1:
*param_2 = *param_2 + 1;
auVar10 = JS_ToPrimitiveFree(param_1,param_2,param_3,0);
uVar7 = auVar10._8_8_;
piVar8 = auVar10._0_8_;
uVar9 = auVar10._8_4_;
if ((uVar9 != 6) &&
(auVar10 = JS_ToStringInternal(param_1,piVar8,uVar7,param_4), 0xfffffff6 < uVar9)) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar8;
*piVar8 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,piVar8,uVar7);
}
}
goto LAB_00127712;
}
uVar6 = auVar10._0_8_ & 0xffffffff00000000;
LAB_0012771f:
auVar11._0_8_ = auVar10._0_8_ & 0xffffffff | uVar6;
auVar11._8_8_ = auVar10._8_8_;
return auVar11;
}
|
|
5,051 |
ggml_fopen
|
ngxson[P]ggml-easy/ggml/src/ggml.c
|
FILE * ggml_fopen(const char * fname, const char * mode) {
#ifdef _WIN32
FILE * file = NULL;
// convert fname (UTF-8)
wchar_t * wfname = ggml_mbstowcs(fname);
if (wfname) {
// convert mode (ANSI)
wchar_t * wmode = GGML_MALLOC((strlen(mode) + 1) * sizeof(wchar_t));
wchar_t * wmode_p = wmode;
do {
*wmode_p++ = (wchar_t)*mode;
} while (*mode++);
// open file
file = _wfopen(wfname, wmode);
GGML_FREE(wfname);
GGML_FREE(wmode);
}
return file;
#else
return fopen(fname, mode);
#endif
}
|
O2
|
c
|
ggml_fopen:
jmp 0x1daf0
|
ggml_fopen:
jmp _fopen
|
// attributes: thunk
long long ggml_fopen()
{
return fopen();
}
|
ggml_fopen:
JMP 0x0011daf0
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
FILE * ggml_fopen(char *__filename,char *__modes)
{
FILE *pFVar1;
pFVar1 = (FILE *)(*(code *)PTR_fopen_0016dd78)();
return pFVar1;
}
|
|
5,052 |
find_type_with_warning
|
eloqsql/mysys/typelib.c
|
int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option)
{
int res;
const char **ptr;
if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) <= 0)
{
ptr= typelib->type_names;
if (!*x)
fprintf(stderr, "No option given to %s\n", option);
else
fprintf(stderr, "Unknown option to %s: %s\n", option, x);
fprintf(stderr, "Alternatives are: '%s'", *ptr);
while (*++ptr)
fprintf(stderr, ",'%s'", *ptr);
fprintf(stderr, "\n");
}
return res;
}
|
O0
|
c
|
find_type_with_warning:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xc6730
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jg 0xc6720
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc6692
movq 0x1c095d(%rip), %rax # 0x286fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5afb8(%rip), %rsi # 0x121641
movb $0x0, %al
callq 0x271d0
jmp 0xc66b2
movq 0x1c093f(%rip), %rax # 0x286fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x5afad(%rip), %rsi # 0x121658
movb $0x0, %al
callq 0x271d0
movq 0x1c091f(%rip), %rax # 0x286fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x5afa8(%rip), %rsi # 0x121672
movb $0x0, %al
callq 0x271d0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xc6708
movq 0x1c08ea(%rip), %rax # 0x286fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x5af8a(%rip), %rsi # 0x121689
movb $0x0, %al
callq 0x271d0
jmp 0xc66d1
movq 0x1c08c9(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0x57c3b(%rip), %rsi # 0x11e354
movb $0x0, %al
callq 0x271d0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
find_type_with_warning:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
xor edx, edx
call find_type
mov [rbp+var_1C], eax
cmp eax, 0
jg loc_C6720
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jnz short loc_C6692
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_18]
lea rsi, aNoOptionGivenT; "No option given to %s\n"
mov al, 0
call _fprintf
jmp short loc_C66B2
loc_C6692:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_8]
lea rsi, aUnknownOptionT; "Unknown option to %s: %s\n"
mov al, 0
call _fprintf
loc_C66B2:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, [rbp+var_28]
mov rdx, [rax]
lea rsi, aAlternativesAr; "Alternatives are: '%s'"
mov al, 0
call _fprintf
loc_C66D1:
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 8
mov [rbp+var_28], rcx
cmp qword ptr [rax+8], 0
jz short loc_C6708
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, [rbp+var_28]
mov rdx, [rax]
lea rsi, aS_1; ",'%s'"
mov al, 0
call _fprintf
jmp short loc_C66D1
loc_C6708:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aLibmarias3SDS+18h; "\n"
mov al, 0
call _fprintf
loc_C6720:
mov eax, [rbp+var_1C]
add rsp, 30h
pop rbp
retn
|
long long find_type_with_warning(const char *a1, long long a2, const char *a3)
{
const char **v3; // rax
const char **v5; // [rsp+8h] [rbp-28h]
int type; // [rsp+14h] [rbp-1Ch]
type = find_type(a1, a2, 0LL);
if ( type <= 0 )
{
v5 = *(const char ***)(a2 + 16);
if ( *a1 )
fprintf(stderr, "Unknown option to %s: %s\n", a3, a1);
else
fprintf(stderr, "No option given to %s\n", a3);
fprintf(stderr, "Alternatives are: '%s'", *v5);
while ( 1 )
{
v3 = v5++;
if ( !v3[1] )
break;
fprintf(stderr, ",'%s'", *v5);
}
fprintf(stderr, "\n");
}
return (unsigned int)type;
}
|
find_type_with_warning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
XOR EDX,EDX
CALL 0x001c6730
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JG 0x001c6720
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JNZ 0x001c6692
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x221641]
MOV AL,0x0
CALL 0x001271d0
JMP 0x001c66b2
LAB_001c6692:
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
LEA RSI,[0x221658]
MOV AL,0x0
CALL 0x001271d0
LAB_001c66b2:
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x221672]
MOV AL,0x0
CALL 0x001271d0
LAB_001c66d1:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001c6708
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x221689]
MOV AL,0x0
CALL 0x001271d0
JMP 0x001c66d1
LAB_001c6708:
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21e354]
MOV AL,0x0
CALL 0x001271d0
LAB_001c6720:
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSP,0x30
POP RBP
RET
|
int find_type_with_warning(char *param_1,long param_2,int8 param_3)
{
int iVar1;
int8 *local_30;
iVar1 = find_type(param_1,param_2,0);
if (iVar1 < 1) {
local_30 = *(int8 **)(param_2 + 0x10);
if (*param_1 == '\0') {
fprintf(*(FILE **)PTR_stderr_00386fd8,"No option given to %s\n",param_3);
}
else {
fprintf(*(FILE **)PTR_stderr_00386fd8,"Unknown option to %s: %s\n",param_3,param_1);
}
fprintf(*(FILE **)PTR_stderr_00386fd8,"Alternatives are: \'%s\'",*local_30);
while( true ) {
if (local_30[1] == 0) break;
fprintf(*(FILE **)PTR_stderr_00386fd8,",\'%s\'",local_30[1]);
local_30 = local_30 + 1;
}
fprintf(*(FILE **)PTR_stderr_00386fd8,"\n");
}
return iVar1;
}
|
|
5,053 |
bitmap_invert
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_invert(MY_BITMAP *map)
{
my_bitmap_map *to= map->bitmap, *end;
DBUG_ASSERT(map->bitmap);
end= map->last_word_ptr;
while (to <= end)
*to++ ^= 0xFFFFFFFF;
}
|
O0
|
c
|
bitmap_invert:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xee4b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xee4e3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movl (%rax), %ecx
xorl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xee4c1
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
bitmap_invert:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short $+2
loc_EE4B5:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
loc_EE4C1:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
ja short loc_EE4E3
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 4
mov [rbp+var_10], rcx
mov ecx, [rax]
xor ecx, 0FFFFFFFFh
mov [rax], ecx
jmp short loc_EE4C1
loc_EE4E3:
pop rbp
retn
|
int * bitmap_invert(int **a1)
{
int *result; // rax
int *v2; // rax
unsigned long long v3; // [rsp+0h] [rbp-18h]
int *v4; // [rsp+8h] [rbp-10h]
v4 = *a1;
v3 = (unsigned long long)a1[1];
while ( 1 )
{
result = v4;
if ( (unsigned long long)v4 > v3 )
break;
v2 = v4++;
*v2 = ~*v2;
}
return result;
}
|
bitmap_invert:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001ee4b5
LAB_001ee4b5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_001ee4c1:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JA 0x001ee4e3
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x10],RCX
MOV ECX,dword ptr [RAX]
XOR ECX,0xffffffff
MOV dword ptr [RAX],ECX
JMP 0x001ee4c1
LAB_001ee4e3:
POP RBP
RET
|
void bitmap_invert(int8 *param_1)
{
uint *puVar1;
uint *local_18;
puVar1 = (uint *)param_1[1];
local_18 = (uint *)*param_1;
while (local_18 <= puVar1) {
*local_18 = *local_18 ^ 0xffffffff;
local_18 = local_18 + 1;
}
return;
}
|
|
5,054 |
my_charset_get_by_name
|
eloqsql/mysys/charset.c
|
CHARSET_INFO *
my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *cs_name, uint cs_flags, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
DBUG_ENTER("get_charset_by_csname");
DBUG_PRINT("enter",("name: '%s'", cs_name));
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_charset_number(cs_name, cs_flags, flags);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
}
DBUG_RETURN(cs);
}
|
O3
|
c
|
my_charset_get_by_name:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq 0xb74a3e(%rip), %rdi # 0xc07b30
leaq -0x9ae(%rip), %rsi # 0x9274b
callq 0x29240
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x92936
testl %eax, %eax
je 0x93122
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x92bda
movq %rax, %r14
jmp 0x93125
xorl %r14d, %r14d
testq %r14, %r14
setne %al
testb $0x10, %r15b
sete %cl
orb %al, %cl
jne 0x9316f
leaq -0x240(%rbp), %r15
movq %r15, %rdi
callq 0x9250b
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
movl $0x4, %esi
movl $0x16, %edi
movq %rbx, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x9e1d7
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x93191
movq %r14, %rax
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
my_charset_get_by_name:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 220h
mov r15, rcx
mov r12d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
mov esi, r12d
mov rdx, r15
call get_charset_number
test eax, eax
jz short loc_93122
mov rdi, r14
mov esi, eax
mov rdx, r15
call get_internal_charset
mov r14, rax
jmp short loc_93125
loc_93122:
xor r14d, r14d
loc_93125:
test r14, r14
setnz al
test r15b, 10h
setz cl
or cl, al
jnz short loc_9316F
lea r15, [rbp+var_240]
mov rdi, r15
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
mov esi, 4
mov edi, 16h
mov rdx, rbx
mov rcx, r15
xor eax, eax
call my_error
loc_9316F:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_93191
mov rax, r14
add rsp, 220h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_93191:
call ___stack_chk_fail
|
long long my_charset_get_by_name(long long a1, long long a2, unsigned int a3, long long a4)
{
unsigned int charset_number; // eax
long long internal_charset; // r14
int v8; // r8d
int v9; // r9d
_BYTE v11[536]; // [rsp+0h] [rbp-240h] BYREF
unsigned long long v12; // [rsp+218h] [rbp-28h]
v12 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
charset_number = get_charset_number(a2, a3, a4);
if ( charset_number )
internal_charset = get_internal_charset(a1, charset_number, a4);
else
internal_charset = 0LL;
if ( internal_charset == 0 && (a4 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v11), "Index.xml");
my_error(22, 4, a2, (unsigned int)v11, v8, v9);
}
return internal_charset;
}
|
my_charset_get_by_name:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x220
MOV R15,RCX
MOV R12D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[0xd07b30]
LEA RSI,[0x19274b]
CALL 0x00129240
MOV RDI,RBX
MOV ESI,R12D
MOV RDX,R15
CALL 0x00192936
TEST EAX,EAX
JZ 0x00193122
MOV RDI,R14
MOV ESI,EAX
MOV RDX,R15
CALL 0x00192bda
MOV R14,RAX
JMP 0x00193125
LAB_00193122:
XOR R14D,R14D
LAB_00193125:
TEST R14,R14
SETNZ AL
TEST R15B,0x10
SETZ CL
OR CL,AL
JNZ 0x0019316f
LEA R15,[RBP + -0x240]
MOV RDI,R15
CALL 0x0019250b
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
MOV ESI,0x4
MOV EDI,0x16
MOV RDX,RBX
MOV RCX,R15
XOR EAX,EAX
CALL 0x0019e1d7
LAB_0019316f:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00193191
MOV RAX,R14
ADD RSP,0x220
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00193191:
CALL 0x00129270
|
long my_charset_get_by_name(int8 param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
long lVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_248 [536];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_charset_number(param_2,param_3,param_4);
if (iVar1 == 0) {
lVar2 = 0;
}
else {
lVar2 = get_internal_charset(param_1,iVar1,param_4);
}
if ((param_4 & 0x10) != 0 && lVar2 == 0) {
puVar3 = (int8 *)get_charsets_dir(local_248);
*puVar3 = 0x6d782e7865646e49;
*(int2 *)(puVar3 + 1) = 0x6c;
my_error(0x16,4,param_2,local_248);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return lVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
5,055 |
JS_ThrowReferenceErrorUninitialized2
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowReferenceErrorUninitialized2(JSContext *ctx,
JSFunctionBytecode *b,
int idx, BOOL is_ref)
{
JSAtom atom = JS_ATOM_NULL;
if (is_ref) {
atom = b->closure_var[idx].var_name;
} else {
/* not present if the function is stripped and contains no eval() */
if (b->vardefs)
atom = b->vardefs[b->arg_count + idx].var_name;
}
return JS_ThrowReferenceErrorUninitialized(ctx, atom);
}
|
O0
|
c
|
JS_ThrowReferenceErrorUninitialized2:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x670cd
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x14(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, 0xc(%rsp)
jmp 0x67101
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x670ff
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
movzwl 0x40(%rcx), %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x67101
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x604d0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
JS_ThrowReferenceErrorUninitialized2:
sub rsp, 38h
mov [rsp+38h+var_18], rdi
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_24], edx
mov [rsp+38h+var_28], ecx
mov [rsp+38h+var_2C], 0
cmp [rsp+38h+var_28], 0
jz short loc_670CD
mov rax, [rsp+38h+var_20]
mov rax, [rax+38h]
movsxd rcx, [rsp+38h+var_24]
mov eax, [rax+rcx*8+4]
mov [rsp+38h+var_2C], eax
jmp short loc_67101
loc_670CD:
mov rax, [rsp+38h+var_20]
cmp qword ptr [rax+30h], 0
jz short loc_670FF
mov rax, [rsp+38h+var_20]
mov rax, [rax+30h]
mov rcx, [rsp+38h+var_20]
movzx ecx, word ptr [rcx+40h]
add ecx, [rsp+38h+var_24]
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov [rsp+38h+var_2C], eax
loc_670FF:
jmp short $+2
loc_67101:
mov rdi, [rsp+38h+var_18]
mov esi, [rsp+38h+var_2C]
call JS_ThrowReferenceErrorUninitialized
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long JS_ThrowReferenceErrorUninitialized2(
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)
{
unsigned int v15; // [rsp+Ch] [rbp-2Ch]
v15 = 0;
if ( (_DWORD)a4 )
return JS_ThrowReferenceErrorUninitialized(
a1,
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 8LL * (int)a3 + 4),
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a3,
(int)a3,
a5,
a6);
if ( *(_QWORD *)(a2 + 48) )
{
a4 = 16LL * (int)(a3 + *(unsigned __int16 *)(a2 + 64));
v15 = *(_DWORD *)(a4 + *(_QWORD *)(a2 + 48));
}
return JS_ThrowReferenceErrorUninitialized(a1, v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, a4, a5, a6);
}
|
js_atof:
SUB RSP,0x118
MOV qword ptr [RSP + 0x100],RDI
MOV qword ptr [RSP + 0xf8],RSI
MOV qword ptr [RSP + 0xf0],RDX
MOV qword ptr [RSP + 0xe8],RCX
MOV dword ptr [RSP + 0xe4],R8D
MOV dword ptr [RSP + 0xe0],R9D
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,qword ptr [RSP + 0xf0]
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [0x00217e90]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [0x00217e98]
MOV qword ptr [RSP + 0x60],RAX
CMP dword ptr [RSP + 0xe4],0x2
JL 0x00167118
CMP dword ptr [RSP + 0xe4],0x24
JLE 0x0016711d
LAB_00167118:
JMP 0x00167941
LAB_0016711d:
MOV EDX,dword ptr [RSP + 0xe0]
AND EDX,0x40
MOV EAX,0x100
MOV ECX,0x5f
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RSP + 0xcc],EAX
MOV byte ptr [RSP + 0x4f],0x0
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00167177
MOV RDI,qword ptr [RSP + 0xf8]
CALL 0x00167a60
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0xf8]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0xf8],RAX
LAB_00167177:
MOV RAX,qword ptr [RSP + 0xf8]
CMP RAX,qword ptr [RSP + 0xd0]
JNZ 0x0016720d
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0016720d
CMP qword ptr [RSP + 0xe8],0x0
JZ 0x001671ba
MOV RCX,qword ptr [RSP + 0xf8]
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RAX],RCX
LAB_001671ba:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x100
CMP EAX,0x0
JZ 0x001671f1
MOV RDI,qword ptr [RSP + 0x100]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0013de70
MOV qword ptr [RSP + 0x108],RAX
MOV qword ptr [RSP + 0x110],RDX
JMP 0x00167a40
LAB_001671f1:
XOR EDI,EDI
CALL 0x00137e40
MOV qword ptr [RSP + 0x108],RAX
MOV qword ptr [RSP + 0x110],RDX
JMP 0x00167a40
LAB_0016720d:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2b
JZ 0x0016722d
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00167273
LAB_0016722d:
MOV RAX,qword ptr [RSP + 0xf8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x4f],AL
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x200
CMP EAX,0x0
JZ 0x00167271
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0xffffffcf
MOV dword ptr [RSP + 0xe0],EAX
LAB_00167271:
JMP 0x00167273
LAB_00167273:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x30
JNZ 0x00167388
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x78
JZ 0x001672a9
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x58
JNZ 0x001672e6
LAB_001672a9:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x20
CMP EAX,0x0
JNZ 0x001672c2
CMP dword ptr [RSP + 0xe4],0x10
JNZ 0x001672e6
LAB_001672c2:
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x2
MOV qword ptr [RSP + 0xf8],RAX
MOV dword ptr [RSP + 0xe4],0x10
JMP 0x00167383
LAB_001672e6:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00167381
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x6f
JZ 0x0016731b
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x4f
JNZ 0x0016733c
LAB_0016731b:
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x2
MOV qword ptr [RSP + 0xf8],RAX
MOV dword ptr [RSP + 0xe4],0x8
JMP 0x0016737f
LAB_0016733c:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x62
JZ 0x0016735e
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x42
JNZ 0x0016737d
LAB_0016735e:
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x2
MOV qword ptr [RSP + 0xf8],RAX
MOV dword ptr [RSP + 0xe4],0x2
LAB_0016737d:
JMP 0x0016737f
LAB_0016737f:
JMP 0x00167381
LAB_00167381:
JMP 0x00167383
LAB_00167383:
JMP 0x0016743b
LAB_00167388:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x49
JNZ 0x00167439
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00167439
MOV RDI,qword ptr [RSP + 0xf8]
LEA RSI,[0x21871f]
LEA RDX,[RSP + 0xf8]
CALL 0x001223b0
CMP EAX,0x0
JZ 0x00167439
MOVSD XMM0,qword ptr [0x00217de0]
MOVSD qword ptr [RSP + 0x50],XMM0
MOVZX EAX,byte ptr [RSP + 0x4f]
CMP EAX,0x2d
JNZ 0x0016740b
MOVSD XMM0,qword ptr [RSP + 0x50]
MOVQ RAX,XMM0
MOV RCX,-0x8000000000000000
XOR RAX,RCX
MOVQ XMM0,RAX
MOVSD qword ptr [RSP + 0x50],XMM0
LAB_0016740b:
MOVSD XMM0,qword ptr [RSP + 0x50]
CALL 0x001517e0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x00167941
LAB_00167439:
JMP 0x0016743b
LAB_0016743b:
MOV dword ptr [RSP + 0xc8],0x0
MOV RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0xd8],RAX
LAB_00167456:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX]
CALL 0x00167b00
CMP EAX,dword ptr [RSP + 0xe4]
JGE 0x001674c7
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RSP + 0xcc]
JNZ 0x001674c5
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX + 0x1]
CALL 0x00167b00
CMP EAX,dword ptr [RSP + 0xe4]
JGE 0x001674c5
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
LAB_001674c5:
JMP 0x00167456
LAB_001674c7:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001676f4
CMP dword ptr [RSP + 0xe4],0xa
JNZ 0x001676f4
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x001675be
MOV RAX,qword ptr [RSP + 0xf8]
CMP RAX,qword ptr [RSP + 0xd8]
JA 0x0016752c
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX + 0x1]
CALL 0x00167b00
CMP EAX,dword ptr [RSP + 0xe4]
JGE 0x001675be
LAB_0016752c:
MOV dword ptr [RSP + 0xc8],0x1
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
LAB_0016754b:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX]
CALL 0x00167b00
CMP EAX,dword ptr [RSP + 0xe4]
JGE 0x001675bc
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RSP + 0xcc]
JNZ 0x001675ba
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX + 0x1]
CALL 0x00167b00
CMP EAX,dword ptr [RSP + 0xe4]
JGE 0x001675ba
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
LAB_001675ba:
JMP 0x0016754b
LAB_001675bc:
JMP 0x001675be
LAB_001675be:
MOV RAX,qword ptr [RSP + 0xf8]
CMP RAX,qword ptr [RSP + 0xd8]
JBE 0x001676f2
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x65
JZ 0x001675f8
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x45
JNZ 0x001676f2
LAB_001675f8:
MOV qword ptr [RSP + 0x70],0x1
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2b
JZ 0x00167623
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2d
JNZ 0x00167631
LAB_00167623:
MOV RAX,qword ptr [RSP + 0x70]
ADD RAX,0x1
MOV qword ptr [RSP + 0x70],RAX
LAB_00167631:
MOV RAX,qword ptr [RSP + 0xf8]
MOV RCX,qword ptr [RSP + 0x70]
MOVZX EDI,byte ptr [RAX + RCX*0x1]
CALL 0x0012c270
CMP EAX,0x0
JZ 0x001676f0
MOV dword ptr [RSP + 0xc8],0x1
MOV RAX,qword ptr [RSP + 0x70]
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xf8]
MOV qword ptr [RSP + 0xf8],RAX
LAB_00167674:
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX]
CALL 0x0012c270
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RSP + 0x7],AL
JNZ 0x001676ce
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RSP + 0xcc]
MOV byte ptr [RSP + 0x6],AL
JNZ 0x001676c6
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EDI,byte ptr [RAX + 0x1]
CALL 0x0012c270
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RSP + 0x6],AL
LAB_001676c6:
MOV AL,byte ptr [RSP + 0x6]
MOV byte ptr [RSP + 0x7],AL
LAB_001676ce:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x001676d8
JMP 0x001676ee
LAB_001676d8:
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
JMP 0x00167674
LAB_001676ee:
JMP 0x001676f0
LAB_001676f0:
JMP 0x001676f2
LAB_001676f2:
JMP 0x001676f4
LAB_001676f4:
MOV RAX,qword ptr [RSP + 0xf8]
CMP RAX,qword ptr [RSP + 0xd8]
JNZ 0x0016770b
JMP 0x00167941
LAB_0016770b:
MOV RAX,qword ptr [RSP + 0xf8]
MOV RCX,qword ptr [RSP + 0xd8]
SUB RAX,RCX
MOV qword ptr [RSP + 0xf0],RAX
MOV RAX,qword ptr [RSP + 0xf0]
ADD RAX,0x2
CMP RAX,0x40
SETA AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001677b6
MOV RAX,qword ptr [RSP + 0x100]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0xf0]
ADD RSI,0x2
CALL 0x00125a10
MOV qword ptr [RSP + 0x78],RAX
CMP qword ptr [RSP + 0x78],0x0
JNZ 0x001677b4
CMP qword ptr [RSP + 0xe8],0x0
JZ 0x00167792
MOV RCX,qword ptr [RSP + 0xf8]
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RAX],RCX
LAB_00167792:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x00125d90
MOV qword ptr [RSP + 0x108],RAX
MOV qword ptr [RSP + 0x110],RDX
JMP 0x00167a40
LAB_001677b4:
JMP 0x001677b6
LAB_001677b6:
MOV qword ptr [RSP + 0x68],0x0
MOVZX EAX,byte ptr [RSP + 0x4f]
CMP EAX,0x2d
JNZ 0x001677e3
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x68]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RSP + 0x68],RDX
MOV byte ptr [RAX + RCX*0x1],0x2d
LAB_001677e3:
MOV qword ptr [RSP + 0x70],0x0
LAB_001677ec:
MOV RAX,qword ptr [RSP + 0x70]
CMP RAX,qword ptr [RSP + 0xf0]
JNC 0x0016784c
MOV RAX,qword ptr [RSP + 0xd8]
MOV RCX,qword ptr [RSP + 0x70]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x5f
JZ 0x0016783a
MOV RAX,qword ptr [RSP + 0xd8]
MOV RCX,qword ptr [RSP + 0x70]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x68]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RSP + 0x68],RSI
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0016783a:
JMP 0x0016783c
LAB_0016783c:
MOV RAX,qword ptr [RSP + 0x70]
ADD RAX,0x1
MOV qword ptr [RSP + 0x70],RAX
JMP 0x001677ec
LAB_0016784c:
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x68]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001678a4
MOV RAX,qword ptr [RSP + 0xf8]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x6e
JNZ 0x001678a2
MOV RAX,qword ptr [RSP + 0xf8]
ADD RAX,0x1
MOV qword ptr [RSP + 0xf8],RAX
MOV EAX,dword ptr [RSP + 0xe0]
OR EAX,0x100
MOV dword ptr [RSP + 0xe0],EAX
LAB_001678a2:
JMP 0x001678a4
LAB_001678a4:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x100
CMP EAX,0x0
JZ 0x001678f8
CMP dword ptr [RSP + 0xc8],0x0
JNZ 0x001678f6
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,dword ptr [RSP + 0xe4]
CALL 0x00167b70
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x60],RAX
LAB_001678f6:
JMP 0x0016793f
LAB_001678f8:
MOV RDI,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RSP + 0xe4]
MOV EDX,dword ptr [RSP + 0xc8]
CALL 0x00167c80
MOVSD qword ptr [RSP + 0x50],XMM0
MOVSD XMM0,qword ptr [RSP + 0x50]
CALL 0x001257b0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
LAB_0016793f:
JMP 0x00167941
LAB_00167941:
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x400
CMP EAX,0x0
JZ 0x001679e0
MOV EAX,dword ptr [RSP + 0xe0]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016798a
MOV RDI,qword ptr [RSP + 0xf8]
CALL 0x00167a60
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0xf8]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0xf8],RAX
LAB_0016798a:
MOV RAX,qword ptr [RSP + 0xf8]
CMP RAX,qword ptr [RSP + 0xd0]
JZ 0x001679de
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x00127e10
MOVSD XMM0,qword ptr [0x00217db0]
MOVSD qword ptr [RSP + 0x8],XMM0
MOV qword ptr [RSP + 0x10],0x7
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x60],RAX
LAB_001679de:
JMP 0x001679e0
LAB_001679e0:
MOV RAX,qword ptr [RSP + 0x78]
LEA RCX,[RSP + 0x80]
CMP RAX,RCX
JZ 0x00167a08
MOV RAX,qword ptr [RSP + 0x100]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00125ae0
LAB_00167a08:
CMP qword ptr [RSP + 0xe8],0x0
JZ 0x00167a26
MOV RCX,qword ptr [RSP + 0xf8]
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RAX],RCX
LAB_00167a26:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x110],RAX
LAB_00167a40:
MOV RAX,qword ptr [RSP + 0x108]
MOV RDX,qword ptr [RSP + 0x110]
ADD RSP,0x118
RET
|
int1 [16]
js_atof(long param_1,byte *param_2,ulong param_3,int8 *param_4,int param_5,uint param_6)
{
byte *pbVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int iVar5;
byte *pbVar6;
bool bVar7;
int8 uVar8;
int1 auVar9 [16];
byte local_c9;
ulong local_c8;
int8 local_c0;
int8 local_b8;
ulong local_b0;
ulong local_a8;
int1 *local_a0;
int1 local_98 [72];
int local_50;
uint local_4c;
byte *local_48;
byte *local_40;
uint local_38;
int local_34;
int8 *local_30;
ulong local_28;
byte *local_20;
long local_18;
local_48 = param_2 + param_3;
local_a0 = local_98;
auVar4._8_8_ = DAT_00217e98;
auVar4._0_8_ = DAT_00217e90;
auVar3._8_8_ = DAT_00217e98;
auVar3._0_8_ = DAT_00217e90;
auVar2._8_8_ = DAT_00217e98;
auVar2._0_8_ = DAT_00217e90;
auVar9._8_8_ = DAT_00217e98;
auVar9._0_8_ = DAT_00217e90;
local_38 = param_6;
local_34 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((1 < param_5) && (auVar9 = auVar2, param_5 < 0x25)) {
local_4c = 0x100;
if ((param_6 & 0x40) != 0) {
local_4c = 0x5f;
}
local_c9 = 0;
if ((param_6 & 1) != 0) {
iVar5 = skip_spaces(param_2);
local_20 = local_20 + iVar5;
}
if ((local_20 == local_48) && ((local_38 & 2) != 0)) {
if (local_30 != (int8 *)0x0) {
*local_30 = local_20;
}
if ((local_38 & 0x100) != 0) {
auVar9 = JS_NewBigInt64(local_18,0);
return auVar9;
}
auVar9 = js_int32(0);
return auVar9;
}
if ((*local_20 == 0x2b) || (*local_20 == 0x2d)) {
local_c9 = *local_20;
local_20 = local_20 + 1;
if ((local_38 & 0x200) != 0) {
local_38 = local_38 & 0xffffffcf;
}
}
if (*local_20 == 0x30) {
if (((local_20[1] == 0x78) || (local_20[1] == 0x58)) &&
(((local_38 & 0x20) != 0 || (local_34 == 0x10)))) {
local_20 = local_20 + 2;
local_34 = 0x10;
}
else if ((local_38 & 0x10) != 0) {
if ((local_20[1] == 0x6f) || (local_20[1] == 0x4f)) {
local_20 = local_20 + 2;
local_34 = 8;
}
else if ((local_20[1] == 0x62) || (local_20[1] == 0x42)) {
local_20 = local_20 + 2;
local_34 = 2;
}
}
}
else if (((*local_20 == 0x49) && ((local_38 & 8) != 0)) &&
(iVar5 = js__strstart(local_20,"Infinity",&local_20), iVar5 != 0)) {
local_c8 = DAT_00217de0;
if (local_c9 == 0x2d) {
local_c8 = DAT_00217de0 ^ 0x8000000000000000;
}
auVar9 = js_float64(local_c8);
goto LAB_00167941;
}
local_50 = 0;
local_40 = local_20;
pbVar6 = local_20;
while (local_20 = pbVar6, iVar5 = to_digit(*local_20), iVar5 < local_34) {
pbVar6 = local_20 + 1;
if ((*pbVar6 == local_4c) &&
(pbVar1 = local_20 + 2, local_20 = pbVar6, iVar5 = to_digit(*pbVar1), pbVar6 = local_20,
iVar5 < local_34)) {
pbVar6 = local_20 + 1;
}
}
if (((local_38 & 4) != 0) && (local_34 == 10)) {
if ((*local_20 == 0x2e) &&
((local_40 < local_20 || (iVar5 = to_digit(local_20[1]), iVar5 < local_34)))) {
local_50 = 1;
pbVar6 = local_20 + 1;
while (local_20 = pbVar6, iVar5 = to_digit(*local_20), iVar5 < local_34) {
pbVar6 = local_20 + 1;
if ((*pbVar6 == local_4c) &&
(pbVar1 = local_20 + 2, local_20 = pbVar6, iVar5 = to_digit(*pbVar1), pbVar6 = local_20
, iVar5 < local_34)) {
pbVar6 = local_20 + 1;
}
}
}
if ((local_40 < local_20) && ((*local_20 == 0x65 || (*local_20 == 0x45)))) {
local_a8 = 1;
if ((local_20[1] == 0x2b) || (local_20[1] == 0x2d)) {
local_a8 = 2;
}
iVar5 = is_digit(local_20[local_a8]);
if (iVar5 != 0) {
local_50 = 1;
local_20 = local_20 + local_a8 + 1;
while( true ) {
iVar5 = is_digit(*local_20);
bVar7 = true;
if ((iVar5 == 0) && (bVar7 = false, *local_20 == local_4c)) {
iVar5 = is_digit(local_20[1]);
bVar7 = iVar5 != 0;
}
if (!bVar7) break;
local_20 = local_20 + 1;
}
}
}
}
auVar9 = auVar4;
if (local_20 != local_40) {
local_28 = (long)local_20 - (long)local_40;
if ((0x40 < local_28 + 2) &&
(local_a0 = (int1 *)js_malloc_rt(*(int8 *)(local_18 + 0x18),local_28 + 2),
local_a0 == (int1 *)0x0)) {
if (local_30 != (int8 *)0x0) {
*local_30 = local_20;
}
auVar9 = JS_ThrowOutOfMemory(local_18);
return auVar9;
}
if (local_c9 == 0x2d) {
*local_a0 = 0x2d;
}
local_b0 = (ulong)(local_c9 == 0x2d);
for (local_a8 = 0; local_a8 < local_28; local_a8 = local_a8 + 1) {
if (local_40[local_a8] != 0x5f) {
local_a0[local_b0] = local_40[local_a8];
local_b0 = local_b0 + 1;
}
}
local_a0[local_b0] = 0;
if (((local_38 & 0x80) != 0) && (*local_20 == 0x6e)) {
local_20 = local_20 + 1;
local_38 = local_38 | 0x100;
}
if ((local_38 & 0x100) == 0) {
uVar8 = js_strtod(local_a0,local_34,local_50);
auVar9 = js_number(uVar8);
}
else {
auVar9 = auVar3;
if (local_50 == 0) {
auVar9 = js_string_to_bigint(local_18,local_a0,local_34);
}
}
}
}
LAB_00167941:
local_b8 = auVar9._8_8_;
local_c0 = auVar9._0_8_;
if ((local_38 & 0x400) != 0) {
if ((local_38 & 1) != 0) {
iVar5 = skip_spaces(local_20);
local_20 = local_20 + iVar5;
}
if (local_20 != local_48) {
JS_FreeValue(local_18,local_c0,local_b8);
auVar9._8_8_ = 7;
auVar9._0_8_ = DAT_00217db0;
}
}
if (local_a0 != local_98) {
js_free_rt(*(int8 *)(local_18 + 0x18),local_a0);
}
if (local_30 != (int8 *)0x0) {
*local_30 = local_20;
}
return auVar9;
}
|
|
5,056 |
JS_ThrowReferenceErrorUninitialized2
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ThrowReferenceErrorUninitialized2(JSContext *ctx,
JSFunctionBytecode *b,
int idx, BOOL is_ref)
{
JSAtom atom = JS_ATOM_NULL;
if (is_ref) {
atom = b->closure_var[idx].var_name;
} else {
/* not present if the function is stripped and contains no eval() */
if (b->vardefs)
atom = b->vardefs[b->arg_count + idx].var_name;
}
return JS_ThrowReferenceErrorUninitialized(ctx, atom);
}
|
O2
|
c
|
JS_ThrowReferenceErrorUninitialized2:
testl %ecx, %ecx
je 0x37be2
movq 0x38(%rsi), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $0x4, %rax
jmp 0x37bf8
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x37bff
movzwl 0x40(%rsi), %ecx
addl %edx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
jmp 0x35ece
xorl %esi, %esi
jmp 0x35ece
|
JS_ThrowReferenceErrorUninitialized2:
test ecx, ecx
jz short loc_37BE2
mov rax, [rsi+38h]
mov ecx, edx
lea rax, [rax+rcx*8]
add rax, 4
jmp short loc_37BF8
loc_37BE2:
mov rax, [rsi+30h]
test rax, rax
jz short loc_37BFF
movzx ecx, word ptr [rsi+40h]
add ecx, edx
shl rcx, 4
add rax, rcx
loc_37BF8:
mov esi, [rax]
jmp JS_ThrowReferenceErrorUninitialized
loc_37BFF:
xor esi, esi
jmp JS_ThrowReferenceErrorUninitialized
|
long long JS_ThrowReferenceErrorUninitialized2(
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 v14; // rcx
int *v15; // rax
long long v16; // rax
if ( (_DWORD)a4 )
{
v14 = (unsigned int)a3;
v15 = (int *)(*(_QWORD *)(a2 + 56) + 8LL * (unsigned int)a3 + 4);
return JS_ThrowReferenceErrorUninitialized(a1, *v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, v14, a5, a6);
}
v16 = *(_QWORD *)(a2 + 48);
if ( v16 )
{
v14 = 16LL * ((unsigned int)a3 + *(unsigned __int16 *)(a2 + 64));
v15 = (int *)(v14 + v16);
return JS_ThrowReferenceErrorUninitialized(a1, *v15, a7, a8, a9, a10, a11, a12, a13, a14, a3, v14, a5, a6);
}
return JS_ThrowReferenceErrorUninitialized(a1, 0, a7, a8, a9, a10, a11, a12, a13, a14, a3, a4, a5, a6);
}
|
JS_ThrowReferenceErrorUninitialized2:
TEST ECX,ECX
JZ 0x00137be2
MOV RAX,qword ptr [RSI + 0x38]
MOV ECX,EDX
LEA RAX,[RAX + RCX*0x8]
ADD RAX,0x4
JMP 0x00137bf8
LAB_00137be2:
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00137bff
MOVZX ECX,word ptr [RSI + 0x40]
ADD ECX,EDX
SHL RCX,0x4
ADD RAX,RCX
LAB_00137bf8:
MOV ESI,dword ptr [RAX]
JMP 0x00135ece
LAB_00137bff:
XOR ESI,ESI
JMP 0x00135ece
|
void JS_ThrowReferenceErrorUninitialized2(int8 param_1,long param_2,uint param_3,int param_4)
{
int4 *puVar1;
if (param_4 == 0) {
if (*(long *)(param_2 + 0x30) == 0) {
JS_ThrowReferenceErrorUninitialized(param_1,0);
return;
}
puVar1 = (int4 *)
(*(long *)(param_2 + 0x30) + (ulong)(*(ushort *)(param_2 + 0x40) + param_3) * 0x10);
}
else {
puVar1 = (int4 *)(*(long *)(param_2 + 0x38) + (ulong)param_3 * 8 + 4);
}
JS_ThrowReferenceErrorUninitialized(param_1,*puVar1);
return;
}
|
|
5,057 |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_float(double)
|
monkey531[P]llama/common/json.hpp
|
void dump_float(number_float_t x)
{
// NaN / inf
if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
}
// If number_float_t is an IEEE-754 single or double precision number,
// use the Grisu2 algorithm to produce short numbers which are
// guaranteed to round-trip, using strtof and strtod, resp.
//
// NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double
= (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
(std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_float(double):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xba07b
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x38756(%rip), %rsi # 0xf27c3
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xba2bf
movq (%rbx), %rdi
subq %r14, %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10dump_floatEd:
push r14
push rbx
push rax
mov rbx, rdi
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_BA07B
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax+8]
lea rsi, aOnNull_0+5; "null"
mov edx, 4
add rsp, 8
pop rbx
pop r14
jmp rax
loc_BA07B:
lea r14, [rbx+10h]
lea rsi, [rbx+50h]
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail8to_charsIdEEPcS3_PKcT_; nlohmann::json_abi_v3_11_3::detail::to_chars<double>(char *,char const*,double)
mov rdi, [rbx]
sub rax, r14
mov rcx, [rdi]
mov rcx, [rcx+8]
mov rsi, r14
mov rdx, rax
add rsp, 8
pop rbx
pop r14
jmp rcx
|
long long nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::dump_float(
_QWORD *a1,
double a2)
{
long long v3; // rax
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return (*(long long ( **)(_QWORD, char *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, "null", 4LL);
v3 = nlohmann::json_abi_v3_11_3::detail::to_chars<double>((nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)(a1 + 2));
return (*(long long ( **)(_QWORD, _QWORD *, long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
a1 + 2,
v3 - (_QWORD)(a1 + 2));
}
|
dump_float:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JL 0x001ba07b
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
LEA RSI,[0x1f27c3]
MOV EDX,0x4
ADD RSP,0x8
POP RBX
POP R14
JMP RAX
LAB_001ba07b:
LEA R14,[RBX + 0x10]
LEA RSI,[RBX + 0x50]
MOV RDI,R14
CALL 0x001ba2bf
MOV RDI,qword ptr [RBX]
SUB RAX,R14
MOV RCX,qword ptr [RDI]
MOV RCX,qword ptr [RCX + 0x8]
MOV RSI,R14
MOV RDX,RAX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::dump_float(double) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::dump_float(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,double param_1)
{
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*psVar1;
code *UNRECOVERED_JUMPTABLE;
char *pcVar2;
if (0x7fefffffffffffff < (ulong)ABS(param_1)) {
/* WARNING: Could not recover jumptable at 0x001ba079. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)this + 8))(*(long **)this,"null",4);
return;
}
psVar1 = this + 0x10;
pcVar2 = to_chars<double>((char *)psVar1,(char *)(this + 0x50),param_1);
UNRECOVERED_JUMPTABLE = *(code **)(**(long **)this + 8);
/* WARNING: Could not recover jumptable at 0x001ba0a5. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(*(long **)this,psVar1,(long)pcVar2 - (long)psVar1,UNRECOVERED_JUMPTABLE);
return;
}
|
|
5,058 |
Vector3OrthoNormalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)
{
float length = 0.0f;
float ilength = 0.0f;
// Vector3Normalize(*v1);
Vector3 v = *v1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
v1->x *= ilength;
v1->y *= ilength;
v1->z *= ilength;
// Vector3CrossProduct(*v1, *v2)
Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x };
// Vector3Normalize(vn1);
v = vn1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
vn1.x *= ilength;
vn1.y *= ilength;
vn1.z *= ilength;
// Vector3CrossProduct(vn1, *v1)
Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x };
*v2 = vn2;
}
|
O0
|
c
|
Vector3OrthoNormalize:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x24(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movss -0x24(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x20(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xaa30
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xb9e85
jp 0xb9e85
movss 0xea274(%rip), %xmm0 # 0x1a40f4
movss %xmm0, -0x14(%rbp)
movss 0xea267(%rip), %xmm0 # 0x1a40f4
divss -0x14(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0x8(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
mulss (%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movss -0x24(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x20(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xaa30
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xb9fe6
jp 0xb9fe6
movss 0xea113(%rip), %xmm0 # 0x1a40f4
movss %xmm0, -0x14(%rbp)
movss 0xea106(%rip), %xmm0 # 0x1a40f4
divss -0x14(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm2
movss -0x28(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss (%rax), %xmm2
movss -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulss 0x8(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm2
movss -0x2c(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulss (%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
Vector3OrthoNormalize:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
xorps xmm0, xmm0
movss [rbp+var_14], xmm0
xorps xmm0, xmm0
movss [rbp+var_18], xmm0
mov rax, [rbp+var_8]
mov rcx, [rax]
mov [rbp+var_24], rcx
mov eax, [rax+8]
mov [rbp+var_1C], eax
movss xmm1, dword ptr [rbp+var_24]
movss xmm2, dword ptr [rbp+var_24]
movss xmm0, dword ptr [rbp+var_24+4]
mulss xmm0, dword ptr [rbp+var_24+4]
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, [rbp+var_1C]
movss xmm2, [rbp+var_1C]
mulss xmm0, xmm2
addss xmm0, xmm1
call _sqrtf
movss [rbp+var_14], xmm0
movss xmm0, [rbp+var_14]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_B9E85
jp short loc_B9E85
movss xmm0, cs:dword_1A40F4
movss [rbp+var_14], xmm0
loc_B9E85:
movss xmm0, cs:dword_1A40F4
divss xmm0, [rbp+var_14]
movss [rbp+var_18], xmm0
movss xmm0, [rbp+var_18]
mov rax, [rbp+var_8]
mulss xmm0, dword ptr [rax]
movss dword ptr [rax], xmm0
movss xmm0, [rbp+var_18]
mov rax, [rbp+var_8]
mulss xmm0, dword ptr [rax+4]
movss dword ptr [rax+4], xmm0
movss xmm0, [rbp+var_18]
mov rax, [rbp+var_8]
mulss xmm0, dword ptr [rax+8]
movss dword ptr [rax+8], xmm0
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rax+4]
mov rax, [rbp+var_10]
movss xmm2, dword ptr [rax+8]
mov rax, [rbp+var_8]
movss xmm1, dword ptr [rax+8]
mov rax, [rbp+var_10]
mulss xmm1, dword ptr [rax+4]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_30], xmm0
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rax+8]
mov rax, [rbp+var_10]
movss xmm2, dword ptr [rax]
mov rax, [rbp+var_8]
movss xmm1, dword ptr [rax]
mov rax, [rbp+var_10]
mulss xmm1, dword ptr [rax+8]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_30+4], xmm0
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_10]
movss xmm2, dword ptr [rax+4]
mov rax, [rbp+var_8]
movss xmm1, dword ptr [rax+4]
mov rax, [rbp+var_10]
mulss xmm1, dword ptr [rax]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_28], xmm0
mov rax, [rbp+var_30]
mov [rbp+var_24], rax
mov eax, [rbp+var_28]
mov [rbp+var_1C], eax
movss xmm1, dword ptr [rbp+var_24]
movss xmm2, dword ptr [rbp+var_24]
movss xmm0, dword ptr [rbp+var_24+4]
mulss xmm0, dword ptr [rbp+var_24+4]
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, [rbp+var_1C]
movss xmm2, [rbp+var_1C]
mulss xmm0, xmm2
addss xmm0, xmm1
call _sqrtf
movss [rbp+var_14], xmm0
movss xmm0, [rbp+var_14]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_B9FE6
jp short loc_B9FE6
movss xmm0, cs:dword_1A40F4
movss [rbp+var_14], xmm0
loc_B9FE6:
movss xmm0, cs:dword_1A40F4
divss xmm0, [rbp+var_14]
movss [rbp+var_18], xmm0
movss xmm0, [rbp+var_18]
mulss xmm0, dword ptr [rbp+var_30]
movss dword ptr [rbp+var_30], xmm0
movss xmm0, [rbp+var_18]
mulss xmm0, dword ptr [rbp+var_30+4]
movss dword ptr [rbp+var_30+4], xmm0
movss xmm0, [rbp+var_18]
mulss xmm0, [rbp+var_28]
movss [rbp+var_28], xmm0
movss xmm0, dword ptr [rbp+var_30+4]
mov rax, [rbp+var_8]
movss xmm2, dword ptr [rax+8]
movss xmm1, [rbp+var_28]
mov rax, [rbp+var_8]
mulss xmm1, dword ptr [rax+4]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_3C], xmm0
movss xmm0, [rbp+var_28]
mov rax, [rbp+var_8]
movss xmm2, dword ptr [rax]
movss xmm1, dword ptr [rbp+var_30]
mov rax, [rbp+var_8]
mulss xmm1, dword ptr [rax+8]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_3C+4], xmm0
movss xmm0, dword ptr [rbp+var_30]
mov rax, [rbp+var_8]
movss xmm2, dword ptr [rax+4]
movss xmm1, dword ptr [rbp+var_30+4]
mov rax, [rbp+var_8]
mulss xmm1, dword ptr [rax]
movd eax, xmm1
xor eax, 80000000h
movd xmm1, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_34], xmm0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_3C]
mov [rax], rcx
mov ecx, [rbp+var_34]
mov [rax+8], ecx
add rsp, 40h
pop rbp
retn
|
float * Vector3OrthoNormalize(float *a1, float *a2)
{
double v2; // xmm0_8
__m128i v3; // xmm1
__m128i v4; // xmm1
__m128i v5; // xmm1
double v6; // xmm0_8
__m128i v7; // xmm1
__m128i v8; // xmm1
__m128i v9; // xmm1
float v10; // xmm0_4
float *result; // rax
long long v12; // [rsp+4h] [rbp-3Ch]
float v13; // [rsp+10h] [rbp-30h]
unsigned int v14; // [rsp+10h] [rbp-30h]
float v15; // [rsp+14h] [rbp-2Ch]
unsigned int v16; // [rsp+14h] [rbp-2Ch]
float v17; // [rsp+18h] [rbp-28h]
unsigned int v18; // [rsp+18h] [rbp-28h]
float v19; // [rsp+2Ch] [rbp-14h]
float v20; // [rsp+2Ch] [rbp-14h]
v2 = sqrtf(
(float)(a1[2] * a1[2])
+ (float)((float)(COERCE_FLOAT(*(_QWORD *)a1) * COERCE_FLOAT(*(_QWORD *)a1))
+ (float)(COERCE_FLOAT(HIDWORD(*(_QWORD *)a1)) * COERCE_FLOAT(HIDWORD(*(_QWORD *)a1)))));
v19 = *(float *)&v2;
if ( *(float *)&v2 == 0.0 )
v19 = 1.0;
*a1 = (float)(1.0 / v19) * *a1;
a1[1] = (float)(1.0 / v19) * a1[1];
a1[2] = (float)(1.0 / v19) * a1[2];
v3 = (__m128i)*((unsigned int *)a1 + 2);
*(float *)v3.m128i_i32 = *(float *)v3.m128i_i32 * a2[1];
v13 = (float)(a1[1] * a2[2]) + COERCE_FLOAT(_mm_cvtsi128_si32(v3) ^ 0x80000000);
v4 = (__m128i)*(unsigned int *)a1;
*(float *)v4.m128i_i32 = *(float *)v4.m128i_i32 * a2[2];
v15 = (float)(a1[2] * *a2) + COERCE_FLOAT(_mm_cvtsi128_si32(v4) ^ 0x80000000);
v5 = (__m128i)*((unsigned int *)a1 + 1);
*(float *)v5.m128i_i32 = *(float *)v5.m128i_i32 * *a2;
v17 = (float)(*a1 * a2[1]) + COERCE_FLOAT(_mm_cvtsi128_si32(v5) ^ 0x80000000);
v6 = sqrtf((float)(v17 * v17) + (float)((float)(v13 * v13) + (float)(v15 * v15)));
v20 = *(float *)&v6;
if ( *(float *)&v6 == 0.0 )
v20 = 1.0;
*(float *)&v14 = (float)(1.0 / v20) * v13;
*(float *)&v16 = (float)(1.0 / v20) * v15;
*(float *)&v18 = (float)(1.0 / v20) * v17;
v7 = (__m128i)v18;
*(float *)v7.m128i_i32 = *(float *)&v18 * a1[1];
*(float *)&v12 = (float)(*(float *)&v16 * a1[2]) + COERCE_FLOAT(_mm_cvtsi128_si32(v7) ^ 0x80000000);
v8 = (__m128i)v14;
*(float *)v8.m128i_i32 = *(float *)&v14 * a1[2];
*((float *)&v12 + 1) = (float)(*(float *)&v18 * *a1) + COERCE_FLOAT(_mm_cvtsi128_si32(v8) ^ 0x80000000);
v9 = (__m128i)v16;
*(float *)v9.m128i_i32 = *(float *)&v16 * *a1;
v10 = (float)(*(float *)&v14 * a1[1]) + COERCE_FLOAT(_mm_cvtsi128_si32(v9) ^ 0x80000000);
result = a2;
*(_QWORD *)a2 = v12;
a2[2] = v10;
return result;
}
|
Vector3OrthoNormalize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x14],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x18],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x24],RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x1c],EAX
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM2,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [RBP + -0x20]
MULSS XMM0,dword ptr [RBP + -0x20]
MULSS XMM1,XMM2
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM2,dword ptr [RBP + -0x1c]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
CALL 0x0010aa30
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x001b9e85
JP 0x001b9e85
MOVSS XMM0,dword ptr [0x002a40f4]
MOVSS dword ptr [RBP + -0x14],XMM0
LAB_001b9e85:
MOVSS XMM0,dword ptr [0x002a40f4]
DIVSS XMM0,dword ptr [RBP + -0x14]
MOVSS dword ptr [RBP + -0x18],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM0,dword ptr [RAX]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM0,dword ptr [RAX + 0x4]
MOVSS dword ptr [RAX + 0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM0,dword ptr [RAX + 0x8]
MOVSS dword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM2,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MULSS XMM1,dword ptr [RAX + 0x4]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x30],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM2,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MULSS XMM1,dword ptr [RAX + 0x8]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS XMM2,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM1,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x10]
MULSS XMM1,dword ptr [RAX]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x28],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x24],RAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x1c],EAX
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM2,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [RBP + -0x20]
MULSS XMM0,dword ptr [RBP + -0x20]
MULSS XMM1,XMM2
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1c]
MOVSS XMM2,dword ptr [RBP + -0x1c]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
CALL 0x0010aa30
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x001b9fe6
JP 0x001b9fe6
MOVSS XMM0,dword ptr [0x002a40f4]
MOVSS dword ptr [RBP + -0x14],XMM0
LAB_001b9fe6:
MOVSS XMM0,dword ptr [0x002a40f4]
DIVSS XMM0,dword ptr [RBP + -0x14]
MOVSS dword ptr [RBP + -0x18],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MULSS XMM0,dword ptr [RBP + -0x30]
MOVSS dword ptr [RBP + -0x30],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MULSS XMM0,dword ptr [RBP + -0x2c]
MOVSS dword ptr [RBP + -0x2c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x18]
MULSS XMM0,dword ptr [RBP + -0x28]
MOVSS dword ptr [RBP + -0x28],XMM0
MOVSS XMM0,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RAX + 0x8]
MOVSS XMM1,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM1,dword ptr [RAX + 0x4]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x3c],XMM0
MOVSS XMM0,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RAX]
MOVSS XMM1,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM1,dword ptr [RAX + 0x8]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x38],XMM0
MOVSS XMM0,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM2,dword ptr [RAX + 0x4]
MOVSS XMM1,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x8]
MULSS XMM1,dword ptr [RAX]
MOVD EAX,XMM1
XOR EAX,0x80000000
MOVD XMM1,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x34],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x3c]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX + 0x8],ECX
ADD RSP,0x40
POP RBP
RET
|
void Vector3OrthoNormalize(float *param_1,float *param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float local_2c;
float fStack_28;
float local_1c;
local_2c = (float)*(int8 *)param_1;
fStack_28 = (float)((ulong)*(int8 *)param_1 >> 0x20);
local_1c = sqrtf(param_1[2] * param_1[2] + local_2c * local_2c + fStack_28 * fStack_28);
if ((local_1c == 0.0) && (!NAN(local_1c))) {
local_1c = DAT_002a40f4;
}
local_1c = DAT_002a40f4 / local_1c;
*param_1 = local_1c * *param_1;
param_1[1] = local_1c * param_1[1];
param_1[2] = local_1c * param_1[2];
fVar3 = param_1[1] * param_2[2] + -(param_1[2] * param_2[1]);
fVar4 = param_1[2] * *param_2 + -(*param_1 * param_2[2]);
fVar5 = *param_1 * param_2[1] + -(param_1[1] * *param_2);
local_1c = sqrtf(fVar5 * fVar5 + fVar3 * fVar3 + fVar4 * fVar4);
if ((local_1c == 0.0) && (!NAN(local_1c))) {
local_1c = DAT_002a40f4;
}
local_1c = DAT_002a40f4 / local_1c;
fVar1 = param_1[1];
fVar2 = *param_1;
*(ulong *)param_2 =
CONCAT44(local_1c * fVar5 * *param_1 + -(local_1c * fVar3 * param_1[2]),
local_1c * fVar4 * param_1[2] + -(local_1c * fVar5 * param_1[1]));
param_2[2] = local_1c * fVar3 * fVar1 + -(local_1c * fVar4 * fVar2);
return;
}
|
|
5,059 |
Vector3OrthoNormalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)
{
float length = 0.0f;
float ilength = 0.0f;
// Vector3Normalize(*v1);
Vector3 v = *v1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
v1->x *= ilength;
v1->y *= ilength;
v1->z *= ilength;
// Vector3CrossProduct(*v1, *v2)
Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x };
// Vector3Normalize(vn1);
v = vn1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
vn1.x *= ilength;
vn1.y *= ilength;
vn1.z *= ilength;
// Vector3CrossProduct(vn1, *v1)
Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x };
*v2 = vn2;
}
|
O1
|
c
|
Vector3OrthoNormalize:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm2
movss 0x8(%rdi), %xmm0
mulss %xmm2, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm8, %xmm8
ucomiss %xmm8, %xmm0
jb 0x682ae
sqrtss %xmm0, %xmm4
jmp 0x682ba
callq 0x99f0
xorps %xmm8, %xmm8
movaps %xmm0, %xmm4
movss 0x71682(%rip), %xmm7 # 0xd9944
movaps %xmm7, %xmm0
divss %xmm4, %xmm0
cmpeqss %xmm8, %xmm4
movaps %xmm4, %xmm1
andnps %xmm0, %xmm1
andps %xmm7, %xmm4
orps %xmm1, %xmm4
movss (%r14), %xmm5
mulss %xmm4, %xmm5
movss %xmm5, (%r14)
movss 0x4(%r14), %xmm0
mulss %xmm4, %xmm0
movss %xmm0, 0x4(%r14)
mulss 0x8(%r14), %xmm4
movss %xmm4, 0x8(%r14)
movss 0x8(%rbx), %xmm1
movss (%rbx), %xmm2
movss 0x4(%rbx), %xmm3
movaps %xmm0, %xmm6
mulss %xmm1, %xmm6
mulss %xmm5, %xmm1
mulss %xmm3, %xmm5
mulss %xmm4, %xmm3
subss %xmm3, %xmm6
mulss %xmm2, %xmm4
subss %xmm1, %xmm4
mulss %xmm2, %xmm0
subss %xmm0, %xmm5
movaps %xmm4, %xmm0
mulss %xmm4, %xmm0
movaps %xmm6, %xmm1
mulss %xmm6, %xmm1
addss %xmm0, %xmm1
movaps %xmm5, %xmm0
mulss %xmm5, %xmm0
addss %xmm1, %xmm0
ucomiss %xmm8, %xmm0
jb 0x68363
sqrtss %xmm0, %xmm0
jmp 0x68392
movaps %xmm4, 0x10(%rsp)
movss %xmm5, 0xc(%rsp)
movss %xmm6, 0x8(%rsp)
callq 0x99f0
movss 0x715c3(%rip), %xmm7 # 0xd9944
movss 0x8(%rsp), %xmm6
movss 0xc(%rsp), %xmm5
movaps 0x10(%rsp), %xmm4
movaps %xmm7, %xmm1
divss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpeqss %xmm0, %xmm2
movaps %xmm2, %xmm0
andnps %xmm1, %xmm0
andps %xmm7, %xmm2
orps %xmm0, %xmm2
mulss %xmm2, %xmm6
mulss %xmm2, %xmm4
mulss %xmm2, %xmm5
movss 0x8(%r14), %xmm0
movss (%r14), %xmm1
movss 0x4(%r14), %xmm2
movaps %xmm4, %xmm3
mulss %xmm0, %xmm3
mulss %xmm6, %xmm0
mulss %xmm2, %xmm6
mulss %xmm5, %xmm2
subss %xmm2, %xmm3
mulss %xmm1, %xmm5
subss %xmm0, %xmm5
mulss %xmm1, %xmm4
subss %xmm4, %xmm6
movss %xmm3, (%rbx)
movss %xmm5, 0x4(%rbx)
movss %xmm6, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
Vector3OrthoNormalize:
push r14
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
movss xmm1, dword ptr [rdi]
movss xmm2, dword ptr [rdi+4]
movss xmm0, dword ptr [rdi+8]
mulss xmm2, xmm2
mulss xmm1, xmm1
addss xmm1, xmm2
mulss xmm0, xmm0
addss xmm0, xmm1
xorps xmm8, xmm8
ucomiss xmm0, xmm8
jb short loc_682AE
sqrtss xmm4, xmm0
jmp short loc_682BA
loc_682AE:
call _sqrtf
xorps xmm8, xmm8
movaps xmm4, xmm0
loc_682BA:
movss xmm7, cs:dword_D9944
movaps xmm0, xmm7
divss xmm0, xmm4
cmpeqss xmm4, xmm8
movaps xmm1, xmm4
andnps xmm1, xmm0
andps xmm4, xmm7
orps xmm4, xmm1
movss xmm5, dword ptr [r14]
mulss xmm5, xmm4
movss dword ptr [r14], xmm5
movss xmm0, dword ptr [r14+4]
mulss xmm0, xmm4
movss dword ptr [r14+4], xmm0
mulss xmm4, dword ptr [r14+8]
movss dword ptr [r14+8], xmm4
movss xmm1, dword ptr [rbx+8]
movss xmm2, dword ptr [rbx]
movss xmm3, dword ptr [rbx+4]
movaps xmm6, xmm0
mulss xmm6, xmm1
mulss xmm1, xmm5
mulss xmm5, xmm3
mulss xmm3, xmm4
subss xmm6, xmm3
mulss xmm4, xmm2
subss xmm4, xmm1
mulss xmm0, xmm2
subss xmm5, xmm0
movaps xmm0, xmm4
mulss xmm0, xmm4
movaps xmm1, xmm6
mulss xmm1, xmm6
addss xmm1, xmm0
movaps xmm0, xmm5
mulss xmm0, xmm5
addss xmm0, xmm1
ucomiss xmm0, xmm8
jb short loc_68363
sqrtss xmm0, xmm0
jmp short loc_68392
loc_68363:
movaps [rsp+38h+var_28], xmm4
movss [rsp+38h+var_2C], xmm5
movss [rsp+38h+var_30], xmm6
call _sqrtf
movss xmm7, cs:dword_D9944
movss xmm6, [rsp+38h+var_30]
movss xmm5, [rsp+38h+var_2C]
movaps xmm4, [rsp+38h+var_28]
loc_68392:
movaps xmm1, xmm7
divss xmm1, xmm0
xorps xmm2, xmm2
cmpeqss xmm2, xmm0
movaps xmm0, xmm2
andnps xmm0, xmm1
andps xmm2, xmm7
orps xmm2, xmm0
mulss xmm6, xmm2
mulss xmm4, xmm2
mulss xmm5, xmm2
movss xmm0, dword ptr [r14+8]
movss xmm1, dword ptr [r14]
movss xmm2, dword ptr [r14+4]
movaps xmm3, xmm4
mulss xmm3, xmm0
mulss xmm0, xmm6
mulss xmm6, xmm2
mulss xmm2, xmm5
subss xmm3, xmm2
mulss xmm5, xmm1
subss xmm5, xmm0
mulss xmm4, xmm1
subss xmm6, xmm4
movss dword ptr [rbx], xmm3
movss dword ptr [rbx+4], xmm5
movss dword ptr [rbx+8], xmm6
add rsp, 28h
pop rbx
pop r14
retn
|
void Vector3OrthoNormalize(float *a1, float *a2, double a3, double a4, double a5, double a6, __m128 a7)
{
__m128 v7; // xmm0
__m128 v8; // xmm8
__m128 v9; // xmm7
__m128 v10; // xmm4
long long v11; // xmm5_8
float v12; // xmm1_4
float v13; // xmm3_4
float v14; // xmm6_4
float v15; // xmm4_4
float v16; // xmm5_4
__m128 v17; // xmm0
__m128 v18; // xmm1
__m128 v19; // xmm2
float v20; // xmm6_4
float v21; // xmm4_4
float v22; // xmm5_4
float v23; // xmm0_4
float v24; // [rsp+Ch] [rbp-2Ch]
float v25; // [rsp+10h] [rbp-28h]
v7 = (__m128)*((unsigned int *)a1 + 2);
v7.m128_f32[0] = (float)(v7.m128_f32[0] * v7.m128_f32[0]) + (float)((float)(*a1 * *a1) + (float)(a1[1] * a1[1]));
v8.m128_i32[0] = 0;
if ( v7.m128_f32[0] < 0.0 )
{
*(double *)v7.m128_u64 = sqrtf(*(double *)v7.m128_u64);
v8.m128_i32[0] = 0;
a7 = v7;
}
else
{
a7.m128_f32[0] = fsqrt(v7.m128_f32[0]);
}
v9 = (__m128)0x3F800000u;
v17 = (__m128)0x3F800000u;
v17.m128_f32[0] = 1.0 / a7.m128_f32[0];
v10 = _mm_cmpeq_ss(a7, v8);
v10.m128_i32[0] = v10.m128_i32[0] & 0x3F800000 | _mm_andnot_ps(v10, v17).m128_u32[0];
v11 = *(unsigned int *)a1;
*(float *)&v11 = *(float *)&v11 * v10.m128_f32[0];
*(_DWORD *)a1 = v11;
v17.m128_f32[0] = a1[1] * v10.m128_f32[0];
a1[1] = v17.m128_f32[0];
v10.m128_f32[0] = v10.m128_f32[0] * a1[2];
a1[2] = v10.m128_f32[0];
v12 = a2[2];
v13 = a2[1];
v14 = (float)(v17.m128_f32[0] * v12) - (float)(v13 * v10.m128_f32[0]);
v15 = (float)(v10.m128_f32[0] * *a2) - (float)(v12 * *(float *)&v11);
v16 = (float)(*(float *)&v11 * v13) - (float)(v17.m128_f32[0] * *a2);
v17.m128_i32[1] = HIDWORD(v11);
v17.m128_f32[0] = (float)(v16 * v16) + (float)((float)(v14 * v14) + (float)(v15 * v15));
if ( v17.m128_f32[0] < 0.0 )
{
v25 = v15;
v24 = v16;
*(double *)v17.m128_u64 = sqrtf(*(double *)v17.m128_u64);
v9 = (__m128)0x3F800000u;
v16 = v24;
v15 = v25;
}
else
{
v17.m128_f32[0] = fsqrt(v17.m128_f32[0]);
}
v18 = v9;
v18.m128_f32[0] = v9.m128_f32[0] / v17.m128_f32[0];
v19 = _mm_cmpeq_ss((__m128)0LL, v17);
v19.m128_i32[0] = v19.m128_i32[0] & v9.m128_i32[0] | _mm_andnot_ps(v19, v18).m128_u32[0];
v20 = v14 * v19.m128_f32[0];
v21 = v15 * v19.m128_f32[0];
v22 = v16 * v19.m128_f32[0];
v23 = a1[2];
v18.m128_f32[0] = *a1;
v19.m128_f32[0] = a1[1];
*a2 = (float)(v21 * v23) - (float)(v19.m128_f32[0] * v22);
a2[1] = (float)(v22 * v18.m128_f32[0]) - (float)(v23 * v20);
a2[2] = (float)(v20 * v19.m128_f32[0]) - (float)(v21 * v18.m128_f32[0]);
}
|
Vector3OrthoNormalize:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOVSS XMM1,dword ptr [RDI]
MOVSS XMM2,dword ptr [RDI + 0x4]
MOVSS XMM0,dword ptr [RDI + 0x8]
MULSS XMM2,XMM2
MULSS XMM1,XMM1
ADDSS XMM1,XMM2
MULSS XMM0,XMM0
ADDSS XMM0,XMM1
XORPS XMM8,XMM8
UCOMISS XMM0,XMM8
JC 0x001682ae
SQRTSS XMM4,XMM0
JMP 0x001682ba
LAB_001682ae:
CALL 0x001099f0
XORPS XMM8,XMM8
MOVAPS XMM4,XMM0
LAB_001682ba:
MOVSS XMM7,dword ptr [0x001d9944]
MOVAPS XMM0,XMM7
DIVSS XMM0,XMM4
CMPEQSS XMM4,XMM8
MOVAPS XMM1,XMM4
ANDNPS XMM1,XMM0
ANDPS XMM4,XMM7
ORPS XMM4,XMM1
MOVSS XMM5,dword ptr [R14]
MULSS XMM5,XMM4
MOVSS dword ptr [R14],XMM5
MOVSS XMM0,dword ptr [R14 + 0x4]
MULSS XMM0,XMM4
MOVSS dword ptr [R14 + 0x4],XMM0
MULSS XMM4,dword ptr [R14 + 0x8]
MOVSS dword ptr [R14 + 0x8],XMM4
MOVSS XMM1,dword ptr [RBX + 0x8]
MOVSS XMM2,dword ptr [RBX]
MOVSS XMM3,dword ptr [RBX + 0x4]
MOVAPS XMM6,XMM0
MULSS XMM6,XMM1
MULSS XMM1,XMM5
MULSS XMM5,XMM3
MULSS XMM3,XMM4
SUBSS XMM6,XMM3
MULSS XMM4,XMM2
SUBSS XMM4,XMM1
MULSS XMM0,XMM2
SUBSS XMM5,XMM0
MOVAPS XMM0,XMM4
MULSS XMM0,XMM4
MOVAPS XMM1,XMM6
MULSS XMM1,XMM6
ADDSS XMM1,XMM0
MOVAPS XMM0,XMM5
MULSS XMM0,XMM5
ADDSS XMM0,XMM1
UCOMISS XMM0,XMM8
JC 0x00168363
SQRTSS XMM0,XMM0
JMP 0x00168392
LAB_00168363:
MOVAPS xmmword ptr [RSP + 0x10],XMM4
MOVSS dword ptr [RSP + 0xc],XMM5
MOVSS dword ptr [RSP + 0x8],XMM6
CALL 0x001099f0
MOVSS XMM7,dword ptr [0x001d9944]
MOVSS XMM6,dword ptr [RSP + 0x8]
MOVSS XMM5,dword ptr [RSP + 0xc]
MOVAPS XMM4,xmmword ptr [RSP + 0x10]
LAB_00168392:
MOVAPS XMM1,XMM7
DIVSS XMM1,XMM0
XORPS XMM2,XMM2
CMPEQSS XMM2,XMM0
MOVAPS XMM0,XMM2
ANDNPS XMM0,XMM1
ANDPS XMM2,XMM7
ORPS XMM2,XMM0
MULSS XMM6,XMM2
MULSS XMM4,XMM2
MULSS XMM5,XMM2
MOVSS XMM0,dword ptr [R14 + 0x8]
MOVSS XMM1,dword ptr [R14]
MOVSS XMM2,dword ptr [R14 + 0x4]
MOVAPS XMM3,XMM4
MULSS XMM3,XMM0
MULSS XMM0,XMM6
MULSS XMM6,XMM2
MULSS XMM2,XMM5
SUBSS XMM3,XMM2
MULSS XMM5,XMM1
SUBSS XMM5,XMM0
MULSS XMM4,XMM1
SUBSS XMM6,XMM4
MOVSS dword ptr [RBX],XMM3
MOVSS dword ptr [RBX + 0x4],XMM5
MOVSS dword ptr [RBX + 0x8],XMM6
ADD RSP,0x28
POP RBX
POP R14
RET
|
void Vector3OrthoNormalize(float *param_1,float *param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
fVar2 = param_1[2] * param_1[2] + *param_1 * *param_1 + param_1[1] * param_1[1];
if (fVar2 < 0.0) {
fVar2 = sqrtf(fVar2);
}
else {
fVar2 = SQRT(fVar2);
}
fVar7 = DAT_001d9944;
fVar2 = (float)(-(uint)(fVar2 == 0.0) & (uint)DAT_001d9944 |
~-(uint)(fVar2 == 0.0) & (uint)(DAT_001d9944 / fVar2));
fVar5 = *param_1 * fVar2;
*param_1 = fVar5;
fVar3 = param_1[1] * fVar2;
param_1[1] = fVar3;
fVar2 = fVar2 * param_1[2];
param_1[2] = fVar2;
fVar6 = fVar3 * param_2[2] - param_2[1] * fVar2;
fVar4 = fVar2 * *param_2 - param_2[2] * fVar5;
fVar3 = fVar5 * param_2[1] - fVar3 * *param_2;
fVar2 = fVar3 * fVar3 + fVar6 * fVar6 + fVar4 * fVar4;
if (fVar2 < 0.0) {
fVar2 = sqrtf(fVar2);
fVar7 = DAT_001d9944;
}
else {
fVar2 = SQRT(fVar2);
}
fVar1 = (float)(-(uint)(fVar2 == 0.0) & (uint)fVar7 |
~-(uint)(fVar2 == 0.0) & (uint)(fVar7 / fVar2));
fVar2 = param_1[2];
fVar7 = *param_1;
fVar5 = param_1[1];
*param_2 = fVar4 * fVar1 * fVar2 - fVar5 * fVar3 * fVar1;
param_2[1] = fVar3 * fVar1 * fVar7 - fVar2 * fVar6 * fVar1;
param_2[2] = fVar6 * fVar1 * fVar5 - fVar4 * fVar1 * fVar7;
return;
}
|
|
5,060 |
Vector3OrthoNormalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)
{
float length = 0.0f;
float ilength = 0.0f;
// Vector3Normalize(*v1);
Vector3 v = *v1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
v1->x *= ilength;
v1->y *= ilength;
v1->z *= ilength;
// Vector3CrossProduct(*v1, *v2)
Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x };
// Vector3Normalize(vn1);
v = vn1;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
vn1.x *= ilength;
vn1.y *= ilength;
vn1.z *= ilength;
// Vector3CrossProduct(vn1, *v1)
Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x };
*v2 = vn2;
}
|
O2
|
c
|
Vector3OrthoNormalize:
movss 0x8(%rdi), %xmm3
movsd (%rdi), %xmm5
movaps %xmm5, %xmm0
mulps %xmm5, %xmm0
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm5, %xmm1
mulss %xmm5, %xmm1
addss %xmm0, %xmm1
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
sqrtss %xmm0, %xmm0
movss 0x62f3c(%rip), %xmm2 # 0xb969c
movaps %xmm2, %xmm1
divss %xmm0, %xmm1
xorps %xmm4, %xmm4
cmpeqss %xmm4, %xmm0
movaps %xmm0, %xmm6
andnps %xmm1, %xmm6
andps %xmm2, %xmm0
orps %xmm6, %xmm0
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1 # xmm1 = xmm1[0,0],xmm0[0,0]
mulps %xmm5, %xmm1
movlps %xmm1, (%rdi)
mulss %xmm3, %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x8(%rsi), %xmm8
movsd (%rsi), %xmm6
movaps %xmm6, %xmm5
shufps $0x55, %xmm6, %xmm5 # xmm5 = xmm5[1,1],xmm6[1,1]
mulss %xmm0, %xmm5
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, %xmm7
mulss %xmm8, %xmm7
subss %xmm5, %xmm7
unpcklps %xmm6, %xmm8 # xmm8 = xmm8[0],xmm6[0],xmm8[1],xmm6[1]
mulps %xmm1, %xmm8
movaps %xmm1, %xmm5
shufps $0xe1, %xmm1, %xmm5 # xmm5 = xmm5[1,0],xmm1[2,3]
movss %xmm0, %xmm5 # xmm5 = xmm0[0],xmm5[1,2,3]
mulps %xmm5, %xmm6
subps %xmm8, %xmm6
movaps %xmm6, %xmm8
mulss %xmm6, %xmm8
movaps %xmm7, %xmm9
mulss %xmm7, %xmm9
addss %xmm8, %xmm9
movaps %xmm6, %xmm8
shufps $0x55, %xmm6, %xmm8 # xmm8 = xmm8[1,1],xmm6[1,1]
mulss %xmm8, %xmm8
addss %xmm9, %xmm8
sqrtss %xmm8, %xmm8
movaps %xmm2, %xmm9
divss %xmm8, %xmm9
cmpeqss %xmm4, %xmm8
movaps %xmm8, %xmm4
andnps %xmm9, %xmm4
andps %xmm2, %xmm8
orps %xmm4, %xmm8
movaps %xmm8, %xmm2
mulss %xmm7, %xmm2
shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
mulps %xmm6, %xmm8
movaps %xmm2, %xmm4
shufps $0xd4, %xmm8, %xmm4 # xmm4 = xmm4[0,1],xmm8[1,3]
shufps $0x52, %xmm8, %xmm4 # xmm4 = xmm4[2,0],xmm8[1,1]
shufps $0xd4, %xmm1, %xmm0 # xmm0 = xmm0[0,1],xmm1[1,3]
shufps $0xe2, %xmm1, %xmm0 # xmm0 = xmm0[2,0],xmm1[2,3]
mulps %xmm4, %xmm0
mulps %xmm8, %xmm5
subps %xmm0, %xmm5
mulss %xmm1, %xmm8
mulss %xmm3, %xmm2
subss %xmm8, %xmm2
movlps %xmm5, (%rsi)
movss %xmm2, 0x8(%rsi)
retq
|
Vector3OrthoNormalize:
movss xmm3, dword ptr [rdi+8]
movsd xmm5, qword ptr [rdi]
movaps xmm0, xmm5
mulps xmm0, xmm5
shufps xmm0, xmm0, 55h ; 'U'
movaps xmm1, xmm5
mulss xmm1, xmm5
addss xmm1, xmm0
movaps xmm0, xmm3
mulss xmm0, xmm3
addss xmm0, xmm1
sqrtss xmm0, xmm0
movss xmm2, cs:dword_B969C
movaps xmm1, xmm2
divss xmm1, xmm0
xorps xmm4, xmm4
cmpeqss xmm0, xmm4
movaps xmm6, xmm0
andnps xmm6, xmm1
andps xmm0, xmm2
orps xmm0, xmm6
movaps xmm1, xmm0
shufps xmm1, xmm0, 0
mulps xmm1, xmm5
movlps qword ptr [rdi], xmm1
mulss xmm0, xmm3
movss dword ptr [rdi+8], xmm0
movss xmm8, dword ptr [rsi+8]
movsd xmm6, qword ptr [rsi]
movaps xmm5, xmm6
shufps xmm5, xmm6, 55h ; 'U'
mulss xmm5, xmm0
movaps xmm3, xmm1
shufps xmm3, xmm1, 55h ; 'U'
movaps xmm7, xmm3
mulss xmm7, xmm8
subss xmm7, xmm5
unpcklps xmm8, xmm6
mulps xmm8, xmm1
movaps xmm5, xmm1
shufps xmm5, xmm1, 0E1h
movss xmm5, xmm0
mulps xmm6, xmm5
subps xmm6, xmm8
movaps xmm8, xmm6
mulss xmm8, xmm6
movaps xmm9, xmm7
mulss xmm9, xmm7
addss xmm9, xmm8
movaps xmm8, xmm6
shufps xmm8, xmm6, 55h ; 'U'
mulss xmm8, xmm8
addss xmm8, xmm9
sqrtss xmm8, xmm8
movaps xmm9, xmm2
divss xmm9, xmm8
cmpeqss xmm8, xmm4
movaps xmm4, xmm8
andnps xmm4, xmm9
andps xmm8, xmm2
orps xmm8, xmm4
movaps xmm2, xmm8
mulss xmm2, xmm7
shufps xmm8, xmm8, 0
mulps xmm8, xmm6
movaps xmm4, xmm2
shufps xmm4, xmm8, 0D4h
shufps xmm4, xmm8, 52h ; 'R'
shufps xmm0, xmm1, 0D4h
shufps xmm0, xmm1, 0E2h
mulps xmm0, xmm4
mulps xmm5, xmm8
subps xmm5, xmm0
mulss xmm8, xmm1
mulss xmm2, xmm3
subss xmm2, xmm8
movlps qword ptr [rsi], xmm5
movss dword ptr [rsi+8], xmm2
retn
|
void Vector3OrthoNormalize(unsigned long long *a1, double *a2)
{
__m128 v2; // xmm3
__m128 v3; // xmm5
__m128 v4; // xmm0
float v5; // xmm1_4
__m128 v6; // xmm0
__m128 v7; // xmm1
__m128 v8; // xmm4
__m128 v9; // xmm0
__m128 v10; // xmm0
__m128 v11; // xmm1
__m128 v12; // xmm8
__m128 v13; // xmm6
float v14; // xmm7_4
__m128 v15; // xmm5
__m128 v16; // xmm6
__m128 v17; // xmm8
__m128 v18; // xmm9
__m128 v19; // xmm8
__m128 v20; // xmm8
__m128 v21; // xmm2
__m128 v22; // xmm8
v2 = (__m128)*((unsigned int *)a1 + 2);
v3 = (__m128)*a1;
v4 = _mm_mul_ps(v3, v3);
v5 = (float)(COERCE_FLOAT(*a1) * v3.m128_f32[0]) + _mm_shuffle_ps(v4, v4, 85).m128_f32[0];
v6 = v2;
v6.m128_f32[0] = fsqrt((float)(v2.m128_f32[0] * v2.m128_f32[0]) + v5);
v7 = (__m128)0x3F800000u;
v7.m128_f32[0] = 1.0 / v6.m128_f32[0];
v8.m128_i32[0] = 0;
v9 = _mm_cmpeq_ss(v6, v8);
v10 = _mm_or_ps(_mm_and_ps(v9, (__m128)0x3F800000u), _mm_andnot_ps(v9, v7));
v11 = _mm_mul_ps(_mm_shuffle_ps(v10, v10, 0), v3);
_mm_storel_ps((double *)a1, v11);
v10.m128_f32[0] = v10.m128_f32[0] * v2.m128_f32[0];
*((_DWORD *)a1 + 2) = v10.m128_i32[0];
v12 = (__m128)*((unsigned int *)a2 + 2);
v13 = (__m128)*(unsigned long long *)a2;
v2.m128_f32[0] = _mm_shuffle_ps(v11, v11, 85).m128_f32[0];
v14 = (float)(v2.m128_f32[0] * v12.m128_f32[0]) - (float)(_mm_shuffle_ps(v13, v13, 85).m128_f32[0] * v10.m128_f32[0]);
v15 = _mm_shuffle_ps(v11, v11, 225);
v15.m128_f32[0] = v10.m128_f32[0];
v16 = _mm_sub_ps(_mm_mul_ps(v13, v15), _mm_mul_ps(_mm_unpacklo_ps(v12, v13), v11));
v17 = _mm_shuffle_ps(v16, v16, 85);
v17.m128_f32[0] = fsqrt(
(float)(v17.m128_f32[0] * v17.m128_f32[0])
+ (float)((float)(v14 * v14) + (float)(v16.m128_f32[0] * v16.m128_f32[0])));
v18 = (__m128)0x3F800000u;
v18.m128_f32[0] = 1.0 / v17.m128_f32[0];
v19 = _mm_cmpeq_ss(v17, v8);
v20 = _mm_or_ps(_mm_and_ps(v19, (__m128)0x3F800000u), _mm_andnot_ps(v19, v18));
v21 = v20;
v21.m128_f32[0] = v20.m128_f32[0] * v14;
v22 = _mm_mul_ps(_mm_shuffle_ps(v20, v20, 0), v16);
_mm_storel_ps(
a2,
_mm_sub_ps(
_mm_mul_ps(v15, v22),
_mm_mul_ps(
_mm_shuffle_ps(_mm_shuffle_ps(v10, v11, 212), v11, 226),
_mm_shuffle_ps(_mm_shuffle_ps(v21, v22, 212), v22, 82))));
*((float *)a2 + 2) = (float)(v21.m128_f32[0] * v2.m128_f32[0]) - (float)(v22.m128_f32[0] * v11.m128_f32[0]);
}
|
Vector3OrthoNormalize:
MOVSS XMM3,dword ptr [RDI + 0x8]
MOVSD XMM5,qword ptr [RDI]
MOVAPS XMM0,XMM5
MULPS XMM0,XMM5
SHUFPS XMM0,XMM0,0x55
MOVAPS XMM1,XMM5
MULSS XMM1,XMM5
ADDSS XMM1,XMM0
MOVAPS XMM0,XMM3
MULSS XMM0,XMM3
ADDSS XMM0,XMM1
SQRTSS XMM0,XMM0
MOVSS XMM2,dword ptr [0x001b969c]
MOVAPS XMM1,XMM2
DIVSS XMM1,XMM0
XORPS XMM4,XMM4
CMPEQSS XMM0,XMM4
MOVAPS XMM6,XMM0
ANDNPS XMM6,XMM1
ANDPS XMM0,XMM2
ORPS XMM0,XMM6
MOVAPS XMM1,XMM0
SHUFPS XMM1,XMM0,0x0
MULPS XMM1,XMM5
MOVLPS qword ptr [RDI],XMM1
MULSS XMM0,XMM3
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM8,dword ptr [RSI + 0x8]
MOVSD XMM6,qword ptr [RSI]
MOVAPS XMM5,XMM6
SHUFPS XMM5,XMM6,0x55
MULSS XMM5,XMM0
MOVAPS XMM3,XMM1
SHUFPS XMM3,XMM1,0x55
MOVAPS XMM7,XMM3
MULSS XMM7,XMM8
SUBSS XMM7,XMM5
UNPCKLPS XMM8,XMM6
MULPS XMM8,XMM1
MOVAPS XMM5,XMM1
SHUFPS XMM5,XMM1,0xe1
MOVSS XMM5,XMM0
MULPS XMM6,XMM5
SUBPS XMM6,XMM8
MOVAPS XMM8,XMM6
MULSS XMM8,XMM6
MOVAPS XMM9,XMM7
MULSS XMM9,XMM7
ADDSS XMM9,XMM8
MOVAPS XMM8,XMM6
SHUFPS XMM8,XMM6,0x55
MULSS XMM8,XMM8
ADDSS XMM8,XMM9
SQRTSS XMM8,XMM8
MOVAPS XMM9,XMM2
DIVSS XMM9,XMM8
CMPEQSS XMM8,XMM4
MOVAPS XMM4,XMM8
ANDNPS XMM4,XMM9
ANDPS XMM8,XMM2
ORPS XMM8,XMM4
MOVAPS XMM2,XMM8
MULSS XMM2,XMM7
SHUFPS XMM8,XMM8,0x0
MULPS XMM8,XMM6
MOVAPS XMM4,XMM2
SHUFPS XMM4,XMM8,0xd4
SHUFPS XMM4,XMM8,0x52
SHUFPS XMM0,XMM1,0xd4
SHUFPS XMM0,XMM1,0xe2
MULPS XMM0,XMM4
MULPS XMM5,XMM8
SUBPS XMM5,XMM0
MULSS XMM8,XMM1
MULSS XMM2,XMM3
SUBSS XMM2,XMM8
MOVLPS qword ptr [RSI],XMM5
MOVSS dword ptr [RSI + 0x8],XMM2
RET
|
void Vector3OrthoNormalize(int8 *param_1,int8 *param_2)
{
float fVar1;
uint uVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float fVar9;
fVar1 = DAT_001b969c;
fVar9 = *(float *)(param_1 + 1);
fVar4 = (float)*param_1;
fVar5 = (float)((ulong)*param_1 >> 0x20);
fVar3 = SQRT(fVar9 * fVar9 + fVar4 * fVar4 + fVar5 * fVar5);
uVar2 = -(uint)(fVar3 == 0.0);
fVar3 = (float)(uVar2 & (uint)DAT_001b969c | ~uVar2 & (uint)(DAT_001b969c / fVar3));
fVar4 = fVar3 * fVar4;
fVar5 = fVar3 * fVar5;
*param_1 = CONCAT44(fVar5,fVar4);
fVar3 = fVar3 * fVar9;
*(float *)(param_1 + 1) = fVar3;
fVar9 = (float)*param_2;
fVar7 = (float)((ulong)*param_2 >> 0x20);
fVar8 = fVar5 * *(float *)(param_2 + 1) - fVar7 * fVar3;
fVar6 = fVar9 * fVar3 - *(float *)(param_2 + 1) * fVar4;
fVar7 = fVar7 * fVar4 - fVar9 * fVar5;
fVar9 = SQRT(fVar7 * fVar7 + fVar8 * fVar8 + fVar6 * fVar6);
uVar2 = -(uint)(fVar9 == 0.0);
fVar9 = (float)(uVar2 & (uint)fVar1 | ~uVar2 & (uint)(fVar1 / fVar9));
*param_2 = CONCAT44(fVar4 * fVar9 * fVar7 - fVar3 * fVar9 * fVar8,
fVar3 * fVar9 * fVar6 - fVar5 * fVar9 * fVar7);
*(float *)(param_2 + 1) = fVar9 * fVar8 * fVar5 - fVar9 * fVar6 * fVar4;
return;
}
|
|
5,061 |
httplib::detail::read_socket(int, void*, unsigned long, int)::'lambda'()::operator()() const
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) {
return handle_EINTR([&]() {
return recv(sock,
#ifdef _WIN32
static_cast<char *>(ptr), static_cast<int>(size),
#else
ptr, size,
#endif
flags);
});
}
|
O0
|
c
|
httplib::detail::read_socket(int, void*, unsigned long, int)::'lambda'()::operator()() const:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
movl (%rcx), %edi
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movq 0x10(%rax), %rcx
movq (%rcx), %rdx
movq 0x18(%rax), %rax
movl (%rax), %ecx
callq 0xb230
popq %rcx
retq
nopl (%rax)
|
_ZZN7httplib6detail11read_socketEiPvmiENKUlvE_clEv:
push rax
mov [rsp+8+var_8], rdi
mov rax, [rsp+8+var_8]
mov rcx, [rax]
mov edi, [rcx]
mov rcx, [rax+8]
mov rsi, [rcx]
mov rcx, [rax+10h]
mov rdx, [rcx]
mov rax, [rax+18h]
mov ecx, [rax]
call _recv
pop rcx
retn
|
long long httplib::detail::read_socket(int,void *,unsigned long,int)::{lambda(void)#1}::operator()(
unsigned int **a1)
{
return recv(**a1, *(_QWORD *)a1[1], *(_QWORD *)a1[2], *a1[3]);
}
|
operator():
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX]
MOV EDI,dword ptr [RCX]
MOV RCX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RCX]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RAX]
CALL 0x0010b230
POP RCX
RET
|
/* httplib::detail::read_socket(int, void*, unsigned long,
int)::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE() const */
void __thiscall
httplib::detail::read_socket(int,void*,unsigned_long,int)::{lambda()#1}::operator()
(_lambda___1_ *this)
{
recv(**(int **)this,(void *)**(int8 **)(this + 8),**(size_t **)(this + 0x10),
**(int **)(this + 0x18));
return;
}
|
|
5,062 |
reset_key_cache_counters
|
eloqsql/mysys/mf_keycache.c
|
int reset_key_cache_counters(const char *name __attribute__((unused)),
KEY_CACHE *keycache,
void *unused __attribute__((unused)))
{
int rc= 0;
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
rc= keycache->interface_funcs->reset_counters(name,
keycache->keycache_cb);
pthread_mutex_unlock(&keycache->op_lock);
}
return rc;
}
|
O3
|
c
|
reset_key_cache_counters:
cmpb $0x0, 0x48(%rsi)
je 0x98771
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsi), %r15
movq %r15, %rdi
callq 0x29220
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movl %eax, %ebx
movq %r15, %rdi
callq 0x291e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
|
reset_key_cache_counters:
cmp byte ptr [rsi+48h], 0
jz short loc_98771
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+58h]
mov rdi, r15
call _pthread_mutex_lock
mov rsi, [r14+8]
mov rax, [r14+10h]
mov rdi, rbx
call qword ptr [rax+38h]
mov ebx, eax
mov rdi, r15
call _pthread_mutex_unlock
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_98771:
xor eax, eax
retn
|
long long reset_key_cache_counters(long long a1, long long a2)
{
unsigned int v2; // ebx
if ( !*(_BYTE *)(a2 + 72) )
return 0LL;
pthread_mutex_lock(a2 + 88);
v2 = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)(a2 + 16) + 56LL))(a1, *(_QWORD *)(a2 + 8));
pthread_mutex_unlock(a2 + 88);
return v2;
}
|
reset_key_cache_counters:
CMP byte ptr [RSI + 0x48],0x0
JZ 0x00198771
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x58]
MOV RDI,R15
CALL 0x00129220
MOV RSI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
MOV RDI,RBX
CALL qword ptr [RAX + 0x38]
MOV EBX,EAX
MOV RDI,R15
CALL 0x001291e0
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00198771:
XOR EAX,EAX
RET
|
int4 reset_key_cache_counters(int8 param_1,long param_2)
{
int4 uVar1;
if (*(char *)(param_2 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_2 + 0x58));
uVar1 = (**(code **)(*(long *)(param_2 + 0x10) + 0x38))(param_1,*(int8 *)(param_2 + 8));
pthread_mutex_unlock((pthread_mutex_t *)(param_2 + 0x58));
return uVar1;
}
return 0;
}
|
|
5,063 |
google::protobuf::EnumDescriptorProto::SharedCtor(google::protobuf::Arena*, bool)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
inline void EnumDescriptorProto::SharedCtor(
::_pb::Arena* arena, bool is_message_owned) {
(void)arena;
(void)is_message_owned;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.value_){arena}
, decltype(_impl_.reserved_range_){arena}
, decltype(_impl_.reserved_name_){arena}
, decltype(_impl_.name_){}
, decltype(_impl_.options_){nullptr}
};
_impl_.name_.InitDefault();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
_impl_.name_.Set("", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
|
O0
|
cpp
|
google::protobuf::EnumDescriptorProto::SharedCtor(google::protobuf::Arena*, bool):
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movl $0x0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, 0x30(%rsp)
jne 0x534b54
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x4, %rdi
movl $0x0, 0x4(%rax)
callq 0x3b6830
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rsi
callq 0x53acf0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x10(%rsp)
movq 0x50(%rsp), %rsi
callq 0x53ad20
jmp 0x534bbc
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
movq 0x50(%rsp), %rsi
callq 0x3e63d0
jmp 0x534bd1
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1914a0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq $0x0, 0x58(%rax)
addq $0x10, %rdi
addq $0x50, %rdi
callq 0x3b6850
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x534c32
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x534d10
movq 0x8(%rsp), %rdi
callq 0x534d60
movq 0x40(%rsp), %rdi
callq 0x198ce0
nopw %cs:(%rax,%rax)
|
_ZN6google8protobuf19EnumDescriptorProto10SharedCtorEPNS0_5ArenaEb:
sub rsp, 68h
mov al, dl
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
and al, 1
mov [rsp+68h+var_19], al
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_50], rax
add rax, 10h
mov [rsp+68h+var_48], rax
mov [rsp+68h+var_8], rax
mov rax, [rsp+68h+var_8]
mov rcx, rax
add rcx, 4
mov [rsp+68h+var_40], rcx
mov [rsp+68h+var_38], rax
loc_534B54:
mov rax, [rsp+68h+var_38]
mov rcx, [rsp+68h+var_40]
mov dword ptr [rax], 0
add rax, 4
cmp rax, rcx
mov [rsp+68h+var_38], rax
jnz short loc_534B54
mov rax, [rsp+68h+var_48]
mov rdi, rax
add rdi, 4; this
mov dword ptr [rax+4], 0
call _ZN6google8protobuf8internal10CachedSizeC2Ev; google::protobuf::internal::CachedSize::CachedSize(void)
mov rdi, [rsp+68h+var_48]
add rdi, 8
mov [rsp+68h+var_60], rdi
mov rsi, [rsp+68h+var_18]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEEC2EPNS0_5ArenaE; google::protobuf::RepeatedPtrField<google::protobuf::EnumValueDescriptorProto>::RepeatedPtrField(google::protobuf::Arena *)
mov rdi, [rsp+68h+var_48]
add rdi, 20h ; ' '
mov [rsp+68h+var_58], rdi
mov rsi, [rsp+68h+var_18]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_37EnumDescriptorProto_EnumReservedRangeEEC2EPNS0_5ArenaE; google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto_EnumReservedRange>::RepeatedPtrField(google::protobuf::Arena *)
jmp short $+2
loc_534BBC:
mov rdi, [rsp+68h+var_48]
add rdi, 38h ; '8'
mov rsi, [rsp+68h+var_18]
call _ZN6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2EPNS0_5ArenaE; google::protobuf::RepeatedPtrField<std::string>::RepeatedPtrField(google::protobuf::Arena *)
jmp short $+2
loc_534BD1:
mov rdi, [rsp+68h+var_48]
add rdi, 50h ; 'P'
xor esi, esi
mov edx, 8
call _memset
mov rax, [rsp+68h+var_48]
mov rdi, [rsp+68h+var_50]
mov qword ptr [rax+58h], 0
add rdi, 10h
add rdi, 50h ; 'P'; this
call _ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv; google::protobuf::internal::ArenaStringPtr::InitDefault(void)
add rsp, 68h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_534C32
mov rdi, [rsp+arg_8]
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
call _ZN6google8protobuf16RepeatedPtrFieldINS0_37EnumDescriptorProto_EnumReservedRangeEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto_EnumReservedRange>::~RepeatedPtrField()
loc_534C32:
mov rdi, [rsp+arg_0]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_24EnumValueDescriptorProtoEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::EnumValueDescriptorProto>::~RepeatedPtrField()
mov rdi, [rsp+arg_38]
call __Unwind_Resume
|
google::protobuf::internal::ArenaStringPtr * google::protobuf::EnumDescriptorProto::SharedCtor(
google::protobuf::EnumDescriptorProto *this,
google::protobuf::Arena *a2)
{
google::protobuf::EnumDescriptorProto *v3; // [rsp+30h] [rbp-38h]
v3 = (google::protobuf::EnumDescriptorProto *)((char *)this + 16);
do
{
*(_DWORD *)v3 = 0;
v3 = (google::protobuf::EnumDescriptorProto *)((char *)v3 + 4);
}
while ( v3 != (google::protobuf::EnumDescriptorProto *)((char *)this + 20) );
*((_DWORD *)this + 5) = 0;
google::protobuf::internal::CachedSize::CachedSize((google::protobuf::EnumDescriptorProto *)((char *)this + 20));
google::protobuf::RepeatedPtrField<google::protobuf::EnumValueDescriptorProto>::RepeatedPtrField(
(char *)this + 24,
a2);
google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto_EnumReservedRange>::RepeatedPtrField(
(char *)this + 48,
a2);
google::protobuf::RepeatedPtrField<std::string>::RepeatedPtrField(
(google::protobuf::EnumDescriptorProto *)((char *)this + 72),
a2);
memset((char *)this + 96, 0LL, 8LL);
*((_QWORD *)this + 13) = 0LL;
return google::protobuf::internal::ArenaStringPtr::InitDefault((google::protobuf::EnumDescriptorProto *)((char *)this + 96));
}
|
RepeatedFieldPrimitiveAccessor:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00534b40
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x8475d0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x18
RET
|
/* google::protobuf::internal::RepeatedFieldPrimitiveAccessor<int>::RepeatedFieldPrimitiveAccessor()
*/
void __thiscall
google::protobuf::internal::RepeatedFieldPrimitiveAccessor<int>::RepeatedFieldPrimitiveAccessor
(RepeatedFieldPrimitiveAccessor<int> *this)
{
RepeatedFieldWrapper<int>::RepeatedFieldWrapper((RepeatedFieldWrapper<int> *)this);
*(int ***)this = &PTR_IsEmpty_008475e0;
return;
}
|
|
5,064 |
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>)
|
llama.cpp/common/json.hpp
|
iterator erase(iterator first, iterator last)
{
if (first == last)
{
return first;
}
const auto elements_affected = std::distance(first, last);
const auto offset = std::distance(Container::begin(), first);
// This is the start situation. We need to delete elements_affected
// elements (3 in this example: e, f, g), and need to return an
// iterator past the last deleted element (h in this example).
// Note that offset is the distance from the start of the vector
// to first. We will need this later.
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// first last
// Since we cannot move const Keys, we re-construct them in place.
// We start at first and re-construct (viz. copy) the elements from
// the back of the vector. Example for first iteration:
// ,--------.
// v | destroy e and re-construct with h
// [ a, b, c, d, e, f, g, h, i, j ]
// ^ ^
// it it + elements_affected
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
{
it->~value_type(); // destroy but keep allocation
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
}
// [ a, b, c, d, h, i, j, h, i, j ]
// ^ ^
// first last
// remove the unneeded elements at the end of the vector
Container::resize(this->size() - static_cast<size_type>(elements_affected));
// [ a, b, c, d, h, i, j ]
// ^ ^
// first last
// first is now pointing past the last deleted element, but we cannot
// use this iterator, because it may have been invalidated by the
// resize call. Instead, we can return begin() + offset.
return Container::begin() + offset;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x8b064
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rax
subq %rbx, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rbx), %rbp
movq %rdx, %r12
negq %r12
cmpq 0x8(%r14), %r15
je 0x8b034
leaq 0x10(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r13, %rdi
callq 0x89fe4
movq -0x10(%rbp), %rdi
cmpq %rdi, %rbp
je 0x8b01a
movq (%rbp), %rsi
incq %rsi
callq 0x20170
leaq -0x10(%rbp), %rdi
movq %r15, %rsi
callq 0x8b076
addq $0x30, %r15
addq $0x30, %rbp
addq $-0x30, %r12
jmp 0x8afe9
subq 0x8(%rsp), %rbx
addq (%r14), %r12
negq %r12
sarq $0x4, %r12
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
subq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x8b0ce
addq (%r14), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEESP_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
cmp rsi, rdx
jz loc_8B064
mov r15, rdx
mov r14, rdi
mov rax, rdx
sub rax, rbx
sar rax, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rax, rcx
mov [rsp+48h+var_38], rax
mov rax, [rdi]
mov [rsp+48h+var_40], rax
lea rbp, [rbx+10h]
mov r12, rdx
neg r12
loc_8AFE9:
cmp r15, [r14+8]
jz short loc_8B034
lea r13, [rbp+10h]
mov rdi, r13
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, r13
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, [rbp-10h]; void *
cmp rbp, rdi
jz short loc_8B01A
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8B01A:
lea rdi, [rbp-10h]
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; 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(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>>&&)
add r15, 30h ; '0'
add rbp, 30h ; '0'
add r12, 0FFFFFFFFFFFFFFD0h
jmp short loc_8AFE9
loc_8B034:
sub rbx, [rsp+48h+var_40]
add r12, [r14]
neg r12
sar r12, 4
mov rax, 0AAAAAAAAAAAAAAABh
imul r12, rax
sub r12, [rsp+48h+var_38]
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE6resizeEm; std::vector<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>>>::resize(ulong)
add rbx, [r14]
loc_8B064:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::erase(
long long *a1,
long long a2,
long long a3)
{
long long v3; // rbx
long long v4; // r15
char *v6; // rbp
long long v7; // r12
char *v8; // rdi
long long v10; // [rsp+8h] [rbp-40h]
unsigned long long v11; // [rsp+10h] [rbp-38h]
v3 = a2;
if ( a2 != a3 )
{
v4 = a3;
v11 = 0xAAAAAAAAAAAAAAABLL * ((a3 - a2) >> 4);
v10 = *a1;
v6 = (char *)(a2 + 16);
v7 = -a3;
while ( v4 != a1[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(v6 + 16);
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(v6 + 16);
v8 = (char *)*((_QWORD *)v6 - 2);
if ( v6 != v8 )
operator delete(v8, *(_QWORD *)v6 + 1LL);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
v6 - 16,
v4);
v4 += 48LL;
v6 += 48;
v7 -= 48LL;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::resize(
a1,
0xAAAAAAAAAAAAAAABLL * (-(*a1 + v7) >> 4) - v11);
return *a1 + a2 - v10;
}
return v3;
}
|
erase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
CMP RSI,RDX
JZ 0x0018b064
MOV R15,RDX
MOV R14,RDI
MOV RAX,RDX
SUB RAX,RBX
SAR RAX,0x4
MOV RCX,-0x5555555555555555
IMUL RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RAX
LEA RBP,[RBX + 0x10]
MOV R12,RDX
NEG R12
LAB_0018afe9:
CMP R15,qword ptr [R14 + 0x8]
JZ 0x0018b034
LEA R13,[RBP + 0x10]
MOV RDI,R13
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,R13
CALL 0x00189fe4
MOV RDI,qword ptr [RBP + -0x10]
CMP RBP,RDI
JZ 0x0018b01a
MOV RSI,qword ptr [RBP]
INC RSI
CALL 0x00120170
LAB_0018b01a:
LEA RDI,[RBP + -0x10]
MOV RSI,R15
CALL 0x0018b076
ADD R15,0x30
ADD RBP,0x30
ADD R12,-0x30
JMP 0x0018afe9
LAB_0018b034:
SUB RBX,qword ptr [RSP + 0x8]
ADD R12,qword ptr [R14]
NEG R12
SAR R12,0x4
MOV RAX,-0x5555555555555555
IMUL R12,RAX
SUB R12,qword ptr [RSP + 0x10]
MOV RDI,R14
MOV RSI,R12
CALL 0x0018b0ce
ADD RBX,qword ptr [R14]
LAB_0018b064:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::erase(__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >*, std::vector<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > > >, __gnu_cxx::__normal_iterator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >*, std::vector<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > > >) */
pair * __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::erase(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,pair *param_2,pair *param_3)
{
long lVar1;
long lVar2;
long *plVar3;
long lVar4;
if (param_2 != param_3) {
lVar2 = (long)param_3 - (long)param_2;
lVar1 = *(long *)this;
plVar3 = (long *)(param_2 + 0x10);
lVar4 = -(long)param_3;
for (; param_3 != *(pair **)(this + 8); param_3 = param_3 + 0x30) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(plVar3 + 2),0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(plVar3 + 2));
if (plVar3 != (long *)plVar3[-2]) {
operator_delete((long *)plVar3[-2],*plVar3 + 1);
}
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)(plVar3 + -2),param_3);
plVar3 = plVar3 + 6;
lVar4 = lVar4 + -0x30;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::resize((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,(-(lVar4 + *(long *)this) >> 4) * -0x5555555555555555 +
(lVar2 >> 4) * 0x5555555555555555);
param_2 = param_2 + (*(long *)this - lVar1);
}
return param_2;
}
|
|
5,065 |
coro::detail::make_task_self_deleting(coro::task<void>)
|
AlayaLite/build_O3/_deps/libcoro-src/src/detail/task_self_deleting.cpp
|
auto make_task_self_deleting(coro::task<void> user_task) -> task_self_deleting
{
co_await user_task;
co_return;
}
|
O3
|
cpp
|
coro::detail::make_task_self_deleting(coro::task<void>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r13
movq %rdi, %r15
movl $0x30, %edi
callq 0x171f0
movq %rax, %rbx
leaq 0x82(%rip), %rax # 0xc8552
movq %rax, (%rbx)
leaq 0x116(%rip), %rax # 0xc85f0
movq %rax, 0x8(%rbx)
movq (%r13), %r14
movq %r14, 0x20(%rbx)
movq %rbx, %r12
addq $0x10, %r12
movq $0x0, (%r13)
movq %r12, %rdi
callq 0xc8440
movq %r15, %rdi
movq %r12, %rsi
callq 0xc8490
movb $0x0, 0x28(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r12, %rdi
callq 0xc8448
jmp 0xc8529
movq %rax, %r15
testq %r14, %r14
je 0xc8535
movq %r14, %rdi
callq *0x8(%r14)
movl $0x30, %esi
movq %rbx, %rdi
callq 0x17150
movq %r15, %rdi
callq 0x17740
movq %rax, %rdi
callq 0x1f2c3
|
_ZN4coro6detail23make_task_self_deletingENS_4taskIvEE:
push r15
push r14
push r13
push r12
push rbx
mov r13, rsi
mov r15, rdi
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
lea rax, _ZN4coro6detail23make_task_self_deletingENS_4taskIvEE_resume; coro::detail::make_task_self_deleting(coro::task<void>) [clone]
mov [rbx], rax
lea rax, _ZN4coro6detail23make_task_self_deletingENS_4taskIvEE_destroy; coro::detail::make_task_self_deleting(coro::task<void>) [clone]
mov [rbx+8], rax
mov r14, [r13+0]
mov [rbx+20h], r14
mov r12, rbx
add r12, 10h
mov qword ptr [r13+0], 0
mov rdi, r12; this
call _ZN4coro6detail21promise_self_deletingC2Ev; coro::detail::promise_self_deleting::promise_self_deleting(void)
mov rdi, r15; this
mov rsi, r12; coro::detail::promise_self_deleting *
call _ZN4coro6detail18task_self_deletingC2ERNS0_21promise_self_deletingE; coro::detail::task_self_deleting::task_self_deleting(coro::detail::promise_self_deleting &)
mov byte ptr [rbx+28h], 0
mov rax, r15
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r15, rax
mov rdi, r12; this
call _ZN4coro6detail21promise_self_deletingD2Ev; coro::detail::promise_self_deleting::~promise_self_deleting()
jmp short loc_C8529
mov r15, rax
loc_C8529:
test r14, r14
jz short loc_C8535
mov rdi, r14
call qword ptr [r14+8]
loc_C8535:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
coro::detail::task_self_deleting * coro::detail::make_task_self_deleting(
coro::detail::task_self_deleting *this,
_QWORD *a2)
{
long long v2; // rbx
v2 = operator new(0x30uLL);
*(_QWORD *)v2 = coro::detail::make_task_self_deleting;
*(_QWORD *)(v2 + 8) = coro::detail::make_task_self_deleting;
*(_QWORD *)(v2 + 32) = *a2;
*a2 = 0LL;
coro::detail::promise_self_deleting::promise_self_deleting((coro::detail::promise_self_deleting *)(v2 + 16));
coro::detail::task_self_deleting::task_self_deleting(this, (coro::detail::promise_self_deleting *)(v2 + 16));
*(_BYTE *)(v2 + 40) = 0;
return this;
}
|
make_task_self_deleting:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R13,RSI
MOV R15,RDI
MOV EDI,0x30
CALL 0x001171f0
MOV RBX,RAX
LEA RAX,[0x1c8552]
MOV qword ptr [RBX],RAX
LEA RAX,[0x1c85f0]
MOV qword ptr [RBX + 0x8],RAX
MOV R14,qword ptr [R13]
MOV qword ptr [RBX + 0x20],R14
MOV R12,RBX
ADD R12,0x10
MOV qword ptr [R13],0x0
LAB_001c84f5:
MOV RDI,R12
CALL 0x001c8440
LAB_001c84fd:
MOV RDI,R15
MOV RSI,R12
CALL 0x001c8490
LAB_001c8508:
MOV byte ptr [RBX + 0x28],0x0
MOV RAX,R15
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* coro::detail::make_task_self_deleting(coro::task<void>) */
detail * __thiscall coro::detail::make_task_self_deleting(detail *this,int8 *param_2)
{
int8 *puVar1;
puVar1 = (int8 *)operator_new(0x30);
*puVar1 = make_task_self_deleting;
puVar1[1] = make_task_self_deleting;
puVar1[4] = *param_2;
*param_2 = 0;
/* try { // try from 001c84f5 to 001c84fc has its CatchHandler @ 001c8526 */
promise_self_deleting::promise_self_deleting((promise_self_deleting *)(puVar1 + 2));
/* try { // try from 001c84fd to 001c8507 has its CatchHandler @ 001c8519 */
task_self_deleting::task_self_deleting
((task_self_deleting *)this,(promise_self_deleting *)(puVar1 + 2));
*(int1 *)(puVar1 + 5) = 0;
return this;
}
|
|
5,066 |
outline::prepare()
|
untodesu[P]voxelius/game/client/outline.cc
|
void outline::prepare(void)
{
program.set_variant_vert(WORLD_CURVATURE, client_game::world_curvature.get_value());
if(!program.update()) {
spdlog::critical("outline_renderer: program update failed");
std::terminate();
}
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glUseProgram(program.handle);
glUniformMatrix4fv(program.uniforms[u_vpmatrix].location, 1, false, glm::value_ptr(camera::matrix));
glUniform1f(program.uniforms[u_viewdist].location, CHUNK_SIZE * camera::view_distance.get_value());
glBindVertexArray(vaobj);
glEnableVertexAttribArray(0);
glVertexAttribDivisor(0, 0);
}
|
O3
|
cpp
|
outline::prepare():
pushq %rbx
leaq 0x2006b2(%rip), %rdi # 0x259cc8
callq 0x12d660
movzbl %al, %edx
leaq 0x200dbb(%rip), %rbx # 0x25a3e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5f294
movq %rbx, %rdi
callq 0x5eb00
testb %al, %al
je 0x596f8
leaq 0x2040aa(%rip), %rax # 0x25d6f0
movl $0xb44, %edi # imm = 0xB44
callq *(%rax)
leaq 0x2044dc(%rip), %rax # 0x25db30
movl $0x408, %edi # imm = 0x408
movl $0x1b02, %esi # imm = 0x1B02
callq *(%rax)
leaq 0x204739(%rip), %rax # 0x25dda0
movl 0x200e2f(%rip), %edi # 0x25a49c
callq *(%rax)
leaq 0x20470a(%rip), %rax # 0x25dd80
movq 0x200e23(%rip), %rcx # 0x25a4a0
movq 0x200dfc(%rip), %rdx # 0x25a480
leaq (%rcx,%rcx,4), %rcx
movl 0x20(%rdx,%rcx,8), %edi
leaq 0x1fffe5(%rip), %rcx # 0x259678
movl $0x1, %esi
xorl %edx, %edx
callq *(%rax)
leaq 0x2045e5(%rip), %rax # 0x25dc88
movq 0x200e06(%rip), %rcx # 0x25a4b0
movq 0x200dcf(%rip), %rdx # 0x25a480
leaq (%rcx,%rcx,4), %rcx
movl 0x20(%rdx,%rcx,8), %edi
leaq 0x1fff68(%rip), %rcx # 0x259628
movl 0x8(%rcx), %ecx
shll $0x4, %ecx
cvtsi2ss %rcx, %xmm0
callq *(%rax)
leaq 0x203e64(%rip), %rax # 0x25d538
movl 0x200df6(%rip), %edi # 0x25a4d0
callq *(%rax)
leaq 0x20407d(%rip), %rax # 0x25d760
xorl %edi, %edi
callq *(%rax)
leaq 0x2047e2(%rip), %rax # 0x25ded0
movq (%rax), %rax
xorl %edi, %edi
xorl %esi, %esi
popq %rbx
jmpq *%rax
leaq 0x13f4c8(%rip), %rdi # 0x198bc7
callq 0x4bb2d
callq 0x261e0
|
_ZN7outline7prepareEv:
push rbx
lea rdi, _ZN11client_game15world_curvatureE; this
call _ZNK13ConfigBoolean9get_valueEv; ConfigBoolean::get_value(void)
movzx edx, al; unsigned int
lea rbx, _ZL7program; program
mov rdi, rbx; this
xor esi, esi; unsigned int
call _ZN10GL_Program16set_variant_vertEjj; GL_Program::set_variant_vert(uint,uint)
mov rdi, rbx; this
call _ZN10GL_Program6updateEv; GL_Program::update(void)
test al, al
jz loc_596F8
lea rax, glad_glDisable
mov edi, 0B44h
call qword ptr [rax]
lea rax, glad_glPolygonMode
mov edi, 408h
mov esi, 1B02h
call qword ptr [rax]
lea rax, glad_glUseProgram
mov edi, cs:dword_25A49C
call qword ptr [rax]
lea rax, glad_glUniformMatrix4fv
mov rcx, cs:_ZL10u_vpmatrix; u_vpmatrix
mov rdx, qword ptr cs:xmmword_25A480
lea rcx, [rcx+rcx*4]
mov edi, [rdx+rcx*8+20h]
lea rcx, _ZN6camera6matrixE; camera::matrix
mov esi, 1
xor edx, edx
call qword ptr [rax]
lea rax, glad_glUniform1f
mov rcx, cs:_ZL10u_viewdist; u_viewdist
mov rdx, qword ptr cs:xmmword_25A480
lea rcx, [rcx+rcx*4]
mov edi, [rdx+rcx*8+20h]
lea rcx, _ZN6camera13view_distanceE; camera::view_distance
mov ecx, [rcx+8]
shl ecx, 4
cvtsi2ss xmm0, rcx
call qword ptr [rax]
lea rax, glad_glBindVertexArray
mov edi, cs:_ZL5vaobj; vaobj
call qword ptr [rax]
lea rax, glad_glEnableVertexAttribArray
xor edi, edi
call qword ptr [rax]
lea rax, glad_glVertexAttribDivisor
mov rax, [rax]
xor edi, edi
xor esi, esi
pop rbx
jmp rax
loc_596F8:
lea rdi, aOutlineRendere; "outline_renderer: program update failed"
call _ZN6spdlog8criticalIA40_cEEvRKT_; spdlog::critical<char [40]>(char [40] const&)
call __ZSt9terminatev; std::terminate(void)
|
long long outline::prepare(outline *this)
{
unsigned __int8 value; // al
value = ConfigBoolean::get_value((ConfigBoolean *)&client_game::world_curvature);
GL_Program::set_variant_vert((GL_Program *)&program, 0, value);
if ( !(unsigned __int8)GL_Program::update((GL_Program *)&program) )
{
spdlog::critical<char [40]>((spdlog *)"outline_renderer: program update failed");
std::terminate();
}
glad_glDisable(2884LL);
glad_glPolygonMode(1032LL, 6914LL);
glad_glUseProgram((unsigned int)dword_25A49C);
glad_glUniformMatrix4fv(*(unsigned int *)(xmmword_25A480 + 40 * u_vpmatrix + 32), 1LL, 0LL, &camera::matrix);
glad_glUniform1f(
*(unsigned int *)(xmmword_25A480 + 40 * u_viewdist + 32),
(float)(16 * *((_DWORD *)&camera::view_distance + 2)));
glad_glBindVertexArray((unsigned int)vaobj);
glad_glEnableVertexAttribArray(0LL);
return glad_glVertexAttribDivisor(0LL, 0LL);
}
|
prepare:
PUSH RBX
LEA RDI,[0x359cc8]
CALL 0x0022d660
MOVZX EDX,AL
LEA RBX,[0x35a3e0]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0015f294
MOV RDI,RBX
CALL 0x0015eb00
TEST AL,AL
JZ 0x001596f8
LEA RAX,[0x35d6f0]
MOV EDI,0xb44
CALL qword ptr [RAX]
LEA RAX,[0x35db30]
MOV EDI,0x408
MOV ESI,0x1b02
CALL qword ptr [RAX]
LEA RAX,[0x35dda0]
MOV EDI,dword ptr [0x0035a49c]
CALL qword ptr [RAX]
LEA RAX,[0x35dd80]
MOV RCX,qword ptr [0x0035a4a0]
MOV RDX,qword ptr [0x0035a480]
LEA RCX,[RCX + RCX*0x4]
MOV EDI,dword ptr [RDX + RCX*0x8 + 0x20]
LEA RCX,[0x359678]
MOV ESI,0x1
XOR EDX,EDX
CALL qword ptr [RAX]
LEA RAX,[0x35dc88]
MOV RCX,qword ptr [0x0035a4b0]
MOV RDX,qword ptr [0x0035a480]
LEA RCX,[RCX + RCX*0x4]
MOV EDI,dword ptr [RDX + RCX*0x8 + 0x20]
LEA RCX,[0x359628]
MOV ECX,dword ptr [RCX + 0x8]
SHL ECX,0x4
CVTSI2SS XMM0,RCX
CALL qword ptr [RAX]
LEA RAX,[0x35d538]
MOV EDI,dword ptr [0x0035a4d0]
CALL qword ptr [RAX]
LEA RAX,[0x35d760]
XOR EDI,EDI
CALL qword ptr [RAX]
LEA RAX,[0x35ded0]
MOV RAX,qword ptr [RAX]
XOR EDI,EDI
XOR ESI,ESI
POP RBX
JMP RAX
LAB_001596f8:
LEA RDI,[0x298bc7]
CALL 0x0014bb2d
CALL 0x001261e0
|
/* outline::prepare() */
void outline::prepare(void)
{
byte bVar1;
char cVar2;
bVar1 = ConfigBoolean::get_value((ConfigBoolean *)client_game::world_curvature);
GL_Program::set_variant_vert((GL_Program *)program,0,(uint)bVar1);
cVar2 = GL_Program::update((GL_Program *)program);
if (cVar2 != '\0') {
(*glad_glDisable)(0xb44);
(*glad_glPolygonMode)(0x408,0x1b02);
(*glad_glUseProgram)(program._188_4_);
(*glad_glUniformMatrix4fv)
(*(int4 *)(program._160_8_ + 0x20 + u_vpmatrix * 0x28),1,0,camera::matrix);
(*glad_glUniform1f)((float)(uint)(camera::view_distance._8_4_ << 4),
*(int4 *)(program._160_8_ + 0x20 + u_viewdist * 0x28));
(*glad_glBindVertexArray)(vaobj);
(*glad_glEnableVertexAttribArray)(0);
/* WARNING: Could not recover jumptable at 0x001596f6. Too many branches */
/* WARNING: Treating indirect jump as call */
(*glad_glVertexAttribDivisor)(0,0);
return;
}
spdlog::critical<char[40]>("outline_renderer: program update failed");
/* WARNING: Subroutine does not return */
std::terminate();
}
|
|
5,067 |
get_options
|
eloqsql/libmariadb/unittest/libmariadb/my_test.h
|
void get_options(int argc, char **argv)
{
int c= 0;
while ((c=getopt(argc,argv, "h:u:p:d:w:P:S:t:?")) >= 0)
{
switch(c) {
case 'h':
hostname= optarg;
break;
case 'u':
username= optarg;
break;
case 'p':
password= optarg;
break;
case 'd':
schema= optarg;
break;
case 'P':
port= atoi(optarg);
ssl_port=port;
break;
case 'S':
socketname= optarg;
break;
case 't':
force_tls= 1;
break;
case '?':
usage();
exit(0);
break;
default:
usage();
BAIL_OUT("Unknown option %c\n", c);
}
}
}
|
O0
|
c
|
get_options:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x3c283(%rip), %rdx # 0x502c7
callq 0x13110
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x14139
movl -0x14(%rbp), %eax
addl $-0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x36, %eax
ja 0x1411e
movq -0x20(%rbp), %rax
leaq 0x3bf93(%rip), %rcx # 0x50008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50f53(%rip), %rax # 0x64fd8
movq (%rax), %rax
movq %rax, 0x53521(%rip) # 0x675b0
jmp 0x14134
movq 0x50f3d(%rip), %rax # 0x64fd8
movq (%rax), %rax
movq %rax, 0x53513(%rip) # 0x675b8
jmp 0x14134
movq 0x50f27(%rip), %rax # 0x64fd8
movq (%rax), %rax
movq %rax, 0x53505(%rip) # 0x675c0
jmp 0x14134
movq 0x50f14(%rip), %rax # 0x64fd8
movq (%rax), %rax
movq %rax, 0x534fa(%rip) # 0x675c8
jmp 0x14134
movq 0x50f01(%rip), %rax # 0x64fd8
movq (%rax), %rdi
callq 0x136b0
movl %eax, 0x534eb(%rip) # 0x675d0
movl 0x534e5(%rip), %eax # 0x675d0
movl %eax, 0x534e3(%rip) # 0x675d4
jmp 0x14134
movq 0x50ede(%rip), %rax # 0x64fd8
movq (%rax), %rax
movq %rax, 0x534d4(%rip) # 0x675d8
jmp 0x14134
movl $0x1, 0x534d0(%rip) # 0x675e0
jmp 0x14134
callq 0x19250
xorl %edi, %edi
callq 0x13530
callq 0x19250
movl -0x14(%rbp), %esi
leaq 0x3c1ac(%rip), %rdi # 0x502d9
movb $0x0, %al
callq 0x19f30
jmp 0x14036
addq $0x20, %rsp
popq %rbp
retq
nop
|
get_options:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], 0
loc_14036:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
lea rdx, aHUPDWPST; "h:u:p:d:w:P:S:t:?"
call _getopt
mov [rbp+var_14], eax
cmp eax, 0
jl loc_14139
mov eax, [rbp+var_14]
add eax, 0FFFFFFC1h; switch 55 cases
mov ecx, eax
mov [rbp+var_20], rcx
sub eax, 36h
ja def_1407C; jumptable 000000000001407C default case, cases 64-79,81,82,84-99,101-103,105-111,113-115
mov rax, [rbp+var_20]
lea rcx, jpt_1407C
movsxd rax, ds:(jpt_1407C - 50008h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1407E:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 104
mov rax, [rax]
mov cs:hostname, rax
jmp loc_14134
loc_14094:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 117
mov rax, [rax]
mov cs:username, rax
jmp loc_14134
loc_140AA:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 112
mov rax, [rax]
mov cs:password, rax
jmp short loc_14134
loc_140BD:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 100
mov rax, [rax]
mov cs:schema, rax
jmp short loc_14134
loc_140D0:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 80
mov rdi, [rax]
call _atoi
mov cs:port, eax
mov eax, cs:port
mov cs:ssl_port, eax
jmp short loc_14134
loc_140F3:
mov rax, cs:optarg_ptr; jumptable 000000000001407C case 83
mov rax, [rax]
mov cs:socketname, rax
jmp short loc_14134
loc_14106:
mov cs:force_tls, 1; jumptable 000000000001407C case 116
jmp short loc_14134
loc_14112:
call usage; jumptable 000000000001407C case 63
xor edi, edi
call _exit
def_1407C:
call usage; jumptable 000000000001407C default case, cases 64-79,81,82,84-99,101-103,105-111,113-115
mov esi, [rbp+var_14]
lea rdi, aUnknownOptionC; "Unknown option %c\n"
mov al, 0
call BAIL_OUT
loc_14134:
jmp loc_14036
loc_14139:
add rsp, 20h
pop rbp
retn
|
long long get_options(unsigned int a1, long long a2)
{
long long result; // rax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
char v7; // [rsp+0h] [rbp-20h]
int v8; // [rsp+Ch] [rbp-14h]
while ( 1 )
{
result = getopt(a1, a2, "h:u:p:d:w:P:S:t:?");
v8 = result;
if ( (int)result < 0 )
break;
v7 = result - 63;
switch ( (int)result )
{
case '?':
usage(a1);
exit(0LL);
case 'P':
port = atoi(optarg);
ssl_port = port;
break;
case 'S':
socketname = optarg;
break;
case 'd':
schema = optarg;
break;
case 'h':
hostname = optarg;
break;
case 'p':
password = optarg;
break;
case 't':
force_tls = 1;
break;
case 'u':
username = optarg;
break;
default:
((void (*)(void))usage)();
BAIL_OUT((unsigned int)"Unknown option %c\n", v8, v3, v4, v5, v6, v7);
}
}
return result;
}
|
get_options:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],0x0
LAB_00114036:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x1502c7]
CALL 0x00113110
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JL 0x00114139
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,-0x3f
MOV ECX,EAX
MOV qword ptr [RBP + -0x20],RCX
SUB EAX,0x36
JA 0x0011411e
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x150008]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_68:
MOV RAX,qword ptr [0x00164fd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x001675b0],RAX
JMP 0x00114134
caseD_75:
MOV RAX,qword ptr [0x00164fd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x001675b8],RAX
JMP 0x00114134
caseD_70:
MOV RAX,qword ptr [0x00164fd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x001675c0],RAX
JMP 0x00114134
caseD_64:
MOV RAX,qword ptr [0x00164fd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x001675c8],RAX
JMP 0x00114134
caseD_50:
MOV RAX,qword ptr [0x00164fd8]
MOV RDI,qword ptr [RAX]
CALL 0x001136b0
MOV dword ptr [0x001675d0],EAX
MOV EAX,dword ptr [0x001675d0]
MOV dword ptr [0x001675d4],EAX
JMP 0x00114134
caseD_53:
MOV RAX,qword ptr [0x00164fd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x001675d8],RAX
JMP 0x00114134
caseD_74:
MOV dword ptr [0x001675e0],0x1
JMP 0x00114134
caseD_3f:
CALL 0x00119250
XOR EDI,EDI
CALL 0x00113530
caseD_40:
CALL 0x00119250
MOV ESI,dword ptr [RBP + -0x14]
LEA RDI,[0x1502d9]
MOV AL,0x0
CALL 0x00119f30
LAB_00114134:
JMP 0x00114036
LAB_00114139:
ADD RSP,0x20
POP RBP
RET
|
void get_options(int param_1,char **param_2)
{
int iVar1;
while (iVar1 = getopt(param_1,param_2,"h:u:p:d:w:P:S:t:?"), -1 < iVar1) {
switch(iVar1) {
case 0x3f:
usage();
/* WARNING: Subroutine does not return */
exit(0);
default:
usage();
BAIL_OUT("Unknown option %c\n",iVar1);
break;
case 0x50:
port = atoi(*(char **)PTR_optarg_00164fd8);
ssl_port = port;
break;
case 0x53:
socketname = *(int8 *)PTR_optarg_00164fd8;
break;
case 100:
schema = *(int8 *)PTR_optarg_00164fd8;
break;
case 0x68:
hostname = *(int8 *)PTR_optarg_00164fd8;
break;
case 0x70:
password = *(int8 *)PTR_optarg_00164fd8;
break;
case 0x74:
force_tls = 1;
break;
case 0x75:
username = *(int8 *)PTR_optarg_00164fd8;
}
}
return;
}
|
|
5,068 |
my_strnxfrm_unicode_full_bin
|
eloqsql/strings/ctype-utf8.c
|
size_t
my_strnxfrm_unicode_full_bin(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *dst0= dst;
uchar *de= dst + dstlen;
dst+= my_strnxfrm_unicode_full_bin_internal(cs, dst, de, &nweights,
src, src + srclen);
DBUG_ASSERT(dst <= de); /* Safety */
if (flags & MY_STRXFRM_PAD_WITH_SPACE)
{
for ( ; dst < de && nweights; nweights--)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
my_strxfrm_desc_and_reverse(dst0, dst, flags, 0);
if (flags & MY_STRXFRM_PAD_TO_MAXLEN)
{
while (dst < de)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
return dst - dst0;
}
|
O0
|
c
|
my_strnxfrm_unicode_full_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x28(%rbp), %r9
addq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x647a0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x64941
movl 0x10(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x649cb
jmp 0x6494e
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x64967
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x64970
jmp 0x649c9
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x649bc
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x649ba
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0x649bc
jmp 0x649be
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6494e
jmp 0x649cb
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0x45ca0
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x64a46
jmp 0x649ec
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x64a44
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x64a42
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x64a40
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0x64a42
jmp 0x649ec
jmp 0x64a46
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_strnxfrm_unicode_full_bin:
push rbp
mov rbp, rsp
sub rsp, 50h
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]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_40]
mov r8, [rbp+var_28]
mov r9, [rbp+var_28]
add r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_unicode_full_bin_internal
add rax, [rbp+var_10]
mov [rbp+var_10], rax
jmp short $+2
loc_64941:
mov eax, [rbp+arg_0]
and eax, 40h
cmp eax, 0
jz short loc_649CB
jmp short $+2
loc_6494E:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_64967
cmp [rbp+var_1C], 0
setnz al
mov [rbp+var_41], al
loc_64967:
mov al, [rbp+var_41]
test al, 1
jnz short loc_64970
jmp short loc_649C9
loc_64970:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_649BC
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_649BA
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 20h ; ' '
loc_649BA:
jmp short $+2
loc_649BC:
jmp short $+2
loc_649BE:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_6494E
loc_649C9:
jmp short $+2
loc_649CB:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+arg_0]
xor ecx, ecx
call my_strxfrm_desc_and_reverse
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_64A46
jmp short $+2
loc_649EC:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_64A44
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_64A42
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_64A40
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 20h ; ' '
loc_64A40:
jmp short $+2
loc_64A42:
jmp short loc_649EC
loc_64A44:
jmp short $+2
loc_64A46:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 50h
pop rbp
retn
|
unsigned long long my_strnxfrm_unicode_full_bin(
long long a1,
_BYTE *a2,
long long a3,
int a4,
long long a5,
long long a6,
unsigned int a7)
{
_BYTE *v7; // rax
_BYTE *v8; // rax
_BYTE *v9; // rax
_BYTE *v10; // rax
_BYTE *v11; // rax
_BYTE *v12; // rax
_BYTE *v13; // rax
bool v15; // [rsp+Fh] [rbp-41h]
unsigned long long v16; // [rsp+10h] [rbp-40h]
int v17; // [rsp+34h] [rbp-1Ch] BYREF
long long v18; // [rsp+38h] [rbp-18h]
unsigned long long v19; // [rsp+40h] [rbp-10h]
long long v20; // [rsp+48h] [rbp-8h]
v20 = a1;
v19 = (unsigned long long)a2;
v18 = a3;
v17 = a4;
v16 = (unsigned long long)&a2[a3];
v7 = my_strnxfrm_unicode_full_bin_internal(a1, a2, (unsigned long long)&a2[a3], &v17, a5, a6 + a5);
v19 += (unsigned long long)v7;
if ( (a7 & 0x40) != 0 )
{
while ( 1 )
{
v15 = 0;
if ( v19 < v16 )
v15 = v17 != 0;
if ( !v15 )
break;
v8 = (_BYTE *)v19++;
*v8 = 0;
if ( v19 < v16 )
{
v9 = (_BYTE *)v19++;
*v9 = 0;
if ( v19 < v16 )
{
v10 = (_BYTE *)v19++;
*v10 = 32;
}
}
--v17;
}
}
my_strxfrm_desc_and_reverse(a2, v19, a7, 0);
if ( (a7 & 0x80) != 0 )
{
while ( v19 < v16 )
{
v11 = (_BYTE *)v19++;
*v11 = 0;
if ( v19 < v16 )
{
v12 = (_BYTE *)v19++;
*v12 = 0;
if ( v19 < v16 )
{
v13 = (_BYTE *)v19++;
*v13 = 32;
}
}
}
}
return v19 - (_QWORD)a2;
}
|
my_strnxfrm_unicode_full_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x28]
ADD R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001647a0
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00164941
LAB_00164941:
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x40
CMP EAX,0x0
JZ 0x001649cb
JMP 0x0016494e
LAB_0016494e:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x00164967
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_00164967:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x00164970
JMP 0x001649c9
LAB_00164970:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001649bc
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001649ba
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x20
LAB_001649ba:
JMP 0x001649bc
LAB_001649bc:
JMP 0x001649be
LAB_001649be:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0016494e
LAB_001649c9:
JMP 0x001649cb
LAB_001649cb:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + 0x10]
XOR ECX,ECX
CALL 0x00145ca0
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00164a46
JMP 0x001649ec
LAB_001649ec:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00164a44
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00164a42
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00164a40
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x20
LAB_00164a40:
JMP 0x00164a42
LAB_00164a42:
JMP 0x001649ec
LAB_00164a44:
JMP 0x00164a46
LAB_00164a46:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x50
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin
(int8 param_1,long param_2,long param_3,int param_4,long param_5,long param_6,
uint param_7)
{
int1 *puVar1;
long lVar2;
int1 *puVar3;
int1 *puVar4;
int local_24;
long local_20;
int1 *local_18;
int8 local_10;
puVar1 = (int1 *)(param_2 + param_3);
local_24 = param_4;
local_20 = param_3;
local_18 = (int1 *)param_2;
local_10 = param_1;
lVar2 = my_strnxfrm_unicode_full_bin_internal
(param_1,param_2,puVar1,&local_24,param_5,param_5 + param_6);
local_18 = (int1 *)(lVar2 + (long)local_18);
if ((param_7 & 0x40) != 0) {
for (; local_18 < puVar1 && local_24 != 0; local_24 = local_24 + -1) {
puVar3 = local_18 + 1;
*local_18 = 0;
if (puVar3 < puVar1) {
puVar4 = local_18 + 2;
*puVar3 = 0;
puVar3 = puVar4;
if (puVar4 < puVar1) {
*puVar4 = 0x20;
puVar3 = local_18 + 3;
}
}
local_18 = puVar3;
}
}
my_strxfrm_desc_and_reverse(param_2,local_18,param_7,0);
puVar3 = local_18;
if ((param_7 & 0x80) != 0) {
while (local_18 = puVar3, local_18 < puVar1) {
puVar3 = local_18 + 1;
*local_18 = 0;
if (puVar3 < puVar1) {
puVar4 = local_18 + 2;
*puVar3 = 0;
puVar3 = puVar4;
if (puVar4 < puVar1) {
*puVar4 = 0x20;
puVar3 = local_18 + 3;
}
}
}
}
return (long)local_18 - param_2;
}
|
|
5,069 |
lre_is_in_table
|
bluesky950520[P]quickjs/libunicode.c
|
static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, b, bit;
int pos;
const uint8_t *p;
pos = get_index_pos(&code, c, index_table, index_table_len);
if (pos < 0)
return FALSE; /* outside the table */
p = table + pos;
bit = 0;
for(;;) {
b = *p++;
if (b < 64) {
code += (b >> 3) + 1;
if (c < code)
return bit;
bit ^= 1;
code += (b & 7) + 1;
} else if (b >= 0x80) {
code += b - 0x80 + 1;
} else if (b < 0x60) {
code += (((b - 0x40) << 8) | p[0]) + 1;
p++;
} else {
code += (((b - 0x60) << 16) | (p[0] << 8) | p[1]) + 1;
p += 2;
}
if (c < code)
return bit;
bit ^= 1;
}
}
|
O0
|
c
|
lre_is_in_table:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x30(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
leaq 0x18(%rsp), %rdi
callq 0x106410
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x103385
movl $0x0, 0x34(%rsp)
jmp 0x1034b8
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movl $0x0, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jae 0x103406
movl 0x14(%rsp), %eax
shrl $0x3, %eax
addl $0x1, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x1033e4
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1034b8
movl 0x10(%rsp), %eax
xorl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
addl $0x1, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x103494
cmpl $0x80, 0x14(%rsp)
jb 0x103426
movl 0x14(%rsp), %eax
subl $0x80, %eax
addl $0x1, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x103492
cmpl $0x60, 0x14(%rsp)
jae 0x103459
movl 0x14(%rsp), %eax
subl $0x40, %eax
shll $0x8, %eax
movq (%rsp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
addl $0x1, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x103490
movl 0x14(%rsp), %eax
subl $0x60, %eax
shll $0x10, %eax
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq (%rsp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
addl $0x1, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq (%rsp), %rax
addq $0x2, %rax
movq %rax, (%rsp)
jmp 0x103492
jmp 0x103494
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x1034a8
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1034b8
movl 0x10(%rsp), %eax
xorl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x10339e
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
lre_is_in_table:
sub rsp, 38h
mov [rsp+38h+var_8], edi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_1C], ecx
mov esi, [rsp+38h+var_8]
mov rdx, [rsp+38h+var_18]
mov ecx, [rsp+38h+var_1C]
lea rdi, [rsp+38h+var_20]
call get_index_pos
mov [rsp+38h+var_2C], eax
cmp [rsp+38h+var_2C], 0
jge short loc_103385
mov [rsp+38h+var_4], 0
jmp loc_1034B8
loc_103385:
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_2C]
add rax, rcx
mov [rsp+38h+var_38], rax
mov [rsp+38h+var_28], 0
loc_10339E:
mov rax, [rsp+38h+var_38]
mov rcx, rax
add rcx, 1
mov [rsp+38h+var_38], rcx
movzx eax, byte ptr [rax]
mov [rsp+38h+var_24], eax
cmp [rsp+38h+var_24], 40h ; '@'
jnb short loc_103406
mov eax, [rsp+38h+var_24]
shr eax, 3
add eax, 1
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
mov eax, [rsp+38h+var_8]
cmp eax, [rsp+38h+var_20]
jnb short loc_1033E4
mov eax, [rsp+38h+var_28]
mov [rsp+38h+var_4], eax
jmp loc_1034B8
loc_1033E4:
mov eax, [rsp+38h+var_28]
xor eax, 1
mov [rsp+38h+var_28], eax
mov eax, [rsp+38h+var_24]
and eax, 7
add eax, 1
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
jmp loc_103494
loc_103406:
cmp [rsp+38h+var_24], 80h
jb short loc_103426
mov eax, [rsp+38h+var_24]
sub eax, 80h
add eax, 1
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
jmp short loc_103492
loc_103426:
cmp [rsp+38h+var_24], 60h ; '`'
jnb short loc_103459
mov eax, [rsp+38h+var_24]
sub eax, 40h ; '@'
shl eax, 8
mov rcx, [rsp+38h+var_38]
movzx ecx, byte ptr [rcx]
or eax, ecx
add eax, 1
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
mov rax, [rsp+38h+var_38]
add rax, 1
mov [rsp+38h+var_38], rax
jmp short loc_103490
loc_103459:
mov eax, [rsp+38h+var_24]
sub eax, 60h ; '`'
shl eax, 10h
mov rcx, [rsp+38h+var_38]
movzx ecx, byte ptr [rcx]
shl ecx, 8
or eax, ecx
mov rcx, [rsp+38h+var_38]
movzx ecx, byte ptr [rcx+1]
or eax, ecx
add eax, 1
add eax, [rsp+38h+var_20]
mov [rsp+38h+var_20], eax
mov rax, [rsp+38h+var_38]
add rax, 2
mov [rsp+38h+var_38], rax
loc_103490:
jmp short $+2
loc_103492:
jmp short $+2
loc_103494:
mov eax, [rsp+38h+var_8]
cmp eax, [rsp+38h+var_20]
jnb short loc_1034A8
mov eax, [rsp+38h+var_28]
mov [rsp+38h+var_4], eax
jmp short loc_1034B8
loc_1034A8:
mov eax, [rsp+38h+var_28]
xor eax, 1
mov [rsp+38h+var_28], eax
jmp loc_10339E
loc_1034B8:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long lre_is_in_table(unsigned int a1, long long a2, long long a3, unsigned int a4)
{
unsigned __int8 *v4; // rax
unsigned __int8 *v6; // [rsp+0h] [rbp-38h]
int index_pos; // [rsp+Ch] [rbp-2Ch]
unsigned int i; // [rsp+10h] [rbp-28h]
unsigned int v9; // [rsp+14h] [rbp-24h]
_DWORD v10[2]; // [rsp+18h] [rbp-20h] BYREF
long long v11; // [rsp+20h] [rbp-18h]
long long v12; // [rsp+28h] [rbp-10h]
unsigned int v13; // [rsp+30h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10[1] = a4;
index_pos = get_index_pos(v10, a1, a3, a4);
if ( index_pos >= 0 )
{
v6 = (unsigned __int8 *)(index_pos + v12);
for ( i = 0; ; i ^= 1u )
{
v4 = v6++;
v9 = *v4;
if ( v9 >= 0x40 )
{
if ( v9 < 0x80 )
{
if ( v9 >= 0x60 )
{
v10[0] += (v6[1] | (*v6 << 8) | ((v9 - 96) << 16)) + 1;
v6 += 2;
}
else
{
v10[0] += (*v6++ | ((v9 - 64) << 8)) + 1;
}
}
else
{
v10[0] += v9 - 128 + 1;
}
}
else
{
v10[0] += (v9 >> 3) + 1;
if ( v13 < v10[0] )
return i;
i ^= 1u;
v10[0] += (v9 & 7) + 1;
}
if ( v13 < v10[0] )
break;
}
return i;
}
else
{
return 0;
}
}
| |||
5,070 |
lre_is_in_table
|
bluesky950520[P]quickjs/libunicode.c
|
static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, b, bit;
int pos;
const uint8_t *p;
pos = get_index_pos(&code, c, index_table, index_table_len);
if (pos < 0)
return FALSE; /* outside the table */
p = table + pos;
bit = 0;
for(;;) {
b = *p++;
if (b < 64) {
code += (b >> 3) + 1;
if (c < code)
return bit;
bit ^= 1;
code += (b & 7) + 1;
} else if (b >= 0x80) {
code += b - 0x80 + 1;
} else if (b < 0x60) {
code += (((b - 0x40) << 8) | p[0]) + 1;
p++;
} else {
code += (((b - 0x60) << 16) | (p[0] << 8) | p[1]) + 1;
p += 2;
}
if (c < code)
return bit;
bit ^= 1;
}
}
|
O1
|
c
|
lre_is_in_table:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x4(%rsp), %rdi
movl %ebx, %esi
callq 0x99943
testl %eax, %eax
js 0x97a02
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
movl 0x4(%rsp), %ecx
leaq 0x1(%r14), %rdx
movzbl (%r14), %esi
cmpl $0x3f, %esi
ja 0x979a1
movl %esi, %edi
shrl $0x3, %edi
addl %edi, %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
cmpl %ebx, %ecx
ja 0x97a04
xorl $0x1, %eax
andl $0x7, %esi
addl %esi, %ecx
incl %ecx
jmp 0x979cb
testb %sil, %sil
js 0x979c6
movzbl (%rdx), %edx
cmpb $0x5f, %sil
ja 0x979d1
shll $0x8, %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffffc001, %ecx # imm = 0xFFFFC001
movl %ecx, 0x4(%rsp)
addq $0x2, %r14
jmp 0x979f0
addl %esi, %ecx
addl $-0x7f, %ecx
movl %ecx, 0x4(%rsp)
jmp 0x979f3
shll $0x10, %esi
shll $0x8, %edx
orl %esi, %edx
movzbl 0x2(%r14), %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffa00001, %ecx # imm = 0xFFA00001
movl %ecx, 0x4(%rsp)
addq $0x3, %r14
movq %r14, %rdx
cmpl %ebx, %ecx
ja 0x97a04
xorl $0x1, %eax
movq %rdx, %r14
jmp 0x97977
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
lre_is_in_table:
push r14
push rbx
push rax
mov r14, rsi
mov ebx, edi
lea rdi, [rsp+18h+var_14]
mov esi, ebx
call get_index_pos
test eax, eax
js loc_97A02
mov eax, eax
add r14, rax
xor eax, eax
mov ecx, [rsp+18h+var_14]
loc_97977:
lea rdx, [r14+1]
movzx esi, byte ptr [r14]
cmp esi, 3Fh ; '?'
ja short loc_979A1
mov edi, esi
shr edi, 3
add ecx, edi
inc ecx
mov [rsp+18h+var_14], ecx
cmp ecx, ebx
ja short loc_97A04
xor eax, 1
and esi, 7
add ecx, esi
inc ecx
jmp short loc_979CB
loc_979A1:
test sil, sil
js short loc_979C6
movzx edx, byte ptr [rdx]
cmp sil, 5Fh ; '_'
ja short loc_979D1
shl esi, 8
or esi, edx
add ecx, esi
add ecx, 0FFFFC001h
mov [rsp+18h+var_14], ecx
add r14, 2
jmp short loc_979F0
loc_979C6:
add ecx, esi
add ecx, 0FFFFFF81h
loc_979CB:
mov [rsp+18h+var_14], ecx
jmp short loc_979F3
loc_979D1:
shl esi, 10h
shl edx, 8
or edx, esi
movzx esi, byte ptr [r14+2]
or esi, edx
add ecx, esi
add ecx, 0FFA00001h
mov [rsp+18h+var_14], ecx
add r14, 3
loc_979F0:
mov rdx, r14
loc_979F3:
cmp ecx, ebx
ja short loc_97A04
xor eax, 1
mov r14, rdx
jmp loc_97977
loc_97A02:
xor eax, eax
loc_97A04:
add rsp, 8
pop rbx
pop r14
retn
|
long long lre_is_in_table(unsigned int a1, long long a2)
{
long long v2; // rax
int index_pos; // eax
unsigned __int8 *v4; // r14
long long result; // rax
unsigned int v6; // ecx
unsigned __int8 *v7; // rdx
unsigned int v8; // esi
unsigned int v9; // ecx
int v10; // edx
unsigned __int8 *v11; // r14
unsigned int v12[5]; // [rsp+0h] [rbp-14h] BYREF
v12[0] = HIDWORD(v2);
index_pos = get_index_pos(v12, a1);
if ( index_pos >= 0 )
{
v4 = (unsigned __int8 *)((unsigned int)index_pos + a2);
result = 0LL;
v6 = v12[0];
while ( 1 )
{
v7 = v4 + 1;
v8 = *v4;
if ( v8 <= 0x3F )
break;
if ( (v8 & 0x80u) != 0 )
{
v6 = v8 + v6 - 127;
LABEL_10:
v12[0] = v6;
goto LABEL_13;
}
v10 = *v7;
if ( (unsigned __int8)v8 > 0x5Fu )
{
v6 = ((v8 << 16) | (v10 << 8) | v4[2]) + v6 - 6291455;
v12[0] = v6;
v11 = v4 + 3;
}
else
{
v6 = (v10 | (v8 << 8)) + v6 - 0x3FFF;
v12[0] = v6;
v11 = v4 + 2;
}
v7 = v11;
LABEL_13:
if ( v6 > a1 )
return result;
result = (unsigned int)result ^ 1;
v4 = v7;
}
v9 = (v8 >> 3) + v6 + 1;
v12[0] = v9;
if ( v9 > a1 )
return result;
result = (unsigned int)result ^ 1;
v6 = (v8 & 7) + v9 + 1;
goto LABEL_10;
}
return 0LL;
}
|
lre_is_in_table:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV EBX,EDI
LEA RDI,[RSP + 0x4]
MOV ESI,EBX
CALL 0x00199943
TEST EAX,EAX
JS 0x00197a02
MOV EAX,EAX
ADD R14,RAX
XOR EAX,EAX
MOV ECX,dword ptr [RSP + 0x4]
LAB_00197977:
LEA RDX,[R14 + 0x1]
MOVZX ESI,byte ptr [R14]
CMP ESI,0x3f
JA 0x001979a1
MOV EDI,ESI
SHR EDI,0x3
ADD ECX,EDI
INC ECX
MOV dword ptr [RSP + 0x4],ECX
CMP ECX,EBX
JA 0x00197a04
XOR EAX,0x1
AND ESI,0x7
ADD ECX,ESI
INC ECX
JMP 0x001979cb
LAB_001979a1:
TEST SIL,SIL
JS 0x001979c6
MOVZX EDX,byte ptr [RDX]
CMP SIL,0x5f
JA 0x001979d1
SHL ESI,0x8
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffffc001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x2
JMP 0x001979f0
LAB_001979c6:
ADD ECX,ESI
ADD ECX,-0x7f
LAB_001979cb:
MOV dword ptr [RSP + 0x4],ECX
JMP 0x001979f3
LAB_001979d1:
SHL ESI,0x10
SHL EDX,0x8
OR EDX,ESI
MOVZX ESI,byte ptr [R14 + 0x2]
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffa00001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x3
LAB_001979f0:
MOV RDX,R14
LAB_001979f3:
CMP ECX,EBX
JA 0x00197a04
XOR EAX,0x1
MOV R14,RDX
JMP 0x00197977
LAB_00197a02:
XOR EAX,EAX
LAB_00197a04:
ADD RSP,0x8
POP RBX
POP R14
RET
|
uint lre_is_in_table(uint param_1,long param_2)
{
byte bVar1;
uint uVar2;
uint uVar3;
int8 in_RAX;
byte *pbVar4;
byte *pbVar5;
uint local_14;
local_14 = (uint)((ulong)in_RAX >> 0x20);
uVar2 = get_index_pos(&local_14,param_1);
if ((int)uVar2 < 0) {
return 0;
}
uVar3 = 0;
pbVar4 = (byte *)(param_2 + (ulong)uVar2);
while( true ) {
pbVar5 = pbVar4 + 1;
bVar1 = *pbVar4;
if (bVar1 < 0x40) {
uVar2 = local_14 + (bVar1 >> 3) + 1;
if (param_1 < uVar2) {
return uVar3;
}
uVar3 = uVar3 ^ 1;
local_14 = uVar2 + (bVar1 & 7) + 1;
}
else if ((char)bVar1 < '\0') {
local_14 = (local_14 + bVar1) - 0x7f;
}
else if (bVar1 < 0x60) {
local_14 = (local_14 + CONCAT11(bVar1,*pbVar5)) - 0x3fff;
pbVar5 = pbVar4 + 2;
}
else {
local_14 = (local_14 + ((uint)pbVar4[2] | (uint)*pbVar5 << 8 | (uint)bVar1 << 0x10)) -
0x5fffff;
pbVar5 = pbVar4 + 3;
}
if (param_1 < local_14) break;
uVar3 = uVar3 ^ 1;
pbVar4 = pbVar5;
}
return uVar3;
}
|
|
5,071 |
my_convert_fix
|
eloqsql/strings/ctype.c
|
size_t
my_convert_fix(CHARSET_INFO *to_cs, char *to, size_t to_length,
CHARSET_INFO *from_cs, const char *from, size_t from_length,
size_t nchars,
MY_STRCOPY_STATUS *copy_status,
MY_STRCONV_STATUS *conv_status)
{
int cnvres;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
const uchar *from_end= (const uchar*) from + from_length;
uchar *to_end= (uchar*) to + to_length;
char *to_start= to;
DBUG_ASSERT(to_cs != &my_charset_bin);
DBUG_ASSERT(from_cs != &my_charset_bin);
copy_status->m_well_formed_error_pos= NULL;
conv_status->m_cannot_convert_error_pos= NULL;
for ( ; nchars; nchars--)
{
const char *from_prev= from;
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
if (!copy_status->m_well_formed_error_pos)
copy_status->m_well_formed_error_pos= from;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
if (!conv_status->m_cannot_convert_error_pos)
conv_status->m_cannot_convert_error_pos= from;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; // End of line
// Incomplete byte sequence
if (!copy_status->m_well_formed_error_pos)
copy_status->m_well_formed_error_pos= from;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
if (!conv_status->m_cannot_convert_error_pos)
conv_status->m_cannot_convert_error_pos= from_prev;
wc= '?';
goto outp;
}
else
{
from= from_prev;
break;
}
}
copy_status->m_source_end_pos= from;
return to - to_start;
}
|
O0
|
c
|
my_convert_fix:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xd7984
jmp 0xd7986
jmp 0xd7988
movq 0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x10(%rbp)
je 0xd7b0b
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xd79e6
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xd7a8f
cmpl $0x0, -0x34(%rbp)
jne 0xd7a19
movq 0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd7a03
movq -0x28(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xd7a8d
cmpl $-0x65, -0x34(%rbp)
jle 0xd7a51
movq 0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd7a34
movq -0x28(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xd7a8b
movq -0x28(%rbp), %rax
cmpq -0x58(%rbp), %rax
jb 0xd7a60
jmp 0xd7b0b
movq 0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd7a77
movq -0x28(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0xd7a8d
jmp 0xd7a8f
jmp 0xd7a91
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xd7ac2
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xd7af8
cmpl $0x0, -0x34(%rbp)
jne 0xd7aee
cmpq $0x3f, -0x40(%rbp)
je 0xd7aee
movq 0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd7ae4
movq -0x70(%rbp), %rcx
movq 0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x3f, -0x40(%rbp)
jmp 0xd7a91
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xd7b0b
jmp 0xd7afa
movq 0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rbp)
jmp 0xd799f
movq -0x28(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
subq %rcx, %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_convert_fix:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
jmp short $+2
loc_D7984:
jmp short $+2
loc_D7986:
jmp short $+2
loc_D7988:
mov rax, [rbp+arg_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+arg_10]
mov qword ptr [rax], 0
loc_D799F:
cmp [rbp+arg_0], 0
jz loc_D7B0B
mov rax, [rbp+var_28]
mov [rbp+var_70], rax
mov rax, [rbp+var_48]
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_58]
lea rsi, [rbp+var_40]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_D79E6
mov ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_D7A8F
loc_D79E6:
cmp [rbp+var_34], 0
jnz short loc_D7A19
mov rax, [rbp+arg_8]
cmp qword ptr [rax+8], 0
jnz short loc_D7A03
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_8]
mov [rax+8], rcx
loc_D7A03:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_D7A8D
loc_D7A19:
cmp [rbp+var_34], 0FFFFFF9Bh
jle short loc_D7A51
mov rax, [rbp+arg_10]
cmp qword ptr [rax], 0
jnz short loc_D7A34
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_10]
mov [rax], rcx
loc_D7A34:
xor ecx, ecx
sub ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_D7A8B
loc_D7A51:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_58]
jb short loc_D7A60
jmp loc_D7B0B
loc_D7A60:
mov rax, [rbp+arg_8]
cmp qword ptr [rax+8], 0
jnz short loc_D7A77
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_8]
mov [rax+8], rcx
loc_D7A77:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
loc_D7A8B:
jmp short $+2
loc_D7A8D:
jmp short $+2
loc_D7A8F:
jmp short $+2
loc_D7A91:
mov rax, [rbp+var_50]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_60]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_D7AC2
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_D7AF8
loc_D7AC2:
cmp [rbp+var_34], 0
jnz short loc_D7AEE
cmp [rbp+var_40], 3Fh ; '?'
jz short loc_D7AEE
mov rax, [rbp+arg_10]
cmp qword ptr [rax], 0
jnz short loc_D7AE4
mov rcx, [rbp+var_70]
mov rax, [rbp+arg_10]
mov [rax], rcx
loc_D7AE4:
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_D7A91
loc_D7AEE:
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
jmp short loc_D7B0B
loc_D7AF8:
jmp short $+2
loc_D7AFA:
mov rax, [rbp+arg_0]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+arg_0], rax
jmp loc_D799F
loc_D7B0B:
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_8]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rbp+var_68]
sub rax, rcx
add rsp, 70h
pop rbp
retn
|
long long my_convert_fix(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
long long a6,
long long a7,
unsigned long long *a8,
unsigned long long *a9)
{
unsigned long long v10; // [rsp+0h] [rbp-70h]
long long v11; // [rsp+10h] [rbp-60h]
unsigned long long v12; // [rsp+18h] [rbp-58h]
long long ( *v13)(long long, long long, long long, long long); // [rsp+20h] [rbp-50h]
long long ( *v14)(long long, long long *, unsigned long long, unsigned long long); // [rsp+28h] [rbp-48h]
long long i; // [rsp+30h] [rbp-40h] BYREF
int v16; // [rsp+3Ch] [rbp-34h]
long long v17; // [rsp+40h] [rbp-30h]
unsigned long long v18; // [rsp+48h] [rbp-28h]
long long v19; // [rsp+50h] [rbp-20h]
long long v20; // [rsp+58h] [rbp-18h]
long long v21; // [rsp+60h] [rbp-10h]
long long v22; // [rsp+68h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v14 = *(long long ( **)(long long, long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a4 + 184) + 40LL);
v13 = *(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL);
v12 = a6 + a5;
v11 = a3 + a2;
a8[1] = 0LL;
*a9 = 0LL;
LABEL_2:
if ( a7 )
{
v10 = v18;
v16 = v14(v19, &i, v18, v12);
if ( v16 > 0 )
{
v18 += v16;
goto LABEL_17;
}
if ( !v16 )
{
if ( !a8[1] )
a8[1] = v18;
++v18;
i = 63LL;
goto LABEL_17;
}
if ( v16 > -101 )
{
if ( !*a9 )
*a9 = v18;
v18 += -v16;
i = 63LL;
goto LABEL_17;
}
if ( v18 < v12 )
{
if ( !a8[1] )
a8[1] = v18;
++v18;
for ( i = 63LL; ; i = 63LL )
{
LABEL_17:
v16 = v13(v22, i, v21, v11);
if ( v16 > 0 )
{
v21 += v16;
--a7;
goto LABEL_2;
}
if ( v16 || i == 63 )
break;
if ( !*a9 )
*a9 = v10;
}
v18 = v10;
}
}
*a8 = v18;
return v21 - a2;
}
|
my_convert_fix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001d7984
LAB_001d7984:
JMP 0x001d7986
LAB_001d7986:
JMP 0x001d7988
LAB_001d7988:
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + 0x20]
MOV qword ptr [RAX],0x0
LAB_001d799f:
CMP qword ptr [RBP + 0x10],0x0
JZ 0x001d7b0b
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001d79e6
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001d7a8f
LAB_001d79e6:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001d7a19
MOV RAX,qword ptr [RBP + 0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x001d7a03
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RAX + 0x8],RCX
LAB_001d7a03:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001d7a8d
LAB_001d7a19:
CMP dword ptr [RBP + -0x34],-0x65
JLE 0x001d7a51
MOV RAX,qword ptr [RBP + 0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001d7a34
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV qword ptr [RAX],RCX
LAB_001d7a34:
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001d7a8b
LAB_001d7a51:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x58]
JC 0x001d7a60
JMP 0x001d7b0b
LAB_001d7a60:
MOV RAX,qword ptr [RBP + 0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x001d7a77
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RAX + 0x8],RCX
LAB_001d7a77:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
LAB_001d7a8b:
JMP 0x001d7a8d
LAB_001d7a8d:
JMP 0x001d7a8f
LAB_001d7a8f:
JMP 0x001d7a91
LAB_001d7a91:
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x60]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001d7ac2
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001d7af8
LAB_001d7ac2:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001d7aee
CMP qword ptr [RBP + -0x40],0x3f
JZ 0x001d7aee
MOV RAX,qword ptr [RBP + 0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001d7ae4
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + 0x20]
MOV qword ptr [RAX],RCX
LAB_001d7ae4:
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x001d7a91
LAB_001d7aee:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001d7b0b
LAB_001d7af8:
JMP 0x001d7afa
LAB_001d7afa:
MOV RAX,qword ptr [RBP + 0x10]
ADD RAX,-0x1
MOV qword ptr [RBP + 0x10],RAX
JMP 0x001d799f
LAB_001d7b0b:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
ADD RSP,0x70
POP RBP
RET
|
long my_convert_fix(long param_1,long param_2,long param_3,long param_4,ulong param_5,long param_6,
long param_7,ulong *param_8,ulong *param_9)
{
code *pcVar1;
code *pcVar2;
ulong uVar3;
ulong uVar4;
long local_48;
int local_3c;
long local_38;
ulong local_30;
long local_28;
long local_20;
long local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_4 + 0xb8) + 0x28);
pcVar2 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
param_8[1] = 0;
*param_9 = 0;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
for (; uVar3 = local_30, uVar4 = uVar3, param_7 != 0; param_7 = param_7 + -1) {
local_3c = (*pcVar1)(local_28,&local_48,local_30);
if (local_3c < 1) {
if (local_3c == 0) {
if (param_8[1] == 0) {
param_8[1] = local_30;
}
local_30 = local_30 + 1;
}
else if (local_3c < -100) {
uVar4 = local_30;
if (param_5 + param_6 <= local_30) break;
if (param_8[1] == 0) {
param_8[1] = local_30;
}
local_30 = local_30 + 1;
}
else {
if (*param_9 == 0) {
*param_9 = local_30;
}
local_30 = local_30 + (long)-local_3c;
}
local_48 = 0x3f;
}
else {
local_30 = local_30 + (long)local_3c;
}
while (local_3c = (*pcVar2)(local_10,local_48,local_18,param_2 + param_3), local_3c < 1) {
uVar4 = uVar3;
if ((local_3c != 0) || (local_48 == 0x3f)) goto LAB_001d7b0b;
if (*param_9 == 0) {
*param_9 = uVar3;
}
local_48 = 0x3f;
local_3c = 0;
}
local_18 = local_18 + local_3c;
}
LAB_001d7b0b:
local_30 = uVar4;
*param_8 = local_30;
return local_18 - param_2;
}
|
|
5,072 |
my_mb_wc_gb2312
|
eloqsql/strings/ctype-gb2312.c
|
static int
my_mb_wc_gb2312(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gb2312_uni_onechar(((hi<<8)+s[1])&0x7F7F)))
return -2;
return 2;
}
|
O3
|
c
|
my_mb_wc_gb2312:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb0b50
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0xb0b2c
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xb0b50
leal 0x5f(%rdi), %ecx
xorl %eax, %eax
cmpb $0x56, %cl
ja 0xb0b50
movzbl 0x1(%rdx), %ecx
leal 0x1(%rcx), %edx
cmpb $-0x5e, %dl
jae 0xb0b51
retq
pushq %rbp
movq %rsp, %rbp
movzbl %dil, %eax
shll $0x8, %eax
orl %ecx, %eax
andl $0x7f7f, %eax # imm = 0x7F7F
leal -0x2121(%rax), %ecx
cmpl $0x537, %ecx # imm = 0x537
ja 0xb0b7c
movl %ecx, %eax
leaq 0x136d16(%rip), %rcx # 0x1e7890
jmp 0xb0baa
leal -0x2721(%rax), %ecx
cmpl $0x24e, %ecx # imm = 0x24E
ja 0xb0b95
movl %ecx, %eax
leaq 0x13776d(%rip), %rcx # 0x1e8300
jmp 0xb0baa
addl $0xffffcfdf, %eax # imm = 0xFFFFCFDF
cmpl $0x475e, %eax # imm = 0x475E
jae 0xb0bc3
movl %eax, %eax
leaq 0x137bf6(%rip), %rcx # 0x1e87a0
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0xb0bcf
jmp 0xb0bca
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
|
my_mb_wc_gb2312:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_B0B50
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_B0B2C
mov [rsi], rdi
mov eax, 1
retn
loc_B0B2C:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_B0B50
lea ecx, [rdi+5Fh]
xor eax, eax
cmp cl, 56h ; 'V'
ja short locret_B0B50
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+1]
cmp dl, 0A2h
jnb short loc_B0B51
locret_B0B50:
retn
loc_B0B51:
push rbp
mov rbp, rsp
movzx eax, dil
shl eax, 8
or eax, ecx
and eax, 7F7Fh
lea ecx, [rax-2121h]
cmp ecx, 537h
ja short loc_B0B7C
mov eax, ecx
lea rcx, tab_gb2312_uni0
jmp short loc_B0BAA
loc_B0B7C:
lea ecx, [rax-2721h]
cmp ecx, 24Eh
ja short loc_B0B95
mov eax, ecx
lea rcx, tab_gb2312_uni1
jmp short loc_B0BAA
loc_B0B95:
add eax, 0FFFFCFDFh
cmp eax, 475Eh
jnb short loc_B0BC3
mov eax, eax
lea rcx, tab_gb2312_uni2
loc_B0BAA:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_B0BCF
jmp short loc_B0BCA
loc_B0BC3:
mov qword ptr [rsi], 0
loc_B0BCA:
mov eax, 0FFFFFFFEh
loc_B0BCF:
pop rbp
retn
|
long long my_mb_wc_gb2312(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
unsigned __int16 v6; // cx
int v7; // eax
long long v8; // rax
unsigned __int16 *v9; // rcx
long long v10; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)(v5 + 95) <= 0x56u )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) >= 0xA2u )
{
v7 = (v6 | (unsigned __int16)((unsigned __int8)v5 << 8)) & 0x7F7F;
if ( (unsigned int)(v7 - 8481) > 0x537 )
{
if ( (unsigned int)(v7 - 10017) > 0x24E )
{
LODWORD(v8) = v7 - 12321;
if ( (unsigned int)v8 >= 0x475E )
{
*a2 = 0LL;
return 4294967294LL;
}
v8 = (unsigned int)v8;
v9 = (unsigned __int16 *)&tab_gb2312_uni2;
}
else
{
v8 = (unsigned int)(v7 - 10017);
v9 = (unsigned __int16 *)&tab_gb2312_uni1;
}
}
else
{
v8 = (unsigned int)(v7 - 8481);
v9 = (unsigned __int16 *)&tab_gb2312_uni0;
}
v10 = v9[v8];
*a2 = v10;
result = 2LL;
if ( (_WORD)v10 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
|
my_mb_wc_gb2312:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b0b50
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x001b0b2c
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_001b0b2c:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001b0b50
LEA ECX,[RDI + 0x5f]
XOR EAX,EAX
CMP CL,0x56
JA 0x001b0b50
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x1]
CMP DL,0xa2
JNC 0x001b0b51
LAB_001b0b50:
RET
LAB_001b0b51:
PUSH RBP
MOV RBP,RSP
MOVZX EAX,DIL
SHL EAX,0x8
OR EAX,ECX
AND EAX,0x7f7f
LEA ECX,[RAX + -0x2121]
CMP ECX,0x537
JA 0x001b0b7c
MOV EAX,ECX
LEA RCX,[0x2e7890]
JMP 0x001b0baa
LAB_001b0b7c:
LEA ECX,[RAX + -0x2721]
CMP ECX,0x24e
JA 0x001b0b95
MOV EAX,ECX
LEA RCX,[0x2e8300]
JMP 0x001b0baa
LAB_001b0b95:
ADD EAX,0xffffcfdf
CMP EAX,0x475e
JNC 0x001b0bc3
MOV EAX,EAX
LEA RCX,[0x2e87a0]
LAB_001b0baa:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x001b0bcf
JMP 0x001b0bca
LAB_001b0bc3:
MOV qword ptr [RSI],0x0
LAB_001b0bca:
MOV EAX,0xfffffffe
LAB_001b0bcf:
POP RBP
RET
|
int8 my_mb_wc_gb2312(int8 param_1,ulong *param_2,char *param_3,char *param_4)
{
char cVar1;
ushort uVar2;
uint uVar3;
ulong uVar4;
int1 *puVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
cVar1 = *param_3;
if (-1 < (long)cVar1) {
*param_2 = (long)cVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if ((byte)(cVar1 + 0x5fU) < 0x57) {
if ((byte)(param_3[1] + 1U) < 0xa2) {
return 0;
}
uVar3 = CONCAT11(cVar1,param_3[1]) & 0x7f7f;
if (uVar3 - 0x2121 < 0x538) {
uVar4 = (ulong)(uVar3 - 0x2121);
puVar5 = tab_gb2312_uni0;
}
else if (uVar3 - 0x2721 < 0x24f) {
uVar4 = (ulong)(uVar3 - 0x2721);
puVar5 = tab_gb2312_uni1;
}
else {
if (0x475d < uVar3 - 0x3021) {
*param_2 = 0;
return 0xfffffffe;
}
uVar4 = (ulong)(uVar3 - 0x3021);
puVar5 = tab_gb2312_uni2;
}
uVar2 = *(ushort *)(puVar5 + uVar4 * 2);
*param_2 = (ulong)uVar2;
if (uVar2 == 0) {
return 0xfffffffe;
}
return 2;
}
return 0;
}
|
|
5,073 |
void nlohmann::json_abi_v3_12_0::detail::external_constructor<(nlohmann::json_abi_v3_12_0::detail::value_t)1>::construct<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>, 0>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>> const&)
|
shubhamoy[P]dir2txt/include/nlohmann/json.hpp
|
static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
{
using std::begin;
using std::end;
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::object;
j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
j.set_parents();
j.assert_invariant();
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_12_0::detail::external_constructor<(nlohmann::json_abi_v3_12_0::detail::value_t)1>::construct<nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>, 0>(nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::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_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_12_0::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>> const&):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x2b860
movb $0x1, (%r14)
movq 0x18(%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x2ec52
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x2a79a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
_ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE1EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEESt3mapISE_NS6_ISJ_S8_SE_blmdSaSF_SH_vEESt4lessIvESaISt4pairIKSE_SK_EEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_8object_tEEE5valueEiE4typeELi0EEEvRSU_RKST_:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
add rdi, 8
movzx esi, byte ptr [r14]
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_12_0::detail::value_t)
mov byte ptr [r14], 1
mov rax, [rbx+18h]
lea rdi, [rsp+28h+var_18]
mov [rdi], rax
add rbx, 8
lea rsi, [rsp+28h+var_20]
mov [rsi], rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJSt23_Rb_tree_const_iteratorISH_ISI_NS1_ISt3mapS3_S9_blmdSaSA_SC_vEEEESQ_EEEPT_DpOT0_; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::create<nlohmann::json_abi_v3_12_0::ordered_map<std::string,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>,std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>>(std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>> &&)
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 18h
pop rbx
pop r14
retn
|
long long ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE1EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEESt3mapISE_NS6_ISJ_S8_SE_blmdSaSF_SH_vEESt4lessIvESaISt4pairIKSE_SK_EEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_8object_tEEE5valueEiE4typeELi0EEEvRSU_RKST_(
unsigned __int8 *a1)
{
long long result; // rax
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(void ***)a1 + 1,
*a1);
*a1 = 1;
result = nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::create<nlohmann::json_abi_v3_12_0::ordered_map<std::string,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>,std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>,std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>>>>();
*((_QWORD *)a1 + 1) = result;
nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
|
_ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE1EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEESt3mapISE_NS6_ISJ_S8_SE_blmdSaSF_SH_vEESt4lessIvESaISt4pairIKSE_SK_EEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_8object_tEEE5valueEiE4typeELi0EEEvRSU_RKST_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
ADD RDI,0x8
MOVZX ESI,byte ptr [R14]
CALL 0x0012b860
MOV byte ptr [R14],0x1
MOV RAX,qword ptr [RBX + 0x18]
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],RAX
ADD RBX,0x8
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RBX
CALL 0x0012ec52
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0012a79a
ADD RSP,0x18
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE1EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEESt3mapISE_NS6_ISJ_S8_SE_blmdSaSF_SH_vEESt4lessIvESaISt4pairIKSE_SK_EEETnNSt9enable_ifIXntsr3std7is_sameIT0_NT_8object_tEEE5valueEiE4typeELi0EEEvRSU_RKST_
(int1 *param_1,long param_2)
{
ordered_map *poVar1;
long local_20;
int8 local_18;
nlohmann::json_abi_v3_12_0::
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*param_1 = 1;
local_18 = *(int8 *)(param_2 + 0x18);
local_20 = param_2 + 8;
poVar1 = nlohmann::json_abi_v3_12_0::
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
create<nlohmann::json_abi_v3_12_0::ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,std::_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
((_Rb_tree_const_iterator *)&local_18,(_Rb_tree_const_iterator *)&local_20);
*(ordered_map **)(param_1 + 8) = poVar1;
nlohmann::json_abi_v3_12_0::
basic_json<nlohmann::json_abi_v3_12_0::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return;
}
|
|
5,074 |
js_os_clearTimeout
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_clearTimeout(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSOSTimer *th;
int64_t timer_id;
if (JS_ToInt64(ctx, &timer_id, argv[0]))
return JS_EXCEPTION;
th = find_timer_by_id(ts, timer_id);
if (!th)
return JS_UNDEFINED;
free_timer(rt, th);
return JS_UNDEFINED;
}
|
O0
|
c
|
js_os_clearTimeout:
subq $0x58, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x27f00
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x115d0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rsp, %rsi
callq 0x38bf0
cmpl $0x0, %eax
je 0x1954b
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x1959b
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movl %eax, %esi
callq 0x1ce60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1957b
movl $0x0, 0x48(%rsp)
movq $0x3, 0x50(%rsp)
jmp 0x1959b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x116b0
movl $0x0, 0x48(%rsp)
movq $0x3, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw (%rax,%rax)
|
js_os_clearTimeout:
sub rsp, 58h
mov [rsp+58h+var_20], rsi
mov [rsp+58h+var_18], rdx
mov [rsp+58h+var_28], rdi
mov [rsp+58h+var_2C], ecx
mov [rsp+58h+var_38], r8
mov rdi, [rsp+58h+var_28]
call JS_GetRuntime
mov [rsp+58h+var_40], rax
mov rdi, [rsp+58h+var_40]
call js_get_thread_state
mov [rsp+58h+var_48], rax
mov rdi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
mov rsi, rsp
call JS_ToInt64
cmp eax, 0
jz short loc_1954B
mov dword ptr [rsp+58h+var_10], 0
mov [rsp+58h+var_8], 6
jmp short loc_1959B
loc_1954B:
mov rdi, [rsp+58h+var_48]
mov rax, [rsp+58h+var_58]
mov esi, eax
call find_timer_by_id
mov [rsp+58h+var_50], rax
cmp [rsp+58h+var_50], 0
jnz short loc_1957B
mov dword ptr [rsp+58h+var_10], 0
mov [rsp+58h+var_8], 3
jmp short loc_1959B
loc_1957B:
mov rdi, [rsp+58h+var_40]
mov rsi, [rsp+58h+var_50]
call free_timer
mov dword ptr [rsp+58h+var_10], 0
mov [rsp+58h+var_8], 3
loc_1959B:
mov rax, [rsp+58h+var_10]
mov rdx, [rsp+58h+var_8]
add rsp, 58h
retn
|
long long js_os_clearTimeout(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long v10; // [rsp+0h] [rbp-58h] BYREF
long long timer_by_id; // [rsp+8h] [rbp-50h]
long long thread_state; // [rsp+10h] [rbp-48h]
long long Runtime; // [rsp+18h] [rbp-40h]
_QWORD *v14; // [rsp+20h] [rbp-38h]
int v15; // [rsp+2Ch] [rbp-2Ch]
long long v16; // [rsp+30h] [rbp-28h]
long long v17; // [rsp+38h] [rbp-20h]
long long v18; // [rsp+40h] [rbp-18h]
long long v19; // [rsp+48h] [rbp-10h]
long long v20; // [rsp+50h] [rbp-8h]
v17 = a2;
v18 = a3;
v16 = a1;
v15 = a4;
v14 = a5;
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v5, v6, v7, v8);
if ( (unsigned int)JS_ToInt64(a1, &v10, *v14, v14[1]) )
{
LODWORD(v19) = 0;
v20 = 6LL;
}
else
{
timer_by_id = find_timer_by_id(thread_state, (unsigned int)v10);
if ( timer_by_id )
free_timer(Runtime, timer_by_id);
LODWORD(v19) = 0;
v20 = 3LL;
}
return v19;
}
|
js_os_clearTimeout:
SUB RSP,0x58
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ECX
MOV qword ptr [RSP + 0x20],R8
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00127f00
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001115d0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
MOV RSI,RSP
CALL 0x00138bf0
CMP EAX,0x0
JZ 0x0011954b
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x0011959b
LAB_0011954b:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP]
MOV ESI,EAX
CALL 0x0011ce60
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0011957b
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x3
JMP 0x0011959b
LAB_0011957b:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001116b0
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x3
LAB_0011959b:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RSP,0x58
RET
|
int1 [16]
js_os_clearTimeout(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int1 auVar1 [16];
int iVar2;
ulong local_58;
long local_50;
int8 local_48;
int8 local_40;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_40 = JS_GetRuntime(param_1);
local_48 = js_get_thread_state(local_40);
iVar2 = JS_ToInt64(local_28,&local_58,*local_38,local_38[1]);
if (iVar2 == 0) {
local_50 = find_timer_by_id(local_48,local_58 & 0xffffffff);
if (local_50 == 0) {
local_8 = 3;
}
else {
free_timer(local_40,local_50);
local_8 = 3;
}
}
else {
local_8 = 6;
}
auVar1._4_8_ = local_8;
auVar1._0_4_ = uStack_c;
auVar1._12_4_ = 0;
return auVar1 << 0x20;
}
|
|
5,075 |
js_os_clearTimeout
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_os_clearTimeout(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSOSTimer *th;
int64_t timer_id;
if (JS_ToInt64(ctx, &timer_id, argv[0]))
return JS_EXCEPTION;
th = find_timer_by_id(ts, timer_id);
if (!th)
return JS_UNDEFINED;
free_timer(rt, th);
return JS_UNDEFINED;
}
|
O2
|
c
|
js_os_clearTimeout:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdi, %r12
callq 0x1a185
movq %rax, %rbx
movq %rax, %rdi
callq 0x1028a
movq %rax, %r15
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rsp, %rsi
movq %r12, %rdi
callq 0x214fe
testl %eax, %eax
je 0x13fa6
pushq $0x6
popq %r14
xorl %eax, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rsp), %rax
pushq $0x3
popq %r14
testl %eax, %eax
jle 0x13f95
leaq 0x20(%r15), %rcx
addq $0x28, %r15
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq (%r15), %r15
cmpq %rcx, %r15
je 0x13f95
cmpq %rax, 0x10(%r15)
je 0x13fd3
addq $0x8, %r15
jmp 0x13fbf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10323
jmp 0x13f95
|
js_os_clearTimeout:
push r15
push r14
push r12
push rbx
push rax
mov r14, r8
mov r12, rdi
call JS_GetRuntime
mov rbx, rax
mov rdi, rax
call js_get_thread_state
mov r15, rax
mov rdx, [r14]
mov rcx, [r14+8]
mov rsi, rsp
mov rdi, r12
call JS_ToInt64
test eax, eax
jz short loc_13FA6
push 6
pop r14
loc_13F95:
xor eax, eax
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_13FA6:
mov rax, [rsp+28h+var_28]
push 3
pop r14
test eax, eax
jle short loc_13F95
lea rcx, [r15+20h]
add r15, 28h ; '('
and eax, 7FFFFFFFh
loc_13FBF:
mov r15, [r15]
cmp r15, rcx
jz short loc_13F95
cmp [r15+10h], rax
jz short loc_13FD3
add r15, 8
jmp short loc_13FBF
loc_13FD3:
mov rdi, rbx
mov rsi, r15
call free_timer
jmp short loc_13F95
|
long long js_os_clearTimeout(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
char v5; // al
long long Runtime; // rbx
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
long long thread_state; // r15
long long *v14; // rcx
long long **i; // r15
long long *v16; // r15
_QWORD v17[5]; // [rsp+0h] [rbp-28h] BYREF
LOBYTE(v17[0]) = v5;
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v8, v9, v10, v11, v17[0]);
if ( !(unsigned int)JS_ToInt64(a1, v17, *a5, a5[1]) && SLODWORD(v17[0]) > 0 )
{
v14 = (long long *)(thread_state + 32);
for ( i = (long long **)(thread_state + 40); ; i = (long long **)(v16 + 1) )
{
v16 = *i;
if ( v16 == v14 )
break;
if ( v16[2] == (v17[0] & 0x7FFFFFFF) )
{
free_timer(Runtime, v16);
return 0LL;
}
}
}
return 0LL;
}
|
js_os_clearTimeout:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R12,RDI
CALL 0x0011a185
MOV RBX,RAX
MOV RDI,RAX
CALL 0x0011028a
MOV R15,RAX
MOV RDX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
MOV RSI,RSP
MOV RDI,R12
CALL 0x001214fe
TEST EAX,EAX
JZ 0x00113fa6
PUSH 0x6
POP R14
LAB_00113f95:
XOR EAX,EAX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00113fa6:
MOV RAX,qword ptr [RSP]
PUSH 0x3
POP R14
TEST EAX,EAX
JLE 0x00113f95
LEA RCX,[R15 + 0x20]
ADD R15,0x28
AND EAX,0x7fffffff
LAB_00113fbf:
MOV R15,qword ptr [R15]
CMP R15,RCX
JZ 0x00113f95
CMP qword ptr [R15 + 0x10],RAX
JZ 0x00113fd3
ADD R15,0x8
JMP 0x00113fbf
LAB_00113fd3:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00110323
JMP 0x00113f95
|
int1 [16] js_os_clearTimeout(int8 param_1)
{
long lVar1;
int1 auVar2 [16];
uint in_EAX;
int iVar3;
int8 uVar4;
long lVar5;
int8 *in_R8;
long *plVar6;
ulong uStack_30;
uint local_28 [2];
local_28[0] = in_EAX;
uVar4 = JS_GetRuntime();
lVar5 = js_get_thread_state(uVar4);
iVar3 = JS_ToInt64(param_1,local_28,*in_R8,in_R8[1]);
if (iVar3 == 0) {
uStack_30 = 3;
if (0 < (int)local_28[0]) {
plVar6 = (long *)(lVar5 + 0x28);
while (lVar1 = *plVar6, uStack_30 = 3, lVar1 != lVar5 + 0x20) {
if (*(ulong *)(lVar1 + 0x10) == (ulong)(local_28[0] & 0x7fffffff)) {
free_timer(uVar4,lVar1);
break;
}
plVar6 = (long *)(lVar1 + 8);
}
}
}
else {
uStack_30 = 6;
}
auVar2._8_8_ = 0;
auVar2._0_8_ = uStack_30;
return auVar2 << 0x40;
}
|
|
5,076 |
copy_from_file
|
eloqsql/storage/maria/s3_func.c
|
static my_bool copy_from_file(ms3_st *s3_client, const char *aws_bucket,
char *aws_path,
File file, my_off_t start, my_off_t file_end,
uchar *block, size_t block_size,
my_bool compression, my_bool display)
{
my_off_t pos;
char *path_end= strend(aws_path);
ulong bnr;
my_bool print_done= 0;
size_t length;
for (pos= start, bnr=1 ; pos < file_end ; pos+= length, bnr++)
{
if ((length= my_pread(file, block, block_size, pos, MYF(MY_WME))) ==
MY_FILE_ERROR)
goto err;
if (length == 0)
{
my_error(EE_EOFERR, MYF(0), my_filename(file), my_errno);
goto err;
}
fix_suffix(path_end, bnr);
if (s3_put_object(s3_client, aws_bucket, aws_path, block, length,
compression))
goto err;
/* Write up to DISPLAY_WITH number of '.' during copy */
if (display &&
((pos + block_size) * DISPLAY_WITH / file_end) >
(pos * DISPLAY_WITH/file_end))
{
fputc('.', stdout); fflush(stdout);
print_done= 1;
}
}
if (print_done)
{
fputc('\n', stdout); fflush(stdout);
}
my_close(file, MYF(MY_WME));
return 0;
err:
my_close(file, MYF(MY_WME));
if (print_done)
{
fputc('\n', stdout); fflush(stdout);
}
return 1;
}
|
O0
|
c
|
copy_from_file:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb 0x28(%rbp), %al
movb 0x20(%rbp), %al
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11b2f0
movq %rax, -0x48(%rbp)
movb $0x0, -0x51(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1, -0x50(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x29dbd
movl -0x24(%rbp), %edi
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl $0x10, %r8d
callq 0xbf320
movq %rax, -0x60(%rbp)
cmpq $-0x1, %rax
jne 0x29cd5
jmp 0x29df9
cmpq $0x0, -0x60(%rbp)
jne 0x29d08
movl -0x24(%rbp), %edi
callq 0xb6660
movq %rax, -0x68(%rbp)
callq 0xc0d80
movq -0x68(%rbp), %rdx
movl (%rax), %ecx
movl $0x9, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xb67b0
jmp 0x29df9
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2c070
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x10(%rbp), %rcx
movq -0x60(%rbp), %r8
movsbl 0x20(%rbp), %r9d
callq 0x29a20
cmpl $0x0, %eax
je 0x29d3d
jmp 0x29df9
movsbl 0x28(%rbp), %eax
cmpl $0x0, %eax
je 0x29d9e
movq -0x40(%rbp), %rax
addq 0x18(%rbp), %rax
imulq $0x4f, %rax, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, -0x70(%rbp)
imulq $0x4f, -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x38(%rbp)
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jbe 0x29d9e
movq 0x25d252(%rip), %rax # 0x286fd0
movq (%rax), %rsi
movl $0x2e, %edi
callq 0x27790
movq 0x25d23e(%rip), %rax # 0x286fd0
movq (%rax), %rdi
callq 0x27460
movb $0x1, -0x51(%rbp)
jmp 0x29da0
movq -0x60(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x29c9e
cmpb $0x0, -0x51(%rbp)
je 0x29de6
movq 0x25d206(%rip), %rax # 0x286fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x27790
movq 0x25d1f2(%rip), %rax # 0x286fd0
movq (%rax), %rdi
callq 0x27460
movl -0x24(%rbp), %edi
movl $0x10, %esi
callq 0xbf1c0
movb $0x0, -0x1(%rbp)
jmp 0x29e33
movl -0x24(%rbp), %edi
movl $0x10, %esi
callq 0xbf1c0
cmpb $0x0, -0x51(%rbp)
je 0x29e2f
movq 0x25d1bd(%rip), %rax # 0x286fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x27790
movq 0x25d1a9(%rip), %rax # 0x286fd0
movq (%rax), %rdi
callq 0x27460
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
copy_from_file:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, [rbp+arg_18]
mov al, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rdi, [rbp+var_20]
call strend
mov [rbp+var_48], rax
mov [rbp+var_51], 0
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov [rbp+var_50], 1
loc_29C9E:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_38]
jnb loc_29DBD
mov edi, [rbp+var_24]
mov rsi, [rbp+arg_0]
mov rdx, [rbp+arg_8]
mov rcx, [rbp+var_40]
mov r8d, 10h
call my_pread
mov [rbp+var_60], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_29CD5
jmp loc_29DF9
loc_29CD5:
cmp [rbp+var_60], 0
jnz short loc_29D08
mov edi, [rbp+var_24]
call my_filename
mov [rbp+var_68], rax
call _my_thread_var
mov rdx, [rbp+var_68]
mov ecx, [rax]
mov edi, 9
xor eax, eax
mov esi, eax
mov al, 0
call my_error
jmp loc_29DF9
loc_29D08:
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_50]
call fix_suffix
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+arg_0]
mov r8, [rbp+var_60]
movsx r9d, [rbp+arg_10]
call s3_put_object
cmp eax, 0
jz short loc_29D3D
jmp loc_29DF9
loc_29D3D:
movsx eax, [rbp+arg_18]
cmp eax, 0
jz short loc_29D9E
mov rax, [rbp+var_40]
add rax, [rbp+arg_8]
imul rax, 4Fh ; 'O'
xor ecx, ecx
mov edx, ecx
div [rbp+var_38]
mov [rbp+var_70], rax
imul rax, [rbp+var_40], 4Fh ; 'O'
xor ecx, ecx
mov edx, ecx
div [rbp+var_38]
mov rcx, rax
mov rax, [rbp+var_70]
cmp rax, rcx
jbe short loc_29D9E
mov rax, cs:stdout_ptr
mov rsi, [rax]
mov edi, 2Eh ; '.'
call _fputc
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov [rbp+var_51], 1
loc_29D9E:
jmp short $+2
loc_29DA0:
mov rax, [rbp+var_60]
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp loc_29C9E
loc_29DBD:
cmp [rbp+var_51], 0
jz short loc_29DE6
mov rax, cs:stdout_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_29DE6:
mov edi, [rbp+var_24]
mov esi, 10h
call my_close
mov [rbp+var_1], 0
jmp short loc_29E33
loc_29DF9:
mov edi, [rbp+var_24]
mov esi, 10h
call my_close
cmp [rbp+var_51], 0
jz short loc_29E2F
mov rax, cs:stdout_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_29E2F:
mov [rbp+var_1], 1
loc_29E33:
mov al, [rbp+var_1]
add rsp, 70h
pop rbp
retn
|
char copy_from_file(
long long a1,
long long a2,
long long a3,
unsigned int a4,
unsigned long long a5,
unsigned long long a6,
long long a7,
long long a8,
char a9,
char a10)
{
_DWORD *v10; // rax
int v11; // r8d
int v12; // r9d
unsigned long long v14; // [rsp+0h] [rbp-70h]
int v15; // [rsp+8h] [rbp-68h]
long long v16; // [rsp+10h] [rbp-60h]
char v17; // [rsp+1Fh] [rbp-51h]
long long v18; // [rsp+20h] [rbp-50h]
long long v19; // [rsp+28h] [rbp-48h]
unsigned long long v20; // [rsp+30h] [rbp-40h]
v19 = strend(a3);
v17 = 0;
v20 = a5;
v18 = 1LL;
while ( v20 < a6 )
{
v16 = my_pread(a4, a7, a8, v20, 16LL);
if ( v16 == -1 )
goto LABEL_14;
if ( !v16 )
{
v15 = my_filename(a4);
v10 = (_DWORD *)my_thread_var();
my_error(9, 0, v15, *v10, v11, v12, v14);
LABEL_14:
my_close(a4, 16LL);
if ( v17 )
{
fputc(10LL, stdout);
fflush(stdout);
}
return 1;
}
fix_suffix(v19, v18);
if ( (unsigned int)s3_put_object(a1, a2, a3, a7, v16, a9) )
goto LABEL_14;
if ( a10 )
{
v14 = 79 * (a8 + v20) / a6;
if ( v14 > 79 * v20 / a6 )
{
fputc(46LL, stdout);
fflush(stdout);
v17 = 1;
}
}
v20 += v16;
++v18;
}
if ( v17 )
{
fputc(10LL, stdout);
fflush(stdout);
}
my_close(a4, 16LL);
return 0;
}
|
copy_from_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,byte ptr [RBP + 0x28]
MOV AL,byte ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0021b2f0
MOV qword ptr [RBP + -0x48],RAX
MOV byte ptr [RBP + -0x51],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x50],0x1
LAB_00129c9e:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00129dbd
MOV EDI,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOV R8D,0x10
CALL 0x001bf320
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,-0x1
JNZ 0x00129cd5
JMP 0x00129df9
LAB_00129cd5:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x00129d08
MOV EDI,dword ptr [RBP + -0x24]
CALL 0x001b6660
MOV qword ptr [RBP + -0x68],RAX
CALL 0x001c0d80
MOV RDX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RAX]
MOV EDI,0x9
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001b67b0
JMP 0x00129df9
LAB_00129d08:
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x0012c070
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + 0x10]
MOV R8,qword ptr [RBP + -0x60]
MOVSX R9D,byte ptr [RBP + 0x20]
CALL 0x00129a20
CMP EAX,0x0
JZ 0x00129d3d
JMP 0x00129df9
LAB_00129d3d:
MOVSX EAX,byte ptr [RBP + 0x28]
CMP EAX,0x0
JZ 0x00129d9e
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + 0x18]
IMUL RAX,RAX,0x4f
XOR ECX,ECX
MOV EDX,ECX
DIV qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x70],RAX
IMUL RAX,qword ptr [RBP + -0x40],0x4f
XOR ECX,ECX
MOV EDX,ECX
DIV qword ptr [RBP + -0x38]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,RCX
JBE 0x00129d9e
MOV RAX,qword ptr [0x00386fd0]
MOV RSI,qword ptr [RAX]
MOV EDI,0x2e
CALL 0x00127790
MOV RAX,qword ptr [0x00386fd0]
MOV RDI,qword ptr [RAX]
CALL 0x00127460
MOV byte ptr [RBP + -0x51],0x1
LAB_00129d9e:
JMP 0x00129da0
LAB_00129da0:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00129c9e
LAB_00129dbd:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00129de6
MOV RAX,qword ptr [0x00386fd0]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00127790
MOV RAX,qword ptr [0x00386fd0]
MOV RDI,qword ptr [RAX]
CALL 0x00127460
LAB_00129de6:
MOV EDI,dword ptr [RBP + -0x24]
MOV ESI,0x10
CALL 0x001bf1c0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00129e33
LAB_00129df9:
MOV EDI,dword ptr [RBP + -0x24]
MOV ESI,0x10
CALL 0x001bf1c0
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00129e2f
MOV RAX,qword ptr [0x00386fd0]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00127790
MOV RAX,qword ptr [0x00386fd0]
MOV RDI,qword ptr [RAX]
CALL 0x00127460
LAB_00129e2f:
MOV byte ptr [RBP + -0x1],0x1
LAB_00129e33:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x70
POP RBP
RET
|
int1
copy_from_file(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
ulong param_5,ulong param_6,int8 param_7,long param_8,char param_9,char param_10
)
{
bool bVar1;
int iVar2;
int8 uVar3;
long lVar4;
int4 *puVar5;
long local_58;
ulong local_48;
uVar3 = strend(param_3);
bVar1 = false;
local_58 = 1;
local_48 = param_5;
while( true ) {
if (param_6 <= local_48) {
if (bVar1) {
fputc(10,*(FILE **)PTR_stdout_00386fd0);
fflush(*(FILE **)PTR_stdout_00386fd0);
}
my_close(param_4,0x10);
return 0;
}
lVar4 = my_pread(param_4,param_7,param_8,local_48,0x10);
if (lVar4 == -1) break;
if (lVar4 == 0) {
uVar3 = my_filename(param_4);
puVar5 = (int4 *)_my_thread_var();
my_error(9,0,uVar3,*puVar5);
break;
}
fix_suffix(uVar3,local_58);
iVar2 = s3_put_object(param_1,param_2,param_3,param_7,lVar4,(int)param_9);
if (iVar2 != 0) break;
if ((param_10 != '\0') &&
((local_48 * 0x4f) / param_6 < ((local_48 + param_8) * 0x4f) / param_6)) {
fputc(0x2e,*(FILE **)PTR_stdout_00386fd0);
fflush(*(FILE **)PTR_stdout_00386fd0);
bVar1 = true;
}
local_48 = lVar4 + local_48;
local_58 = local_58 + 1;
}
my_close(param_4,0x10);
if (bVar1) {
fputc(10,*(FILE **)PTR_stdout_00386fd0);
fflush(*(FILE **)PTR_stdout_00386fd0);
}
return 1;
}
|
|
5,077 |
ma_cmp_block_unique
|
eloqsql/storage/maria/ma_blockrec.c
|
my_bool _ma_cmp_block_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
const uchar *record, MARIA_RECORD_POS pos)
{
uchar *org_rec_buff, *old_record;
size_t org_rec_buff_size;
int error;
my_bool buff_alloced;
DBUG_ENTER("_ma_cmp_block_unique");
alloc_on_stack(*info->stack_end_ptr, old_record, buff_alloced,
info->s->base.reclength);
if (!old_record)
DBUG_RETURN(1);
/* Don't let the compare destroy blobs that may be in use */
org_rec_buff= info->rec_buff;
org_rec_buff_size= info->rec_buff_size;
if (info->s->base.blobs)
{
/* Force realloc of record buffer*/
info->rec_buff= 0;
info->rec_buff_size= 0;
}
error= _ma_read_block_record(info, old_record, pos);
if (!error)
error= _ma_unique_comp(def, record, old_record, def->null_are_equal);
if (info->s->base.blobs)
{
my_free(info->rec_buff);
info->rec_buff= org_rec_buff;
info->rec_buff_size= org_rec_buff_size;
}
DBUG_PRINT("exit", ("result: %d", error));
stack_alloc_free(old_record, buff_alloced);
DBUG_RETURN(error != 0);
}
|
O0
|
c
|
ma_cmp_block_unique:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x398(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x58eaf
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x58e86
movq -0x60(%rbp), %rcx
subq -0x58(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x58eaf
movl $0x1000, %eax # imm = 0x1000
cmpq -0x58(%rbp), %rax
ja 0x58eaf
movb $0x0, -0x4d(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x398(%rax), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x40(%rbp)
jmp 0x58ed1
movb $0x1, -0x4d(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x398(%rax), %rsi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf3820
movq %rax, -0x40(%rbp)
jmp 0x58ed3
cmpq $0x0, -0x40(%rbp)
jne 0x58ee5
jmp 0x58edc
movb $0x1, -0x9(%rbp)
jmp 0x58fc8
movq -0x18(%rbp), %rax
movq 0x3a0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x460(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x3f0(%rax)
je 0x58f31
movq -0x18(%rbp), %rax
movq $0x0, 0x3a0(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x460(%rax)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x58be0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x58f6a
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movsbl 0x3(%rax), %ecx
callq 0x6c6c0
movsbl %al, %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x3f0(%rax)
je 0x58fa8
movq -0x18(%rbp), %rax
movq 0x3a0(%rax), %rdi
callq 0xf3ba0
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x3a0(%rax)
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x460(%rax)
jmp 0x58faa
jmp 0x58fac
movq -0x40(%rbp), %rdi
movsbl -0x4d(%rbp), %esi
callq 0x58ff0
cmpl $0x0, -0x4c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x61(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x58fe8
movb -0x61(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a250
nopl (%rax)
|
_ma_cmp_block_unique:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+398h]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_58]
sub rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
cmp rax, [rbp+var_58]
jbe short loc_58EAF
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 10000h
cmp rax, rcx
jb short loc_58E86
mov rcx, [rbp+var_60]
sub rcx, [rbp+var_58]
mov eax, 8000h
cmp rax, rcx
jnb short loc_58EAF
mov eax, 1000h
cmp rax, [rbp+var_58]
ja short loc_58EAF
loc_58E86:
mov [rbp+var_4D], 0
mov rax, [rbp+var_18]
mov rax, [rax]
mov rcx, [rax+398h]
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_40], rax
jmp short loc_58ED1
loc_58EAF:
mov [rbp+var_4D], 1
mov rax, [rbp+var_18]
mov rax, [rax]
mov rsi, [rax+398h]
xor edi, edi
mov edx, 10010h
call my_malloc
mov [rbp+var_40], rax
loc_58ED1:
jmp short $+2
loc_58ED3:
cmp [rbp+var_40], 0
jnz short loc_58EE5
jmp short $+2
loc_58EDC:
mov [rbp+var_9], 1
jmp loc_58FC8
loc_58EE5:
mov rax, [rbp+var_18]
mov rax, [rax+3A0h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov rax, [rax+460h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp dword ptr [rax+3F0h], 0
jz short loc_58F31
mov rax, [rbp+var_18]
mov qword ptr [rax+3A0h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+460h], 0
loc_58F31:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_30]
call _ma_read_block_record
mov [rbp+var_4C], eax
cmp [rbp+var_4C], 0
jnz short loc_58F6A
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_40]
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax+3]
call _ma_unique_comp
movsx eax, al
mov [rbp+var_4C], eax
loc_58F6A:
mov rax, [rbp+var_18]
mov rax, [rax]
cmp dword ptr [rax+3F0h], 0
jz short loc_58FA8
mov rax, [rbp+var_18]
mov rdi, [rax+3A0h]
call my_free
mov rcx, [rbp+var_38]
mov rax, [rbp+var_18]
mov [rax+3A0h], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_18]
mov [rax+460h], rcx
loc_58FA8:
jmp short $+2
loc_58FAA:
jmp short $+2
loc_58FAC:
mov rdi, [rbp+var_40]
movsx esi, [rbp+var_4D]
call stack_alloc_free_0
cmp [rbp+var_4C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_9], al
loc_58FC8:
mov al, [rbp+var_9]
mov [rbp+var_61], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_58FE8
mov al, [rbp+var_61]
mov rsp, rbp
pop rbp
retn
loc_58FE8:
call ___stack_chk_fail
|
bool ma_cmp_block_unique(long long a1, long long a2, long long a3, unsigned long long a4)
{
long long v5; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+10h] [rbp-60h]
unsigned long long v7; // [rsp+18h] [rbp-58h] BYREF
char v8; // [rsp+23h] [rbp-4Dh]
int block_record; // [rsp+24h] [rbp-4Ch]
long long v10; // [rsp+28h] [rbp-48h]
long long v11; // [rsp+30h] [rbp-40h]
long long v12; // [rsp+38h] [rbp-38h]
unsigned long long v13; // [rsp+40h] [rbp-30h]
long long v14; // [rsp+48h] [rbp-28h]
long long v15; // [rsp+50h] [rbp-20h]
_QWORD *v16; // [rsp+58h] [rbp-18h]
unsigned long long v18; // [rsp+68h] [rbp-8h]
v18 = __readfsqword(0x28u);
v16 = (_QWORD *)a1;
v15 = a2;
v14 = a3;
v13 = a4;
v7 = *(_QWORD *)(*(_QWORD *)a1 + 920LL);
v6 = **(_QWORD **)(a1 + 120) - (_QWORD)&v7;
if ( v6 <= v7 || v6 - v7 <= 0x10000 && (v6 - v7 <= 0x8000 || v7 < 0x1000) )
{
v8 = 1;
v11 = my_malloc(0LL, *(_QWORD *)(*v16 + 920LL), 65552LL);
}
else
{
v8 = 0;
v11 = (long long)&v5 - ((*(_QWORD *)(*v16 + 920LL) + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( !v11 )
return 1;
v12 = v16[116];
v10 = v16[140];
if ( *(_DWORD *)(*v16 + 1008LL) )
{
v16[116] = 0LL;
v16[140] = 0LL;
}
block_record = ma_read_block_record(v16, v11, v13);
if ( !block_record )
block_record = (char)ma_unique_comp(v15, v14, v11, (unsigned int)*(char *)(v15 + 3));
if ( *(_DWORD *)(*v16 + 1008LL) )
{
my_free(v16[116]);
v16[116] = v12;
v16[140] = v10;
}
stack_alloc_free_0(v11, (unsigned int)v8);
return block_record != 0;
}
|
_ma_cmp_block_unique:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x398]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0x58]
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x58]
JBE 0x00158eaf
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x00158e86
MOV RCX,qword ptr [RBP + -0x60]
SUB RCX,qword ptr [RBP + -0x58]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x00158eaf
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0x58]
JA 0x00158eaf
LAB_00158e86:
MOV byte ptr [RBP + -0x4d],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x398]
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00158ed1
LAB_00158eaf:
MOV byte ptr [RBP + -0x4d],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x398]
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f3820
MOV qword ptr [RBP + -0x40],RAX
LAB_00158ed1:
JMP 0x00158ed3
LAB_00158ed3:
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x00158ee5
JMP 0x00158edc
LAB_00158edc:
MOV byte ptr [RBP + -0x9],0x1
JMP 0x00158fc8
LAB_00158ee5:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x3a0]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x460]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x00158f31
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x3a0],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x460],0x0
LAB_00158f31:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00158be0
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x0
JNZ 0x00158f6a
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX + 0x3]
CALL 0x0016c6c0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x4c],EAX
LAB_00158f6a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x00158fa8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x3a0]
CALL 0x001f3ba0
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x3a0],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x460],RCX
LAB_00158fa8:
JMP 0x00158faa
LAB_00158faa:
JMP 0x00158fac
LAB_00158fac:
MOV RDI,qword ptr [RBP + -0x40]
MOVSX ESI,byte ptr [RBP + -0x4d]
CALL 0x00158ff0
CMP dword ptr [RBP + -0x4c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x9],AL
LAB_00158fc8:
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x61],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00158fe8
MOV AL,byte ptr [RBP + -0x61]
MOV RSP,RBP
POP RBP
RET
LAB_00158fe8:
CALL 0x0012a250
|
int8 _ma_cmp_block_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
int1 *puVar2;
int8 uVar3;
long *plVar4;
char cVar5;
int1 *puVar6;
int iVar7;
long in_FS_OFFSET;
int1 auStack_78 [15];
bool local_69;
ulong local_68;
ulong local_60;
char local_55;
int local_54;
long local_50;
int1 *local_48;
long local_40;
int8 local_38;
int8 local_30;
long local_28;
long *local_20;
bool local_11;
long local_10;
puVar6 = auStack_78;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = *(ulong *)(*param_1 + 0x398);
local_68 = *(long *)param_1[0xf] - (long)&local_60;
local_38 = param_4;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
if ((local_60 < local_68) &&
((0x10000 < local_68 - local_60 || ((0x8000 < local_68 - local_60 && (0xfff < local_60)))))) {
local_55 = '\0';
puVar6 = auStack_78 + -(*(long *)(*param_1 + 0x398) + 0xfU & 0xfffffffffffffff0);
local_48 = puVar6;
}
else {
local_55 = '\x01';
local_48 = (int1 *)my_malloc(0,*(int8 *)(*param_1 + 0x398),0x10010);
}
plVar4 = local_20;
uVar3 = local_38;
puVar2 = local_48;
if (local_48 == (int1 *)0x0) {
local_11 = true;
}
else {
local_40 = local_20[0x74];
local_50 = local_20[0x8c];
if (*(int *)(*local_20 + 0x3f0) != 0) {
local_20[0x74] = 0;
local_20[0x8c] = 0;
}
*(int8 *)(puVar6 + -8) = 0x158f42;
local_54 = _ma_read_block_record(plVar4,puVar2,uVar3);
lVar1 = local_28;
uVar3 = local_30;
puVar2 = local_48;
if (local_54 == 0) {
cVar5 = *(char *)(local_28 + 3);
*(int8 *)(puVar6 + -8) = 0x158f64;
cVar5 = _ma_unique_comp(lVar1,uVar3,puVar2,(int)cVar5);
local_54 = (int)cVar5;
}
if (*(int *)(*local_20 + 0x3f0) != 0) {
lVar1 = local_20[0x74];
*(int8 *)(puVar6 + -8) = 0x158f8a;
my_free(lVar1);
local_20[0x74] = local_40;
local_20[0x8c] = local_50;
}
puVar2 = local_48;
iVar7 = (int)local_55;
*(int8 *)(puVar6 + -8) = 0x158fb9;
stack_alloc_free(puVar2,iVar7);
local_11 = local_54 != 0;
}
local_69 = local_11;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_11);
}
/* WARNING: Subroutine does not return */
*(int8 *)(puVar6 + -8) = 0x158fed;
__stack_chk_fail();
}
|
|
5,078 |
Workspaces::getWindows[abi:cxx11]()
|
mihussein[P]Hlemon/src/workspaces.cpp
|
std::string Workspaces::getWindows() {
std::string result = "";
for (const std::string name : windowsInWorkspace) {
result += name ;
}
if (result != "") return "%{F#777777}|%{F-} " + result;
return result;
}
|
O3
|
cpp
|
Workspaces::getWindows[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x33e7(%rip), %rdx # 0xc40a
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x5d90
movq 0x73f9(%rip), %r13 # 0x10430
movq 0x73fa(%rip), %r12 # 0x10438
cmpq %r12, %r13
je 0x909c
leaq 0x38(%rsp), %rbp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbp, 0x28(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x6400
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x40f0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9093
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4380
addq $0x20, %r13
cmpq %r12, %r13
jne 0x9052
leaq 0x3367(%rip), %rsi # 0xc40a
leaq 0x8(%rsp), %rdi
callq 0x40b0
testl %eax, %eax
je 0x90e3
leaq 0x3588(%rip), %rsi # 0xc640
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
leaq 0x18(%rsp), %r14
callq 0x5c9b
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x9116
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4380
jmp 0x9116
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x9107
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x910d
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x912a
movq %rax, %rbx
jmp 0x9149
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9149
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4380
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9165
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4380
movq %rbx, %rdi
callq 0x4660
nop
|
_ZN10Workspaces10getWindowsB5cxx11Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
lea rax, [rsp+78h+var_60]
mov [rax-10h], rax
lea rdx, aErrorInitializ+1Ch; ""
lea rdi, [rsp+78h+var_70]
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov r13, qword ptr cs:_ZN10Workspaces18windowsInWorkspaceB5cxx11E; Workspaces::windowsInWorkspace
mov r12, qword ptr cs:_ZN10Workspaces18windowsInWorkspaceB5cxx11E+8; Workspaces::windowsInWorkspace
cmp r13, r12
jz short loc_909C
lea rbp, [rsp+78h+var_40]
lea r14, [rsp+78h+var_50]
lea r15, [rsp+78h+var_70]
loc_9052:
mov [rsp+78h+var_50], rbp
mov rsi, [r13+0]
mov rdx, [r13+8]
add rdx, rsi
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rsi, [rsp+78h+var_50]
mov rdx, [rsp+78h+var_48]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+78h+var_50]; void *
cmp rdi, rbp
jz short loc_9093
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9093:
add r13, 20h ; ' '
cmp r13, r12
jnz short loc_9052
loc_909C:
lea rsi, aErrorInitializ+1Ch; ""
lea rdi, [rsp+78h+var_70]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_90E3
lea rsi, aF777777F_0; "%{F#777777}|%{F-} "
lea rdx, [rsp+78h+var_70]
mov rdi, rbx
lea r14, [rsp+78h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rdi, [rsp+78h+var_70]; void *
cmp rdi, r14
jz short loc_9116
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9116
loc_90E3:
lea rax, [rbx+10h]
mov [rbx], rax
mov rcx, [rsp+78h+var_70]
lea rdx, [rsp+78h+var_60]
cmp rcx, rdx
jz short loc_9107
mov [rbx], rcx
mov rax, [rsp+78h+var_60]
mov [rbx+10h], rax
jmp short loc_910D
loc_9107:
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rax], xmm0
loc_910D:
mov rax, [rsp+78h+var_68]
mov [rbx+8], rax
loc_9116:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_912A:
mov rbx, rax
jmp short loc_9149
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, rbp
jz short loc_9149
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9149:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_9165
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9165:
mov rdi, rbx
call __Unwind_Resume
|
long long Workspaces::getWindows[abi:cxx11](long long a1)
{
long long v1; // r12
long long i; // r13
void *v4[2]; // [rsp+8h] [rbp-70h] BYREF
__int128 v5; // [rsp+18h] [rbp-60h] BYREF
void *v6; // [rsp+28h] [rbp-50h] BYREF
_QWORD v7[8]; // [rsp+38h] [rbp-40h] BYREF
v4[0] = &v5;
std::string::_M_construct<char const*>((long long)v4, "", (long long)"");
v1 = *((_QWORD *)&Workspaces::windowsInWorkspace[abi:cxx11] + 1);
for ( i = Workspaces::windowsInWorkspace[abi:cxx11]; i != v1; i += 32LL )
{
v6 = v7;
std::string::_M_construct<char *>((long long)&v6, *(_BYTE **)i, *(_QWORD *)i + *(_QWORD *)(i + 8));
std::string::_M_append(v4, v6);
if ( v6 != v7 )
operator delete(v6, v7[0] + 1LL);
}
if ( !(unsigned int)std::string::compare(v4, "") )
{
*(_QWORD *)a1 = a1 + 16;
if ( v4[0] == &v5 )
{
*(_OWORD *)(a1 + 16) = v5;
}
else
{
*(void **)a1 = v4[0];
*(_QWORD *)(a1 + 16) = v5;
}
*(void **)(a1 + 8) = v4[1];
}
else
{
std::operator+<char>(a1, (long long)"%{F#777777}|%{F-} ", v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
}
return a1;
}
|
getWindows[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LEA RDX,[0x10c40a]
LEA RDI,[RSP + 0x8]
MOV RSI,RDX
CALL 0x00105d90
MOV R13,qword ptr [0x00110430]
MOV R12,qword ptr [0x00110438]
CMP R13,R12
JZ 0x0010909c
LEA RBP,[RSP + 0x38]
LEA R14,[RSP + 0x28]
LEA R15,[RSP + 0x8]
LAB_00109052:
MOV qword ptr [RSP + 0x28],RBP
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
LAB_00109062:
MOV RDI,R14
CALL 0x00106400
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
LAB_00109074:
MOV RDI,R15
CALL 0x001040f0
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,RBP
JZ 0x00109093
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00104380
LAB_00109093:
ADD R13,0x20
CMP R13,R12
JNZ 0x00109052
LAB_0010909c:
LEA RSI,[0x10c40a]
LEA RDI,[RSP + 0x8]
CALL 0x001040b0
TEST EAX,EAX
JZ 0x001090e3
LAB_001090b1:
LEA RSI,[0x10c640]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
LEA R14,[RSP + 0x18]
CALL 0x00105c9b
LAB_001090ca:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x00109116
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00104380
JMP 0x00109116
LAB_001090e3:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x18]
CMP RCX,RDX
JZ 0x00109107
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0010910d
LAB_00109107:
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RAX],XMM0
LAB_0010910d:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x8],RAX
LAB_00109116:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Workspaces::getWindows[abi:cxx11]() */
Workspaces * __thiscall Workspaces::getWindows_abi_cxx11_(Workspaces *this)
{
long *plVar1;
int iVar2;
long *plVar3;
long *local_70;
int8 local_68;
long local_60;
int8 uStack_58;
long *local_50 [2];
long local_40 [2];
local_70 = &local_60;
std::__cxx11::string::_M_construct<char_const*>(&local_70,"");
plVar1 = DAT_00110438;
if (windowsInWorkspace_abi_cxx11_ != DAT_00110438) {
plVar3 = windowsInWorkspace_abi_cxx11_;
do {
local_50[0] = local_40;
/* try { // try from 00109062 to 00109069 has its CatchHandler @ 0010912a */
std::__cxx11::string::_M_construct<char*>(local_50,*plVar3,plVar3[1] + *plVar3);
/* try { // try from 00109074 to 0010907b has its CatchHandler @ 0010912f */
std::__cxx11::string::_M_append((char *)&local_70,(ulong)local_50[0]);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
plVar3 = plVar3 + 4;
} while (plVar3 != plVar1);
}
iVar2 = std::__cxx11::string::compare((char *)&local_70);
if (iVar2 == 0) {
*(Workspaces **)this = this + 0x10;
if (local_70 == &local_60) {
*(long *)(this + 0x10) = local_60;
*(int8 *)(this + 0x18) = uStack_58;
}
else {
*(long **)this = local_70;
*(long *)(this + 0x10) = local_60;
}
*(int8 *)(this + 8) = local_68;
}
else {
/* try { // try from 001090b1 to 001090c9 has its CatchHandler @ 00109128 */
std::operator+((char *)this,(string *)"%{F#777777}|%{F-} ");
if (local_70 != &local_60) {
operator_delete(local_70,local_60 + 1);
}
}
return this;
}
|
|
5,079 |
ggml_backend_load_all_from_path
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
void ggml_backend_load_all_from_path(const char * dir_path) {
#ifdef NDEBUG
bool silent = true;
#else
bool silent = false;
#endif
ggml_backend_load_best("blas", silent, dir_path);
ggml_backend_load_best("cann", silent, dir_path);
ggml_backend_load_best("cuda", silent, dir_path);
ggml_backend_load_best("hip", silent, dir_path);
ggml_backend_load_best("kompute", silent, dir_path);
ggml_backend_load_best("metal", silent, dir_path);
ggml_backend_load_best("rpc", silent, dir_path);
ggml_backend_load_best("sycl", silent, dir_path);
ggml_backend_load_best("vulkan", silent, dir_path);
ggml_backend_load_best("opencl", silent, dir_path);
ggml_backend_load_best("musa", silent, dir_path);
ggml_backend_load_best("cpu", silent, dir_path);
// check the environment variable GGML_BACKEND_PATH to load an out-of-tree backend
const char * backend_path = std::getenv("GGML_BACKEND_PATH");
if (backend_path) {
ggml_backend_load(backend_path);
}
}
|
O0
|
cpp
|
ggml_backend_load_all_from_path:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdbeb(%rip), %rdi # 0x290d9
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdbd8(%rip), %rdi # 0x290de
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdbc5(%rip), %rdi # 0x290e3
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdbb2(%rip), %rdi # 0x290e8
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb9e(%rip), %rdi # 0x290ec
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb8e(%rip), %rdi # 0x290f4
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb7c(%rip), %rdi # 0x290fa
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb68(%rip), %rdi # 0x290fe
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb55(%rip), %rdi # 0x29103
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb44(%rip), %rdi # 0x2910a
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb33(%rip), %rdi # 0x29111
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rdx
leaq 0xdb20(%rip), %rdi # 0x29116
andb $0x1, %al
movzbl %al, %esi
callq 0x1b630
leaq 0xdb13(%rip), %rdi # 0x2911a
callq 0x19bf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b620
movq -0x18(%rbp), %rdi
callq 0x1a970
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ggml_backend_load_all_from_path:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aBlas; "blas"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aCann; "cann"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aCuda; "cuda"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aHip; "hip"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aKompute; "kompute"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aMetal; "metal"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aRpc; "rpc"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aSycl; "sycl"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aVulkan; "vulkan"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aOpencl; "opencl"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aMusa; "musa"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
mov al, [rbp+var_9]
mov rdx, [rbp+var_8]; char *
lea rdi, aCpu; "cpu"
and al, 1
movzx esi, al; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aGgmlBackendPat; "GGML_BACKEND_PATH"
call _getenv
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_1B620
mov rdi, [rbp+var_18]
call _ggml_backend_load
loc_1B620:
add rsp, 20h
pop rbp
retn
|
long long ggml_backend_load_all_from_path(const char *a1)
{
long long result; // rax
ggml_backend_load_best("blas", 0, a1);
ggml_backend_load_best("cann", 0, a1);
ggml_backend_load_best("cuda", 0, a1);
ggml_backend_load_best("hip", 0, a1);
ggml_backend_load_best("kompute", 0, a1);
ggml_backend_load_best("metal", 0, a1);
ggml_backend_load_best("rpc", 0, a1);
ggml_backend_load_best("sycl", 0, a1);
ggml_backend_load_best("vulkan", 0, a1);
ggml_backend_load_best("opencl", 0, a1);
ggml_backend_load_best("musa", 0, a1);
ggml_backend_load_best("cpu", 0, a1);
result = getenv("GGML_BACKEND_PATH");
if ( result )
return ggml_backend_load(result);
return result;
}
|
ggml_backend_load_all_from_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290d9]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290de]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290e3]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290e8]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290ec]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290f4]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290fa]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x1290fe]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x129103]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x12910a]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x129111]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
MOV AL,byte ptr [RBP + -0x9]
MOV RDX,qword ptr [RBP + -0x8]
LEA RDI,[0x129116]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0011b630
LEA RDI,[0x12911a]
CALL 0x00119bf0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0011b620
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0011a970
LAB_0011b620:
ADD RSP,0x20
POP RBP
RET
|
void ggml_backend_load_all_from_path(char *param_1)
{
char *pcVar1;
ggml_backend_load_best("blas",false,param_1);
ggml_backend_load_best("cann",false,param_1);
ggml_backend_load_best("cuda",false,param_1);
ggml_backend_load_best("hip",false,param_1);
ggml_backend_load_best("kompute",false,param_1);
ggml_backend_load_best("metal",false,param_1);
ggml_backend_load_best("rpc",false,param_1);
ggml_backend_load_best("sycl",false,param_1);
ggml_backend_load_best("vulkan",false,param_1);
ggml_backend_load_best("opencl",false,param_1);
ggml_backend_load_best("musa",false,param_1);
ggml_backend_load_best("cpu",false,param_1);
pcVar1 = getenv("GGML_BACKEND_PATH");
if (pcVar1 != (char *)0x0) {
ggml_backend_load(pcVar1);
}
return;
}
|
|
5,080 |
ggml_backend_load_all_from_path
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
void ggml_backend_load_all_from_path(const char * dir_path) {
#ifdef NDEBUG
bool silent = true;
#else
bool silent = false;
#endif
ggml_backend_load_best("blas", silent, dir_path);
ggml_backend_load_best("cann", silent, dir_path);
ggml_backend_load_best("cuda", silent, dir_path);
ggml_backend_load_best("hip", silent, dir_path);
ggml_backend_load_best("kompute", silent, dir_path);
ggml_backend_load_best("metal", silent, dir_path);
ggml_backend_load_best("rpc", silent, dir_path);
ggml_backend_load_best("sycl", silent, dir_path);
ggml_backend_load_best("vulkan", silent, dir_path);
ggml_backend_load_best("opencl", silent, dir_path);
ggml_backend_load_best("musa", silent, dir_path);
ggml_backend_load_best("cpu", silent, dir_path);
// check the environment variable GGML_BACKEND_PATH to load an out-of-tree backend
const char * backend_path = std::getenv("GGML_BACKEND_PATH");
if (backend_path) {
ggml_backend_load(backend_path);
}
}
|
O1
|
cpp
|
ggml_backend_load_all_from_path:
pushq %rbx
movq %rdi, %rbx
leaq 0x4df9(%rip), %rdi # 0xc0b9
movq %rbx, %rsi
callq 0x7389
leaq 0x4def(%rip), %rdi # 0xc0be
movq %rbx, %rsi
callq 0x7389
leaq 0x4de5(%rip), %rdi # 0xc0c3
movq %rbx, %rsi
callq 0x7389
leaq 0x4ddb(%rip), %rdi # 0xc0c8
movq %rbx, %rsi
callq 0x7389
leaq 0x4dd0(%rip), %rdi # 0xc0cc
movq %rbx, %rsi
callq 0x7389
leaq 0x4dc9(%rip), %rdi # 0xc0d4
movq %rbx, %rsi
callq 0x7389
leaq 0x4dc0(%rip), %rdi # 0xc0da
movq %rbx, %rsi
callq 0x7389
leaq 0x4db5(%rip), %rdi # 0xc0de
movq %rbx, %rsi
callq 0x7389
leaq 0x4dab(%rip), %rdi # 0xc0e3
movq %rbx, %rsi
callq 0x7389
leaq 0x4da3(%rip), %rdi # 0xc0ea
movq %rbx, %rsi
callq 0x7389
leaq 0x4d9b(%rip), %rdi # 0xc0f1
movq %rbx, %rsi
callq 0x7389
leaq 0x4d91(%rip), %rdi # 0xc0f6
movq %rbx, %rsi
callq 0x7389
leaq 0x4d86(%rip), %rdi # 0xc0fa
callq 0x6600
testq %rax, %rax
je 0x7387
movq %rax, %rdi
popq %rbx
jmp 0x6830
popq %rbx
retq
|
ggml_backend_load_all_from_path:
push rbx
mov rbx, rdi
lea rdi, aBlas; "blas"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCann; "cann"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCuda; "cuda"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aHip; "hip"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aKompute; "kompute"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMetal; "metal"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aRpc; "rpc"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aSycl; "sycl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aVulkan; "vulkan"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aOpencl; "opencl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMusa; "musa"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCpu; "cpu"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aGgmlBackendPat; "GGML_BACKEND_PATH"
call _getenv
test rax, rax
jz short loc_7387
mov rdi, rax
pop rbx
jmp _ggml_backend_load
loc_7387:
pop rbx
retn
|
long long ggml_backend_load_all_from_path(bool a1, long long a2, const char *a3)
{
const char *v3; // rdx
const char *v4; // rdx
const char *v5; // rdx
const char *v6; // rdx
const char *v7; // rdx
const char *v8; // rdx
const char *v9; // rdx
const char *v10; // rdx
const char *v11; // rdx
const char *v12; // rdx
const char *v13; // rdx
long long result; // rax
ggml_backend_load_best("blas", a1, a3);
ggml_backend_load_best("cann", a1, v3);
ggml_backend_load_best("cuda", a1, v4);
ggml_backend_load_best("hip", a1, v5);
ggml_backend_load_best("kompute", a1, v6);
ggml_backend_load_best("metal", a1, v7);
ggml_backend_load_best("rpc", a1, v8);
ggml_backend_load_best("sycl", a1, v9);
ggml_backend_load_best("vulkan", a1, v10);
ggml_backend_load_best("opencl", a1, v11);
ggml_backend_load_best("musa", a1, v12);
ggml_backend_load_best("cpu", a1, v13);
result = getenv("GGML_BACKEND_PATH");
if ( result )
return ggml_backend_load(result);
return result;
}
|
ggml_backend_load_all_from_path:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x10c0b9]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0be]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0c3]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0c8]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0cc]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0d4]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0da]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0de]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0e3]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0ea]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0f1]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0f6]
MOV RSI,RBX
CALL 0x00107389
LEA RDI,[0x10c0fa]
CALL 0x00106600
TEST RAX,RAX
JZ 0x00107387
MOV RDI,RAX
POP RBX
JMP 0x00106830
LAB_00107387:
POP RBX
RET
|
void ggml_backend_load_all_from_path(bool param_1,int8 param_2,char *param_3)
{
char *pcVar1;
char *extraout_RDX;
char *extraout_RDX_00;
char *extraout_RDX_01;
char *extraout_RDX_02;
char *extraout_RDX_03;
char *extraout_RDX_04;
char *extraout_RDX_05;
char *extraout_RDX_06;
char *extraout_RDX_07;
char *extraout_RDX_08;
char *extraout_RDX_09;
ggml_backend_load_best("blas",param_1,param_3);
ggml_backend_load_best("cann",param_1,extraout_RDX);
ggml_backend_load_best("cuda",param_1,extraout_RDX_00);
ggml_backend_load_best("hip",param_1,extraout_RDX_01);
ggml_backend_load_best("kompute",param_1,extraout_RDX_02);
ggml_backend_load_best("metal",param_1,extraout_RDX_03);
ggml_backend_load_best("rpc",param_1,extraout_RDX_04);
ggml_backend_load_best("sycl",param_1,extraout_RDX_05);
ggml_backend_load_best("vulkan",param_1,extraout_RDX_06);
ggml_backend_load_best("opencl",param_1,extraout_RDX_07);
ggml_backend_load_best("musa",param_1,extraout_RDX_08);
ggml_backend_load_best("cpu",param_1,extraout_RDX_09);
pcVar1 = getenv("GGML_BACKEND_PATH");
if (pcVar1 != (char *)0x0) {
ggml_backend_load(pcVar1);
return;
}
return;
}
|
|
5,081 |
ggml_backend_load_all_from_path
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
void ggml_backend_load_all_from_path(const char * dir_path) {
#ifdef NDEBUG
bool silent = true;
#else
bool silent = false;
#endif
ggml_backend_load_best("blas", silent, dir_path);
ggml_backend_load_best("cann", silent, dir_path);
ggml_backend_load_best("cuda", silent, dir_path);
ggml_backend_load_best("hip", silent, dir_path);
ggml_backend_load_best("kompute", silent, dir_path);
ggml_backend_load_best("metal", silent, dir_path);
ggml_backend_load_best("rpc", silent, dir_path);
ggml_backend_load_best("sycl", silent, dir_path);
ggml_backend_load_best("vulkan", silent, dir_path);
ggml_backend_load_best("opencl", silent, dir_path);
ggml_backend_load_best("musa", silent, dir_path);
ggml_backend_load_best("cpu", silent, dir_path);
// check the environment variable GGML_BACKEND_PATH to load an out-of-tree backend
const char * backend_path = std::getenv("GGML_BACKEND_PATH");
if (backend_path) {
ggml_backend_load(backend_path);
}
}
|
O2
|
cpp
|
ggml_backend_load_all_from_path:
pushq %rbx
movq %rdi, %rbx
leaq 0x4b8c(%rip), %rdi # 0x100c9
movq %rbx, %rsi
callq 0xb606
leaq 0x4b82(%rip), %rdi # 0x100ce
movq %rbx, %rsi
callq 0xb606
leaq 0x4b78(%rip), %rdi # 0x100d3
movq %rbx, %rsi
callq 0xb606
leaq 0x4b6e(%rip), %rdi # 0x100d8
movq %rbx, %rsi
callq 0xb606
leaq 0x4b63(%rip), %rdi # 0x100dc
movq %rbx, %rsi
callq 0xb606
leaq 0x4b5c(%rip), %rdi # 0x100e4
movq %rbx, %rsi
callq 0xb606
leaq 0x4b53(%rip), %rdi # 0x100ea
movq %rbx, %rsi
callq 0xb606
leaq 0x4b48(%rip), %rdi # 0x100ee
movq %rbx, %rsi
callq 0xb606
leaq 0x4b3e(%rip), %rdi # 0x100f3
movq %rbx, %rsi
callq 0xb606
leaq 0x4b36(%rip), %rdi # 0x100fa
movq %rbx, %rsi
callq 0xb606
leaq 0x4b2e(%rip), %rdi # 0x10101
movq %rbx, %rsi
callq 0xb606
leaq 0x4b24(%rip), %rdi # 0x10106
movq %rbx, %rsi
callq 0xb606
leaq 0x4b19(%rip), %rdi # 0x1010a
callq 0xaa10
testq %rax, %rax
je 0xb604
movq %rax, %rdi
popq %rbx
jmp 0xaee0
popq %rbx
retq
|
ggml_backend_load_all_from_path:
push rbx
mov rbx, rdi
lea rdi, aBlas; "blas"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCann; "cann"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCuda; "cuda"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aHip; "hip"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aKompute; "kompute"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMetal; "metal"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aRpc; "rpc"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aSycl; "sycl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aVulkan; "vulkan"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aOpencl; "opencl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMusa; "musa"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCpu; "cpu"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aGgmlBackendPat; "GGML_BACKEND_PATH"
call _getenv
test rax, rax
jz short loc_B604
mov rdi, rax
pop rbx
jmp _ggml_backend_load
loc_B604:
pop rbx
retn
|
long long ggml_backend_load_all_from_path(bool a1, long long a2, const char *a3)
{
const char *v3; // rdx
const char *v4; // rdx
const char *v5; // rdx
const char *v6; // rdx
const char *v7; // rdx
const char *v8; // rdx
const char *v9; // rdx
const char *v10; // rdx
const char *v11; // rdx
const char *v12; // rdx
const char *v13; // rdx
long long result; // rax
ggml_backend_load_best("blas", a1, a3);
ggml_backend_load_best("cann", a1, v3);
ggml_backend_load_best("cuda", a1, v4);
ggml_backend_load_best("hip", a1, v5);
ggml_backend_load_best("kompute", a1, v6);
ggml_backend_load_best("metal", a1, v7);
ggml_backend_load_best("rpc", a1, v8);
ggml_backend_load_best("sycl", a1, v9);
ggml_backend_load_best("vulkan", a1, v10);
ggml_backend_load_best("opencl", a1, v11);
ggml_backend_load_best("musa", a1, v12);
ggml_backend_load_best("cpu", a1, v13);
result = getenv("GGML_BACKEND_PATH");
if ( result )
return ggml_backend_load(result);
return result;
}
|
ggml_backend_load_all_from_path:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x1100c9]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100ce]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100d3]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100d8]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100dc]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100e4]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100ea]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100ee]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100f3]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x1100fa]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x110101]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x110106]
MOV RSI,RBX
CALL 0x0010b606
LEA RDI,[0x11010a]
CALL 0x0010aa10
TEST RAX,RAX
JZ 0x0010b604
MOV RDI,RAX
POP RBX
JMP 0x0010aee0
LAB_0010b604:
POP RBX
RET
|
void ggml_backend_load_all_from_path(bool param_1,int8 param_2,char *param_3)
{
char *pcVar1;
char *extraout_RDX;
char *extraout_RDX_00;
char *extraout_RDX_01;
char *extraout_RDX_02;
char *extraout_RDX_03;
char *extraout_RDX_04;
char *extraout_RDX_05;
char *extraout_RDX_06;
char *extraout_RDX_07;
char *extraout_RDX_08;
char *extraout_RDX_09;
ggml_backend_load_best("blas",param_1,param_3);
ggml_backend_load_best("cann",param_1,extraout_RDX);
ggml_backend_load_best("cuda",param_1,extraout_RDX_00);
ggml_backend_load_best("hip",param_1,extraout_RDX_01);
ggml_backend_load_best("kompute",param_1,extraout_RDX_02);
ggml_backend_load_best("metal",param_1,extraout_RDX_03);
ggml_backend_load_best("rpc",param_1,extraout_RDX_04);
ggml_backend_load_best("sycl",param_1,extraout_RDX_05);
ggml_backend_load_best("vulkan",param_1,extraout_RDX_06);
ggml_backend_load_best("opencl",param_1,extraout_RDX_07);
ggml_backend_load_best("musa",param_1,extraout_RDX_08);
ggml_backend_load_best("cpu",param_1,extraout_RDX_09);
pcVar1 = getenv("GGML_BACKEND_PATH");
if (pcVar1 != (char *)0x0) {
ggml_backend_load(pcVar1);
return;
}
return;
}
|
|
5,082 |
ggml_backend_load_all_from_path
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp
|
void ggml_backend_load_all_from_path(const char * dir_path) {
#ifdef NDEBUG
bool silent = true;
#else
bool silent = false;
#endif
ggml_backend_load_best("blas", silent, dir_path);
ggml_backend_load_best("cann", silent, dir_path);
ggml_backend_load_best("cuda", silent, dir_path);
ggml_backend_load_best("hip", silent, dir_path);
ggml_backend_load_best("kompute", silent, dir_path);
ggml_backend_load_best("metal", silent, dir_path);
ggml_backend_load_best("rpc", silent, dir_path);
ggml_backend_load_best("sycl", silent, dir_path);
ggml_backend_load_best("vulkan", silent, dir_path);
ggml_backend_load_best("opencl", silent, dir_path);
ggml_backend_load_best("musa", silent, dir_path);
ggml_backend_load_best("cpu", silent, dir_path);
// check the environment variable GGML_BACKEND_PATH to load an out-of-tree backend
const char * backend_path = std::getenv("GGML_BACKEND_PATH");
if (backend_path) {
ggml_backend_load(backend_path);
}
}
|
O3
|
cpp
|
ggml_backend_load_all_from_path:
pushq %rbx
movq %rdi, %rbx
leaq 0x4dd2(%rip), %rdi # 0xc0b9
movq %rbx, %rsi
callq 0x73b0
leaq 0x4dc8(%rip), %rdi # 0xc0be
movq %rbx, %rsi
callq 0x73b0
leaq 0x4dbe(%rip), %rdi # 0xc0c3
movq %rbx, %rsi
callq 0x73b0
leaq 0x4db4(%rip), %rdi # 0xc0c8
movq %rbx, %rsi
callq 0x73b0
leaq 0x4da9(%rip), %rdi # 0xc0cc
movq %rbx, %rsi
callq 0x73b0
leaq 0x4da2(%rip), %rdi # 0xc0d4
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d99(%rip), %rdi # 0xc0da
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d8e(%rip), %rdi # 0xc0de
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d84(%rip), %rdi # 0xc0e3
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d7c(%rip), %rdi # 0xc0ea
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d74(%rip), %rdi # 0xc0f1
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d6a(%rip), %rdi # 0xc0f6
movq %rbx, %rsi
callq 0x73b0
leaq 0x4d5f(%rip), %rdi # 0xc0fa
callq 0x6600
testq %rax, %rax
je 0x73ae
movq %rax, %rdi
popq %rbx
jmp 0x6830
popq %rbx
retq
|
ggml_backend_load_all_from_path:
push rbx
mov rbx, rdi
lea rdi, aBlas; "blas"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCann; "cann"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCuda; "cuda"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aHip; "hip"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aKompute; "kompute"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMetal; "metal"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aRpc; "rpc"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aSycl; "sycl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aVulkan; "vulkan"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aOpencl; "opencl"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aMusa; "musa"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aCpu; "cpu"
mov rsi, rbx; bool
call _ZL22ggml_backend_load_bestPKcbS0_; ggml_backend_load_best(char const*,bool,char const*)
lea rdi, aGgmlBackendPat; "GGML_BACKEND_PATH"
call _getenv
test rax, rax
jz short loc_73AE
mov rdi, rax
pop rbx
jmp _ggml_backend_load
loc_73AE:
pop rbx
retn
|
long long ggml_backend_load_all_from_path(bool a1, long long a2, const char *a3)
{
const char *v3; // rdx
const char *v4; // rdx
const char *v5; // rdx
const char *v6; // rdx
const char *v7; // rdx
const char *v8; // rdx
const char *v9; // rdx
const char *v10; // rdx
const char *v11; // rdx
const char *v12; // rdx
const char *v13; // rdx
long long result; // rax
ggml_backend_load_best("blas", a1, a3);
ggml_backend_load_best("cann", a1, v3);
ggml_backend_load_best("cuda", a1, v4);
ggml_backend_load_best("hip", a1, v5);
ggml_backend_load_best("kompute", a1, v6);
ggml_backend_load_best("metal", a1, v7);
ggml_backend_load_best("rpc", a1, v8);
ggml_backend_load_best("sycl", a1, v9);
ggml_backend_load_best("vulkan", a1, v10);
ggml_backend_load_best("opencl", a1, v11);
ggml_backend_load_best("musa", a1, v12);
ggml_backend_load_best("cpu", a1, v13);
result = getenv("GGML_BACKEND_PATH");
if ( result )
return ggml_backend_load(result);
return result;
}
|
ggml_backend_load_all_from_path:
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x10c0b9]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0be]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0c3]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0c8]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0cc]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0d4]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0da]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0de]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0e3]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0ea]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0f1]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0f6]
MOV RSI,RBX
CALL 0x001073b0
LEA RDI,[0x10c0fa]
CALL 0x00106600
TEST RAX,RAX
JZ 0x001073ae
MOV RDI,RAX
POP RBX
JMP 0x00106830
LAB_001073ae:
POP RBX
RET
|
void ggml_backend_load_all_from_path(bool param_1,int8 param_2,char *param_3)
{
char *pcVar1;
char *extraout_RDX;
char *extraout_RDX_00;
char *extraout_RDX_01;
char *extraout_RDX_02;
char *extraout_RDX_03;
char *extraout_RDX_04;
char *extraout_RDX_05;
char *extraout_RDX_06;
char *extraout_RDX_07;
char *extraout_RDX_08;
char *extraout_RDX_09;
ggml_backend_load_best("blas",param_1,param_3);
ggml_backend_load_best("cann",param_1,extraout_RDX);
ggml_backend_load_best("cuda",param_1,extraout_RDX_00);
ggml_backend_load_best("hip",param_1,extraout_RDX_01);
ggml_backend_load_best("kompute",param_1,extraout_RDX_02);
ggml_backend_load_best("metal",param_1,extraout_RDX_03);
ggml_backend_load_best("rpc",param_1,extraout_RDX_04);
ggml_backend_load_best("sycl",param_1,extraout_RDX_05);
ggml_backend_load_best("vulkan",param_1,extraout_RDX_06);
ggml_backend_load_best("opencl",param_1,extraout_RDX_07);
ggml_backend_load_best("musa",param_1,extraout_RDX_08);
ggml_backend_load_best("cpu",param_1,extraout_RDX_09);
pcVar1 = getenv("GGML_BACKEND_PATH");
if (pcVar1 != (char *)0x0) {
ggml_backend_load(pcVar1);
return;
}
return;
}
|
|
5,083 |
init_sets(st_rep_sets*, unsigned int)
|
eloqsql/client/mysqltest.cc
|
int init_sets(REP_SETS *sets,uint states)
{
bzero(sets, sizeof(*sets));
sets->size_of_bits=((states+7)/8);
if (!(sets->set_buffer=(REP_SET*) my_malloc(PSI_NOT_INSTRUMENTED, sizeof(REP_SET)*SET_MALLOC_HUNC,
MYF(MY_WME))))
return 1;
if (!(sets->bit_buffer=(uint*) my_malloc(PSI_NOT_INSTRUMENTED, sizeof(uint)*sets->size_of_bits*
SET_MALLOC_HUNC,MYF(MY_WME))))
{
my_free(sets->set);
return 1;
}
return 0;
}
|
O3
|
cpp
|
init_sets(st_rep_sets*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
addl $0x7, %esi
shrl $0x3, %esi
movl %esi, 0xc(%rdi)
xorl %r14d, %r14d
movl $0x8800, %esi # imm = 0x8800
movl $0x10, %edx
xorl %edi, %edi
callq 0x9c6fd
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x7085c
movl 0xc(%rbx), %esi
shlq $0x8, %rsi
movl $0x10, %edx
xorl %edi, %edi
callq 0x9c6fd
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x70862
movq 0x10(%rbx), %rdi
callq 0x9c92a
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
_Z9init_setsP11st_rep_setsj:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
movups xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+20h], 0
add esi, 7
shr esi, 3
mov [rdi+0Ch], esi
xor r14d, r14d
mov esi, 8800h
mov edx, 10h
xor edi, edi
call my_malloc
mov [rbx+18h], rax
test rax, rax
jz short loc_7085C
mov esi, [rbx+0Ch]
shl rsi, 8
mov edx, 10h
xor edi, edi
call my_malloc
mov [rbx+20h], rax
test rax, rax
jnz short loc_70862
mov rdi, [rbx+10h]
call my_free
loc_7085C:
mov r14d, 1
loc_70862:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long init_sets(long long a1, int a2)
{
unsigned int v2; // r14d
long long v3; // rax
long long v4; // rax
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
*(_DWORD *)(a1 + 12) = (unsigned int)(a2 + 7) >> 3;
v2 = 0;
v3 = my_malloc(0LL, 34816LL);
*(_QWORD *)(a1 + 24) = v3;
if ( !v3 )
return 1;
v4 = my_malloc(0LL, (unsigned long long)*(unsigned int *)(a1 + 12) << 8);
*(_QWORD *)(a1 + 32) = v4;
if ( !v4 )
{
my_free(*(_QWORD *)(a1 + 16));
return 1;
}
return v2;
}
|
init_sets:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x20],0x0
ADD ESI,0x7
SHR ESI,0x3
MOV dword ptr [RDI + 0xc],ESI
XOR R14D,R14D
MOV ESI,0x8800
MOV EDX,0x10
XOR EDI,EDI
CALL 0x0019c6fd
MOV qword ptr [RBX + 0x18],RAX
TEST RAX,RAX
JZ 0x0017085c
MOV ESI,dword ptr [RBX + 0xc]
SHL RSI,0x8
MOV EDX,0x10
XOR EDI,EDI
CALL 0x0019c6fd
MOV qword ptr [RBX + 0x20],RAX
TEST RAX,RAX
JNZ 0x00170862
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x0019c92a
LAB_0017085c:
MOV R14D,0x1
LAB_00170862:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
/* init_sets(st_rep_sets*, unsigned int) */
int8 init_sets(st_rep_sets *param_1,uint param_2)
{
long lVar1;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(uint *)(param_1 + 0xc) = param_2 + 7 >> 3;
lVar1 = my_malloc(0,0x8800,0x10);
*(long *)(param_1 + 0x18) = lVar1;
if (lVar1 != 0) {
lVar1 = my_malloc(0,(ulong)*(uint *)(param_1 + 0xc) << 8,0x10);
*(long *)(param_1 + 0x20) = lVar1;
if (lVar1 != 0) {
return 0;
}
my_free(*(int8 *)(param_1 + 0x10));
}
return 1;
}
|
|
5,084 |
translog_is_LSN_chunk
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_is_LSN_chunk(uchar type)
{
DBUG_ENTER("translog_is_LSN_chunk");
DBUG_PRINT("info", ("byte: %x chunk type: %u record type: %u",
type, type >> 6, type & TRANSLOG_REC_TYPE));
DBUG_RETURN(((type & TRANSLOG_CHUNK_TYPE) == TRANSLOG_CHUNK_FIXED) ||
(((type & TRANSLOG_CHUNK_TYPE) == TRANSLOG_CHUNK_LSN) &&
((type & TRANSLOG_REC_TYPE)) != TRANSLOG_CHUNK_0_CONT));
}
|
O0
|
c
|
translog_is_LSN_chunk:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
jmp 0x30c3c
jmp 0x30c3e
movzbl -0x1(%rbp), %ecx
andl $0xc0, %ecx
movb $0x1, %al
cmpl $0x40, %ecx
movb %al, -0x2(%rbp)
je 0x30c7c
movzbl -0x1(%rbp), %ecx
andl $0xc0, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3(%rbp)
jne 0x30c76
movzbl -0x1(%rbp), %eax
andl $0x3f, %eax
cmpl $0x3f, %eax
setne %al
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x4(%rbp)
movb -0x4(%rbp), %al
popq %rbp
retq
nopl (%rax)
|
translog_is_LSN_chunk:
push rbp
mov rbp, rsp
mov al, dil
mov [rbp+var_1], al
jmp short $+2
loc_30C3C:
jmp short $+2
loc_30C3E:
movzx ecx, [rbp+var_1]
and ecx, 0C0h
mov al, 1
cmp ecx, 40h ; '@'
mov [rbp+var_2], al
jz short loc_30C7C
movzx ecx, [rbp+var_1]
and ecx, 0C0h
xor eax, eax
cmp ecx, 0
mov [rbp+var_3], al
jnz short loc_30C76
movzx eax, [rbp+var_1]
and eax, 3Fh
cmp eax, 3Fh ; '?'
setnz al
mov [rbp+var_3], al
loc_30C76:
mov al, [rbp+var_3]
mov [rbp+var_2], al
loc_30C7C:
mov al, [rbp+var_2]
and al, 1
movzx eax, al
mov [rbp+var_4], al
mov al, [rbp+var_4]
pop rbp
retn
|
long long translog_is_LSN_chunk(char a1)
{
bool v2; // [rsp+1h] [rbp-3h]
char v3; // [rsp+2h] [rbp-2h]
v3 = 1;
if ( (a1 & 0xC0) != 0x40 )
{
v2 = 0;
if ( (a1 & 0xC0) == 0 )
v2 = (a1 & 0x3F) != 63;
v3 = v2;
}
return v3 & 1;
}
|
translog_is_LSN_chunk:
PUSH RBP
MOV RBP,RSP
MOV AL,DIL
MOV byte ptr [RBP + -0x1],AL
JMP 0x00130c3c
LAB_00130c3c:
JMP 0x00130c3e
LAB_00130c3e:
MOVZX ECX,byte ptr [RBP + -0x1]
AND ECX,0xc0
MOV AL,0x1
CMP ECX,0x40
MOV byte ptr [RBP + -0x2],AL
JZ 0x00130c7c
MOVZX ECX,byte ptr [RBP + -0x1]
AND ECX,0xc0
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x3],AL
JNZ 0x00130c76
MOVZX EAX,byte ptr [RBP + -0x1]
AND EAX,0x3f
CMP EAX,0x3f
SETNZ AL
MOV byte ptr [RBP + -0x3],AL
LAB_00130c76:
MOV AL,byte ptr [RBP + -0x3]
MOV byte ptr [RBP + -0x2],AL
LAB_00130c7c:
MOV AL,byte ptr [RBP + -0x2]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x4],AL
MOV AL,byte ptr [RBP + -0x4]
POP RBP
RET
|
bool translog_is_LSN_chunk(byte param_1)
{
bool local_b;
bool local_a;
local_a = true;
if ((param_1 & 0xc0) != 0x40) {
local_b = (param_1 & 0xc0) == 0 && (param_1 & 0x3f) != 0x3f;
local_a = local_b;
}
return local_a;
}
|
|
5,085 |
ggml_conv_1d_dw
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_conv_1d_dw(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int s0,
int p0,
int d0) {
struct ggml_tensor * new_a = ggml_reshape_4d(ctx, a, a->ne[0], 1, a->ne[1], a->ne[2]);
struct ggml_tensor * new_b = ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);
struct ggml_tensor * im2col = ggml_im2col(ctx, new_a, new_b, s0, 0, p0, 0, d0, 0, false, GGML_TYPE_F16);
struct ggml_tensor * result = ggml_mul_mat(ctx, im2col, a);
result = ggml_reshape_3d(ctx, result, b->ne[0], b->ne[1], 1);
return result;
}
|
O1
|
c
|
ggml_conv_1d_dw:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %r9
movl $0x1, %ecx
callq 0x182a0
movq %rax, %r12
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
movq 0x20(%r14), %r9
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x182a0
subq $0x8, %rsp
xorl %r10d, %r10d
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
pushq $0x1
pushq %r10
pushq %r10
pushq 0x20(%rsp)
pushq %r10
callq 0x18bf0
addq $0x30, %rsp
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x17990
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x1, %r8d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x180b0
|
ggml_conv_1d_dw:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r9
mov ebp, r8d
mov r13d, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdx, [rsi+10h]
mov r8, [rsi+18h]
mov r9, [rsi+20h]
mov ecx, 1
call _ggml_reshape_4d
mov r12, rax
mov rdx, [r14+10h]
mov r8, [r14+18h]
mov r9, [r14+20h]
mov ecx, 1
mov rdi, rbx
mov rsi, r14
call _ggml_reshape_4d
sub rsp, 8
xor r10d, r10d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
mov ecx, r13d
xor r8d, r8d
mov r9d, ebp
push 1
push r10
push r10
push [rsp+58h+var_38]
push r10
call _ggml_im2col
add rsp, 30h
mov rdi, rbx
mov rsi, rax
mov rdx, r15
call _ggml_mul_mat
mov rdx, [r14+10h]
mov rcx, [r14+18h]
mov r8d, 1
mov rdi, rbx
mov rsi, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_reshape_3d
|
long long ggml_conv_1d_dw(long long a1, _QWORD *a2, long long *a3, int a4, int a5, int a6, double a7)
{
_QWORD *v10; // r12
_QWORD *v11; // rax
_QWORD *v12; // rax
long long v13; // rcx
int v14; // r8d
int v15; // r9d
long long v16; // rax
v10 = (_QWORD *)ggml_reshape_4d(a1, (long long)a2, a2[2], 1LL, a2[3], a2[4], a7);
v11 = (_QWORD *)ggml_reshape_4d(a1, (long long)a3, a3[2], 1LL, a3[3], a3[4], a7);
v12 = (_QWORD *)ggml_im2col(a1, v10, v11, a4, 0, a5, a7, 0, a6, 0, 0, 1u);
v16 = ggml_mul_mat(a1, v12, a2, a7, v13, v14, v15);
return ggml_reshape_3d(a1, v16, a3[2], a3[3], 1LL, a7);
}
|
ggml_conv_1d_dw:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R9
MOV EBP,R8D
MOV R13D,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDX,qword ptr [RSI + 0x10]
MOV R8,qword ptr [RSI + 0x18]
MOV R9,qword ptr [RSI + 0x20]
MOV ECX,0x1
CALL 0x001182a0
MOV R12,RAX
MOV RDX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [R14 + 0x18]
MOV R9,qword ptr [R14 + 0x20]
MOV ECX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x001182a0
SUB RSP,0x8
XOR R10D,R10D
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
MOV ECX,R13D
XOR R8D,R8D
MOV R9D,EBP
PUSH 0x1
PUSH R10
PUSH R10
PUSH qword ptr [RSP + 0x20]
PUSH R10
CALL 0x00118bf0
ADD RSP,0x30
MOV RDI,RBX
MOV RSI,RAX
MOV RDX,R15
CALL 0x00117990
MOV RDX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV R8D,0x1
MOV RDI,RBX
MOV RSI,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001180b0
|
void ggml_conv_1d_dw(int8 param_1,long param_2,long param_3,int4 param_4,
int4 param_5,int8 param_6)
{
int8 uVar1;
int8 uVar2;
uVar1 = ggml_reshape_4d(param_1,param_2,*(int8 *)(param_2 + 0x10),1,
*(int8 *)(param_2 + 0x18),*(int8 *)(param_2 + 0x20),param_6);
uVar2 = ggml_reshape_4d(param_1,param_3,*(int8 *)(param_3 + 0x10),1,
*(int8 *)(param_3 + 0x18),*(int8 *)(param_3 + 0x20));
uVar1 = ggml_im2col(param_1,uVar1,uVar2,param_4,0,param_5,0,param_6,0,0,1);
uVar1 = ggml_mul_mat(param_1,uVar1,param_2);
ggml_reshape_3d(param_1,uVar1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x18),1);
return;
}
|
|
5,086 |
ggml_conv_1d_dw
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
struct ggml_tensor * ggml_conv_1d_dw(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int s0,
int p0,
int d0) {
struct ggml_tensor * new_a = ggml_reshape_4d(ctx, a, a->ne[0], 1, a->ne[1], a->ne[2]);
struct ggml_tensor * new_b = ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);
struct ggml_tensor * im2col = ggml_im2col(ctx, new_a, new_b, s0, 0, p0, 0, d0, 0, false, GGML_TYPE_F16);
struct ggml_tensor * result = ggml_mul_mat(ctx, im2col, a);
result = ggml_reshape_3d(ctx, result, b->ne[0], b->ne[1], 1);
return result;
}
|
O3
|
c
|
ggml_conv_1d_dw:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %r8
movq 0x20(%rsi), %r9
movl $0x1, %ecx
callq 0x17290
movq %rax, %r12
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r8
movq 0x20(%r14), %r9
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17290
subq $0x8, %rsp
xorl %r10d, %r10d
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
movl %r13d, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
pushq $0x1
pushq %r10
pushq %r10
pushq 0x20(%rsp)
pushq %r10
callq 0x17be0
addq $0x30, %rsp
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x16990
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x1, %r8d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x170a0
|
ggml_conv_1d_dw:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r9
mov ebp, r8d
mov r13d, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdx, [rsi+10h]
mov r8, [rsi+18h]
mov r9, [rsi+20h]
mov ecx, 1
call _ggml_reshape_4d
mov r12, rax
mov rdx, [r14+10h]
mov r8, [r14+18h]
mov r9, [r14+20h]
mov ecx, 1
mov rdi, rbx
mov rsi, r14
call _ggml_reshape_4d
sub rsp, 8
xor r10d, r10d
mov rdi, rbx
mov rsi, r12
mov rdx, rax
mov ecx, r13d
xor r8d, r8d
mov r9d, ebp
push 1
push r10
push r10
push [rsp+58h+var_38]
push r10
call _ggml_im2col
add rsp, 30h
mov rdi, rbx
mov rsi, rax
mov rdx, r15
call _ggml_mul_mat
mov rdx, [r14+10h]
mov rcx, [r14+18h]
mov r8d, 1
mov rdi, rbx
mov rsi, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_reshape_3d
|
long long ggml_conv_1d_dw(long long a1, _QWORD *a2, long long *a3, int a4, unsigned int a5, int a6, double a7)
{
_QWORD *v10; // r12
_QWORD *v11; // rax
_QWORD *v12; // rax
long long v13; // rcx
long long v14; // r8
int v15; // r9d
long long v16; // rax
v10 = (_QWORD *)ggml_reshape_4d(a1, (long long)a2, a2[2], 1LL, a2[3], a2[4], a7);
v11 = (_QWORD *)ggml_reshape_4d(a1, (long long)a3, a3[2], 1LL, a3[3], a3[4], a7);
v12 = (_QWORD *)ggml_im2col(a1, v10, v11, a4, 0, a5, a7, 0, a6, 0, 0, 1u);
v16 = ggml_mul_mat(a1, v12, a2, a7, v13, v14, v15);
return ggml_reshape_3d(a1, v16, a3[2], a3[3], 1LL, a7);
}
|
ggml_conv_1d_dw:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R9
MOV EBP,R8D
MOV R13D,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDX,qword ptr [RSI + 0x10]
MOV R8,qword ptr [RSI + 0x18]
MOV R9,qword ptr [RSI + 0x20]
MOV ECX,0x1
CALL 0x00117290
MOV R12,RAX
MOV RDX,qword ptr [R14 + 0x10]
MOV R8,qword ptr [R14 + 0x18]
MOV R9,qword ptr [R14 + 0x20]
MOV ECX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x00117290
SUB RSP,0x8
XOR R10D,R10D
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
MOV ECX,R13D
XOR R8D,R8D
MOV R9D,EBP
PUSH 0x1
PUSH R10
PUSH R10
PUSH qword ptr [RSP + 0x20]
PUSH R10
CALL 0x00117be0
ADD RSP,0x30
MOV RDI,RBX
MOV RSI,RAX
MOV RDX,R15
CALL 0x00116990
MOV RDX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV R8D,0x1
MOV RDI,RBX
MOV RSI,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001170a0
|
void ggml_conv_1d_dw(int8 param_1,long param_2,long param_3,int4 param_4,
int4 param_5,int8 param_6)
{
int8 uVar1;
int8 uVar2;
uVar1 = ggml_reshape_4d(param_1,param_2,*(int8 *)(param_2 + 0x10),1,
*(int8 *)(param_2 + 0x18),*(int8 *)(param_2 + 0x20),param_6);
uVar2 = ggml_reshape_4d(param_1,param_3,*(int8 *)(param_3 + 0x10),1,
*(int8 *)(param_3 + 0x18),*(int8 *)(param_3 + 0x20));
uVar1 = ggml_im2col(param_1,uVar1,uVar2,param_4,0,param_5,0,param_6,0,0,1);
uVar1 = ggml_mul_mat(param_1,uVar1,param_2);
ggml_reshape_3d(param_1,uVar1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x18),1);
return;
}
|
|
5,087 |
LefDefParser::GetToken(char**, int*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lef_keywords.cpp
|
static int
GetToken(char **buffer, int *bufferSize)
{
char *s = *buffer;
int ch;
lefData->lef_ntokens++;
lefData->lefInvalidChar = 0;
if (lefData->input_level >= 0) { // if we are expanding an alias
if (GetTokenFromStack(s)) // try to get a token from it
return TRUE; // if we get one, return it
} // but if not, continue
// skip blanks and count lines
while ((ch = lefGetc()) != EOF) {
// check if the file is encrypted and user allows to read
if (lefData->encrypted && !lefSettings->ReadEncrypted)
ch = EOF;
if (ch == '\n') {
print_nlines(++lefData->lef_nlines);
}
if (ch != ' ' && ch != '\t' && (lefData->lefNlToken || ch != '\n'))
break;
}
if (ch == EOF)
return FALSE;
if (ch == '\n') {
*s = ch;
IncCurPos(&s, buffer, bufferSize);
*s = '\0';
if (lefData->lefDebug[11])
printf("Newline token\n");
return TRUE;
}
// now get the token
if (ch == '"') {
do {
/* 5/6/2008 - CCR 556818
** Check if the ch is a valid ascii character 0 =< ch < 128
** If not write out an error
*/
/* 8/7/2008 - CCR 586175
** Some files may not end with \n or \0 or EOF as the lefData->last character
** The parser allows this char instead of error out
*/
if ((ch < -1) || (ch > 127)) {
lefData->lefInvalidChar = 1;
}
/* 8/22/2000 - Wanda da Rosa, pcr 333334
** save the previous char to allow backslash quote within quote
*/
if (!lefSettings->DisPropStrProcess) {
// 3/4/2008 - CCR 523879 - convert \\ to \, \" to ", \x to x
if (ch == '\\') { // got a \, save the lefData->next char only
ch = lefGetc();
if ((ch == '\n') || (ch == EOF)) {
*s = '\0';
lefError(6015, "Unexpected end of the LEF file.");
lefData->hasFatalError = 1;
return FALSE;
}
}
}
// 5/5/2004 - pcr 704784
// If name, or quote string is longer than current buffer size
// increase the buffer.
*s = ch;
IncCurPos(&s, buffer, bufferSize);
ch = lefGetc();
// 7/23/2003 - pcr 606558 - do not allow \n in a string instead
// of ;
if (ch == '\n' ) {
print_nlines(++lefData->lef_nlines);
// 2/2/2007 - PCR 909714, allow string to go more than 1 line
// continue to parse
}
if (ch == EOF) {
*s = '\0';
lefError(6015, "Unexpected end of the LEF file.");
lefData->hasFatalError = 1;
return FALSE;
}
} while (ch != '"');
*s = '\0';
/* 10/31/2006 - pcr 926068
** When it reaches to here, chances are it reaches the end ".
** Check if there is a space following the "
*/
if (ch == '"') {
ch = lefGetc();
if (ch != ' ' && ch != EOF) {
UNlefGetc(ch);
lefData->spaceMissing = 1;
return FALSE;
}
UNlefGetc(ch);
}
return TRUE;
}
if (lefData->namesCaseSensitive) {
for (; ; ch = lefGetc()) {
/* 5/6/2008 - CCR 556818
** Check if the ch is a valid ascii character 0 =< ch < 128
** If not write out an error
*/
if ((ch < -1) || (ch > 127)) {
lefData->lefInvalidChar = 1;
}
if (ch == ' ' || ch == '\t' || ch == '\n' || ch == EOF)
break;
*s = ch;
IncCurPos(&s, buffer, bufferSize);
}
} else if (lefSettings->ShiftCase) { // we are case insensitive, use a different loop
for (; ; ch = lefGetc()) {
/* 5/6/2008 - CCR 556818
** Check if the ch is a valid ascii character 0 =< ch < 128
** If not write out an error
*/
if ((ch < -1) || (ch > 127)) {
lefData->lefInvalidChar = 1;
}
if (ch == ' ' || ch == '\t' || ch == '\n' || ch == EOF)
break;
*s = (ch >= 'a' && ch <= 'z')? (ch - 'a' + 'A') : ch;
IncCurPos(&s, buffer, bufferSize);
}
} else {
for (; ; ch = lefGetc()) {
/* 5/6/2008 - CCR 556818
** Check if the ch is a valid ascii character 0 =< ch < 128
** If not write out an error
*/
if ((ch < -1) || (ch > 127)) {
lefData->lefInvalidChar = 1;
}
if (ch == ' ' || ch == '\t' || ch == '\n' || ch == EOF)
break;
*s = ch;
IncCurPos(&s, buffer, bufferSize);
}
}
// If we got this far, the lefData->last char was whitespace
*s = '\0';
if (ch != EOF) // shouldn't ungetc an EOF
UNlefGetc(ch);
return TRUE;
}
|
O3
|
cpp
|
LefDefParser::GetToken(char**, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0x52559(%rip), %r13 # 0x775e0
movq (%r13), %rdx
incl 0x1e8(%rdx)
movl $0x0, 0x1c0(%rdx)
movslq 0x190(%rdx), %rdi
testq %rdi, %rdi
js 0x250ed
movq 0x5818(%rdx,%rdi,8), %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0x250ce
cmpl $0x20, %ecx
je 0x250ce
testl %ecx, %ecx
je 0x250db
cmpb $0xa, %cl
jne 0x250d3
cmpl $0x0, 0x1cc(%rdx)
jne 0x250d3
incq %rax
jmp 0x250af
testl %ecx, %ecx
jne 0x25190
leaq -0x1(%rdi), %rax
movl %eax, 0x190(%rdx)
testq %rdi, %rdi
movq %rax, %rdi
jg 0x250a7
movq %rsi, %rbp
callq 0x24492
xorl %r15d, %r15d
cmpl $-0x1, %eax
je 0x25246
movl %eax, %r12d
leaq 0x524ad(%rip), %r15 # 0x775b8
movq (%r13), %rcx
cmpl $0x0, 0xf4(%rcx)
je 0x25124
movq (%r15), %rax
cmpl $0x0, 0xc0(%rax)
je 0x25188
cmpl $0x9, %r12d
je 0x2517b
cmpl $0x20, %r12d
je 0x2517b
cmpl $0xa, %r12d
jne 0x25164
movl 0x1e4(%rcx), %edi
incl %edi
movl %edi, 0x1e4(%rcx)
movq (%r15), %r8
movq 0x88(%r8), %rsi
testq %rsi, %rsi
je 0x25164
movl %edi, %eax
cltd
idivl 0x4c(%r8)
testl %edx, %edx
jne 0x25164
callq *%rsi
movq (%r13), %rcx
cmpl $0xa, %r12d
jne 0x25258
cmpl $0x0, 0x1cc(%rcx)
jne 0x25258
callq 0x24492
movl %eax, %r12d
cmpl $-0x1, %eax
jne 0x2510b
xorl %r15d, %r15d
jmp 0x25246
cmpl $0xa, %ecx
jne 0x251c7
movw $0xa, (%rbx)
movq (%r13), %rax
movl $0x1, %r15d
cmpb $0x0, 0x17a3(%rax)
je 0x25246
movl 0x190(%rax), %esi
leaq 0x2cd17(%rip), %rdi # 0x51ed5
xorl %eax, %eax
callq 0x2030
jmp 0x25246
xorl %esi, %esi
movabsq $0x100000601, %rdx # imm = 0x100000601
movq %rbx, %r8
movq %r8, %rdi
cmpb $0x20, %cl
ja 0x251e8
movzbl %cl, %r8d
btq %r8, %rdx
jb 0x251f9
leaq 0x1(%rdi), %r8
movb %cl, (%rdi)
movb 0x1(%rax), %cl
incq %rax
movq %rdi, %rsi
jmp 0x251d6
cmpb $0x22, (%rsi)
cmoveq %rsi, %rdi
movb $0x0, (%rdi)
movq (%r13), %rcx
movslq 0x190(%rcx), %rdx
movq %rax, 0x5818(%rcx,%rdx,8)
movq (%r13), %rax
movl $0x1, %r15d
cmpb $0x0, 0x17a3(%rax)
je 0x25246
movl 0x190(%rax), %esi
movl 0x1b0(%rax), %ecx
leaq 0x2ccb2(%rip), %rdi # 0x51eee
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2030
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0xa, %r12d
je 0x25337
cmpl $0x22, %r12d
jne 0x2538e
cmpl $-0x2, %r12d
jg 0x25282
movq (%r13), %rax
movl $0x1, 0x1c0(%rax)
jmp 0x252ab
cmpl $0x5c, %r12d
jne 0x252ab
movq (%r15), %rax
cmpl $0x0, 0x40(%rax)
jne 0x252ab
callq 0x24492
cmpl $0xa, %eax
je 0x25409
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x25409
movb %r12b, (%rbx)
incq %rbx
movq (%r14), %rdi
movq %rbx, %r12
subq %rdi, %r12
movslq (%rbp), %rsi
cmpq %rsi, %r12
jl 0x252d7
addq %rsi, %rsi
movl %esi, (%rbp)
callq 0x2340
movq %rax, (%r14)
addq %rax, %r12
movq %r12, %rbx
callq 0x24492
movl %eax, %r12d
cmpl $0xa, %eax
je 0x252fd
cmpl $-0x1, %r12d
je 0x25409
cmpl $0x22, %r12d
jne 0x2526c
jmp 0x254c1
movq (%r13), %rax
movl 0x1e4(%rax), %edi
incl %edi
movl %edi, 0x1e4(%rax)
movq (%r15), %rsi
movq 0x88(%rsi), %rcx
testq %rcx, %rcx
je 0x2526c
movl %edi, %eax
cltd
idivl 0x4c(%rsi)
testl %edx, %edx
jne 0x2526c
callq *%rcx
jmp 0x2526c
movb $0xa, (%rbx)
incq %rbx
movq (%r14), %rdi
movq %rbx, %r15
subq %rdi, %r15
movslq (%rbp), %rsi
cmpq %rsi, %r15
jl 0x25363
addq %rsi, %rsi
movl %esi, (%rbp)
callq 0x2340
movq %rax, (%r14)
addq %rax, %r15
movq %r15, %rbx
movb $0x0, (%rbx)
movq (%r13), %rax
movl $0x1, %r15d
cmpb $0x0, 0x17a3(%rax)
je 0x25246
leaq 0x2cc1a(%rip), %rdi # 0x51f9e
callq 0x22e0
jmp 0x25246
cmpl $0x0, 0x220(%rcx)
je 0x25430
movabsq $0x200000c01, %r15 # imm = 0x200000C01
leal -0x80(%r12), %eax
cmpl $0xffffff7e, %eax # imm = 0xFFFFFF7E
ja 0x253bf
movq (%r13), %rax
movl $0x1, 0x1c0(%rax)
leal 0x1(%r12), %eax
cmpl $0x21, %eax
ja 0x253d3
btq %rax, %r15
jb 0x2555a
movb %r12b, (%rbx)
incq %rbx
movq (%r14), %rdi
movq %rbx, %r12
subq %rdi, %r12
movslq (%rbp), %rsi
cmpq %rsi, %r12
jl 0x253ff
addq %rsi, %rsi
movl %esi, (%rbp)
callq 0x2340
movq %rax, (%r14)
addq %rax, %r12
movq %r12, %rbx
callq 0x24492
movl %eax, %r12d
jmp 0x253a5
movb $0x0, (%rbx)
leaq 0x2be6e(%rip), %rsi # 0x51281
movl $0x177f, %edi # imm = 0x177F
callq 0x2453a
movq (%r13), %rax
movl $0x1, 0x178(%rax)
jmp 0x25188
movq (%r15), %rax
cmpl $0x0, 0xcc(%rax)
je 0x254f0
movabsq $0x200000c01, %r15 # imm = 0x200000C01
leal -0x80(%r12), %eax
cmpl $0xffffff7e, %eax # imm = 0xFFFFFF7E
ja 0x25464
movq (%r13), %rax
movl $0x1, 0x1c0(%rax)
leal 0x1(%r12), %eax
cmpl $0x21, %eax
ja 0x25478
btq %rax, %r15
jb 0x2555a
leal -0x61(%r12), %eax
leal -0x20(%r12), %ecx
cmpl $0x1a, %eax
movzbl %cl, %eax
cmovael %r12d, %eax
movb %al, (%rbx)
incq %rbx
movq (%r14), %rdi
movq %rbx, %r12
subq %rdi, %r12
movslq (%rbp), %rsi
cmpq %rsi, %r12
jl 0x254b7
addq %rsi, %rsi
movl %esi, (%rbp)
callq 0x2340
movq %rax, (%r14)
addq %rax, %r12
movq %r12, %rbx
callq 0x24492
movl %eax, %r12d
jmp 0x2544a
movb $0x0, (%rbx)
callq 0x24492
cmpl $-0x1, %eax
movl $0x0, %r15d
je 0x254dd
cmpl $0x20, %eax
jne 0x2557b
movsbl %al, %edi
callq 0x244f9
movl $0x1, %r15d
jmp 0x25246
movabsq $0x200000c01, %r15 # imm = 0x200000C01
leal -0x80(%r12), %eax
cmpl $0xffffff7e, %eax # imm = 0xFFFFFF7E
ja 0x25514
movq (%r13), %rax
movl $0x1, 0x1c0(%rax)
leal 0x1(%r12), %eax
cmpl $0x21, %eax
ja 0x25524
btq %rax, %r15
jb 0x2555a
movb %r12b, (%rbx)
incq %rbx
movq (%r14), %rdi
movq %rbx, %r12
subq %rdi, %r12
movslq (%rbp), %rsi
cmpq %rsi, %r12
jl 0x25550
addq %rsi, %rsi
movl %esi, (%rbp)
callq 0x2340
movq %rax, (%r14)
addq %rax, %r12
movq %r12, %rbx
callq 0x24492
movl %eax, %r12d
jmp 0x254fa
movb $0x0, (%rbx)
movl $0x1, %r15d
cmpl $-0x1, %r12d
je 0x25246
movsbl %r12b, %edi
callq 0x244f9
jmp 0x25246
movsbl %al, %edi
callq 0x244f9
movq (%r13), %rax
movl $0x1, 0x280(%rax)
jmp 0x25246
|
_ZN12LefDefParserL8GetTokenEPPcPi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov rbx, [rdi]
lea r13, _ZN12LefDefParser7lefDataE; LefDefParser::lefData
mov rdx, [r13+0]
inc dword ptr [rdx+1E8h]
mov dword ptr [rdx+1C0h], 0
movsxd rdi, dword ptr [rdx+190h]
test rdi, rdi
js short loc_250ED
loc_250A7:
mov rax, [rdx+rdi*8+5818h]
loc_250AF:
movzx ecx, byte ptr [rax]
cmp ecx, 9
jz short loc_250CE
cmp ecx, 20h ; ' '
jz short loc_250CE
test ecx, ecx
jz short loc_250DB
cmp cl, 0Ah
jnz short loc_250D3
cmp dword ptr [rdx+1CCh], 0
jnz short loc_250D3
loc_250CE:
inc rax
jmp short loc_250AF
loc_250D3:
test ecx, ecx
jnz loc_25190
loc_250DB:
lea rax, [rdi-1]
mov [rdx+190h], eax
test rdi, rdi
mov rdi, rax; this
jg short loc_250A7
loc_250ED:
mov rbp, rsi
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
xor r15d, r15d
cmp eax, 0FFFFFFFFh
jz loc_25246
mov r12d, eax
lea r15, _ZN12LefDefParser11lefSettingsE; LefDefParser::lefSettings
loc_2510B:
mov rcx, [r13+0]
cmp dword ptr [rcx+0F4h], 0
jz short loc_25124
mov rax, [r15]
cmp dword ptr [rax+0C0h], 0
jz short loc_25188
loc_25124:
cmp r12d, 9
jz short loc_2517B
cmp r12d, 20h ; ' '
jz short loc_2517B
cmp r12d, 0Ah
jnz short loc_25164
mov edi, [rcx+1E4h]
inc edi; this
mov [rcx+1E4h], edi
mov r8, [r15]
mov rsi, [r8+88h]; char
test rsi, rsi
jz short loc_25164
mov eax, edi
cdq
idiv dword ptr [r8+4Ch]
test edx, edx
jnz short loc_25164
call rsi
mov rcx, [r13+0]
loc_25164:
cmp r12d, 0Ah
jnz loc_25258
cmp dword ptr [rcx+1CCh], 0
jnz loc_25258
loc_2517B:
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
mov r12d, eax
cmp eax, 0FFFFFFFFh
jnz short loc_2510B
loc_25188:
xor r15d, r15d
jmp loc_25246
loc_25190:
cmp ecx, 0Ah
jnz short loc_251C7
mov word ptr [rbx], 0Ah
mov rax, [r13+0]
mov r15d, 1
cmp byte ptr [rax+17A3h], 0
jz loc_25246
mov esi, [rax+190h]
lea rdi, aStackDNewlineT; "Stack[%d] Newline token\n"
xor eax, eax
call _printf
jmp short loc_25246
loc_251C7:
xor esi, esi
mov rdx, 100000601h
mov r8, rbx
loc_251D6:
mov rdi, r8
cmp cl, 20h ; ' '
ja short loc_251E8
movzx r8d, cl
bt rdx, r8
jb short loc_251F9
loc_251E8:
lea r8, [rdi+1]
mov [rdi], cl
mov cl, [rax+1]
inc rax
mov rsi, rdi
jmp short loc_251D6
loc_251F9:
cmp byte ptr [rsi], 22h ; '"'
cmovz rdi, rsi
mov byte ptr [rdi], 0
mov rcx, [r13+0]
movsxd rdx, dword ptr [rcx+190h]
mov [rcx+rdx*8+5818h], rax
mov rax, [r13+0]
mov r15d, 1
cmp byte ptr [rax+17A3h], 0
jz short loc_25246
mov esi, [rax+190h]
mov ecx, [rax+1B0h]
lea rdi, aStackDSDmD; "Stack[%d]: <%s>, dm=%d\n"
mov rdx, rbx
xor eax, eax
call _printf
loc_25246:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_25258:
cmp r12d, 0Ah
jz loc_25337
cmp r12d, 22h ; '"'
jnz loc_2538E
loc_2526C:
cmp r12d, 0FFFFFFFEh
jg short loc_25282
mov rax, [r13+0]
mov dword ptr [rax+1C0h], 1
jmp short loc_252AB
loc_25282:
cmp r12d, 5Ch ; '\'
jnz short loc_252AB
mov rax, [r15]
cmp dword ptr [rax+40h], 0
jnz short loc_252AB
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
cmp eax, 0Ah
jz loc_25409
mov r12d, eax
cmp eax, 0FFFFFFFFh
jz loc_25409
loc_252AB:
mov [rbx], r12b
inc rbx
mov rdi, [r14]; this
mov r12, rbx
sub r12, rdi
movsxd rsi, dword ptr [rbp+0]
cmp r12, rsi
jl short loc_252D7
add rsi, rsi; char
mov [rbp+0], esi
call _realloc
mov [r14], rax
add r12, rax
mov rbx, r12
loc_252D7:
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
mov r12d, eax
cmp eax, 0Ah
jz short loc_252FD
cmp r12d, 0FFFFFFFFh
jz loc_25409
cmp r12d, 22h ; '"'
jnz loc_2526C
jmp loc_254C1
loc_252FD:
mov rax, [r13+0]
mov edi, [rax+1E4h]
inc edi
mov [rax+1E4h], edi
mov rsi, [r15]
mov rcx, [rsi+88h]
test rcx, rcx
jz loc_2526C
mov eax, edi
cdq
idiv dword ptr [rsi+4Ch]
test edx, edx
jnz loc_2526C
call rcx
jmp loc_2526C
loc_25337:
mov byte ptr [rbx], 0Ah
inc rbx
mov rdi, [r14]
mov r15, rbx
sub r15, rdi
movsxd rsi, dword ptr [rbp+0]
cmp r15, rsi
jl short loc_25363
add rsi, rsi
mov [rbp+0], esi
call _realloc
mov [r14], rax
add r15, rax
mov rbx, r15
loc_25363:
mov byte ptr [rbx], 0
mov rax, [r13+0]
mov r15d, 1
cmp byte ptr [rax+17A3h], 0
jz loc_25246
lea rdi, aNewlineToken; "Newline token"
call _puts
jmp loc_25246
loc_2538E:
cmp dword ptr [rcx+220h], 0
jz loc_25430
mov r15, 200000C01h
loc_253A5:
lea eax, [r12-80h]
cmp eax, 0FFFFFF7Eh
ja short loc_253BF
mov rax, [r13+0]
mov dword ptr [rax+1C0h], 1
loc_253BF:
lea eax, [r12+1]
cmp eax, 21h ; '!'
ja short loc_253D3
bt r15, rax
jb loc_2555A
loc_253D3:
mov [rbx], r12b
inc rbx
mov rdi, [r14]; this
mov r12, rbx
sub r12, rdi
movsxd rsi, dword ptr [rbp+0]
cmp r12, rsi
jl short loc_253FF
add rsi, rsi
mov [rbp+0], esi
call _realloc
mov [r14], rax
add r12, rax
mov rbx, r12
loc_253FF:
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
mov r12d, eax
jmp short loc_253A5
loc_25409:
mov byte ptr [rbx], 0
lea rsi, aUnexpectedEndO; "Unexpected end of the LEF file."
mov edi, 177Fh; this
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
mov rax, [r13+0]
mov dword ptr [rax+178h], 1
jmp loc_25188
loc_25430:
mov rax, [r15]
cmp dword ptr [rax+0CCh], 0
jz loc_254F0
mov r15, 200000C01h
loc_2544A:
lea eax, [r12-80h]
cmp eax, 0FFFFFF7Eh
ja short loc_25464
mov rax, [r13+0]
mov dword ptr [rax+1C0h], 1
loc_25464:
lea eax, [r12+1]
cmp eax, 21h ; '!'
ja short loc_25478
bt r15, rax
jb loc_2555A
loc_25478:
lea eax, [r12-61h]
lea ecx, [r12-20h]
cmp eax, 1Ah
movzx eax, cl
cmovnb eax, r12d
mov [rbx], al
inc rbx
mov rdi, [r14]; this
mov r12, rbx
sub r12, rdi
movsxd rsi, dword ptr [rbp+0]
cmp r12, rsi
jl short loc_254B7
add rsi, rsi
mov [rbp+0], esi
call _realloc
mov [r14], rax
add r12, rax
mov rbx, r12
loc_254B7:
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
mov r12d, eax
jmp short loc_2544A
loc_254C1:
mov byte ptr [rbx], 0
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
cmp eax, 0FFFFFFFFh
mov r15d, 0
jz short loc_254DD
cmp eax, 20h ; ' '
jnz loc_2557B
loc_254DD:
movsx edi, al; this
call _ZN12LefDefParser9UNlefGetcEc; LefDefParser::UNlefGetc(char)
mov r15d, 1
jmp loc_25246
loc_254F0:
mov r15, 200000C01h
loc_254FA:
lea eax, [r12-80h]
cmp eax, 0FFFFFF7Eh
ja short loc_25514
mov rax, [r13+0]
mov dword ptr [rax+1C0h], 1
loc_25514:
lea eax, [r12+1]
cmp eax, 21h ; '!'
ja short loc_25524
bt r15, rax
jb short loc_2555A
loc_25524:
mov [rbx], r12b
inc rbx
mov rdi, [r14]; this
mov r12, rbx
sub r12, rdi
movsxd rsi, dword ptr [rbp+0]
cmp r12, rsi
jl short loc_25550
add rsi, rsi
mov [rbp+0], esi
call _realloc
mov [r14], rax
add r12, rax
mov rbx, r12
loc_25550:
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
mov r12d, eax
jmp short loc_254FA
loc_2555A:
mov byte ptr [rbx], 0
mov r15d, 1
cmp r12d, 0FFFFFFFFh
jz loc_25246
movsx edi, r12b; this
call _ZN12LefDefParser9UNlefGetcEc; LefDefParser::UNlefGetc(char)
jmp loc_25246
loc_2557B:
movsx edi, al; this
call _ZN12LefDefParser9UNlefGetcEc; LefDefParser::UNlefGetc(char)
mov rax, [r13+0]
mov dword ptr [rax+280h], 1
jmp loc_25246
|
long long LefDefParser::GetToken(char **this, char **a2, int *a3)
{
char *v4; // rbx
int *v5; // rdx
long long v6; // rdi
_BYTE *i; // rax
int v8; // ecx
int v11; // eax
unsigned int v12; // r15d
int v13; // r12d
long long v14; // rcx
void ( *v15)(long long); // rsi
char *v16; // rsi
long long v17; // rdx
char *v18; // r8
char *v19; // rdi
int v21; // eax
const char *v22; // rdx
signed long long v23; // r12
signed long long v24; // rsi
long long v25; // rax
void ( *v26)(long long); // rcx
_BYTE *v27; // rbx
char *v28; // rdi
long long v29; // r15
long long v30; // rsi
long long v31; // rax
long long v32; // r15
unsigned long long v33; // rax
LefDefParser *v34; // rdi
signed long long v35; // r12
signed long long v36; // rsi
long long v37; // rax
long long v38; // r15
unsigned long long v39; // rax
char v40; // al
LefDefParser *v41; // rdi
signed long long v42; // r12
signed long long v43; // rsi
long long v44; // rax
int v45; // eax
long long v46; // r15
unsigned long long v47; // rax
LefDefParser *v48; // rdi
signed long long v49; // r12
signed long long v50; // rsi
long long v51; // rax
v4 = *this;
v5 = *(int **)LefDefParser::lefData;
++*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 488LL);
v5[112] = 0;
v6 = v5[100];
if ( v6 >= 0 )
{
LABEL_2:
for ( i = *(_BYTE **)&v5[2 * v6 + 5638]; ; ++i )
{
v8 = (unsigned __int8)*i;
if ( v8 != 9 && v8 != 32 )
{
if ( !*i )
{
v5[100] = v6 - 1;
if ( v6-- > 0 )
goto LABEL_2;
break;
}
if ( (_BYTE)v8 != 10 || v5[115] )
{
if ( v8 == 10 )
{
*(_WORD *)v4 = 10;
v12 = 1;
if ( *(_BYTE *)(*(_QWORD *)LefDefParser::lefData + 6051LL) )
printf("Stack[%d] Newline token\n", *(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 400LL));
}
else
{
v16 = 0LL;
v17 = 0x100000601LL;
v18 = v4;
while ( 1 )
{
v19 = v18;
if ( (unsigned __int8)v8 <= 0x20u )
{
if ( _bittest64(&v17, (unsigned __int8)v8) )
break;
}
++v18;
*v19 = v8;
LOBYTE(v8) = *++i;
v16 = v19;
}
if ( *v16 == 34 )
v19 = v16;
*v19 = 0;
*(_QWORD *)(*(_QWORD *)LefDefParser::lefData
+ 8LL * *(int *)(*(_QWORD *)LefDefParser::lefData + 400LL)
+ 22552) = i;
v12 = 1;
if ( *(_BYTE *)(*(_QWORD *)LefDefParser::lefData + 6051LL) )
printf(
"Stack[%d]: <%s>, dm=%d\n",
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 400LL),
v4,
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 432LL));
}
return v12;
}
}
}
}
v11 = LefDefParser::lefGetc((LefDefParser *)v6);
v12 = 0;
if ( v11 != -1 )
{
v13 = v11;
while ( 1 )
{
v14 = *(_QWORD *)LefDefParser::lefData;
if ( *(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 244LL) && !*((_DWORD *)LefDefParser::lefSettings + 48) )
return 0;
if ( v13 != 9 && v13 != 32 )
{
if ( v13 == 10 )
{
v6 = (unsigned int)(*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) + 1);
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) = v6;
v15 = (void ( *)(long long))*((_QWORD *)LefDefParser::lefSettings + 17);
if ( v15 )
{
if ( !((int)v6 % *((_DWORD *)LefDefParser::lefSettings + 19)) )
{
v15(v6);
v14 = *(_QWORD *)LefDefParser::lefData;
}
}
}
if ( v13 != 10 || *(_DWORD *)(v14 + 460) )
break;
}
v13 = LefDefParser::lefGetc((LefDefParser *)v6);
if ( v13 == -1 )
return 0;
}
if ( v13 == 10 )
{
*v4 = 10;
v27 = v4 + 1;
v28 = *this;
v29 = v27 - *this;
v30 = *(int *)a2;
if ( v29 >= v30 )
{
*(_DWORD *)a2 = 2 * v30;
v31 = realloc(v28);
*this = (char *)v31;
v27 = (_BYTE *)(v31 + v29);
}
*v27 = 0;
v12 = 1;
if ( *(_BYTE *)(*(_QWORD *)LefDefParser::lefData + 6051LL) )
puts("Newline token");
}
else if ( v13 == 34 )
{
do
{
while ( 1 )
{
if ( v13 > -2 )
{
if ( v13 == 92 && !*((_DWORD *)LefDefParser::lefSettings + 16) )
{
v21 = LefDefParser::lefGetc((LefDefParser *)v6);
if ( v21 == 10 || (LOBYTE(v13) = v21, v21 == -1) )
{
LABEL_67:
*v4 = 0;
LefDefParser::lefError((LefDefParser *)0x177F, (long long)"Unexpected end of the LEF file.", v22);
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 376LL) = 1;
return 0;
}
}
}
else
{
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 448LL) = 1;
}
*v4++ = v13;
v6 = (long long)*this;
v23 = v4 - *this;
v24 = *(int *)a2;
if ( v23 >= v24 )
{
*(_DWORD *)a2 = 2 * v24;
v25 = realloc(v6);
*this = (char *)v25;
v4 = (char *)(v25 + v23);
}
v13 = LefDefParser::lefGetc((LefDefParser *)v6);
if ( v13 != 10 )
break;
v6 = (unsigned int)(*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) + 1);
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) = v6;
v26 = (void ( *)(long long))*((_QWORD *)LefDefParser::lefSettings + 17);
if ( v26 && !((int)v6 % *((_DWORD *)LefDefParser::lefSettings + 19)) )
v26(v6);
}
if ( v13 == -1 )
goto LABEL_67;
}
while ( v13 != 34 );
*v4 = 0;
v45 = LefDefParser::lefGetc((LefDefParser *)v6);
v12 = 0;
if ( v45 == -1 || v45 == 32 )
{
LefDefParser::UNlefGetc((LefDefParser *)(unsigned int)(char)v45);
return 1;
}
else
{
LefDefParser::UNlefGetc((LefDefParser *)(unsigned int)(char)v45);
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 640LL) = 1;
}
}
else
{
if ( *(_DWORD *)(v14 + 544) )
{
v32 = 0x200000C01LL;
while ( 1 )
{
if ( (unsigned int)(v13 - 128) <= 0xFFFFFF7E )
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 448LL) = 1;
v33 = (unsigned int)(v13 + 1);
if ( (unsigned int)v33 <= 0x21 )
{
if ( _bittest64(&v32, v33) )
break;
}
*v4++ = v13;
v34 = (LefDefParser *)*this;
v35 = v4 - *this;
v36 = *(int *)a2;
if ( v35 >= v36 )
{
*(_DWORD *)a2 = 2 * v36;
v37 = realloc(v34);
*this = (char *)v37;
v4 = (char *)(v37 + v35);
}
v13 = LefDefParser::lefGetc(v34);
}
}
else if ( *((_DWORD *)LefDefParser::lefSettings + 51) )
{
v38 = 0x200000C01LL;
while ( 1 )
{
if ( (unsigned int)(v13 - 128) <= 0xFFFFFF7E )
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 448LL) = 1;
v39 = (unsigned int)(v13 + 1);
if ( (unsigned int)v39 <= 0x21 )
{
if ( _bittest64(&v38, v39) )
break;
}
v40 = v13 - 32;
if ( (unsigned int)(v13 - 97) >= 0x1A )
v40 = v13;
*v4++ = v40;
v41 = (LefDefParser *)*this;
v42 = v4 - *this;
v43 = *(int *)a2;
if ( v42 >= v43 )
{
*(_DWORD *)a2 = 2 * v43;
v44 = realloc(v41);
*this = (char *)v44;
v4 = (char *)(v44 + v42);
}
v13 = LefDefParser::lefGetc(v41);
}
}
else
{
v46 = 0x200000C01LL;
while ( 1 )
{
if ( (unsigned int)(v13 - 128) <= 0xFFFFFF7E )
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 448LL) = 1;
v47 = (unsigned int)(v13 + 1);
if ( (unsigned int)v47 <= 0x21 )
{
if ( _bittest64(&v46, v47) )
break;
}
*v4++ = v13;
v48 = (LefDefParser *)*this;
v49 = v4 - *this;
v50 = *(int *)a2;
if ( v49 >= v50 )
{
*(_DWORD *)a2 = 2 * v50;
v51 = realloc(v48);
*this = (char *)v51;
v4 = (char *)(v51 + v49);
}
v13 = LefDefParser::lefGetc(v48);
}
}
*v4 = 0;
v12 = 1;
if ( v13 != -1 )
LefDefParser::UNlefGetc((LefDefParser *)(unsigned int)(char)v13);
}
}
return v12;
}
|
GetToken:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LEA R13,[0x1775e0]
MOV RDX,qword ptr [R13]
INC dword ptr [RDX + 0x1e8]
MOV dword ptr [RDX + 0x1c0],0x0
MOVSXD RDI,dword ptr [RDX + 0x190]
TEST RDI,RDI
JS 0x001250ed
LAB_001250a7:
MOV RAX,qword ptr [RDX + RDI*0x8 + 0x5818]
LAB_001250af:
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x9
JZ 0x001250ce
CMP ECX,0x20
JZ 0x001250ce
TEST ECX,ECX
JZ 0x001250db
CMP CL,0xa
JNZ 0x001250d3
CMP dword ptr [RDX + 0x1cc],0x0
JNZ 0x001250d3
LAB_001250ce:
INC RAX
JMP 0x001250af
LAB_001250d3:
TEST ECX,ECX
JNZ 0x00125190
LAB_001250db:
LEA RAX,[RDI + -0x1]
MOV dword ptr [RDX + 0x190],EAX
TEST RDI,RDI
MOV RDI,RAX
JG 0x001250a7
LAB_001250ed:
MOV RBP,RSI
CALL 0x00124492
XOR R15D,R15D
CMP EAX,-0x1
JZ 0x00125246
MOV R12D,EAX
LEA R15,[0x1775b8]
LAB_0012510b:
MOV RCX,qword ptr [R13]
CMP dword ptr [RCX + 0xf4],0x0
JZ 0x00125124
MOV RAX,qword ptr [R15]
CMP dword ptr [RAX + 0xc0],0x0
JZ 0x00125188
LAB_00125124:
CMP R12D,0x9
JZ 0x0012517b
CMP R12D,0x20
JZ 0x0012517b
CMP R12D,0xa
JNZ 0x00125164
MOV EDI,dword ptr [RCX + 0x1e4]
INC EDI
MOV dword ptr [RCX + 0x1e4],EDI
MOV R8,qword ptr [R15]
MOV RSI,qword ptr [R8 + 0x88]
TEST RSI,RSI
JZ 0x00125164
MOV EAX,EDI
CDQ
IDIV dword ptr [R8 + 0x4c]
TEST EDX,EDX
JNZ 0x00125164
CALL RSI
MOV RCX,qword ptr [R13]
LAB_00125164:
CMP R12D,0xa
JNZ 0x00125258
CMP dword ptr [RCX + 0x1cc],0x0
JNZ 0x00125258
LAB_0012517b:
CALL 0x00124492
MOV R12D,EAX
CMP EAX,-0x1
JNZ 0x0012510b
LAB_00125188:
XOR R15D,R15D
JMP 0x00125246
LAB_00125190:
CMP ECX,0xa
JNZ 0x001251c7
MOV word ptr [RBX],0xa
MOV RAX,qword ptr [R13]
MOV R15D,0x1
CMP byte ptr [RAX + 0x17a3],0x0
JZ 0x00125246
MOV ESI,dword ptr [RAX + 0x190]
LEA RDI,[0x151ed5]
XOR EAX,EAX
CALL 0x00102030
JMP 0x00125246
LAB_001251c7:
XOR ESI,ESI
MOV RDX,0x100000601
MOV R8,RBX
LAB_001251d6:
MOV RDI,R8
CMP CL,0x20
JA 0x001251e8
MOVZX R8D,CL
BT RDX,R8
JC 0x001251f9
LAB_001251e8:
LEA R8,[RDI + 0x1]
MOV byte ptr [RDI],CL
MOV CL,byte ptr [RAX + 0x1]
INC RAX
MOV RSI,RDI
JMP 0x001251d6
LAB_001251f9:
CMP byte ptr [RSI],0x22
CMOVZ RDI,RSI
MOV byte ptr [RDI],0x0
MOV RCX,qword ptr [R13]
MOVSXD RDX,dword ptr [RCX + 0x190]
MOV qword ptr [RCX + RDX*0x8 + 0x5818],RAX
MOV RAX,qword ptr [R13]
MOV R15D,0x1
CMP byte ptr [RAX + 0x17a3],0x0
JZ 0x00125246
MOV ESI,dword ptr [RAX + 0x190]
MOV ECX,dword ptr [RAX + 0x1b0]
LEA RDI,[0x151eee]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00102030
LAB_00125246:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00125258:
CMP R12D,0xa
JZ 0x00125337
CMP R12D,0x22
JNZ 0x0012538e
LAB_0012526c:
CMP R12D,-0x2
JG 0x00125282
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x1c0],0x1
JMP 0x001252ab
LAB_00125282:
CMP R12D,0x5c
JNZ 0x001252ab
MOV RAX,qword ptr [R15]
CMP dword ptr [RAX + 0x40],0x0
JNZ 0x001252ab
CALL 0x00124492
CMP EAX,0xa
JZ 0x00125409
MOV R12D,EAX
CMP EAX,-0x1
JZ 0x00125409
LAB_001252ab:
MOV byte ptr [RBX],R12B
INC RBX
MOV RDI,qword ptr [R14]
MOV R12,RBX
SUB R12,RDI
MOVSXD RSI,dword ptr [RBP]
CMP R12,RSI
JL 0x001252d7
ADD RSI,RSI
MOV dword ptr [RBP],ESI
CALL 0x00102340
MOV qword ptr [R14],RAX
ADD R12,RAX
MOV RBX,R12
LAB_001252d7:
CALL 0x00124492
MOV R12D,EAX
CMP EAX,0xa
JZ 0x001252fd
CMP R12D,-0x1
JZ 0x00125409
CMP R12D,0x22
JNZ 0x0012526c
JMP 0x001254c1
LAB_001252fd:
MOV RAX,qword ptr [R13]
MOV EDI,dword ptr [RAX + 0x1e4]
INC EDI
MOV dword ptr [RAX + 0x1e4],EDI
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [RSI + 0x88]
TEST RCX,RCX
JZ 0x0012526c
MOV EAX,EDI
CDQ
IDIV dword ptr [RSI + 0x4c]
TEST EDX,EDX
JNZ 0x0012526c
CALL RCX
JMP 0x0012526c
LAB_00125337:
MOV byte ptr [RBX],0xa
INC RBX
MOV RDI,qword ptr [R14]
MOV R15,RBX
SUB R15,RDI
MOVSXD RSI,dword ptr [RBP]
CMP R15,RSI
JL 0x00125363
ADD RSI,RSI
MOV dword ptr [RBP],ESI
CALL 0x00102340
MOV qword ptr [R14],RAX
ADD R15,RAX
MOV RBX,R15
LAB_00125363:
MOV byte ptr [RBX],0x0
MOV RAX,qword ptr [R13]
MOV R15D,0x1
CMP byte ptr [RAX + 0x17a3],0x0
JZ 0x00125246
LEA RDI,[0x151f9e]
CALL 0x001022e0
JMP 0x00125246
LAB_0012538e:
CMP dword ptr [RCX + 0x220],0x0
JZ 0x00125430
MOV R15,0x200000c01
LAB_001253a5:
LEA EAX,[R12 + -0x80]
CMP EAX,0xffffff7e
JA 0x001253bf
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x1c0],0x1
LAB_001253bf:
LEA EAX,[R12 + 0x1]
CMP EAX,0x21
JA 0x001253d3
BT R15,RAX
JC 0x0012555a
LAB_001253d3:
MOV byte ptr [RBX],R12B
INC RBX
MOV RDI,qword ptr [R14]
MOV R12,RBX
SUB R12,RDI
MOVSXD RSI,dword ptr [RBP]
CMP R12,RSI
JL 0x001253ff
ADD RSI,RSI
MOV dword ptr [RBP],ESI
CALL 0x00102340
MOV qword ptr [R14],RAX
ADD R12,RAX
MOV RBX,R12
LAB_001253ff:
CALL 0x00124492
MOV R12D,EAX
JMP 0x001253a5
LAB_00125409:
MOV byte ptr [RBX],0x0
LEA RSI,[0x151281]
MOV EDI,0x177f
CALL 0x0012453a
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x178],0x1
JMP 0x00125188
LAB_00125430:
MOV RAX,qword ptr [R15]
CMP dword ptr [RAX + 0xcc],0x0
JZ 0x001254f0
MOV R15,0x200000c01
LAB_0012544a:
LEA EAX,[R12 + -0x80]
CMP EAX,0xffffff7e
JA 0x00125464
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x1c0],0x1
LAB_00125464:
LEA EAX,[R12 + 0x1]
CMP EAX,0x21
JA 0x00125478
BT R15,RAX
JC 0x0012555a
LAB_00125478:
LEA EAX,[R12 + -0x61]
LEA ECX,[R12 + -0x20]
CMP EAX,0x1a
MOVZX EAX,CL
CMOVNC EAX,R12D
MOV byte ptr [RBX],AL
INC RBX
MOV RDI,qword ptr [R14]
MOV R12,RBX
SUB R12,RDI
MOVSXD RSI,dword ptr [RBP]
CMP R12,RSI
JL 0x001254b7
ADD RSI,RSI
MOV dword ptr [RBP],ESI
CALL 0x00102340
MOV qword ptr [R14],RAX
ADD R12,RAX
MOV RBX,R12
LAB_001254b7:
CALL 0x00124492
MOV R12D,EAX
JMP 0x0012544a
LAB_001254c1:
MOV byte ptr [RBX],0x0
CALL 0x00124492
CMP EAX,-0x1
MOV R15D,0x0
JZ 0x001254dd
CMP EAX,0x20
JNZ 0x0012557b
LAB_001254dd:
MOVSX EDI,AL
CALL 0x001244f9
MOV R15D,0x1
JMP 0x00125246
LAB_001254f0:
MOV R15,0x200000c01
LAB_001254fa:
LEA EAX,[R12 + -0x80]
CMP EAX,0xffffff7e
JA 0x00125514
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x1c0],0x1
LAB_00125514:
LEA EAX,[R12 + 0x1]
CMP EAX,0x21
JA 0x00125524
BT R15,RAX
JC 0x0012555a
LAB_00125524:
MOV byte ptr [RBX],R12B
INC RBX
MOV RDI,qword ptr [R14]
MOV R12,RBX
SUB R12,RDI
MOVSXD RSI,dword ptr [RBP]
CMP R12,RSI
JL 0x00125550
ADD RSI,RSI
MOV dword ptr [RBP],ESI
CALL 0x00102340
MOV qword ptr [R14],RAX
ADD R12,RAX
MOV RBX,R12
LAB_00125550:
CALL 0x00124492
MOV R12D,EAX
JMP 0x001254fa
LAB_0012555a:
MOV byte ptr [RBX],0x0
MOV R15D,0x1
CMP R12D,-0x1
JZ 0x00125246
MOVSX EDI,R12B
CALL 0x001244f9
JMP 0x00125246
LAB_0012557b:
MOVSX EDI,AL
CALL 0x001244f9
MOV RAX,qword ptr [R13]
MOV dword ptr [RAX + 0x280],0x1
JMP 0x00125246
|
/* LefDefParser::GetToken(char**, int*) */
int8 LefDefParser::GetToken(char **param_1,int *param_2)
{
bool bVar1;
size_t sVar2;
byte bVar3;
int iVar4;
byte *pbVar5;
char *pcVar6;
byte *pbVar7;
byte *pbVar8;
int iVar9;
long lVar10;
byte *pbVar11;
long lVar12;
int8 uVar13;
lVar12 = lefData;
pbVar7 = (byte *)*param_1;
*(int *)(lefData + 0x1e8) = *(int *)(lefData + 0x1e8) + 1;
*(int4 *)(lVar12 + 0x1c0) = 0;
lVar10 = (long)*(int *)(lVar12 + 400);
if (-1 < (long)*(int *)(lVar12 + 400)) {
LAB_001250a7:
pbVar5 = *(byte **)(lVar12 + 0x5818 + lVar10 * 8);
do {
bVar3 = *pbVar5;
if ((bVar3 != 9) && (bVar3 != 0x20)) {
if (bVar3 == 0) goto LAB_001250db;
if ((bVar3 != 10) || (*(int *)(lVar12 + 0x1cc) != 0)) goto LAB_001250d3;
}
pbVar5 = pbVar5 + 1;
} while( true );
}
LAB_001250ed:
iVar4 = lefGetc();
if (iVar4 == -1) {
return 0;
}
do {
lVar12 = lefData;
if ((*(int *)(lefData + 0xf4) != 0) && (*(int *)(lefSettings + 0xc0) == 0)) {
return 0;
}
if ((iVar4 != 9) && (iVar4 != 0x20)) {
if (iVar4 == 10) {
iVar9 = *(int *)(lefData + 0x1e4) + 1;
*(int *)(lefData + 0x1e4) = iVar9;
if ((*(code **)(lefSettings + 0x88) != (code *)0x0) &&
(iVar9 % *(int *)(lefSettings + 0x4c) == 0)) {
(**(code **)(lefSettings + 0x88))();
lVar12 = lefData;
}
}
if ((iVar4 != 10) || (*(int *)(lVar12 + 0x1cc) != 0)) {
if (iVar4 == 10) {
*pbVar7 = 10;
pbVar7 = pbVar7 + 1;
pcVar6 = *param_1;
lVar12 = (long)pbVar7 - (long)pcVar6;
if (*param_2 <= lVar12) {
sVar2 = (long)*param_2 * 2;
*param_2 = (int)sVar2;
pcVar6 = (char *)realloc(pcVar6,sVar2);
*param_1 = pcVar6;
pbVar7 = (byte *)(pcVar6 + lVar12);
}
*pbVar7 = 0;
if (*(char *)(lefData + 0x17a3) != '\0') {
puts("Newline token");
return 1;
}
return 1;
}
if (iVar4 != 0x22) {
if (*(int *)(lVar12 + 0x220) == 0) {
if (*(int *)(lefSettings + 0xcc) == 0) {
while( true ) {
if (iVar4 - 0x80U < 0xffffff7f) {
*(int4 *)(lefData + 0x1c0) = 1;
}
if ((iVar4 + 1U < 0x22) && ((0x200000c01U >> ((ulong)(iVar4 + 1U) & 0x3f) & 1) != 0)
) break;
*pbVar7 = (byte)iVar4;
pbVar7 = pbVar7 + 1;
pcVar6 = *param_1;
lVar12 = (long)pbVar7 - (long)pcVar6;
if (*param_2 <= lVar12) {
sVar2 = (long)*param_2 * 2;
*param_2 = (int)sVar2;
pcVar6 = (char *)realloc(pcVar6,sVar2);
*param_1 = pcVar6;
pbVar7 = (byte *)(pcVar6 + lVar12);
}
iVar4 = lefGetc();
}
}
else {
while( true ) {
if (iVar4 - 0x80U < 0xffffff7f) {
*(int4 *)(lefData + 0x1c0) = 1;
}
if ((iVar4 + 1U < 0x22) && ((0x200000c01U >> ((ulong)(iVar4 + 1U) & 0x3f) & 1) != 0)
) break;
bVar3 = (byte)iVar4 - 0x20;
if (0x19 < iVar4 - 0x61U) {
bVar3 = (byte)iVar4;
}
*pbVar7 = bVar3;
pbVar7 = pbVar7 + 1;
pcVar6 = *param_1;
lVar12 = (long)pbVar7 - (long)pcVar6;
if (*param_2 <= lVar12) {
sVar2 = (long)*param_2 * 2;
*param_2 = (int)sVar2;
pcVar6 = (char *)realloc(pcVar6,sVar2);
*param_1 = pcVar6;
pbVar7 = (byte *)(pcVar6 + lVar12);
}
iVar4 = lefGetc();
}
}
}
else {
while( true ) {
if (iVar4 - 0x80U < 0xffffff7f) {
*(int4 *)(lefData + 0x1c0) = 1;
}
if ((iVar4 + 1U < 0x22) && ((0x200000c01U >> ((ulong)(iVar4 + 1U) & 0x3f) & 1) != 0))
break;
*pbVar7 = (byte)iVar4;
pbVar7 = pbVar7 + 1;
pcVar6 = *param_1;
lVar12 = (long)pbVar7 - (long)pcVar6;
if (*param_2 <= lVar12) {
sVar2 = (long)*param_2 * 2;
*param_2 = (int)sVar2;
pcVar6 = (char *)realloc(pcVar6,sVar2);
*param_1 = pcVar6;
pbVar7 = (byte *)(pcVar6 + lVar12);
}
iVar4 = lefGetc();
}
}
*pbVar7 = 0;
if (iVar4 != -1) {
UNlefGetc((char)iVar4);
return 1;
}
return 1;
}
goto LAB_0012526c;
}
}
iVar4 = lefGetc();
if (iVar4 == -1) {
return 0;
}
} while( true );
LAB_001250d3:
if (bVar3 != 0) {
if (bVar3 == 10) {
pbVar7[0] = 10;
pbVar7[1] = 0;
if (*(char *)(lefData + 0x17a3) != '\0') {
printf("Stack[%d] Newline token\n",(ulong)*(uint *)(lefData + 400));
return 1;
}
return 1;
}
pbVar8 = (byte *)0x0;
pbVar11 = pbVar7;
while ((0x20 < bVar3 || ((0x100000601U >> ((ulong)bVar3 & 0x3f) & 1) == 0))) {
*pbVar11 = bVar3;
bVar3 = pbVar5[1];
pbVar5 = pbVar5 + 1;
pbVar8 = pbVar11;
pbVar11 = pbVar11 + 1;
}
if (*pbVar8 == 0x22) {
pbVar11 = pbVar8;
}
*pbVar11 = 0;
*(byte **)(lefData + 0x5818 + (long)*(int *)(lefData + 400) * 8) = pbVar5;
if (*(char *)(lefData + 0x17a3) != '\0') {
printf("Stack[%d]: <%s>, dm=%d\n",(ulong)*(uint *)(lefData + 400),pbVar7,
(ulong)*(uint *)(lefData + 0x1b0));
return 1;
}
return 1;
}
LAB_001250db:
*(int *)(lVar12 + 400) = (int)(lVar10 + -1);
bVar1 = lVar10 < 1;
lVar10 = lVar10 + -1;
if (bVar1) goto LAB_001250ed;
goto LAB_001250a7;
LAB_0012526c:
if (iVar4 < -1) {
*(int4 *)(lefData + 0x1c0) = 1;
}
else if (((iVar4 == 0x5c) && (*(int *)(lefSettings + 0x40) == 0)) &&
((iVar4 = lefGetc(), iVar4 == 10 || (iVar4 == -1)))) goto LAB_00125409;
*pbVar7 = (byte)iVar4;
pbVar7 = pbVar7 + 1;
pcVar6 = *param_1;
lVar12 = (long)pbVar7 - (long)pcVar6;
if (*param_2 <= lVar12) {
sVar2 = (long)*param_2 * 2;
*param_2 = (int)sVar2;
pcVar6 = (char *)realloc(pcVar6,sVar2);
*param_1 = pcVar6;
pbVar7 = (byte *)(pcVar6 + lVar12);
}
iVar4 = lefGetc();
if (iVar4 == 10) {
iVar9 = *(int *)(lefData + 0x1e4) + 1;
*(int *)(lefData + 0x1e4) = iVar9;
if ((*(code **)(lefSettings + 0x88) != (code *)0x0) &&
(iVar9 % *(int *)(lefSettings + 0x4c) == 0)) {
(**(code **)(lefSettings + 0x88))();
}
goto LAB_0012526c;
}
if (iVar4 == -1) {
LAB_00125409:
*pbVar7 = 0;
lefError(0x177f,"Unexpected end of the LEF file.");
*(int4 *)(lefData + 0x178) = 1;
return 0;
}
if (iVar4 == 0x22) {
*pbVar7 = 0;
iVar4 = lefGetc();
uVar13 = 0;
if ((iVar4 == -1) || (iVar4 == 0x20)) {
UNlefGetc((char)iVar4);
uVar13 = 1;
}
else {
UNlefGetc((char)iVar4);
*(int4 *)(lefData + 0x280) = 1;
}
return uVar13;
}
goto LAB_0012526c;
}
|
|
5,088 |
pow5mult
|
eloqsql/strings/dtoa.c
|
static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
}
|
O0
|
c
|
pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x6a2b3
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x32230f(%rip), %rax # 0x38c5b0
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x6ac00
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6a2ce
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a3c4
leaq 0x3222eb(%rip), %rax # 0x38c5c0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6a30e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6a3d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6a620
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6a320
jmp 0x6a3a8
cmpb $0x0, -0x3d(%rbp)
je 0x6a352
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6a3d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6a620
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6a3a3
leaq 0x322267(%rip), %rax # 0x38c5c0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x6a373
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x6a3a1
leaq 0x322246(%rip), %rax # 0x38c5c0
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x6a39f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6a3d0
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x6a3a1
jmp 0x6a3a3
jmp 0x6a2d9
cmpq $0x0, -0x38(%rbp)
je 0x6a3bc
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6a620
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
|
pow5mult:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_6A2B3
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_6A2B3:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_6A2CE
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_6A3C4
loc_6A2CE:
lea rax, p5_a
mov [rbp+var_30], rax
loc_6A2D9:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_6A30E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_6A30E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_6A320
jmp loc_6A3A8
loc_6A320:
cmp [rbp+var_3D], 0
jz short loc_6A352
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_6A3A3
loc_6A352:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_6A373
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_6A3A1
loc_6A373:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_6A39F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_6A39F:
jmp short $+2
loc_6A3A1:
jmp short $+2
loc_6A3A3:
jmp loc_6A2D9
loc_6A3A8:
cmp [rbp+var_38], 0
jz short loc_6A3BC
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_6A3BC:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_6A3C4:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
|
pow5mult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x0016a2b3
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x48c5b0]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x0016ac00
MOV qword ptr [RBP + -0x10],RAX
LAB_0016a2b3:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0016a2ce
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016a3c4
LAB_0016a2ce:
LEA RAX,[0x48c5c0]
MOV qword ptr [RBP + -0x30],RAX
LAB_0016a2d9:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016a30e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0016a3d0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0016a620
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0016a30e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0016a320
JMP 0x0016a3a8
LAB_0016a320:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x0016a352
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0016a3d0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0016a620
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0016a3a3
LAB_0016a352:
LEA RAX,[0x48c5c0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x0016a373
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0016a3a1
LAB_0016a373:
LEA RAX,[0x48c5c0]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0016a39f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0016a3d0
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0016a39f:
JMP 0x0016a3a1
LAB_0016a3a1:
JMP 0x0016a3a3
LAB_0016a3a3:
JMP 0x0016a2d9
LAB_0016a3a8:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0016a3bc
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0016a620
LAB_0016a3bc:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016a3c4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x48c650) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x48c650) {
local_38 = (int1 *)mult(0x48c650,0x48c650,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
|
|
5,089 |
my_open
|
eloqsql/mysys/my_open.c
|
File my_open(const char *FileName, int Flags, myf MyFlags)
/* Path-name of file */
/* Read | write .. */
/* Special flags */
{
File fd;
DBUG_ENTER("my_open");
DBUG_PRINT("my",("Name: '%s' Flags: %d MyFlags: %lu",
FileName, Flags, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FFNF)))
MyFlags|= my_global_flags;
#if defined(_WIN32)
fd= my_win_open(FileName, Flags);
#else
if (MyFlags & MY_NOSYMLINKS)
fd = open_nosymlinks(FileName, Flags | O_CLOEXEC, my_umask);
else
fd = open(FileName, Flags | O_CLOEXEC, my_umask);
#endif
fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
EE_FILENOTFOUND, MyFlags);
DBUG_RETURN(fd);
}
|
O0
|
c
|
my_open:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xf4225
movq -0x18(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
jne 0xf4245
leaq 0xb8e84e(%rip), %rax # 0xc82a88
movq (%rax), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0xf4275
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x1cbabf(%rip), %rax # 0x2bfd28
movl (%rax), %edx
callq 0xf42d0
movl %eax, -0x1c(%rbp)
jmp 0xf4295
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi # imm = 0x80000
leaq 0x1cba9f(%rip), %rax # 0x2bfd28
movl (%rax), %edx
movb $0x0, %al
callq 0x2a930
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x1, %edx
movl $0x1d, %ecx
callq 0xf4340
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_open:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_F4225:
mov rax, [rbp+var_18]
and rax, 19h
cmp rax, 0
jnz short loc_F4245
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_18]
mov [rbp+var_18], rax
loc_F4245:
mov rax, [rbp+var_18]
and rax, 200h
cmp rax, 0
jz short loc_F4275
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
call open_nosymlinks
mov [rbp+var_1C], eax
jmp short loc_F4295
loc_F4275:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
or esi, 80000h
lea rax, my_umask
mov edx, [rax]
mov al, 0
call _open64
mov [rbp+var_1C], eax
loc_F4295:
mov edi, [rbp+var_1C]
mov rsi, [rbp+var_8]
mov r8, [rbp+var_18]
mov edx, 1
mov ecx, 1Dh
call my_register_filename
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long my_open(long long a1, int a2, long long a3)
{
unsigned int v4; // [rsp+4h] [rbp-1Ch]
long long v5; // [rsp+8h] [rbp-18h]
v5 = a3;
if ( (a3 & 0x19) == 0 )
v5 = a3 | my_global_flags;
if ( (v5 & 0x200) != 0 )
v4 = open_nosymlinks(a1, a2 | 0x80000u, my_umask);
else
v4 = open64(a1, a2 | 0x80000u, my_umask);
return (unsigned int)my_register_filename(v4, a1, 1LL, 29LL, v5);
}
|
my_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001f4225
LAB_001f4225:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x19
CMP RAX,0x0
JNZ 0x001f4245
LEA RAX,[0xd82a88]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
LAB_001f4245:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x200
CMP RAX,0x0
JZ 0x001f4275
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x3bfd28]
MOV EDX,dword ptr [RAX]
CALL 0x001f42d0
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001f4295
LAB_001f4275:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
OR ESI,0x80000
LEA RAX,[0x3bfd28]
MOV EDX,dword ptr [RAX]
MOV AL,0x0
CALL 0x0012a930
MOV dword ptr [RBP + -0x1c],EAX
LAB_001f4295:
MOV EDI,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x18]
MOV EDX,0x1
MOV ECX,0x1d
CALL 0x001f4340
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int4 my_open(char *param_1,uint param_2,ulong param_3)
{
int4 uVar1;
int4 local_24;
int8 local_20;
local_20 = param_3;
if ((param_3 & 0x19) == 0) {
local_20 = my_global_flags | param_3;
}
if ((local_20 & 0x200) == 0) {
local_24 = open64(param_1,param_2 | 0x80000,(ulong)my_umask);
}
else {
local_24 = open_nosymlinks(param_1,param_2 | 0x80000,my_umask);
}
uVar1 = my_register_filename(local_24,param_1,1,0x1d,local_20);
return uVar1;
}
|
|
5,090 |
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
|
monkey531[P]llama/common/json.hpp
|
inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
JSON_ASSERT(M_plus.e >= kAlpha);
JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
JSON_ASSERT(p1 > 0);
std::uint32_t pow10{};
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movl %r8d, 0x10(%rsp)
movl 0x68(%rsp), %eax
cmpl $-0x3d, %eax
jle 0xb7dd8
movq %rdx, (%rsp)
cmpl $-0x1f, %eax
jge 0xb7df4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r13
leaq 0x50(%rsp), %rbp
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0xb7e48
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb7e48
xorl %ecx, %ecx
subl 0x8(%r13), %ecx
movl $0x1, %r9d
shlq %cl, %r9
movq (%r13), %r8
movq %r8, %rdx
shrq %cl, %rdx
testl %edx, %edx
je 0xb7e10
movq %rax, %r10
leaq -0x1(%r9), %rsi
cmpl $0x3b9ac9ff, %edx # imm = 0x3B9AC9FF
jbe 0xb7be1
movl $0x3b9aca00, %edi # imm = 0x3B9ACA00
movl $0xa, %r13d
jmp 0xb7c86
cmpl $0x5f5e0ff, %edx # imm = 0x5F5E0FF
jbe 0xb7bf9
movl $0x5f5e100, %edi # imm = 0x5F5E100
movl $0x9, %r13d
jmp 0xb7c86
cmpl $0x98967f, %edx # imm = 0x98967F
jbe 0xb7c0e
movl $0x989680, %edi # imm = 0x989680
movl $0x8, %r13d
jmp 0xb7c86
cmpl $0xf423f, %edx # imm = 0xF423F
jbe 0xb7c23
movl $0xf4240, %edi # imm = 0xF4240
movl $0x7, %r13d
jmp 0xb7c86
cmpl $0x1869f, %edx # imm = 0x1869F
jbe 0xb7c38
movl $0x186a0, %edi # imm = 0x186A0
movl $0x6, %r13d
jmp 0xb7c86
cmpl $0x270f, %edx # imm = 0x270F
jbe 0xb7c4d
movl $0x2710, %edi # imm = 0x2710
movl $0x5, %r13d
jmp 0xb7c86
cmpl $0x3e7, %edx # imm = 0x3E7
jbe 0xb7c62
movl $0x3e8, %edi # imm = 0x3E8
movl $0x4, %r13d
jmp 0xb7c86
cmpl $0x63, %edx
jbe 0xb7c74
movl $0x64, %edi
movl $0x3, %r13d
jmp 0xb7c86
xorl %r13d, %r13d
cmpl $0xa, %edx
setae %r13b
leal 0x1(%r13,%r13,8), %edi
incl %r13d
andq %rsi, %r8
incl %r13d
movl $0xcccccccd, %ebp # imm = 0xCCCCCCCD
movl %edx, %eax
xorl %edx, %edx
divl %edi
cmpl $0xa, %eax
jae 0xb7d7f
movslq (%r14), %r15
leal 0x1(%r15), %r11d
movl %r11d, (%r14)
movl %edx, %r11d
shlq %cl, %r11
orb $0x30, %al
movb %al, (%rbx,%r15)
addq %r8, %r11
cmpq %r12, %r11
jbe 0xb7d48
movl %edi, %edi
imulq %rbp, %rdi
shrq $0x23, %rdi
decl %r13d
cmpl $0x1, %r13d
ja 0xb7c91
cmpq %r12, %r8
jbe 0xb7e2c
xorl %eax, %eax
movabsq $0x199999999999999a, %rdx # imm = 0x199999999999999A
cmpq %rdx, %r8
jae 0xb7d9b
addq %r8, %r8
leaq (%r8,%r8,4), %r8
movq %r8, %rdi
shrq %cl, %rdi
cmpq $0xa, %rdi
jae 0xb7db7
andq %rsi, %r8
orb $0x30, %dil
movslq (%r14), %r11
leal 0x1(%r11), %ebp
movl %ebp, (%r14)
movb %dil, (%rbx,%r11)
addq %r12, %r12
leaq (%r12,%r12,4), %r12
addq %r10, %r10
leaq (%r10,%r10,4), %r10
decl %eax
cmpq %r12, %r8
ja 0xb7cea
movq (%rsp), %rcx
addl %eax, (%rcx)
movl (%r14), %esi
movq %rbx, %rdi
movq %r10, %rdx
movq %r12, %rcx
jmp 0xb7d6b
movq (%rsp), %rdx
movl (%rdx), %eax
addl %r13d, %eax
addl $-0x2, %eax
movl %eax, (%rdx)
movl %edi, %r9d
shlq %cl, %r9
movl (%r14), %esi
movq %rbx, %rdi
movq %r10, %rdx
movq %r12, %rcx
movq %r11, %r8
callq 0xb7e92
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x330cd(%rip), %rdi # 0xeae53
leaq 0x2d52e(%rip), %rdx # 0xe52bb
leaq 0x38977(%rip), %rcx # 0xf070b
movl $0x44a3, %esi # imm = 0x44A3
jmp 0xb7dd1
leaq 0x330b1(%rip), %rdi # 0xeae53
leaq 0x2d512(%rip), %rdx # 0xe52bb
leaq 0x3896d(%rip), %rcx # 0xf071d
movl $0x4505, %esi # imm = 0x4505
jmp 0xb7dd1
leaq 0x33095(%rip), %rdi # 0xeae53
leaq 0x2d4f6(%rip), %rdx # 0xe52bb
leaq 0x3893f(%rip), %rcx # 0xf070b
movl $0x450e, %esi # imm = 0x450E
xorl %eax, %eax
callq 0x1ae80
leaq 0x33074(%rip), %rdi # 0xeae53
leaq 0x2d4d5(%rip), %rdx # 0xe52bb
leaq 0x388f1(%rip), %rcx # 0xf06de
movl $0x4469, %esi # imm = 0x4469
jmp 0xb7dd1
leaq 0x33058(%rip), %rdi # 0xeae53
leaq 0x2d4b9(%rip), %rdx # 0xe52bb
leaq 0x388e8(%rip), %rcx # 0xf06f1
movl $0x446a, %esi # imm = 0x446A
jmp 0xb7dd1
leaq 0x3303c(%rip), %rdi # 0xeae53
leaq 0x2d49d(%rip), %rdx # 0xe52bb
leaq 0x388df(%rip), %rcx # 0xf0704
movl $0x447f, %esi # imm = 0x447F
jmp 0xb7dd1
leaq 0x33020(%rip), %rdi # 0xeae53
leaq 0x2d481(%rip), %rdx # 0xe52bb
leaq 0x388d1(%rip), %rcx # 0xf0712
movl $0x44fa, %esi # imm = 0x44FA
jmp 0xb7dd1
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rcx
mov [rsp+48h+var_38], r8d
mov eax, [rsp+48h+arg_18]
cmp eax, 0FFFFFFC3h
jle loc_B7DD8
mov [rsp+48h+var_48], rdx; unsigned __int64
cmp eax, 0FFFFFFE1h
jge loc_B7DF4
mov r14, rsi
mov rbx, rdi
lea r13, [rsp+48h+arg_10]
lea rbp, [rsp+48h+arg_0]
lea rsi, [rsp+48h+var_40]
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov r12, rax
mov rdi, r13
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
xor ecx, ecx
sub ecx, [r13+8]
mov r9d, 1
shl r9, cl
mov r8, [r13+0]
mov rdx, r8
shr rdx, cl
test edx, edx
jz loc_B7E10
mov r10, rax
lea rsi, [r9-1]
cmp edx, 3B9AC9FFh
jbe short loc_B7BE1
mov edi, 3B9ACA00h
mov r13d, 0Ah
jmp loc_B7C86
loc_B7BE1:
cmp edx, 5F5E0FFh
jbe short loc_B7BF9
mov edi, 5F5E100h
mov r13d, 9
jmp loc_B7C86
loc_B7BF9:
cmp edx, 98967Fh
jbe short loc_B7C0E
mov edi, 989680h
mov r13d, 8
jmp short loc_B7C86
loc_B7C0E:
cmp edx, 0F423Fh
jbe short loc_B7C23
mov edi, 0F4240h
mov r13d, 7
jmp short loc_B7C86
loc_B7C23:
cmp edx, 1869Fh
jbe short loc_B7C38
mov edi, 186A0h
mov r13d, 6
jmp short loc_B7C86
loc_B7C38:
cmp edx, 270Fh
jbe short loc_B7C4D
mov edi, 2710h
mov r13d, 5
jmp short loc_B7C86
loc_B7C4D:
cmp edx, 3E7h
jbe short loc_B7C62
mov edi, 3E8h
mov r13d, 4
jmp short loc_B7C86
loc_B7C62:
cmp edx, 63h ; 'c'
jbe short loc_B7C74
mov edi, 64h ; 'd'
mov r13d, 3
jmp short loc_B7C86
loc_B7C74:
xor r13d, r13d
cmp edx, 0Ah
setnb r13b
lea edi, [r13+r13*8+1]
inc r13d
loc_B7C86:
and r8, rsi
inc r13d
mov ebp, 0CCCCCCCDh
loc_B7C91:
mov eax, edx
xor edx, edx
div edi
cmp eax, 0Ah
jnb loc_B7D7F
movsxd r15, dword ptr [r14]
lea r11d, [r15+1]
mov [r14], r11d
mov r11d, edx
shl r11, cl
or al, 30h
mov [rbx+r15], al
add r11, r8
cmp r11, r12
jbe loc_B7D48
mov edi, edi
imul rdi, rbp
shr rdi, 23h
dec r13d
cmp r13d, 1
ja short loc_B7C91
cmp r8, r12
jbe loc_B7E2C
xor eax, eax
mov rdx, 199999999999999Ah
loc_B7CEA:
cmp r8, rdx
jnb loc_B7D9B
add r8, r8
lea r8, [r8+r8*4]
mov rdi, r8
shr rdi, cl
cmp rdi, 0Ah
jnb loc_B7DB7
and r8, rsi
or dil, 30h
movsxd r11, dword ptr [r14]
lea ebp, [r11+1]
mov [r14], ebp
mov [rbx+r11], dil
add r12, r12
lea r12, [r12+r12*4]
add r10, r10
lea r10, [r10+r10*4]
dec eax
cmp r8, r12
ja short loc_B7CEA
mov rcx, [rsp+48h+var_48]
add [rcx], eax
mov esi, [r14]
mov rdi, rbx
mov rdx, r10
mov rcx, r12
jmp short loc_B7D6B
loc_B7D48:
mov rdx, [rsp+48h+var_48]
mov eax, [rdx]
add eax, r13d
add eax, 0FFFFFFFEh
mov [rdx], eax
mov r9d, edi
shl r9, cl; unsigned __int64
mov esi, [r14]; char *
mov rdi, rbx; this
mov rdx, r10; int
mov rcx, r12; unsigned __int64
mov r8, r11; unsigned __int64
loc_B7D6B:
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B7D7F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aD9; "d <= 9"
mov esi, 44A3h
jmp short loc_B7DD1
loc_B7D9B:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP2StdNumericLi; "p2 <= (std::numeric_limits<std::uint64_"...
mov esi, 4505h
jmp short loc_B7DD1
loc_B7DB7:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aD9; "d <= 9"
mov esi, 450Eh
loc_B7DD1:
xor eax, eax
call _ggml_abort
loc_B7DD8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEKalpha; "M_plus.e >= kAlpha"
mov esi, 4469h
jmp short loc_B7DD1
loc_B7DF4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMPlusEKgamma; "M_plus.e <= kGamma"
mov esi, 446Ah
jmp short loc_B7DD1
loc_B7E10:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP10; "p1 > 0"
mov esi, 447Fh
jmp short loc_B7DD1
loc_B7E2C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aP2Delta; "p2 > delta"
mov esi, 44FAh
jmp short loc_B7DD1
|
long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
unsigned int *a2,
_DWORD *a3,
long long a4,
int a5,
long long a6,
char a7,
int a8,
unsigned long long a9,
int a10)
{
unsigned long long v12; // r12
int v13; // eax
int v14; // ecx
unsigned long long v15; // r9
unsigned long long v16; // rdx
int v17; // r10d
unsigned long long v18; // rsi
unsigned int v19; // edi
int v20; // r13d
BOOL v21; // r13d
unsigned long long v22; // r8
unsigned int v23; // r13d
unsigned int v24; // eax
unsigned int v25; // eax
long long v26; // r15
unsigned long long v27; // r11
int v28; // eax
unsigned long long v29; // r8
unsigned long long v30; // rdi
long long v31; // r11
char *v32; // rsi
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v33; // rdi
int v34; // edx
unsigned long long v35; // rcx
long long v38; // [rsp+8h] [rbp-40h] BYREF
int v39; // [rsp+10h] [rbp-38h]
v38 = a4;
v39 = a5;
if ( a10 <= -61 )
{
while ( 1 )
LABEL_36:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17513LL,
"GGML_ASSERT(%s) failed",
"M_plus.e >= kAlpha");
}
if ( a10 >= -31 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17514LL,
"GGML_ASSERT(%s) failed",
"M_plus.e <= kGamma");
goto LABEL_36;
}
v12 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(&a9, &v38);
v13 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(&a9, &a7);
v14 = -a10;
v15 = 1LL << -(char)a10;
v16 = a9 >> -(char)a10;
if ( !(_DWORD)v16 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17535LL,
"GGML_ASSERT(%s) failed",
"p1 > 0");
goto LABEL_36;
}
v17 = v13;
v18 = v15 - 1;
if ( (unsigned int)v16 <= 0x3B9AC9FF )
{
if ( (unsigned int)v16 <= 0x5F5E0FF )
{
if ( (unsigned int)v16 <= 0x98967F )
{
if ( (unsigned int)v16 <= 0xF423F )
{
if ( (unsigned int)v16 <= 0x1869F )
{
if ( (unsigned int)v16 <= 0x270F )
{
if ( (unsigned int)v16 <= 0x3E7 )
{
if ( (unsigned int)v16 <= 0x63 )
{
v21 = (unsigned int)v16 >= 0xA;
v19 = 9 * v21 + 1;
v20 = v21 + 1;
}
else
{
v19 = 100;
v20 = 3;
}
}
else
{
v19 = 1000;
v20 = 4;
}
}
else
{
v19 = 10000;
v20 = 5;
}
}
else
{
v19 = 100000;
v20 = 6;
}
}
else
{
v19 = 1000000;
v20 = 7;
}
}
else
{
v19 = 10000000;
v20 = 8;
}
}
else
{
v19 = 100000000;
v20 = 9;
}
}
else
{
v19 = 1000000000;
v20 = 10;
}
v22 = v18 & a9;
v23 = v20 + 1;
do
{
v24 = v16;
LODWORD(v16) = (unsigned int)v16 % v19;
v25 = v24 / v19;
if ( v25 >= 0xA )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17571LL,
"GGML_ASSERT(%s) failed",
"d <= 9");
goto LABEL_36;
}
v26 = (int)*a2;
*a2 = v26 + 1;
*((_BYTE *)this + v26) = v25 | 0x30;
v27 = v22 + ((unsigned long long)(unsigned int)v16 << v14);
if ( v27 <= v12 )
{
*a3 = v23 + *a3 - 2;
v15 = (unsigned long long)v19 << v14;
v32 = (char *)*a2;
v33 = this;
v34 = v17;
v35 = v12;
v22 = v27;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v33,
v32,
v34,
v35,
v22,
v15,
(unsigned long long)a3);
}
v19 /= 0xAu;
--v23;
}
while ( v23 > 1 );
if ( v22 <= v12 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17658LL,
"GGML_ASSERT(%s) failed",
"p2 > delta");
goto LABEL_36;
}
v28 = 0;
while ( 2 )
{
if ( v22 >= 0x199999999999999ALL )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17669LL,
"GGML_ASSERT(%s) failed",
"p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10");
goto LABEL_36;
}
v29 = 10 * v22;
v30 = v29 >> v14;
if ( v29 >> v14 >= 0xA )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17678LL,
"GGML_ASSERT(%s) failed",
"d <= 9");
goto LABEL_36;
}
v22 = v18 & v29;
v31 = (int)*a2;
*a2 = v31 + 1;
*((_BYTE *)this + v31) = v30 | 0x30;
v12 *= 10LL;
v17 *= 10;
--v28;
if ( v22 > v12 )
continue;
break;
}
*a3 += v28;
v32 = (char *)*a2;
v33 = this;
v34 = v17;
v35 = v12;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(v33, v32, v34, v35, v22, v15, (unsigned long long)a3);
}
|
grisu2_digit_gen:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RCX
MOV dword ptr [RSP + 0x10],R8D
MOV EAX,dword ptr [RSP + 0x68]
CMP EAX,-0x3d
JLE 0x001b7dd8
MOV qword ptr [RSP],RDX
CMP EAX,-0x1f
JGE 0x001b7df4
MOV R14,RSI
MOV RBX,RDI
LEA R13,[RSP + 0x60]
LEA RBP,[RSP + 0x50]
LEA RSI,[RSP + 0x8]
MOV RDI,R13
CALL 0x001b7e48
MOV R12,RAX
MOV RDI,R13
MOV RSI,RBP
CALL 0x001b7e48
XOR ECX,ECX
SUB ECX,dword ptr [R13 + 0x8]
MOV R9D,0x1
SHL R9,CL
MOV R8,qword ptr [R13]
MOV RDX,R8
SHR RDX,CL
TEST EDX,EDX
JZ 0x001b7e10
MOV R10,RAX
LEA RSI,[R9 + -0x1]
CMP EDX,0x3b9ac9ff
JBE 0x001b7be1
MOV EDI,0x3b9aca00
MOV R13D,0xa
JMP 0x001b7c86
LAB_001b7be1:
CMP EDX,0x5f5e0ff
JBE 0x001b7bf9
MOV EDI,0x5f5e100
MOV R13D,0x9
JMP 0x001b7c86
LAB_001b7bf9:
CMP EDX,0x98967f
JBE 0x001b7c0e
MOV EDI,0x989680
MOV R13D,0x8
JMP 0x001b7c86
LAB_001b7c0e:
CMP EDX,0xf423f
JBE 0x001b7c23
MOV EDI,0xf4240
MOV R13D,0x7
JMP 0x001b7c86
LAB_001b7c23:
CMP EDX,0x1869f
JBE 0x001b7c38
MOV EDI,0x186a0
MOV R13D,0x6
JMP 0x001b7c86
LAB_001b7c38:
CMP EDX,0x270f
JBE 0x001b7c4d
MOV EDI,0x2710
MOV R13D,0x5
JMP 0x001b7c86
LAB_001b7c4d:
CMP EDX,0x3e7
JBE 0x001b7c62
MOV EDI,0x3e8
MOV R13D,0x4
JMP 0x001b7c86
LAB_001b7c62:
CMP EDX,0x63
JBE 0x001b7c74
MOV EDI,0x64
MOV R13D,0x3
JMP 0x001b7c86
LAB_001b7c74:
XOR R13D,R13D
CMP EDX,0xa
SETNC R13B
LEA EDI,[R13 + R13*0x8 + 0x1]
INC R13D
LAB_001b7c86:
AND R8,RSI
INC R13D
MOV EBP,0xcccccccd
LAB_001b7c91:
MOV EAX,EDX
XOR EDX,EDX
DIV EDI
CMP EAX,0xa
JNC 0x001b7d7f
MOVSXD R15,dword ptr [R14]
LEA R11D,[R15 + 0x1]
MOV dword ptr [R14],R11D
MOV R11D,EDX
SHL R11,CL
OR AL,0x30
MOV byte ptr [RBX + R15*0x1],AL
ADD R11,R8
CMP R11,R12
JBE 0x001b7d48
MOV EDI,EDI
IMUL RDI,RBP
SHR RDI,0x23
DEC R13D
CMP R13D,0x1
JA 0x001b7c91
CMP R8,R12
JBE 0x001b7e2c
XOR EAX,EAX
MOV RDX,0x199999999999999a
LAB_001b7cea:
CMP R8,RDX
JNC 0x001b7d9b
ADD R8,R8
LEA R8,[R8 + R8*0x4]
MOV RDI,R8
SHR RDI,CL
CMP RDI,0xa
JNC 0x001b7db7
AND R8,RSI
OR DIL,0x30
MOVSXD R11,dword ptr [R14]
LEA EBP,[R11 + 0x1]
MOV dword ptr [R14],EBP
MOV byte ptr [RBX + R11*0x1],DIL
ADD R12,R12
LEA R12,[R12 + R12*0x4]
ADD R10,R10
LEA R10,[R10 + R10*0x4]
DEC EAX
CMP R8,R12
JA 0x001b7cea
MOV RCX,qword ptr [RSP]
ADD dword ptr [RCX],EAX
MOV ESI,dword ptr [R14]
MOV RDI,RBX
MOV RDX,R10
MOV RCX,R12
JMP 0x001b7d6b
LAB_001b7d48:
MOV RDX,qword ptr [RSP]
MOV EAX,dword ptr [RDX]
ADD EAX,R13D
ADD EAX,-0x2
MOV dword ptr [RDX],EAX
MOV R9D,EDI
SHL R9,CL
MOV ESI,dword ptr [R14]
MOV RDI,RBX
MOV RDX,R10
MOV RCX,R12
MOV R8,R11
LAB_001b7d6b:
CALL 0x001b7e92
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b7d7f:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f070b]
MOV ESI,0x44a3
JMP 0x001b7dd1
LAB_001b7d9b:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f071d]
MOV ESI,0x4505
JMP 0x001b7dd1
LAB_001b7db7:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f070b]
MOV ESI,0x450e
LAB_001b7dd1:
XOR EAX,EAX
CALL 0x0011ae80
LAB_001b7dd8:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f06de]
MOV ESI,0x4469
JMP 0x001b7dd1
LAB_001b7df4:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f06f1]
MOV ESI,0x446a
JMP 0x001b7dd1
LAB_001b7e10:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f0704]
MOV ESI,0x447f
JMP 0x001b7dd1
LAB_001b7e2c:
LEA RDI,[0x1eae53]
LEA RDX,[0x1e52bb]
LEA RCX,[0x1f0712]
MOV ESI,0x44fa
JMP 0x001b7dd1
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen
(char *param_1,int *param_2,int *param_3,int8 param_4,int4 param_5)
{
int iVar1;
byte bVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
char *pcVar6;
ulong uVar7;
int8 uVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
uint uVar13;
ulong in_stack_00000018;
int in_stack_00000020;
int8 local_40;
int4 local_38;
local_40 = param_4;
local_38 = param_5;
if (in_stack_00000020 < -0x3c) {
pcVar6 = "M_plus.e >= kAlpha";
uVar8 = 0x4469;
}
else if (in_stack_00000020 < -0x1f) {
uVar4 = diyfp::sub((diyfp *)&stack0x00000018,(diyfp *)&local_40);
uVar5 = diyfp::sub((diyfp *)&stack0x00000018,&stack0x00000008);
bVar2 = -(char)in_stack_00000020;
uVar11 = 1L << (bVar2 & 0x3f);
uVar7 = in_stack_00000018 >> (bVar2 & 0x3f);
uVar13 = (uint)uVar7;
if (uVar13 == 0) {
pcVar6 = "p1 > 0";
uVar8 = 0x447f;
}
else {
if (uVar13 < 1000000000) {
if (uVar13 < 100000000) {
if (uVar13 < 10000000) {
if (uVar13 < 1000000) {
if (uVar13 < 100000) {
if (uVar13 < 10000) {
if (uVar13 < 1000) {
if (uVar13 < 100) {
uVar9 = (ulong)(9 < uVar13) * 9 + 1;
iVar3 = (9 < uVar13) + 1;
}
else {
uVar9 = 100;
iVar3 = 3;
}
}
else {
uVar9 = 1000;
iVar3 = 4;
}
}
else {
uVar9 = 10000;
iVar3 = 5;
}
}
else {
uVar9 = 100000;
iVar3 = 6;
}
}
else {
uVar9 = 1000000;
iVar3 = 7;
}
}
else {
uVar9 = 10000000;
iVar3 = 8;
}
}
else {
uVar9 = 100000000;
iVar3 = 9;
}
}
else {
uVar9 = 1000000000;
iVar3 = 10;
}
uVar10 = in_stack_00000018 & uVar11 - 1;
uVar13 = iVar3 + 1;
do {
uVar12 = (uVar7 & 0xffffffff) / uVar9;
uVar7 = (uVar7 & 0xffffffff) % uVar9;
if (9 < (uint)uVar12) {
pcVar6 = "d <= 9";
uVar8 = 0x44a3;
goto LAB_001b7dd1;
}
iVar3 = *param_2;
*param_2 = iVar3 + 1;
param_1[iVar3] = (byte)uVar12 | 0x30;
uVar12 = (uVar7 << (bVar2 & 0x3f)) + uVar10;
if (uVar12 <= uVar4) {
*param_3 = *param_3 + uVar13 + -2;
uVar11 = uVar9 << (bVar2 & 0x3f);
iVar3 = *param_2;
goto LAB_001b7d6b;
}
uVar9 = uVar9 / 10;
uVar13 = uVar13 - 1;
} while (1 < uVar13);
if (uVar4 < uVar10) {
iVar3 = 0;
while( true ) {
if (0x1999999999999999 < uVar10) {
pcVar6 = "p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10";
uVar8 = 0x4505;
goto LAB_001b7dd1;
}
uVar7 = uVar10 * 10 >> (bVar2 & 0x3f);
if (9 < uVar7) break;
uVar10 = uVar10 * 10 & uVar11 - 1;
iVar1 = *param_2;
*param_2 = iVar1 + 1;
param_1[iVar1] = (byte)uVar7 | 0x30;
uVar4 = uVar4 * 10;
uVar5 = uVar5 * 10;
iVar3 = iVar3 + -1;
if (uVar10 <= uVar4) {
*param_3 = *param_3 + iVar3;
iVar3 = *param_2;
uVar12 = uVar10;
LAB_001b7d6b:
grisu2_round(param_1,iVar3,uVar5,uVar4,uVar12,uVar11);
return;
}
}
pcVar6 = "d <= 9";
uVar8 = 0x450e;
}
else {
pcVar6 = "p2 > delta";
uVar8 = 0x44fa;
}
}
}
else {
pcVar6 = "M_plus.e <= kGamma";
uVar8 = 0x446a;
}
LAB_001b7dd1:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar8,
"GGML_ASSERT(%s) failed",pcVar6);
}
|
|
5,091 |
write_dynamic_record
|
eloqsql/storage/myisam/mi_dynrec.c
|
static int write_dynamic_record(MI_INFO *info, const uchar *record,
ulong reclength)
{
int flag;
ulong length;
my_off_t filepos;
DBUG_ENTER("write_dynamic_record");
flag=0;
/*
Check if we have enough room for the new record.
First we do simplified check to make usual case faster.
Then we do more precise check for the space left.
Though it still is not absolutely precise, as
we always use MI_MAX_DYN_BLOCK_HEADER while it can be
less in the most of the cases.
*/
if (unlikely(info->s->base.max_data_file_length -
info->state->data_file_length <
reclength + MI_MAX_DYN_BLOCK_HEADER))
{
if (info->s->base.max_data_file_length - info->state->data_file_length +
info->state->empty - info->state->del * MI_MAX_DYN_BLOCK_HEADER <
reclength + MI_MAX_DYN_BLOCK_HEADER)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
DBUG_RETURN(1);
}
}
do
{
if (_mi_find_writepos(info,reclength,&filepos,&length))
goto err;
if (_mi_write_part_record(info,filepos,length,
(info->append_insert_at_end ?
HA_OFFSET_ERROR : info->s->state.dellink),
(uchar**) &record,&reclength,&flag))
goto err;
} while (reclength);
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
}
|
O0
|
c
|
write_dynamic_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x110(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq 0x28(%rcx), %rax
movq -0x20(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa7c67
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x110(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq 0x28(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0x10(%rcx), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
imulq $0x14, 0x8(%rcx), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
addq $0x14, %rcx
cmpq %rcx, %rax
jae 0xa7c65
callq 0xf6060
movl $0x87, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa7d19
jmp 0xa7c67
jmp 0xa7c69
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xac840
cmpl $0x0, %eax
je 0xa7c88
jmp 0xa7d10
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x33a(%rax), %eax
cmpl $0x0, %eax
je 0xa7cbd
movq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xa7ccc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x20(%rbp), %r9
leaq -0x24(%rbp), %rax
movq %rax, (%rsp)
callq 0xa8ba0
cmpl $0x0, %eax
je 0xa7cf8
jmp 0xa7d10
jmp 0xa7cfa
cmpq $0x0, -0x20(%rbp)
jne 0xa7c69
jmp 0xa7d07
movl $0x0, -0x4(%rbp)
jmp 0xa7d19
jmp 0xa7d12
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
write_dynamic_record_0:
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_24], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+110h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, [rcx+28h]
mov rcx, [rbp+var_20]
add rcx, 14h
cmp rax, rcx
setb 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_A7C67
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+110h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, [rcx+28h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
add rax, [rcx+10h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
imul rcx, [rcx+8], 14h
sub rax, rcx
mov rcx, [rbp+var_20]
add rcx, 14h
cmp rax, rcx
jnb short loc_A7C65
call _my_thread_var
mov dword ptr [rax], 87h
mov [rbp+var_4], 1
jmp loc_A7D19
loc_A7C65:
jmp short $+2
loc_A7C67:
jmp short $+2
loc_A7C69:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_30]
call _mi_find_writepos
cmp eax, 0
jz short loc_A7C88
jmp loc_A7D10
loc_A7C88:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+33Ah]
cmp eax, 0
jz short loc_A7CBD
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rax
jmp short loc_A7CCC
loc_A7CBD:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+58h]
mov [rbp+var_58], rax
loc_A7CCC:
mov rdx, [rbp+var_40]
mov rsi, [rbp+var_48]
mov rdi, [rbp+var_50]
mov rcx, [rbp+var_58]
lea r8, [rbp+var_18]
lea r9, [rbp+var_20]
lea rax, [rbp+var_24]
mov [rsp+60h+var_60], rax
call _mi_write_part_record
cmp eax, 0
jz short loc_A7CF8
jmp short loc_A7D10
loc_A7CF8:
jmp short $+2
loc_A7CFA:
cmp [rbp+var_20], 0
jnz loc_A7C69
jmp short $+2
loc_A7D07:
mov [rbp+var_4], 0
jmp short loc_A7D19
loc_A7D10:
jmp short $+2
loc_A7D12:
mov [rbp+var_4], 1
loc_A7D19:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long write_dynamic_record_0(_QWORD *a1, const char *a2, long long a3)
{
long long v5; // [rsp+28h] [rbp-38h] BYREF
long long v6; // [rsp+30h] [rbp-30h] BYREF
int v7; // [rsp+3Ch] [rbp-24h] BYREF
long long v8; // [rsp+40h] [rbp-20h] BYREF
const char *v9; // [rsp+48h] [rbp-18h] BYREF
_QWORD *v10; // [rsp+50h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = 0;
if ( *(_QWORD *)(*a1 + 272LL) - *(_QWORD *)(a1[1] + 40LL) >= (unsigned long long)(a3 + 20)
|| *(_QWORD *)(v10[1] + 16LL)
+ *(_QWORD *)(*v10 + 272LL)
- *(_QWORD *)(v10[1] + 40LL)
- 20LL * *(_QWORD *)(v10[1] + 8LL) >= (unsigned long long)(v8 + 20) )
{
while ( !(unsigned int)mi_find_writepos(v10, v8, &v5, &v6) )
{
if ( *((_BYTE *)v10 + 826)
? mi_write_part_record((_DWORD)v10, v5, v6, -1, (unsigned int)&v9, (unsigned int)&v8, (long long)&v7)
: (unsigned int)mi_write_part_record(
(_DWORD)v10,
v5,
v6,
*(_QWORD *)(*v10 + 88LL),
(unsigned int)&v9,
(unsigned int)&v8,
(long long)&v7) )
{
break;
}
if ( !v8 )
return 0;
}
return 1;
}
else
{
*(_DWORD *)my_thread_var(a1, a2) = 135;
return 1;
}
}
|
write_dynamic_record:
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 dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x110]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x14
CMP RAX,RCX
SETC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001a7c67
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x110]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
ADD RAX,qword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
IMUL RCX,qword ptr [RCX + 0x8],0x14
SUB RAX,RCX
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x14
CMP RAX,RCX
JNC 0x001a7c65
CALL 0x001f6060
MOV dword ptr [RAX],0x87
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a7d19
LAB_001a7c65:
JMP 0x001a7c67
LAB_001a7c67:
JMP 0x001a7c69
LAB_001a7c69:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x30]
CALL 0x001ac840
CMP EAX,0x0
JZ 0x001a7c88
JMP 0x001a7d10
LAB_001a7c88:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x33a]
CMP EAX,0x0
JZ 0x001a7cbd
MOV RAX,-0x1
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001a7ccc
LAB_001a7cbd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x58],RAX
LAB_001a7ccc:
MOV RDX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
LEA R8,[RBP + -0x18]
LEA R9,[RBP + -0x20]
LEA RAX,[RBP + -0x24]
MOV qword ptr [RSP],RAX
CALL 0x001a8ba0
CMP EAX,0x0
JZ 0x001a7cf8
JMP 0x001a7d10
LAB_001a7cf8:
JMP 0x001a7cfa
LAB_001a7cfa:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001a7c69
JMP 0x001a7d07
LAB_001a7d07:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a7d19
LAB_001a7d10:
JMP 0x001a7d12
LAB_001a7d12:
MOV dword ptr [RBP + -0x4],0x1
LAB_001a7d19:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 write_dynamic_record(long *param_1,int8 param_2,long param_3)
{
int iVar1;
int4 *puVar2;
int8 local_60;
int8 local_40;
int8 local_38;
int4 local_2c;
long local_28;
int8 local_20;
long *local_18;
int4 local_c;
local_2c = 0;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (((ulong)(*(long *)(*param_1 + 0x110) - *(long *)(param_1[1] + 0x28)) < param_3 + 0x14U) &&
((ulong)((*(long *)(*param_1 + 0x110) - *(long *)(param_1[1] + 0x28)) +
*(long *)(param_1[1] + 0x10) + *(long *)(param_1[1] + 8) * -0x14) < param_3 + 0x14U))
{
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x87;
local_c = 1;
}
else {
do {
iVar1 = _mi_find_writepos(local_18,local_28,&local_40,&local_38);
if (iVar1 != 0) {
return 1;
}
if (*(char *)((long)local_18 + 0x33a) == '\0') {
local_60 = *(int8 *)(*local_18 + 0x58);
}
else {
local_60 = 0xffffffffffffffff;
}
iVar1 = _mi_write_part_record
(local_18,local_40,local_38,local_60,&local_20,&local_28,&local_2c);
if (iVar1 != 0) {
return 1;
}
} while (local_28 != 0);
local_c = 0;
}
return local_c;
}
|
|
5,092 |
js_string_toLowerCase
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_toLowerCase(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int to_lower)
{
JSValue val;
StringBuffer b_s, *b = &b_s;
JSString *p;
int i, c, j, l;
uint32_t res[LRE_CC_RES_LEN_MAX];
val = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(val))
return val;
p = JS_VALUE_GET_STRING(val);
if (p->len == 0)
return val;
if (string_buffer_init(ctx, b, p->len))
goto fail;
for(i = 0; i < p->len;) {
c = string_getc(p, &i);
if (c == 0x3a3 && to_lower && test_final_sigma(p, i - 1)) {
res[0] = 0x3c2; /* final sigma */
l = 1;
} else {
l = lre_case_conv(res, c, to_lower);
}
for(j = 0; j < l; j++) {
if (string_buffer_putc(b, res[j]))
goto fail;
}
}
JS_FreeValue(ctx, val);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, val);
string_buffer_free(b);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_string_toLowerCase:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r13d
movq %rdi, %r14
callq 0x425ff
movq %rdx, %rbx
movq %rax, 0x18(%rsp)
cmpl $0x6, %ebx
je 0x7d522
movq 0x18(%rsp), %r15
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
andl 0x4(%r15), %esi
je 0x7d4db
movq %r14, 0x20(%rsp)
movl %esi, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %r14, %rdi
xorl %edx, %edx
callq 0x20b73
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x7d4e2
movl $0x0, 0x10(%rsp)
testl $0x7fffffff, 0x4(%r15) # imm = 0x7FFFFFFF
je 0x7d4bb
leaq 0x20(%rsp), %r12
movl %r13d, 0xc(%rsp)
testl %r13d, %r13d
sete %bpl
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c5ad
movl %eax, %esi
cmpl $0x3a3, %eax # imm = 0x3A3
setne %al
orb %bpl, %al
jne 0x7d473
movl %esi, 0x14(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x40(%rsp)
leal -0x1(%rax), %r13d
movl %r13d, 0x8(%rsp)
testl %r13d, %r13d
jle 0x7d3a5
leal -0x1(%r13), %eax
testb $-0x80, 0x7(%r15)
jne 0x7d3b4
movzbl 0x18(%r15,%rax), %ebp
movl %eax, %r13d
jmp 0x7d3a7
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x98620
testl %eax, %eax
jne 0x7d38a
jmp 0x7d403
movzwl 0x18(%r15,%rax,2), %ebp
cmpl $0x1, %r13d
je 0x7d3a0
movl %ebp, %ecx
andl $0xfc00, %ecx # imm = 0xFC00
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x7d3a0
addl $-0x2, %r13d
movzwl 0x18(%r15,%r13,2), %ecx
movl %ecx, %edx
andl $0xfc00, %edx # imm = 0xFC00
cmpl $0xd800, %edx # imm = 0xD800
jne 0x7d3a0
shll $0xa, %ecx
andl $0xffc00, %ecx # imm = 0xFFC00
andl $0x3ff, %ebp # imm = 0x3FF
addl %ecx, %ebp
addl $0x10000, %ebp # imm = 0x10000
jmp 0x7d3a7
movl %r13d, 0x8(%rsp)
movl %ebp, %edi
callq 0x98507
testl %eax, %eax
je 0x7d46a
movq 0x40(%rsp), %rax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %r13d
movl 0x4(%r15), %eax
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl %ecx, %eax
cmpl %eax, 0x8(%rsp)
jge 0x7d45b
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4c5ad
movl %eax, %ebp
movl %eax, %edi
callq 0x98620
testl %eax, %eax
jne 0x7d421
movl %ebp, %edi
callq 0x98507
testl %eax, %eax
movl 0x14(%rsp), %esi
jne 0x7d473
movl $0x3c2, 0x4c(%rsp) # imm = 0x3C2
movl $0x1, %eax
jmp 0x7d480
movl 0xc(%rsp), %r13d
movl 0x14(%rsp), %esi
leaq 0x4c(%rsp), %rdi
movl %r13d, %edx
callq 0x98094
testl %eax, %eax
jle 0x7d4a1
movl %eax, %r13d
xorl %ebp, %ebp
movl 0x4c(%rsp,%rbp,4), %esi
movq %r12, %rdi
callq 0x333f0
testl %eax, %eax
jne 0x7d4f2
incq %rbp
cmpq %rbp, %r13
jne 0x7d489
movl 0x4(%r15), %eax
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl %ecx, %eax
cmpl %eax, 0x10(%rsp)
movl 0xc(%rsp), %r13d
jl 0x7d34d
movq 0x18(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %rbx, %rdx
callq 0x1d8c6
leaq 0x20(%rsp), %rdi
callq 0x33444
movq %rdx, %rbx
jmp 0x7d522
movq 0x18(%rsp), %rax
jmp 0x7d522
movl $0x0, 0x34(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %rbx, %rdx
callq 0x1d8c6
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1cb99
movq $0x0, 0x28(%rsp)
movl $0x6, %ebx
xorl %eax, %eax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_string_toLowerCase:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r13d, r9d
mov r14, rdi
call JS_ToStringCheckObject
mov rbx, rdx
mov [rsp+88h+var_70], rax
cmp ebx, 6
jz loc_7D522
mov r15, [rsp+88h+var_70]
mov esi, 7FFFFFFFh
and esi, [r15+4]
jz loc_7D4DB
mov [rsp+88h+var_68], r14
mov [rsp+88h+var_54], esi
mov [rsp+88h+var_58], 0
mov [rsp+88h+var_50], 0
mov rdi, r14
xor edx, edx
call js_alloc_string
mov [rsp+88h+var_60], rax
test rax, rax
jz loc_7D4E2
mov [rsp+88h+var_78], 0
test dword ptr [r15+4], 7FFFFFFFh
jz loc_7D4BB
lea r12, [rsp+88h+var_68]
mov [rsp+88h+var_7C], r13d
loc_7D34D:
test r13d, r13d
setz bpl
mov rdi, r15
lea rsi, [rsp+88h+var_78]
call string_getc
mov esi, eax
cmp eax, 3A3h
setnz al
or al, bpl
jnz loc_7D473
mov [rsp+88h+var_74], esi
mov eax, [rsp+88h+var_78]
mov [rsp+88h+var_48], rax
lea r13d, [rax-1]
mov [rsp+88h+var_80], r13d
loc_7D38A:
test r13d, r13d
jle short loc_7D3A5
lea eax, [r13-1]
test byte ptr [r15+7], 80h
jnz short loc_7D3B4
movzx ebp, byte ptr [r15+rax+18h]
loc_7D3A0:
mov r13d, eax
jmp short loc_7D3A7
loc_7D3A5:
xor ebp, ebp
loc_7D3A7:
mov edi, ebp
call lre_is_case_ignorable
test eax, eax
jnz short loc_7D38A
jmp short loc_7D403
loc_7D3B4:
movzx ebp, word ptr [r15+rax*2+18h]
cmp r13d, 1
jz short loc_7D3A0
mov ecx, ebp
and ecx, 0FC00h
cmp ecx, 0DC00h
jnz short loc_7D3A0
add r13d, 0FFFFFFFEh
movzx ecx, word ptr [r15+r13*2+18h]
mov edx, ecx
and edx, 0FC00h
cmp edx, 0D800h
jnz short loc_7D3A0
shl ecx, 0Ah
and ecx, 0FFC00h
and ebp, 3FFh
add ebp, ecx
add ebp, 10000h
jmp short loc_7D3A7
loc_7D403:
mov [rsp+88h+var_80], r13d
mov edi, ebp
call lre_is_cased
test eax, eax
jz short loc_7D46A
mov rax, [rsp+88h+var_48]
mov [rsp+88h+var_80], eax
mov r13d, [rsp+88h+var_7C]
loc_7D421:
mov eax, [r15+4]
mov ecx, 7FFFFFFFh
and eax, ecx
cmp [rsp+88h+var_80], eax
jge short loc_7D45B
mov rdi, r15
lea rsi, [rsp+88h+var_80]
call string_getc
mov ebp, eax
mov edi, eax
call lre_is_case_ignorable
test eax, eax
jnz short loc_7D421
mov edi, ebp
call lre_is_cased
test eax, eax
mov esi, [rsp+88h+var_74]
jnz short loc_7D473
loc_7D45B:
mov [rsp+88h+var_3C], 3C2h
mov eax, 1
jmp short loc_7D480
loc_7D46A:
mov r13d, [rsp+88h+var_7C]
mov esi, [rsp+88h+var_74]
loc_7D473:
lea rdi, [rsp+88h+var_3C]
mov edx, r13d
call lre_case_conv
loc_7D480:
test eax, eax
jle short loc_7D4A1
mov r13d, eax
xor ebp, ebp
loc_7D489:
mov esi, [rsp+rbp*4+88h+var_3C]
mov rdi, r12
call string_buffer_putc
test eax, eax
jnz short loc_7D4F2
inc rbp
cmp r13, rbp
jnz short loc_7D489
loc_7D4A1:
mov eax, [r15+4]
mov ecx, 7FFFFFFFh
and eax, ecx
cmp [rsp+88h+var_78], eax
mov r13d, [rsp+88h+var_7C]
jl loc_7D34D
loc_7D4BB:
mov rsi, [rsp+88h+var_70]
mov rdi, [r14+18h]
mov rdx, rbx
call JS_FreeValueRT
lea rdi, [rsp+88h+var_68]
call string_buffer_end
mov rbx, rdx
jmp short loc_7D522
loc_7D4DB:
mov rax, [rsp+88h+var_70]
jmp short loc_7D522
loc_7D4E2:
mov [rsp+88h+var_54], 0
mov dword ptr [rsp+88h+var_50+4], 0FFFFFFFFh
loc_7D4F2:
mov rsi, [rsp+88h+var_70]
mov rdi, [r14+18h]
mov rdx, rbx
call JS_FreeValueRT
mov rdi, [rsp+88h+var_68]
mov rsi, [rsp+88h+var_60]
call js_free
mov [rsp+88h+var_60], 0
mov ebx, 6
xor eax, eax
loc_7D522:
mov rdx, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char * js_string_toLowerCase(
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)
{
unsigned int v14; // r13d
char *result; // rax
long long v16; // rdx
long long v17; // rbx
char *v18; // r15
long long v19; // rsi
unsigned int v20; // eax
long long v21; // rsi
long long v22; // r13
long long v23; // rax
unsigned int v24; // ebp
long long v26; // rbp
int is_cased; // eax
int v28; // eax
long long v29; // r13
long long v30; // rbp
int v31; // [rsp+8h] [rbp-80h] BYREF
unsigned int v32; // [rsp+Ch] [rbp-7Ch]
int v33; // [rsp+10h] [rbp-78h] BYREF
unsigned int v34; // [rsp+14h] [rbp-74h]
char *v35; // [rsp+18h] [rbp-70h]
long long v36; // [rsp+20h] [rbp-68h] BYREF
long long v37; // [rsp+28h] [rbp-60h]
int v38; // [rsp+30h] [rbp-58h]
int v39; // [rsp+34h] [rbp-54h]
long long v40; // [rsp+38h] [rbp-50h]
long long v41; // [rsp+40h] [rbp-48h]
_DWORD v42[15]; // [rsp+4Ch] [rbp-3Ch] BYREF
v14 = a6;
result = (char *)JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
v35 = result;
if ( (_DWORD)v16 == 6 )
return result;
v18 = v35;
v19 = *((_DWORD *)v35 + 1) & 0x7FFFFFFF;
if ( (*((_DWORD *)v35 + 1) & 0x7FFFFFFF) == 0 )
return v35;
v36 = a1;
v39 = v19;
v38 = 0;
v40 = 0LL;
v37 = js_alloc_string(a1, v19, 0);
if ( !v37 )
{
v39 = 0;
HIDWORD(v40) = -1;
goto LABEL_35;
}
v33 = 0;
if ( (*((_DWORD *)v35 + 1) & 0x7FFFFFFF) == 0 )
{
LABEL_32:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v35, v17);
return (char *)string_buffer_end((long long)&v36);
}
v32 = v14;
while ( 2 )
{
v20 = string_getc((long long)v18, &v33);
v21 = v20;
if ( v14 == 0 || v20 != 931 )
goto LABEL_26;
v34 = v20;
v41 = (unsigned int)v33;
LODWORD(v22) = v33 - 1;
v31 = v33 - 1;
do
{
if ( (int)v22 <= 0 )
{
v24 = 0;
}
else
{
v23 = (unsigned int)(v22 - 1);
if ( v18[7] >= 0 )
{
v24 = (unsigned __int8)v18[v23 + 24];
LABEL_11:
LODWORD(v22) = v23;
continue;
}
v24 = *(unsigned __int16 *)&v18[2 * v23 + 24];
if ( (_DWORD)v22 == 1 )
goto LABEL_11;
if ( (v24 & 0xFC00) != 0xDC00 )
goto LABEL_11;
v22 = (unsigned int)(v22 - 2);
if ( (*(_WORD *)&v18[2 * v22 + 24] & 0xFC00) != 0xD800 )
goto LABEL_11;
v24 = ((*(unsigned __int16 *)&v18[2 * v22 + 24] << 10) & 0xFFC00) + (v24 & 0x3FF) + 0x10000;
}
}
while ( (unsigned int)lre_is_case_ignorable(v24) );
v31 = v22;
if ( !(unsigned int)lre_is_cased(v24) )
{
v14 = v32;
v21 = v34;
LABEL_26:
v28 = lre_case_conv(v42, v21, v14);
goto LABEL_27;
}
v31 = v41;
v14 = v32;
while ( v31 < (*((_DWORD *)v18 + 1) & 0x7FFFFFFF) )
{
v26 = (unsigned int)string_getc((long long)v18, &v31);
if ( !(unsigned int)lre_is_case_ignorable(v26) )
{
is_cased = lre_is_cased((unsigned int)v26);
v21 = v34;
if ( is_cased )
goto LABEL_26;
break;
}
}
v42[0] = 962;
v28 = 1;
LABEL_27:
if ( v28 <= 0 )
{
LABEL_31:
v14 = v32;
if ( v33 >= (*((_DWORD *)v18 + 1) & 0x7FFFFFFF) )
goto LABEL_32;
continue;
}
break;
}
v29 = (unsigned int)v28;
v30 = 0LL;
while ( !(unsigned int)string_buffer_putc((long long)&v36, v42[v30]) )
{
if ( v29 == ++v30 )
goto LABEL_31;
}
LABEL_35:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v35, v17);
js_free(v36, v37);
return 0LL;
}
| |||
5,093 |
js_string_toLowerCase
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_toLowerCase(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int to_lower)
{
JSValue val;
StringBuffer b_s, *b = &b_s;
JSString *p;
int i, c, j, l;
uint32_t res[LRE_CC_RES_LEN_MAX];
val = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(val))
return val;
p = JS_VALUE_GET_STRING(val);
if (p->len == 0)
return val;
if (string_buffer_init(ctx, b, p->len))
goto fail;
for(i = 0; i < p->len;) {
c = string_getc(p, &i);
if (c == 0x3a3 && to_lower && test_final_sigma(p, i - 1)) {
res[0] = 0x3c2; /* final sigma */
l = 1;
} else {
l = lre_case_conv(res, c, to_lower);
}
for(j = 0; j < l; j++) {
if (string_buffer_putc(b, res[j]))
goto fail;
}
}
JS_FreeValue(ctx, val);
return string_buffer_end(b);
fail:
JS_FreeValue(ctx, val);
string_buffer_free(b);
return JS_EXCEPTION;
}
|
O2
|
c
|
js_string_toLowerCase:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %rdi, %r15
callq 0x3a290
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x69294
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl 0x4(%r14), %edx
je 0x69294
movl %ebp, (%rsp)
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x2e042
testl %eax, %eax
je 0x692a9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
leaq 0x28(%rsp), %rdi
callq 0x2ef01
pushq $0x6
popq %rbx
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4(%rsp), %rax
andl $0x0, (%rax)
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x28(%rsp), %r12
xorl %eax, %eax
movl 0x4(%r14), %ecx
andl %edx, %ecx
cmpl %ecx, %eax
movl (%rsp), %r13d
jge 0x69432
testl %r13d, %r13d
sete %bpl
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
callq 0x41a28
movl %eax, %esi
cmpl $0x3a3, %eax # imm = 0x3A3
setne %al
orb %bpl, %al
jne 0x693ea
movl %esi, 0x8(%rsp)
movl 0x4(%rsp), %eax
movq %rax, 0x10(%rsp)
leal -0x1(%rax), %ebp
testl %ebp, %ebp
jle 0x6931e
leal -0x1(%rbp), %eax
testb $-0x80, 0x7(%r14)
jne 0x6932f
movzbl 0x18(%r14,%rax), %r13d
movl %eax, %ebp
jmp 0x69321
xorl %r13d, %r13d
movl %r13d, %edi
callq 0x7f3de
testl %eax, %eax
jne 0x69306
jmp 0x69380
movzwl 0x18(%r14,%rax,2), %r13d
cmpl $0x1, %ebp
je 0x6931a
movl %r13d, %ecx
andl $0xfc00, %ecx # imm = 0xFC00
cmpl $0xdc00, %ecx # imm = 0xDC00
jne 0x6931a
addl $-0x2, %ebp
movzwl 0x18(%r14,%rbp,2), %ecx
movl %ecx, %edx
andl $0xfc00, %edx # imm = 0xFC00
cmpl $0xd800, %edx # imm = 0xD800
jne 0x6931a
shll $0xa, %ecx
andl $0xffc00, %ecx # imm = 0xFFC00
andl $0x3ff, %r13d # imm = 0x3FF
addl %ecx, %r13d
addl $0x10000, %r13d # imm = 0x10000
jmp 0x69321
movl %r13d, %edi
callq 0x7f2cb
testl %eax, %eax
je 0x693e2
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
movl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
movl 0x4(%r14), %eax
andl %ebp, %eax
cmpl %eax, 0xc(%rsp)
jge 0x693d5
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x41a28
movl %eax, %r13d
movl %eax, %edi
callq 0x7f3de
testl %eax, %eax
jne 0x6939a
movl %r13d, %edi
callq 0x7f2cb
testl %eax, %eax
movl (%rsp), %r13d
movl 0x8(%rsp), %esi
jne 0x693ea
movl $0x3c2, 0x1c(%rsp) # imm = 0x3C2
pushq $0x1
popq %rax
jmp 0x693f7
movl (%rsp), %r13d
movl 0x8(%rsp), %esi
leaq 0x1c(%rsp), %rdi
movl %r13d, %edx
callq 0x7eee8
movl %eax, %r13d
testl %eax, %eax
movl $0x0, %eax
cmovlel %eax, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x69424
movl 0x1c(%rsp,%rbp,4), %esi
movq %r12, %rdi
callq 0x2ca82
incq %rbp
testl %eax, %eax
je 0x69407
jmp 0x69276
movl 0x4(%rsp), %eax
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
jmp 0x692bd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
leaq 0x28(%rsp), %rdi
callq 0x2cad4
movq %rax, %r14
movq %rdx, %rbx
jmp 0x69294
|
js_string_toLowerCase:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, r9d
mov r15, rdi
call JS_ToStringCheckObject
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz short loc_69294
mov edx, 7FFFFFFFh
and edx, [r14+4]
jz short loc_69294
mov [rsp+78h+var_78], ebp
lea rsi, [rsp+78h+var_50]
mov rdi, r15
call string_buffer_init
test eax, eax
jz short loc_692A9
loc_69276:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
lea rdi, [rsp+78h+var_50]
call string_buffer_free
push 6
pop rbx
xor r14d, r14d
loc_69294:
mov rax, r14
mov rdx, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_692A9:
lea rax, [rsp+78h+var_74]
and dword ptr [rax], 0
mov edx, 7FFFFFFFh
lea r12, [rsp+78h+var_50]
xor eax, eax
loc_692BD:
mov ecx, [r14+4]
and ecx, edx
cmp eax, ecx
mov r13d, [rsp+78h+var_78]
jge loc_69432
test r13d, r13d
setz bpl
mov rdi, r14
lea rsi, [rsp+78h+var_74]
call string_getc
mov esi, eax
cmp eax, 3A3h
setnz al
or al, bpl
jnz loc_693EA
mov [rsp+78h+var_70], esi
mov eax, [rsp+78h+var_74]
mov [rsp+78h+var_68], rax
lea ebp, [rax-1]
loc_69306:
test ebp, ebp
jle short loc_6931E
lea eax, [rbp-1]
test byte ptr [r14+7], 80h
jnz short loc_6932F
movzx r13d, byte ptr [r14+rax+18h]
loc_6931A:
mov ebp, eax
jmp short loc_69321
loc_6931E:
xor r13d, r13d
loc_69321:
mov edi, r13d
call lre_is_case_ignorable
test eax, eax
jnz short loc_69306
jmp short loc_69380
loc_6932F:
movzx r13d, word ptr [r14+rax*2+18h]
cmp ebp, 1
jz short loc_6931A
mov ecx, r13d
and ecx, 0FC00h
cmp ecx, 0DC00h
jnz short loc_6931A
add ebp, 0FFFFFFFEh
movzx ecx, word ptr [r14+rbp*2+18h]
mov edx, ecx
and edx, 0FC00h
cmp edx, 0D800h
jnz short loc_6931A
shl ecx, 0Ah
and ecx, 0FFC00h
and r13d, 3FFh
add r13d, ecx
add r13d, 10000h
jmp short loc_69321
loc_69380:
mov edi, r13d
call lre_is_cased
test eax, eax
jz short loc_693E2
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_6C], eax
mov ebp, 7FFFFFFFh
loc_6939A:
mov eax, [r14+4]
and eax, ebp
cmp [rsp+78h+var_6C], eax
jge short loc_693D5
mov rdi, r14
lea rsi, [rsp+78h+var_6C]
call string_getc
mov r13d, eax
mov edi, eax
call lre_is_case_ignorable
test eax, eax
jnz short loc_6939A
mov edi, r13d
call lre_is_cased
test eax, eax
mov r13d, [rsp+78h+var_78]
mov esi, [rsp+78h+var_70]
jnz short loc_693EA
loc_693D5:
mov [rsp+78h+var_5C], 3C2h
push 1
pop rax
jmp short loc_693F7
loc_693E2:
mov r13d, [rsp+78h+var_78]
mov esi, [rsp+78h+var_70]
loc_693EA:
lea rdi, [rsp+78h+var_5C]
mov edx, r13d
call lre_case_conv
loc_693F7:
mov r13d, eax
test eax, eax
mov eax, 0
cmovle r13d, eax
xor ebp, ebp
loc_69407:
cmp r13, rbp
jz short loc_69424
mov esi, [rsp+rbp*4+78h+var_5C]
mov rdi, r12
call string_buffer_putc
inc rbp
test eax, eax
jz short loc_69407
jmp loc_69276
loc_69424:
mov eax, [rsp+78h+var_74]
mov edx, 7FFFFFFFh
jmp loc_692BD
loc_69432:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
lea rdi, [rsp+78h+var_50]
call string_buffer_end
mov r14, rax
mov rbx, rdx
jmp loc_69294
|
long long js_string_toLowerCase(
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)
{
unsigned int v14; // ebp
long long v15; // rax
long long v16; // r14
long long v17; // rdx
long long v18; // rbx
int v20; // eax
unsigned int v21; // r13d
unsigned int v22; // eax
long long v23; // rsi
long long v24; // rbp
long long v25; // rax
unsigned int v26; // r13d
long long v28; // r13
int is_cased; // eax
int v30; // eax
long long v31; // r13
long long v32; // rbp
unsigned int v34; // [rsp+0h] [rbp-78h]
unsigned int v35; // [rsp+4h] [rbp-74h] BYREF
unsigned int v36; // [rsp+8h] [rbp-70h]
int v37; // [rsp+Ch] [rbp-6Ch] BYREF
long long v38; // [rsp+10h] [rbp-68h]
_DWORD v39[3]; // [rsp+1Ch] [rbp-5Ch] BYREF
long long v40[10]; // [rsp+28h] [rbp-50h] BYREF
v14 = a6;
v15 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v16 = v15;
v18 = v17;
if ( (_DWORD)v17 != 6 && (*(_DWORD *)(v15 + 4) & 0x7FFFFFFF) != 0 )
{
v34 = v14;
if ( (unsigned int)string_buffer_init(a1, (long long)v40, *(_DWORD *)(v15 + 4) & 0x7FFFFFFF) )
{
LABEL_4:
JS_FreeValue(a1, v16, v18);
string_buffer_free(v40);
return 0LL;
}
v35 = 0;
v20 = 0;
LABEL_7:
v21 = v34;
if ( v20 >= (*(_DWORD *)(v16 + 4) & 0x7FFFFFFF) )
{
JS_FreeValue(a1, v16, v18);
return string_buffer_end(v40);
}
v22 = string_getc(v16, (int *)&v35);
v23 = v22;
if ( v34 == 0 || v22 != 931 )
goto LABEL_28;
v36 = v22;
v38 = v35;
LODWORD(v24) = v35 - 1;
while ( 1 )
{
if ( (int)v24 <= 0 )
{
v26 = 0;
}
else
{
v25 = (unsigned int)(v24 - 1);
if ( *(char *)(v16 + 7) < 0 )
{
v26 = *(unsigned __int16 *)(v16 + 2 * v25 + 24);
if ( (_DWORD)v24 != 1 && (v26 & 0xFC00) == 0xDC00 )
{
v24 = (unsigned int)(v24 - 2);
if ( (*(_WORD *)(v16 + 2 * v24 + 24) & 0xFC00) == 0xD800 )
{
v26 = ((*(unsigned __int16 *)(v16 + 2 * v24 + 24) << 10) & 0xFFC00) + (v26 & 0x3FF) + 0x10000;
goto LABEL_15;
}
}
}
else
{
v26 = *(unsigned __int8 *)(v16 + v25 + 24);
}
LODWORD(v24) = v25;
}
LABEL_15:
if ( !(unsigned int)lre_is_case_ignorable(v26) )
{
if ( !(unsigned int)lre_is_cased(v26) )
{
v21 = v34;
v23 = v36;
LABEL_28:
v30 = lre_case_conv(v39, v23, v21);
goto LABEL_29;
}
v37 = v38;
while ( v37 < (*(_DWORD *)(v16 + 4) & 0x7FFFFFFF) )
{
v28 = (unsigned int)string_getc(v16, &v37);
if ( !(unsigned int)lre_is_case_ignorable(v28) )
{
is_cased = lre_is_cased((unsigned int)v28);
v21 = v34;
v23 = v36;
if ( is_cased )
goto LABEL_28;
break;
}
}
v39[0] = 962;
v30 = 1;
LABEL_29:
v31 = (unsigned int)v30;
if ( v30 <= 0 )
v31 = 0LL;
v32 = 0LL;
while ( v31 != v32 )
{
if ( (unsigned int)string_buffer_putc((long long)v40, v39[v32++]) )
goto LABEL_4;
}
v20 = v35;
goto LABEL_7;
}
}
}
return v16;
}
|
js_string_toLowerCase:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,R9D
MOV R15,RDI
CALL 0x0013a290
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00169294
MOV EDX,0x7fffffff
AND EDX,dword ptr [R14 + 0x4]
JZ 0x00169294
MOV dword ptr [RSP],EBP
LEA RSI,[RSP + 0x28]
MOV RDI,R15
CALL 0x0012e042
TEST EAX,EAX
JZ 0x001692a9
LAB_00169276:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
LEA RDI,[RSP + 0x28]
CALL 0x0012ef01
PUSH 0x6
POP RBX
XOR R14D,R14D
LAB_00169294:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001692a9:
LEA RAX,[RSP + 0x4]
AND dword ptr [RAX],0x0
MOV EDX,0x7fffffff
LEA R12,[RSP + 0x28]
XOR EAX,EAX
LAB_001692bd:
MOV ECX,dword ptr [R14 + 0x4]
AND ECX,EDX
CMP EAX,ECX
MOV R13D,dword ptr [RSP]
JGE 0x00169432
TEST R13D,R13D
SETZ BPL
MOV RDI,R14
LEA RSI,[RSP + 0x4]
CALL 0x00141a28
MOV ESI,EAX
CMP EAX,0x3a3
SETNZ AL
OR AL,BPL
JNZ 0x001693ea
MOV dword ptr [RSP + 0x8],ESI
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x10],RAX
LEA EBP,[RAX + -0x1]
LAB_00169306:
TEST EBP,EBP
JLE 0x0016931e
LEA EAX,[RBP + -0x1]
TEST byte ptr [R14 + 0x7],0x80
JNZ 0x0016932f
MOVZX R13D,byte ptr [R14 + RAX*0x1 + 0x18]
LAB_0016931a:
MOV EBP,EAX
JMP 0x00169321
LAB_0016931e:
XOR R13D,R13D
LAB_00169321:
MOV EDI,R13D
CALL 0x0017f3de
TEST EAX,EAX
JNZ 0x00169306
JMP 0x00169380
LAB_0016932f:
MOVZX R13D,word ptr [R14 + RAX*0x2 + 0x18]
CMP EBP,0x1
JZ 0x0016931a
MOV ECX,R13D
AND ECX,0xfc00
CMP ECX,0xdc00
JNZ 0x0016931a
ADD EBP,-0x2
MOVZX ECX,word ptr [R14 + RBP*0x2 + 0x18]
MOV EDX,ECX
AND EDX,0xfc00
CMP EDX,0xd800
JNZ 0x0016931a
SHL ECX,0xa
AND ECX,0xffc00
AND R13D,0x3ff
ADD R13D,ECX
ADD R13D,0x10000
JMP 0x00169321
LAB_00169380:
MOV EDI,R13D
CALL 0x0017f2cb
TEST EAX,EAX
JZ 0x001693e2
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0xc],EAX
MOV EBP,0x7fffffff
LAB_0016939a:
MOV EAX,dword ptr [R14 + 0x4]
AND EAX,EBP
CMP dword ptr [RSP + 0xc],EAX
JGE 0x001693d5
MOV RDI,R14
LEA RSI,[RSP + 0xc]
CALL 0x00141a28
MOV R13D,EAX
MOV EDI,EAX
CALL 0x0017f3de
TEST EAX,EAX
JNZ 0x0016939a
MOV EDI,R13D
CALL 0x0017f2cb
TEST EAX,EAX
MOV R13D,dword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x8]
JNZ 0x001693ea
LAB_001693d5:
MOV dword ptr [RSP + 0x1c],0x3c2
PUSH 0x1
POP RAX
JMP 0x001693f7
LAB_001693e2:
MOV R13D,dword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x8]
LAB_001693ea:
LEA RDI,[RSP + 0x1c]
MOV EDX,R13D
CALL 0x0017eee8
LAB_001693f7:
MOV R13D,EAX
TEST EAX,EAX
MOV EAX,0x0
CMOVLE R13D,EAX
XOR EBP,EBP
LAB_00169407:
CMP R13,RBP
JZ 0x00169424
MOV ESI,dword ptr [RSP + RBP*0x4 + 0x1c]
MOV RDI,R12
CALL 0x0012ca82
INC RBP
TEST EAX,EAX
JZ 0x00169407
JMP 0x00169276
LAB_00169424:
MOV EAX,dword ptr [RSP + 0x4]
MOV EDX,0x7fffffff
JMP 0x001692bd
LAB_00169432:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
LEA RDI,[RSP + 0x28]
CALL 0x0012cad4
MOV R14,RAX
MOV RBX,RDX
JMP 0x00169294
|
int1 [16] js_string_toLowerCase(int8 param_1)
{
ushort uVar1;
int iVar2;
uint uVar3;
int iVar4;
int4 uVar5;
long lVar6;
ulong uVar7;
ulong uVar8;
int in_R9D;
uint uVar9;
int1 auVar10 [16];
uint local_74;
int local_70;
int local_6c;
ulong local_68;
int4 local_5c [3];
int1 local_50 [32];
auVar10 = JS_ToStringCheckObject();
lVar6 = auVar10._0_8_;
if ((auVar10._8_4_ != 6) && ((*(uint *)(lVar6 + 4) & 0x7fffffff) != 0)) {
iVar2 = string_buffer_init(param_1,local_50);
if (iVar2 == 0) {
local_74 = 0;
while ((int)local_74 < (int)(*(uint *)(lVar6 + 4) & 0x7fffffff)) {
iVar2 = string_getc(lVar6,&local_74);
if (iVar2 == 0x3a3 && in_R9D != 0) {
local_68 = (ulong)local_74;
uVar7 = (ulong)(local_74 - 1);
local_70 = iVar2;
do {
iVar2 = (int)uVar7;
if (iVar2 < 1) {
uVar9 = 0;
}
else {
uVar3 = iVar2 - 1;
if ((*(byte *)(lVar6 + 7) & 0x80) == 0) {
uVar9 = (uint)*(byte *)(lVar6 + 0x18 + (ulong)uVar3);
}
else {
uVar9 = (uint)*(ushort *)(lVar6 + 0x18 + (ulong)uVar3 * 2);
if ((iVar2 != 1) && ((uVar9 & 0xfc00) == 0xdc00)) {
uVar7 = (ulong)(iVar2 - 2);
uVar1 = *(ushort *)(lVar6 + 0x18 + uVar7 * 2);
if ((uVar1 & 0xfc00) == 0xd800) {
uVar9 = (uVar9 & 0x3ff) + (uVar1 & 0x3ff) * 0x400 + 0x10000;
goto LAB_00169321;
}
}
}
uVar7 = (ulong)uVar3;
}
LAB_00169321:
iVar2 = lre_is_case_ignorable(uVar9);
} while (iVar2 != 0);
iVar4 = lre_is_cased(uVar9);
iVar2 = local_70;
if (iVar4 == 0) goto LAB_001693ea;
local_6c = (int)local_68;
do {
if ((int)(*(uint *)(lVar6 + 4) & 0x7fffffff) <= local_6c) goto LAB_001693d5;
uVar5 = string_getc(lVar6,&local_6c);
iVar2 = lre_is_case_ignorable(uVar5);
} while (iVar2 != 0);
iVar4 = lre_is_cased(uVar5);
iVar2 = local_70;
if (iVar4 != 0) goto LAB_001693ea;
LAB_001693d5:
local_5c[0] = 0x3c2;
uVar9 = 1;
}
else {
LAB_001693ea:
uVar9 = lre_case_conv(local_5c,iVar2,in_R9D);
}
uVar7 = (ulong)uVar9;
if ((int)uVar9 < 1) {
uVar7 = 0;
}
uVar8 = 0;
while (uVar7 != uVar8) {
iVar2 = string_buffer_putc(local_50,local_5c[uVar8]);
uVar8 = uVar8 + 1;
if (iVar2 != 0) goto LAB_00169276;
}
}
JS_FreeValue(param_1,lVar6,auVar10._8_8_);
auVar10 = string_buffer_end(local_50);
}
else {
LAB_00169276:
JS_FreeValue(param_1,lVar6,auVar10._8_8_);
string_buffer_free(local_50);
auVar10 = ZEXT816(6) << 0x40;
}
}
return auVar10;
}
|
|
5,094 |
string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/common.cpp
|
std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
}
|
O3
|
cpp
|
string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x20fa0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0xf5b63
movl $0x8, %r13d
xorl %ebp, %ebp
movq %rsp, %r12
testq %rbp, %rbp
je 0xf5b38
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x21000
movq (%r15), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r12, %rdi
callq 0x21000
incq %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rcx, %rbp
jb 0xf5b21
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20620
movq 0x6b3e1(%rip), %rsi # 0x160f58
movq %rsp, %rdi
callq 0x20c30
leaq 0x70(%rsp), %rdi
callq 0x20c00
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf5ba0
movq %rax, %rbx
movq 0x6b3ae(%rip), %rsi # 0x160f58
movq %rsp, %rdi
callq 0x20c30
leaq 0x70(%rsp), %rdi
callq 0x20c00
movq %rbx, %rdi
callq 0x20ab0
|
_Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 178h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [r15]
cmp [r15+8], rax
jz short loc_F5B63
mov r13d, 8
xor ebp, ebp
mov r12, rsp
loc_F5B21:
test rbp, rbp
jz short loc_F5B38
mov rsi, [r14]
mov rdx, [r14+8]
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 rax, [r15]
loc_F5B38:
mov rsi, [rax+r13-8]
mov rdx, [rax+r13]
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)
inc rbp
mov rax, [r15]
mov rcx, [r15+8]
sub rcx, rax
sar rcx, 5
add r13, 20h ; ' '
cmp rbp, rcx
jb short loc_F5B21
loc_F5B63:
lea rsi, [rsp+1A8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1A8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 178h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_F5BA0:
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_68]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
|
long long string_join(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rax
long long v5; // r13
unsigned long long v6; // rbp
long long v8; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v9[104]; // [rsp+8h] [rbp-1A0h] BYREF
_BYTE v10[312]; // [rsp+70h] [rbp-138h] BYREF
std::ostringstream::basic_ostringstream(&v8);
v4 = *a2;
if ( a2[1] != *a2 )
{
v5 = 8LL;
v6 = 0LL;
do
{
if ( v6 )
{
std::__ostream_insert<char,std::char_traits<char>>(&v8, *a3, a3[1]);
v4 = *a2;
}
std::__ostream_insert<char,std::char_traits<char>>(&v8, *(_QWORD *)(v4 + v5 - 8), *(_QWORD *)(v4 + v5));
++v6;
v4 = *a2;
v5 += 32LL;
}
while ( v6 < (a2[1] - *a2) >> 5 );
}
std::stringbuf::str(a1, v9);
std::ostringstream::~ostringstream(&v8, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v10);
return a1;
}
|
string_join:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x178
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x00120fa0
MOV RAX,qword ptr [R15]
CMP qword ptr [R15 + 0x8],RAX
JZ 0x001f5b63
MOV R13D,0x8
XOR EBP,EBP
MOV R12,RSP
LAB_001f5b21:
TEST RBP,RBP
JZ 0x001f5b38
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LAB_001f5b2d:
MOV RDI,R12
CALL 0x00121000
MOV RAX,qword ptr [R15]
LAB_001f5b38:
MOV RSI,qword ptr [RAX + R13*0x1 + -0x8]
MOV RDX,qword ptr [RAX + R13*0x1]
MOV RDI,R12
CALL 0x00121000
INC RBP
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
SUB RCX,RAX
SAR RCX,0x5
ADD R13,0x20
CMP RBP,RCX
JC 0x001f5b21
LAB_001f5b63:
LEA RSI,[RSP + 0x8]
LAB_001f5b68:
MOV RDI,RBX
CALL 0x00120620
LAB_001f5b70:
MOV RSI,qword ptr [0x00260f58]
MOV RDI,RSP
CALL 0x00120c30
LEA RDI,[RSP + 0x70]
CALL 0x00120c00
MOV RAX,RBX
ADD RSP,0x178
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_join(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::__cxx11::string const&) */
vector * string_join(vector *param_1,string *param_2)
{
long lVar1;
int8 *in_RDX;
ulong uVar2;
long lVar3;
ostringstream aoStack_1a8 [112];
ios_base local_138 [264];
std::__cxx11::ostringstream::ostringstream(aoStack_1a8);
lVar1 = *(long *)param_2;
if (*(long *)(param_2 + 8) != lVar1) {
lVar3 = 8;
uVar2 = 0;
do {
if (uVar2 != 0) {
/* try { // try from 001f5b2d to 001f5b48 has its CatchHandler @ 001f5ba0 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)aoStack_1a8,(char *)*in_RDX,in_RDX[1]);
lVar1 = *(long *)param_2;
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)aoStack_1a8,*(char **)(lVar1 + -8 + lVar3),*(long *)(lVar1 + lVar3));
uVar2 = uVar2 + 1;
lVar1 = *(long *)param_2;
lVar3 = lVar3 + 0x20;
} while (uVar2 < (ulong)(*(long *)(param_2 + 8) - lVar1 >> 5));
}
/* try { // try from 001f5b68 to 001f5b6f has its CatchHandler @ 001f5b9e */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(aoStack_1a8);
std::ios_base::~ios_base(local_138);
return param_1;
}
|
|
5,095 |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/json.hpp
|
std::string exception_message(const token_type expected, const std::string& context)
{
std::string error_msg = "syntax error ";
if (!context.empty())
{
error_msg += concat("while parsing ", context, ' ');
}
error_msg += "- ";
if (last_token == token_type::parse_error)
{
error_msg += concat(m_lexer.get_error_message(), "; last read: '",
m_lexer.get_token_string(), '\'');
}
else
{
error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
}
if (expected != token_type::uninitialized)
{
error_msg += concat("; expected ", lexer_t::token_type_name(expected));
}
return error_msg;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x95e57(%rip), %rsi # 0x11d5da
leaq 0x95e5d(%rip), %rdx # 0x11d5e7
callq 0x3a58a
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x87816
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addq $0xf, %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e80
leaq 0x95e25(%rip), %rsi # 0x11d5e8
leaq 0x8(%rsp), %rdi
callq 0x21b70
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x21560
leaq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x22400
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21560
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x87816
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
leaq 0x95dda(%rip), %rsi # 0x11d5f7
movq %rbx, %rdi
callq 0x21b70
movl 0x20(%r14), %edi
cmpl $0xe, %edi
jne 0x878b9
movq 0x98(%r14), %rax
addq $0x28, %r14
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x876a2
leaq 0x2f(%rsp), %r8
movb $0x27, (%r8)
leaq 0x95d9b(%rip), %rdx # 0x11d5fa
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rcx
callq 0x35f68
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21560
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x878a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87933
movq 0x48(%rsp), %rsi
jmp 0x8792b
callq 0x8c920
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x21690
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e80
leaq 0x95d16(%rip), %rsi # 0x11d609
leaq 0x8(%rsp), %rdi
callq 0x21b70
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21b70
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21560
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x87933
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
testl %ebp, %ebp
je 0x879b3
movl %ebp, %edi
callq 0x8c920
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x21690
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21e80
leaq 0x95ca2(%rip), %rsi # 0x11d615
leaq 0x8(%rsp), %rdi
callq 0x21b70
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21b70
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21560
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x879b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x87a0c
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x879ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
jmp 0x879ea
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87a35
movq 0x48(%rsp), %rsi
jmp 0x87a2d
jmp 0x87a05
jmp 0x87a0c
jmp 0x87a1b
movq %rax, %r14
jmp 0x87a35
jmp 0x87a0c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x87a28
jmp 0x87a35
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x87a35
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x87a49
movq (%r12), %rsi
incq %rsi
callq 0x21180
movq %r14, %rdi
callq 0x21b20
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE17exception_messageENS1_10lexer_baseISF_E10token_typeERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rcx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
lea rsi, aSyntaxError; "syntax error "
lea rdx, aSyntaxError+0Dh; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [r15+8]
test rsi, rsi
jz short loc_87816
lea r13, [rsp+88h+var_70]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
add rsi, 0Fh
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aWhileParsing; "while parsing "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rdi, [rsp+88h+var_80]
mov esi, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r13
jz short loc_87816
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87816:
lea rsi, asc_11D5F7; "- "
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov edi, [r14+20h]
cmp edi, 0Eh
jnz loc_878B9
mov rax, [r14+98h]
add r14, 28h ; '('
mov [rsp+88h+var_58], rax
lea rdi, [rsp+88h+var_50]
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE16get_token_stringEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string(void)
lea r8, [rsp+88h+var_59]
mov byte ptr [r8], 27h ; '''
lea rdx, aLastRead; "; last read: '"
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_58]
lea rcx, [rsp+88h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJPKcRA15_S9_S8_cEEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(char const*,char const(&)[15],std::string,char &&)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_878A0
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_878A0:
lea rax, [rsp+88h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz loc_87933
mov rsi, [rsp+88h+var_40]
jmp short loc_8792B
loc_878B9:
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aUnexpected; "unexpected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_87933
mov rsi, [rsp+88h+var_70]
loc_8792B:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87933:
test ebp, ebp
jz short loc_879B3
mov edi, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aExpected; "; expected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_879B3
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_879B3:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_87A0C
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_879EA
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_879EA
mov r14, rax
loc_879EA:
lea rax, [rsp+arg_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_87A35
mov rsi, [rsp+arg_40]
jmp short loc_87A2D
jmp short loc_87A05
jmp short loc_87A0C
jmp short loc_87A1B
loc_87A05:
mov r14, rax
jmp short loc_87A35
jmp short $+2
loc_87A0C:
mov r14, rax
mov rdi, [rsp+arg_0]
cmp rdi, r15
jnz short loc_87A28
jmp short loc_87A35
loc_87A1B:
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_87A35
loc_87A28:
mov rsi, [rsp+arg_10]
loc_87A2D:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87A35:
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_87A49
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87A49:
mov rdi, r14
call __Unwind_Resume
|
_QWORD * nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::exception_message(
_QWORD *a1,
long long a2,
unsigned int a3,
_QWORD *a4)
{
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
void *v17; // rdi
long long v18; // rsi
long long v19; // r14
long long v20; // rax
long long v21; // r14
long long v22; // rax
void *v24; // [rsp+8h] [rbp-80h] BYREF
long long v25; // [rsp+10h] [rbp-78h]
_QWORD v26[2]; // [rsp+18h] [rbp-70h] BYREF
char v27; // [rsp+2Fh] [rbp-59h] BYREF
long long v28; // [rsp+30h] [rbp-58h] BYREF
_QWORD v29[2]; // [rsp+38h] [rbp-50h] BYREF
long long v30; // [rsp+48h] [rbp-40h] BYREF
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, "syntax error ", (long long)"");
v8 = a4[1];
if ( v8 )
{
v24 = v26;
v25 = 0LL;
LOBYTE(v26[0]) = 0;
std::string::reserve(&v24, v8 + 15);
std::string::append(&v24, "while parsing ");
std::string::append(&v24, *a4, a4[1]);
std::string::push_back(&v24, 32LL, v9, v10, v11, v12);
std::string::append(a1, v24, v25);
if ( v24 != v26 )
operator delete(v24, v26[0] + 1LL);
}
std::string::append(a1, "- ");
if ( *(_DWORD *)(a2 + 32) == 14 )
{
v28 = *(_QWORD *)(a2 + 152);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_token_string(
(long long)v29,
a2 + 40,
v13,
v14,
v15,
v16);
v27 = 39;
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(
(long long)&v24,
&v28,
(long long)"; last read: '",
v29,
&v27);
std::string::append(a1, v24, v25);
if ( v24 != v26 )
operator delete(v24, v26[0] + 1LL);
v17 = (void *)v29[0];
if ( (long long *)v29[0] != &v30 )
{
v18 = v30;
LABEL_11:
operator delete(v17, v18 + 1);
}
}
else
{
v19 = ((long long (*)(void))nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name)();
v24 = v26;
v25 = 0LL;
LOBYTE(v26[0]) = 0;
v20 = strlen(v19);
std::string::reserve(&v24, v20 + 11);
std::string::append(&v24, "unexpected ");
std::string::append(&v24, v19);
std::string::append(a1, v24, v25);
v17 = v24;
if ( v24 != v26 )
{
v18 = v26[0];
goto LABEL_11;
}
}
if ( a3 )
{
v21 = nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name(a3);
v24 = v26;
v25 = 0LL;
LOBYTE(v26[0]) = 0;
v22 = strlen(v21);
std::string::reserve(&v24, v22 + 11);
std::string::append(&v24, "; expected ");
std::string::append(&v24, v21);
std::string::append(a1, v24, v25);
if ( v24 != v26 )
operator delete(v24, v26[0] + 1LL);
}
return a1;
}
|
exception_message:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RCX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
LEA RSI,[0x21d5da]
LEA RDX,[0x21d5e7]
CALL 0x0013a58a
MOV RSI,qword ptr [R15 + 0x8]
TEST RSI,RSI
JZ 0x00187816
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
ADD RSI,0xf
LAB_001877b2:
LEA RDI,[RSP + 0x8]
CALL 0x00121e80
LEA RSI,[0x21d5e8]
LEA RDI,[RSP + 0x8]
CALL 0x00121b70
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x00121560
LEA RDI,[RSP + 0x8]
MOV ESI,0x20
CALL 0x00122400
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001877f7:
MOV RDI,RBX
CALL 0x00121560
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x00187816
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_00187816:
LEA RSI,[0x21d5f7]
MOV RDI,RBX
CALL 0x00121b70
MOV EDI,dword ptr [R14 + 0x20]
CMP EDI,0xe
JNZ 0x001878b9
MOV RAX,qword ptr [R14 + 0x98]
ADD R14,0x28
MOV qword ptr [RSP + 0x30],RAX
LAB_00187842:
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x001876a2
LEA R8,[RSP + 0x2f]
MOV byte ptr [R8],0x27
LAB_00187858:
LEA RDX,[0x21d5fa]
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x30]
LEA RCX,[RSP + 0x38]
CALL 0x00135f68
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0018787d:
MOV RDI,RBX
CALL 0x00121560
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001878a0
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_001878a0:
LEA RAX,[RSP + 0x48]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00187933
MOV RSI,qword ptr [RSP + 0x48]
JMP 0x0018792b
LAB_001878b9:
CALL 0x0018c920
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x00121690
LEA RSI,[RAX + 0xb]
LAB_001878e2:
LEA RDI,[RSP + 0x8]
CALL 0x00121e80
LEA RSI,[0x21d609]
LEA RDI,[RSP + 0x8]
CALL 0x00121b70
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x00121b70
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00187914:
MOV RDI,RBX
CALL 0x00121560
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00187933
MOV RSI,qword ptr [RSP + 0x18]
LAB_0018792b:
INC RSI
CALL 0x00121180
LAB_00187933:
TEST EBP,EBP
JZ 0x001879b3
MOV EDI,EBP
CALL 0x0018c920
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x00121690
LEA RSI,[RAX + 0xb]
LAB_00187962:
LEA RDI,[RSP + 0x8]
CALL 0x00121e80
LEA RSI,[0x21d615]
LEA RDI,[RSP + 0x8]
CALL 0x00121b70
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x00121b70
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00187994:
MOV RDI,RBX
CALL 0x00121560
LAB_0018799c:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001879b3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_001879b3:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type, std::__cxx11::string const&) */
long * nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::exception_message(long *param_1,long param_2,int param_3,ulong *param_4)
{
char *pcVar1;
long *local_80;
int8 local_78;
int1 local_70;
int7 uStack_6f;
int1 local_59;
int8 local_58;
long *local_50 [2];
long local_40 [2];
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"syntax error ","");
if (param_4[1] != 0) {
local_78 = 0;
local_70 = 0;
/* try { // try from 001877b2 to 001877ec has its CatchHandler @ 00187a1b */
local_80 = (long *)&local_70;
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80,*param_4);
std::__cxx11::string::push_back((char)&local_80);
/* try { // try from 001877f7 to 001877fe has its CatchHandler @ 00187a03 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
/* try { // try from 00187816 to 00187824 has its CatchHandler @ 00187a05 */
std::__cxx11::string::append((char *)param_1);
if (*(int *)(param_2 + 0x20) == 0xe) {
local_58 = *(int8 *)(param_2 + 0x98);
/* try { // try from 00187842 to 0018784e has its CatchHandler @ 001879ff */
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::get_token_string();
local_59 = 0x27;
/* try { // try from 00187858 to 00187872 has its CatchHandler @ 001879e7 */
concat<std::__cxx11::string,char_const*,char_const(&)[15],std::__cxx11::string,char>
((char **)&local_80,(char *)&local_58,(string *)"; last read: \'",(char *)local_50);
/* try { // try from 0018787d to 00187884 has its CatchHandler @ 001879c7 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
if (local_50[0] == local_40) goto LAB_00187933;
}
else {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name();
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 001878e2 to 00187909 has its CatchHandler @ 00187a0a */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 00187914 to 0018791b has its CatchHandler @ 001879c5 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 == (long *)&local_70) goto LAB_00187933;
local_40[0] = CONCAT71(uStack_6f,local_70);
local_50[0] = local_80;
}
operator_delete(local_50[0],local_40[0] + 1);
LAB_00187933:
if (param_3 != 0) {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(param_3);
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 00187962 to 00187989 has its CatchHandler @ 00187a0c */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 00187994 to 0018799b has its CatchHandler @ 00187a01 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
return param_1;
}
|
|
5,096 |
set_max_sort_char
|
eloqsql/strings/ctype-simple.c
|
static void set_max_sort_char(struct charset_info_st *cs)
{
uchar max_char;
uint i;
if (!cs->sort_order)
return;
max_char=cs->sort_order[(uchar) cs->max_sort_char];
for (i= 0; i < 256; i++)
{
if ((uchar) cs->sort_order[i] > max_char)
{
max_char=(uchar) cs->sort_order[i];
cs->max_sort_char= i;
}
}
}
|
O0
|
c
|
set_max_sort_char:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x464f5
jmp 0x46566
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xa8(%rcx), %rcx
movzbl %cl, %ecx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp) # imm = 0x100
jae 0x46566
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jle 0x46559
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x10(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
jmp 0x4655b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x46518
popq %rbp
retq
nopl (%rax,%rax)
|
set_max_sort_char:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+58h], 0
jnz short loc_464F5
jmp short loc_46566
loc_464F5:
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+0A8h]
movzx ecx, cl
mov al, [rax+rcx]
mov [rbp+var_9], al
mov [rbp+var_10], 0
loc_46518:
cmp [rbp+var_10], 100h
jnb short loc_46566
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov ecx, [rbp+var_10]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_9]
cmp eax, ecx
jle short loc_46559
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov ecx, [rbp+var_10]
mov al, [rax+rcx]
mov [rbp+var_9], al
mov eax, [rbp+var_10]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
loc_46559:
jmp short $+2
loc_4655B:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_46518
loc_46566:
pop rbp
retn
|
unsigned __int8 set_max_sort_char(long long a1)
{
unsigned __int8 result; // al
unsigned int i; // [rsp+0h] [rbp-10h]
unsigned __int8 v3; // [rsp+7h] [rbp-9h]
result = a1;
if ( *(_QWORD *)(a1 + 88) )
{
result = *(_BYTE *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*(_QWORD *)(a1 + 168));
v3 = result;
for ( i = 0; i < 0x100; ++i )
{
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + i) > (int)v3 )
{
v3 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + i);
*(_QWORD *)(a1 + 168) = i;
}
result = i + 1;
}
}
return result;
}
|
set_max_sort_char:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x58],0x0
JNZ 0x001464f5
JMP 0x00146566
LAB_001464f5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0xa8]
MOVZX ECX,CL
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x9],AL
MOV dword ptr [RBP + -0x10],0x0
LAB_00146518:
CMP dword ptr [RBP + -0x10],0x100
JNC 0x00146566
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV ECX,dword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x9]
CMP EAX,ECX
JLE 0x00146559
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV ECX,dword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x9],AL
MOV EAX,dword ptr [RBP + -0x10]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
LAB_00146559:
JMP 0x0014655b
LAB_0014655b:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00146518
LAB_00146566:
POP RBP
RET
|
void set_max_sort_char(long param_1)
{
int4 local_18;
int1 local_11;
if (*(long *)(param_1 + 0x58) != 0) {
local_11 = *(byte *)(*(long *)(param_1 + 0x58) + (*(ulong *)(param_1 + 0xa8) & 0xff));
for (local_18 = 0; local_18 < 0x100; local_18 = local_18 + 1) {
if (local_11 < *(byte *)(*(long *)(param_1 + 0x58) + (ulong)local_18)) {
local_11 = *(byte *)(*(long *)(param_1 + 0x58) + (ulong)local_18);
*(ulong *)(param_1 + 0xa8) = (ulong)local_18;
}
}
}
return;
}
|
|
5,097 |
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
}
return true;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x18(%rsp)
movb $0x3, 0x10(%rsp)
movq %rsi, %rdi
callq 0x75caa
movq %rax, 0x18(%rsp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x745ce
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x73d48
testb %bpl, %bpl
je 0x745b9
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x745b9
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6d6e4
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x75c2e
movb (%rax), %cl
leaq 0x20(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0x6d512
leaq 0x10(%rsp), %rdi
callq 0x6d512
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xa1e0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6d512
jmp 0x745e5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6d512
movq %rbx, %rdi
callq 0xaae0
nop
|
_ZN8nlohmann16json_abi_v3_11_26detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov [rsp+48h+var_30], 0
mov [rsp+48h+var_38], 3
mov rdi, rsi
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEE6createIS9_JRKS9_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::create<std::string,std::string const&>(std::string const&)
mov [rsp+48h+var_30], rax
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_745CE
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_745B9
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_745B9
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2ERKSD_; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_210basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEEESt4lessIvESaISt4pairIKS5_SD_EEEixERSH_; std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_28]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
loc_745B9:
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_745CE:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
jmp short loc_745E5
mov rbx, rax
loc_745E5:
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v4; // cl
long long v5; // rcx
char v7; // [rsp+Bh] [rbp-3Dh] BYREF
int v8; // [rsp+Ch] [rbp-3Ch] BYREF
char v9[8]; // [rsp+10h] [rbp-38h] BYREF
long long v10; // [rsp+18h] [rbp-30h]
_BYTE v11[8]; // [rsp+20h] [rbp-28h] BYREF
long long v12; // [rsp+28h] [rbp-20h]
v9[0] = 3;
v10 = nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::create<std::string,std::string const&>(a2);
v8 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v7 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, char *))(a1 + 152))(a1 + 128, &v8, &v7, v9);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::basic_json(
(long long)v11,
(unsigned __int8 *)(a1 + 168));
v3 = std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
v4 = *(_BYTE *)v3;
*(_BYTE *)v3 = v11[0];
v11[0] = v4;
v5 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(v3 + 8) = v12;
v12 = v5;
*(_QWORD *)(a1 + 112) = v3;
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v11);
}
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v9);
return 1;
}
| |||
5,098 |
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
}
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x51f68
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x4
popq %rdx
movq %r15, %rcx
callq 0x51230
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x50550
testb %bpl, %bpl
je 0x50dbc
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x50dbc
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4a842
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x51f76
movb (%rax), %cl
leaq 0x8(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0x4a6b0
leaq 0x18(%rsp), %rdi
callq 0x4a6b0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4a6b0
jmp 0x50de5
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4a6b0
movq %rbx, %rdi
callq 0xaab0
nop
|
_ZN8nlohmann16json_abi_v3_11_26detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEEE3keyERSB_:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+48h+var_30]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 4
pop rdx
mov rcx, r15
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_26detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_2::detail::parse_event_t,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>> &)>::operator()(int,nlohmann::json_abi_v3_11_2::detail::parse_event_t,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>> &)
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_50DBC
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_50DBC
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_40]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2ERKSD_; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_210basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEEESt4lessIvESaISt4pairIKS5_SD_EEEixERSH_; std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_40]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
loc_50DBC:
lea rdi, [rsp+48h+var_30]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov al, 1
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
jmp short loc_50DE5
mov rbx, rax
loc_50DE5:
lea rdi, [rsp+arg_10]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::key(
_QWORD *a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v4; // cl
long long v5; // rcx
_BYTE v7[8]; // [rsp+8h] [rbp-40h] BYREF
long long v8; // [rsp+10h] [rbp-38h]
_BYTE v9[48]; // [rsp+18h] [rbp-30h] BYREF
ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v9);
v2 = std::function<bool ()(int,nlohmann::json_abi_v3_11_2::detail::parse_event_t,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>> &)>::operator()(
a1 + 16,
(a1[2] - a1[1]) >> 3,
4LL,
v9);
std::vector<bool>::push_back((long long)(a1 + 9), v2);
if ( v2 && *(_QWORD *)(a1[2] - 8LL) )
{
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::basic_json(
v7,
a1 + 21);
v3 = std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::operator[](
*(_QWORD *)(*(_QWORD *)(a1[2] - 8LL) + 8LL),
a2);
v4 = *(_BYTE *)v3;
*(_BYTE *)v3 = v7[0];
v7[0] = v4;
v5 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(v3 + 8) = v8;
v8 = v5;
a1[14] = v3;
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v7);
}
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v9);
return 1;
}
|
key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x18]
MOV RDI,R15
CALL 0x00151f68
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_00150d48:
PUSH 0x4
POP RDX
MOV RCX,R15
CALL 0x00151230
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x00150550
TEST BPL,BPL
JZ 0x00150dbc
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x00150dbc
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x8]
CALL 0x0014a842
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_00150d8e:
MOV RSI,R14
CALL 0x00151f76
LAB_00150d96:
MOV CL,byte ptr [RAX]
LEA RDI,[RSP + 0x8]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV qword ptr [RBX + 0x70],RAX
CALL 0x0014a6b0
LAB_00150dbc:
LEA RDI,[RSP + 0x18]
CALL 0x0014a6b0
MOV AL,0x1
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > > >::key(std::__cxx11::string&) */
int8 __thiscall
nlohmann::json_abi_v3_11_2::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>
::key(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>
*this,string *param_1)
{
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
bVar1;
int8 uVar2;
bool bVar3;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
*pbVar4;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
local_40 [8];
int8 local_38;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
local_30 [16];
_ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_30);
/* try { // try from 00150d48 to 00150d81 has its CatchHandler @ 00150de2 */
bVar3 = (bool)std::
function<bool(int,nlohmann::json_abi_v3_11_2::detail::parse_event_t,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,
4,local_30);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar3);
if ((bVar3 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 0)) {
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
::basic_json(local_40,this + 0xa8);
/* try { // try from 00150d8e to 00150d95 has its CatchHandler @ 00150dd3 */
pbVar4 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
*)std::
map<std::__cxx11::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>>>
::operator[](*(map<std::__cxx11::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
bVar1 = *pbVar4;
*pbVar4 = local_40[0];
uVar2 = *(int8 *)(pbVar4 + 8);
*(int8 *)(pbVar4 + 8) = local_38;
*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
**)(this + 0x70) = pbVar4;
local_40[0] = bVar1;
local_38 = uVar2;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
::~basic_json(local_40);
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>
::~basic_json(local_30);
return 1;
}
|
|
5,099 |
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
7CodeWizard[P]stablediffusion/thirdparty/json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
}
return true;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x3, 0x10(%rsp)
movq %rsi, %rdi
callq 0x74d80
movq %rax, 0x18(%rsp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x73795
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x72efc
testb %bpl, %bpl
je 0x73780
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x73780
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x6cac0
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x74d04
movb (%rax), %cl
leaq 0x20(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0x6c896
leaq 0x10(%rsp), %rdi
callq 0x6c896
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xa1e0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6c896
jmp 0x737ac
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6c896
movq %rbx, %rdi
callq 0xaad0
|
_ZN8nlohmann16json_abi_v3_11_26detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov [rsp+48h+var_38], 3
mov rdi, rsi
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEE6createIS9_JRKS9_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::create<std::string,std::string const&>(std::string const&)
mov [rsp+48h+var_30], rax
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_73795
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_73780
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_73780
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEEC2ERKSD_; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::basic_json(nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_210basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEEESt4lessIvESaISt4pairIKS5_SD_EEEixERSH_; std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_28]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
loc_73780:
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_73795:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
jmp short loc_737AC
mov rbx, rax
loc_737AC:
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_210basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEED2Ev; nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_2::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v4; // cl
long long v5; // rcx
char v7; // [rsp+Bh] [rbp-3Dh] BYREF
int v8; // [rsp+Ch] [rbp-3Ch] BYREF
char v9[8]; // [rsp+10h] [rbp-38h] BYREF
long long v10; // [rsp+18h] [rbp-30h]
_BYTE v11[8]; // [rsp+20h] [rbp-28h] BYREF
long long v12; // [rsp+28h] [rbp-20h]
v9[0] = 3;
v10 = nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::create<std::string,std::string const&>(a2);
v8 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v7 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, char *))(a1 + 152))(a1 + 128, &v8, &v7, v9);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::basic_json(
(long long)v11,
(unsigned __int8 *)(a1 + 168));
v3 = std::map<std::string,nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
v4 = *(_BYTE *)v3;
*(_BYTE *)v3 = v11[0];
v11[0] = v4;
v5 = *(_QWORD *)(v3 + 8);
*(_QWORD *)(v3 + 8) = v12;
v12 = v5;
*(_QWORD *)(a1 + 112) = v3;
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v11);
}
nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>::~basic_json(v9);
return 1;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.