index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
---|---|---|---|---|---|---|---|---|---|---|---|
9,500 |
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc
|
std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
const TestResult& result, const std::string& indent) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n"
<< indent << "\"" << property.key() << "\": " << "\""
<< EscapeJson(property.value()) << "\"";
}
return attributes.GetString();
}
|
O3
|
cpp
|
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult 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 $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x1c968
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x2af4c
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %r13
xorl %ebp, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x1f850
movq %rax, %r14
movl $0x2, %edx
movq %r13, %rdi
leaq 0x1892e(%rip), %rsi # 0x43765
callq 0x85b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0x85b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x18931(%rip), %rsi # 0x4378b
callq 0x85b0
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2ae74
movq %rbx, %rdi
callq 0x8200
movq %rax, %rdx
jmp 0x2ae80
movl $0x6, %edx
leaq 0x157d9(%rip), %rbx # 0x40659
movq %r13, %rdi
movq %rbx, %rsi
callq 0x85b0
movl $0x3, %edx
movq %r13, %rdi
leaq 0x18879(%rip), %rsi # 0x43713
callq 0x85b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x188dd(%rip), %rsi # 0x4378b
callq 0x85b0
movq 0x20(%r14), %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
leaq 0xf(%rsp), %rdx
callq 0x81e0
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x28c22
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r13, %rdi
callq 0x85b0
movl $0x1, %edx
movq %r13, %rdi
leaq 0x18894(%rip), %rsi # 0x4378b
callq 0x85b0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2af18
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x2af34
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x84e0
incl %ebp
movq 0x58(%r12), %rax
subq 0x50(%r12), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x2ae1b
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x1cbbf
testq %r14, %r14
je 0x2af6f
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2afd4
jmp 0x2afcc
movq %rax, %rbx
jmp 0x2afac
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2afac
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x2afcf
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x2afcf
jmp 0x2afcc
movq %rax, %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x2afe2
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal25JsonUnitTestResultPrinter20TestPropertiesAsJsonERKNS_10TestResultERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rdx
mov r12, rsi
mov [rsp+98h+var_60], rdi
lea rbx, [rsp+98h+var_38]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [r12+58h]
sub rax, [r12+50h]
shr rax, 6
mov rcx, [rbx]
mov [rsp+98h+var_88], rcx; __int64
test eax, eax
jle loc_2AF4C
mov rax, [rsp+98h+var_88]
lea r13, [rax+10h]
xor ebp, ebp
loc_2AE1B:
mov rdi, r12; this
mov esi, ebp; int
call _ZNK7testing10TestResult15GetTestPropertyEi; testing::TestResult::GetTestProperty(int)
mov r14, rax
mov edx, 2
mov rdi, r13
lea rsi, asc_43764+1; ",\n"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, r13
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
mov rdi, r13
lea rsi, aMessage+0Fh; "\""
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [r14]
test rbx, rbx
jz short loc_2AE74
mov rdi, rbx
call _strlen
mov rdx, rax
jmp short loc_2AE80
loc_2AE74:
mov edx, 6
lea rbx, aNull; "(null)"
loc_2AE80:
mov rdi, r13
mov rsi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 3
mov rdi, r13
lea rsi, asc_43713; "\": "
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
mov rdi, r13
lea rsi, aMessage+0Fh; "\""
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [r14+20h]
lea rbx, [rsp+98h+var_58]
mov rdi, rbx
lea rdx, [rsp+98h+var_89]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
lea rdi, [rsp+98h+var_80]; int
mov rsi, rbx; int
call _ZN7testing8internal25JsonUnitTestResultPrinter10EscapeJsonERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::string const&)
mov rsi, [rsp+98h+var_80]
mov rdx, [rsp+98h+var_78]
mov rdi, r13
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
mov rdi, r13
lea rsi, aMessage+0Fh; "\""
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+98h+var_80]; void *
lea rax, [rsp+98h+var_70]
cmp rdi, rax
jz short loc_2AF18
mov rsi, [rsp+98h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AF18:
mov rdi, [rsp+98h+var_58]; void *
lea rax, [rsp+98h+var_48]
cmp rdi, rax
jz short loc_2AF34
mov rsi, [rsp+98h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AF34:
inc ebp
mov rax, [r12+58h]
sub rax, [r12+50h]
shr rax, 6
cmp ebp, eax
jl loc_2AE1B
loc_2AF4C:
mov rbx, [rsp+98h+var_60]
mov rdi, rbx
mov r14, [rsp+98h+var_88]
mov rsi, r14
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
test r14, r14
jz short loc_2AF6F
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_2AF6F:
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_2AFD4
jmp short loc_2AFCC
mov rbx, rax
jmp short loc_2AFAC
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
lea rax, [rsp+arg_20]
cmp rdi, rax
jz short loc_2AFAC
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2AFAC:
mov rdi, [rsp+arg_38]; void *
lea rax, [rsp+arg_48]
cmp rdi, rax
jz short loc_2AFCF
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2AFCF
jmp short $+2
loc_2AFCC:
mov rbx, rax
loc_2AFCF:
mov r14, [rsp+arg_8]
loc_2AFD4:
test r14, r14
jz short loc_2AFE2
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_2AFE2:
mov rdi, rbx
call __Unwind_Resume
|
long long testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(
long long a1,
testing::TestResult *a2,
_QWORD *a3)
{
long long v4; // rax
long long v5; // r13
int v6; // ebp
const char **TestProperty; // r14
const char *v8; // rbx
long long v9; // rdx
long long v10; // rbx
long long v11; // r14
char v13; // [rsp+Fh] [rbp-89h] BYREF
long long v14; // [rsp+10h] [rbp-88h]
void *v15[2]; // [rsp+18h] [rbp-80h] BYREF
long long v16; // [rsp+28h] [rbp-70h] BYREF
long long v17; // [rsp+38h] [rbp-60h]
void *v18[2]; // [rsp+40h] [rbp-58h] BYREF
long long v19; // [rsp+50h] [rbp-48h] BYREF
long long v20[7]; // [rsp+60h] [rbp-38h] BYREF
v17 = a1;
testing::Message::Message((testing::Message *)v20);
v4 = (*((_QWORD *)a2 + 11) - *((_QWORD *)a2 + 10)) >> 6;
v14 = v20[0];
if ( (int)v4 > 0 )
{
v5 = v14 + 16;
v6 = 0;
do
{
TestProperty = (const char **)testing::TestResult::GetTestProperty(a2, v6);
std::__ostream_insert<char,std::char_traits<char>>(v5, ",\n", 2LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, *a3, a3[1]);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\"", 1LL);
v8 = *TestProperty;
if ( *TestProperty )
{
v9 = strlen(*TestProperty);
}
else
{
v9 = 6LL;
v8 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v5, v8, v9);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\": ", 3LL);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\"", 1LL);
std::string::basic_string(v18, TestProperty[4], &v13);
testing::internal::JsonUnitTestResultPrinter::EscapeJson((long long)v15, v18);
std::__ostream_insert<char,std::char_traits<char>>(v5, v15[0], v15[1]);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\"", 1LL);
if ( v15[0] != &v16 )
operator delete(v15[0], v16 + 1);
if ( v18[0] != &v19 )
operator delete(v18[0], v19 + 1);
++v6;
}
while ( v6 < (int)((*((_QWORD *)a2 + 11) - *((_QWORD *)a2 + 10)) >> 6) );
}
v10 = v17;
v11 = v14;
testing::internal::StringStreamToString(v17, v14);
if ( v11 )
(*(void ( **)(long long))(*(_QWORD *)v11 + 8LL))(v11);
return v10;
}
|
TestPropertiesAsJson:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RDX
MOV R12,RSI
MOV qword ptr [RSP + 0x38],RDI
LEA RBX,[RSP + 0x60]
MOV RDI,RBX
CALL 0x0011c968
MOV RAX,qword ptr [R12 + 0x58]
SUB RAX,qword ptr [R12 + 0x50]
SHR RAX,0x6
MOV RCX,qword ptr [RBX]
MOV qword ptr [RSP + 0x10],RCX
TEST EAX,EAX
JLE 0x0012af4c
MOV RAX,qword ptr [RSP + 0x10]
LEA R13,[RAX + 0x10]
XOR EBP,EBP
LAB_0012ae1b:
MOV RDI,R12
MOV ESI,EBP
CALL 0x0011f850
MOV R14,RAX
MOV EDX,0x2
MOV RDI,R13
LEA RSI,[0x143765]
CALL 0x001085b0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV RDI,R13
CALL 0x001085b0
MOV EDX,0x1
MOV RDI,R13
LEA RSI,[0x14378b]
CALL 0x001085b0
MOV RBX,qword ptr [R14]
TEST RBX,RBX
JZ 0x0012ae74
MOV RDI,RBX
CALL 0x00108200
MOV RDX,RAX
JMP 0x0012ae80
LAB_0012ae74:
MOV EDX,0x6
LEA RBX,[0x140659]
LAB_0012ae80:
MOV RDI,R13
MOV RSI,RBX
CALL 0x001085b0
MOV EDX,0x3
MOV RDI,R13
LEA RSI,[0x143713]
CALL 0x001085b0
MOV EDX,0x1
MOV RDI,R13
LEA RSI,[0x14378b]
CALL 0x001085b0
MOV RSI,qword ptr [R14 + 0x20]
LAB_0012aeb7:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
LEA RDX,[RSP + 0xf]
CALL 0x001081e0
LAB_0012aec9:
LEA RDI,[RSP + 0x18]
MOV RSI,RBX
CALL 0x00128c22
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
LAB_0012aee0:
MOV RDI,R13
CALL 0x001085b0
MOV EDX,0x1
MOV RDI,R13
LEA RSI,[0x14378b]
CALL 0x001085b0
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x0012af18
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001084e0
LAB_0012af18:
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x0012af34
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x001084e0
LAB_0012af34:
INC EBP
MOV RAX,qword ptr [R12 + 0x58]
SUB RAX,qword ptr [R12 + 0x50]
SHR RAX,0x6
CMP EBP,EAX
JL 0x0012ae1b
LAB_0012af4c:
MOV RBX,qword ptr [RSP + 0x38]
MOV RDI,RBX
MOV R14,qword ptr [RSP + 0x10]
MOV RSI,R14
CALL 0x0011cbbf
LAB_0012af61:
TEST R14,R14
JZ 0x0012af6f
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x8]
LAB_0012af6f:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&,
std::__cxx11::string const&) */
stringstream * __thiscall
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson
(JsonUnitTestResultPrinter *this,TestResult *param_1,string *param_2)
{
ostream *poVar1;
long *plVar2;
JsonUnitTestResultPrinter *pJVar3;
int8 *puVar4;
size_t sVar5;
char *__s;
int iVar6;
allocator local_89;
long *local_88;
long *local_80;
long local_78;
long local_70 [2];
JsonUnitTestResultPrinter *local_60;
long *local_58 [2];
long local_48 [2];
long *local_38;
local_60 = this;
Message::Message((Message *)&local_38);
local_88 = local_38;
if (0 < (int)((ulong)(*(long *)(param_1 + 0x58) - *(long *)(param_1 + 0x50)) >> 6)) {
poVar1 = (ostream *)(local_38 + 2);
iVar6 = 0;
do {
/* try { // try from 0012ae1b to 0012ae5e has its CatchHandler @ 0012afcc */
puVar4 = (int8 *)TestResult::GetTestProperty(param_1,iVar6);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,",\n",2);
std::__ostream_insert<char,std::char_traits<char>>
(poVar1,*(char **)param_2,*(long *)(param_2 + 8));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\"",1);
__s = (char *)*puVar4;
if (__s == (char *)0x0) {
sVar5 = 6;
__s = "(null)";
}
else {
sVar5 = strlen(__s);
}
/* try { // try from 0012ae80 to 0012aeb2 has its CatchHandler @ 0012afca */
std::__ostream_insert<char,std::char_traits<char>>(poVar1,__s,sVar5);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\": ",3);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\"",1);
/* try { // try from 0012aeb7 to 0012aec8 has its CatchHandler @ 0012af86 */
std::__cxx11::string::string((string *)local_58,(char *)puVar4[4],&local_89);
/* try { // try from 0012aec9 to 0012aed5 has its CatchHandler @ 0012af88 */
EscapeJson((JsonUnitTestResultPrinter *)&local_80,(string *)local_58);
/* try { // try from 0012aee0 to 0012aefb has its CatchHandler @ 0012af8d */
std::__ostream_insert<char,std::char_traits<char>>(poVar1,(char *)local_80,local_78);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\"",1);
if (local_80 != local_70) {
operator_delete(local_80,local_70[0] + 1);
}
if (local_58[0] != local_48) {
operator_delete(local_58[0],local_48[0] + 1);
}
iVar6 = iVar6 + 1;
} while (iVar6 < (int)((ulong)(*(long *)(param_1 + 0x58) - *(long *)(param_1 + 0x50)) >> 6));
}
/* try { // try from 0012af4c to 0012af60 has its CatchHandler @ 0012af81 */
pJVar3 = local_60;
plVar2 = local_88;
StringStreamToString((stringstream *)local_60);
if (plVar2 != (long *)0x0) {
(**(code **)(*plVar2 + 8))(plVar2);
}
return (stringstream *)pJVar3;
}
|
|
9,501 |
void nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_integer<unsigned char, 0>(unsigned char)
|
llama.cpp/common/json.hpp
|
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::serializer<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>>::dump_integer<unsigned char, 0>(unsigned char):
pushq %rbx
testq %rsi, %rsi
je 0x8ec84
movq %rsi, %rcx
leaq 0x10(%rdi), %rsi
cmpq $0xa, %rcx
jae 0x8ec95
leaq 0x11(%rdi), %r9
movl $0x1, %r8d
jmp 0x8ed60
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rbx
jmpq *%rax
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D63886594B
movq %rcx, %r8
cmpq $0x63, %r8
jbe 0x8ece0
cmpq $0x3e7, %r8 # imm = 0x3E7
jbe 0x8ece6
cmpq $0x2710, %r8 # imm = 0x2710
jb 0x8ece9
movq %r8, %rax
mulq %r10
shrq $0xb, %rdx
addl $0x4, %r9d
cmpq $0x1869f, %r8 # imm = 0x1869F
movq %rdx, %r8
ja 0x8eca8
addl $-0x3, %r9d
jmp 0x8ece9
addl $-0x2, %r9d
jmp 0x8ece9
decl %r9d
cmpl $0x3f, %r9d
jae 0x8ed77
movl %r9d, %r8d
leaq (%rsi,%r8), %r9
cmpq $0x64, %rcx
jb 0x8ed42
movabsq $0x28f5c28f5c28f5c3, %r10 # imm = 0x28F5C28F5C28F5C3
leaq 0x986d5(%rip), %r11 # 0x1273e6
movq %rcx, %rax
shrq $0x2, %rax
mulq %r10
shrq $0x2, %rdx
imull $0x64, %edx, %eax
movl %ecx, %ebx
subl %eax, %ebx
movzwl (%r11,%rbx,2), %eax
movw %ax, -0x2(%r9)
addq $-0x2, %r9
cmpq $0x270f, %rcx # imm = 0x270F
movq %rdx, %rcx
ja 0x8ed11
jmp 0x8ed45
movq %rcx, %rdx
cmpq $0xa, %rdx
jb 0x8ed5d
leaq 0x98694(%rip), %rax # 0x1273e6
movzwl (%rax,%rdx,2), %eax
movw %ax, -0x2(%r9)
jmp 0x8ed67
movq %rdx, %rcx
orb $0x30, %cl
movb %cl, -0x1(%r9)
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r8, %rdx
popq %rbx
jmpq *%rax
leaq 0x96528(%rip), %rdi # 0x1252a6
leaq 0x8d67b(%rip), %rdx # 0x11c400
leaq 0x96a39(%rip), %rcx # 0x1257c5
movl $0x4952, %esi # imm = 0x4952
xorl %eax, %eax
callq 0x21ec0
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
push rbx
test rsi, rsi
jz short loc_8EC84
mov rcx, rsi
lea rsi, [rdi+10h]
cmp rcx, 0Ah
jnb short loc_8EC95
lea r9, [rdi+11h]
mov r8d, 1
jmp loc_8ED60
loc_8EC84:
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax]
mov esi, 30h ; '0'
pop rbx
jmp rax
loc_8EC95:
mov r9d, 4
mov r10, 346DC5D63886594Bh
mov r8, rcx
loc_8ECA8:
cmp r8, 63h ; 'c'
jbe short loc_8ECE0
cmp r8, 3E7h
jbe short loc_8ECE6
cmp r8, 2710h
jb short loc_8ECE9
mov rax, r8
mul r10
shr rdx, 0Bh
add r9d, 4
cmp r8, 1869Fh
mov r8, rdx
ja short loc_8ECA8
add r9d, 0FFFFFFFDh
jmp short loc_8ECE9
loc_8ECE0:
add r9d, 0FFFFFFFEh
jmp short loc_8ECE9
loc_8ECE6:
dec r9d
loc_8ECE9:
cmp r9d, 3Fh ; '?'
jnb loc_8ED77
mov r8d, r9d
lea r9, [rsi+r8]
cmp rcx, 64h ; 'd'
jb short loc_8ED42
mov r10, 28F5C28F5C28F5C3h
lea r11, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
loc_8ED11:
mov rax, rcx
shr rax, 2
mul r10
shr rdx, 2
imul eax, edx, 64h ; 'd'
mov ebx, ecx
sub ebx, eax
movzx eax, word ptr [r11+rbx*2]
mov [r9-2], ax
add r9, 0FFFFFFFFFFFFFFFEh
cmp rcx, 270Fh
mov rcx, rdx
ja short loc_8ED11
jmp short loc_8ED45
loc_8ED42:
mov rdx, rcx
loc_8ED45:
cmp rdx, 0Ah
jb short loc_8ED5D
lea rax, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
movzx eax, word ptr [rax+rdx*2]
mov [r9-2], ax
jmp short loc_8ED67
loc_8ED5D:
mov rcx, rdx
loc_8ED60:
or cl, 30h
mov [r9-1], cl
loc_8ED67:
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax+8]
mov rdx, r8
pop rbx
jmp rax
loc_8ED77:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsNumberBu; "n_chars < number_buffer.size() - 1"
mov esi, 4952h
xor eax, eax
call _ggml_abort
|
long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
_QWORD *a1,
unsigned long long a2)
{
unsigned long long v2; // rcx
_QWORD *v3; // rsi
char *v4; // r9
long long v5; // r8
unsigned int v7; // r9d
unsigned long long v8; // r8
bool v9; // cc
unsigned long long v10; // rdx
if ( !a2 )
return (**(long long ( ***)(_QWORD, long long))*a1)(*a1, 48LL);
v2 = a2;
v3 = a1 + 2;
if ( v2 < 0xA )
{
v4 = (char *)a1 + 17;
v5 = 1LL;
goto LABEL_21;
}
v7 = 4;
v8 = v2;
while ( 1 )
{
if ( v8 <= 0x63 )
{
v7 -= 2;
goto LABEL_13;
}
if ( v8 <= 0x3E7 )
break;
if ( v8 < 0x2710 )
goto LABEL_13;
v7 += 4;
v9 = v8 <= 0x1869F;
v8 /= 0x2710uLL;
if ( v9 )
{
v7 -= 3;
goto LABEL_13;
}
}
--v7;
LABEL_13:
if ( v7 < 0x3F )
{
v5 = v7;
v4 = (char *)v3 + v7;
if ( v2 < 0x64 )
{
v10 = v2;
}
else
{
do
{
v10 = v2 / 0x64;
*((_WORD *)v4 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[v2 % 0x64];
v4 -= 2;
v9 = v2 <= 0x270F;
v2 /= 0x64uLL;
}
while ( !v9 );
}
if ( v10 >= 0xA )
{
*((_WORD *)v4 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[v10];
return (*(long long ( **)(_QWORD, _QWORD *, long long, unsigned long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
v3,
v5,
v2);
}
v2 = v10;
LABEL_21:
LOBYTE(v2) = v2 | 0x30;
*(v4 - 1) = v2;
return (*(long long ( **)(_QWORD, _QWORD *, long long, unsigned long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
v3,
v5,
v2);
}
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
18770LL,
"GGML_ASSERT(%s) failed",
"n_chars < number_buffer.size() - 1");
return ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
18770LL);
}
|
_ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
PUSH RBX
TEST RSI,RSI
JZ 0x0018ec84
MOV RCX,RSI
LEA RSI,[RDI + 0x10]
CMP RCX,0xa
JNC 0x0018ec95
LEA R9,[RDI + 0x11]
MOV R8D,0x1
JMP 0x0018ed60
LAB_0018ec84:
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV ESI,0x30
POP RBX
JMP RAX
LAB_0018ec95:
MOV R9D,0x4
MOV R10,0x346dc5d63886594b
MOV R8,RCX
LAB_0018eca8:
CMP R8,0x63
JBE 0x0018ece0
CMP R8,0x3e7
JBE 0x0018ece6
CMP R8,0x2710
JC 0x0018ece9
MOV RAX,R8
MUL R10
SHR RDX,0xb
ADD R9D,0x4
CMP R8,0x1869f
MOV R8,RDX
JA 0x0018eca8
ADD R9D,-0x3
JMP 0x0018ece9
LAB_0018ece0:
ADD R9D,-0x2
JMP 0x0018ece9
LAB_0018ece6:
DEC R9D
LAB_0018ece9:
CMP R9D,0x3f
JNC 0x0018ed77
MOV R8D,R9D
LEA R9,[RSI + R8*0x1]
CMP RCX,0x64
JC 0x0018ed42
MOV R10,0x28f5c28f5c28f5c3
LEA R11,[0x2273e6]
LAB_0018ed11:
MOV RAX,RCX
SHR RAX,0x2
MUL R10
SHR RDX,0x2
IMUL EAX,EDX,0x64
MOV EBX,ECX
SUB EBX,EAX
MOVZX EAX,word ptr [R11 + RBX*0x2]
MOV word ptr [R9 + -0x2],AX
ADD R9,-0x2
CMP RCX,0x270f
MOV RCX,RDX
JA 0x0018ed11
JMP 0x0018ed45
LAB_0018ed42:
MOV RDX,RCX
LAB_0018ed45:
CMP RDX,0xa
JC 0x0018ed5d
LEA RAX,[0x2273e6]
MOVZX EAX,word ptr [RAX + RDX*0x2]
MOV word ptr [R9 + -0x2],AX
JMP 0x0018ed67
LAB_0018ed5d:
MOV RCX,RDX
LAB_0018ed60:
OR CL,0x30
MOV byte ptr [R9 + -0x1],CL
LAB_0018ed67:
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,R8
POP RBX
JMP RAX
LAB_0018ed77:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x2257c5]
MOV ESI,0x4952
XOR EAX,EAX
CALL 0x00121ec0
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(int8 *param_1,ulong param_2)
{
bool bVar1;
ulong uVar2;
ulong uVar3;
int iVar4;
long lVar5;
if (param_2 == 0) {
/* WARNING: Could not recover jumptable at 0x0018ec93. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)**(int8 **)*param_1)((int8 *)*param_1,0x30);
return;
}
if (param_2 < 10) {
lVar5 = (long)param_1 + 0x11;
uVar3 = 1;
}
else {
uVar3 = 4;
uVar2 = param_2;
do {
iVar4 = (int)uVar3;
if (uVar2 < 100) {
uVar3 = (ulong)(iVar4 - 2);
goto LAB_0018ece9;
}
if (uVar2 < 1000) {
uVar3 = (ulong)(iVar4 - 1);
goto LAB_0018ece9;
}
if (uVar2 < 10000) goto LAB_0018ece9;
uVar3 = (ulong)(iVar4 + 4);
bVar1 = 99999 < uVar2;
uVar2 = uVar2 / 10000;
} while (bVar1);
uVar3 = (ulong)(iVar4 + 1);
LAB_0018ece9:
if (0x3e < (uint)uVar3) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x4952,
"GGML_ASSERT(%s) failed","n_chars < number_buffer.size() - 1");
}
lVar5 = (long)(param_1 + 2) + uVar3;
if (99 < param_2) {
do {
uVar2 = param_2 / 100;
*(int2 *)(lVar5 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ (ulong)(uint)((int)param_2 + (int)uVar2 * -100) * 2);
lVar5 = lVar5 + -2;
bVar1 = 9999 < param_2;
param_2 = uVar2;
} while (bVar1);
}
if (9 < param_2) {
*(int2 *)(lVar5 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerImTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ param_2 * 2);
goto LAB_0018ed67;
}
}
*(byte *)(lVar5 + -1) = (byte)param_2 | 0x30;
LAB_0018ed67:
/* WARNING: Could not recover jumptable at 0x0018ed75. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)*param_1 + 8))((long *)*param_1,param_1 + 2,uVar3);
return;
}
|
|
9,502 |
translog_sync_files
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_sync_files(uint32 min, uint32 max,
my_bool sync_dir)
{
uint fn;
my_bool rc= 0;
ulonglong flush_interval;
DBUG_ENTER("translog_sync_files");
DBUG_PRINT("info", ("min: %lu max: %lu sync dir: %d",
(ulong) min, (ulong) max, (int) sync_dir));
DBUG_ASSERT(min <= max);
flush_interval= group_commit_wait;
if (flush_interval)
flush_start= microsecond_interval_timer();
for (fn= min; fn <= max; fn++)
{
TRANSLOG_FILE *file= get_logfile_by_number(fn);
DBUG_ASSERT(file != NULL);
if (!file->is_sync)
{
if (mysql_file_sync(file->handler.file, MYF(MY_WME)))
{
rc= 1;
translog_stop_writing();
DBUG_RETURN(rc);
}
translog_syncs++;
file->is_sync= 1;
}
}
if (sync_dir)
{
if (!(rc= sync_dir(log_descriptor.directory_fd,
MYF(MY_WME | MY_IGNORE_BADFD))))
translog_syncs++;
}
DBUG_RETURN(rc);
}
|
O3
|
c
|
translog_sync_files:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, -0x30(%rbp)
movl %esi, %r14d
movl %edi, %r15d
cmpl $0x0, 0xbb2515(%rip) # 0xbff6e4
je 0x4d1f2
callq 0x9e0ac
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
shrq $0x4, %rdx
movq %rdx, 0xbb24de(%rip) # 0xbff6d0
cmpl %r14d, %r15d
jbe 0x4d249
cmpb $0x0, -0x30(%rbp)
je 0x4d242
movl 0x3b18ad(%rip), %ebx # 0x3feab0
leaq 0x338e06(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %ebx, %esi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4d2f2
movl $0x30, %esi
movl %ebx, %edi
callq 0xa0ff4
testb %al, %al
jne 0x4d2e3
incq 0x3b0376(%rip) # 0x3fd5b8
xorl %eax, %eax
jmp 0x4d2e3
leaq -0x78(%rbp), %r12
movl %r15d, %edi
callq 0x4e906
cmpb $0x0, 0x51(%rax)
jne 0x4d29c
movq %rax, %r13
movl 0x18(%rax), %ebx
leaq 0x338da8(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r12, %rdi
movl %ebx, %esi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4d2a9
movl $0x10, %esi
movl %ebx, %edi
callq 0xa0ff4
testl %eax, %eax
jne 0x4d2bc
incq 0x3b0321(%rip) # 0x3fd5b8
movb $0x1, 0x51(%r13)
incl %r15d
cmpl %r14d, %r15d
jbe 0x4d24d
jmp 0x4d1f7
movq %rax, %rdi
movl %ebx, %esi
leaq -0x2c(%rbp), %rdx
callq 0x2cb15
movl -0x2c(%rbp), %eax
jmp 0x4d28c
xorl %eax, %eax
cmpl $0x3, 0x3b02eb(%rip) # 0x3fd5b0
setne %al
addl %eax, %eax
movl %eax, 0x3b02e0(%rip) # 0x3fd5b0
movb $0x1, 0xbb23b9(%rip) # 0xbff690
movl $0x0, 0x3b14eb(%rip) # 0x3fe7cc
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2c(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2cb6e
movl (%r14), %eax
jmp 0x4d233
|
translog_sync_files:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], edx
mov r14d, esi
mov r15d, edi
cmp cs:group_commit_wait, 0
jz short loc_4D1F2
call my_interval_timer
shr rax, 3
mov rcx, 20C49BA5E353F7CFh
mul rcx
shr rdx, 4
mov cs:flush_start, rdx
loc_4D1F2:
cmp r15d, r14d
jbe short loc_4D249
loc_4D1F7:
cmp byte ptr [rbp+var_30], 0
jz short loc_4D242
mov ebx, cs:dword_3FEAB0
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, ebx
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz loc_4D2F2
mov esi, 30h ; '0'
mov edi, ebx
call my_sync
loc_4D233:
test al, al
jnz loc_4D2E3
inc cs:translog_syncs
loc_4D242:
xor eax, eax
jmp loc_4D2E3
loc_4D249:
lea r12, [rbp+var_78]
loc_4D24D:
mov edi, r15d
call get_logfile_by_number
cmp byte ptr [rax+51h], 0
jnz short loc_4D29C
mov r13, rax
mov ebx, [rax+18h]
lea rax, PSI_server
mov rax, [rax]
mov rdi, r12
mov esi, ebx
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz short loc_4D2A9
mov esi, 10h
mov edi, ebx
call my_sync
loc_4D28C:
test eax, eax
jnz short loc_4D2BC
inc cs:translog_syncs
mov byte ptr [r13+51h], 1
loc_4D29C:
inc r15d
cmp r15d, r14d
jbe short loc_4D24D
jmp loc_4D1F7
loc_4D2A9:
mov rdi, rax
mov esi, ebx
lea rdx, [rbp+var_2C]
call translog_sync_files_cold_1
mov eax, [rbp+var_2C]
jmp short loc_4D28C
loc_4D2BC:
xor eax, eax
cmp cs:translog_status, 3
setnz al
add eax, eax
mov cs:translog_status, eax
mov byte ptr cs:word_BFF690, 1
mov cs:dword_3FE7CC, 0
mov al, 1
loc_4D2E3:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4D2F2:
lea r14, [rbp+var_2C]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call translog_sync_files_cold_2
mov eax, [r14]
jmp loc_4D233
|
char translog_sync_files(unsigned int a1, unsigned int a2, int a3)
{
unsigned int v3; // r15d
unsigned int v4; // ebx
long long v5; // rax
char result; // al
long long logfile_by_number; // rax
long long v8; // r13
unsigned int v9; // ebx
long long v10; // rax
int v11; // eax
_BYTE v12[72]; // [rsp+8h] [rbp-78h] BYREF
int v13; // [rsp+50h] [rbp-30h]
_DWORD v14[11]; // [rsp+54h] [rbp-2Ch] BYREF
v13 = a3;
v3 = a1;
if ( group_commit_wait )
flush_start = my_interval_timer() / 0x3E8uLL;
if ( a1 <= a2 )
{
do
{
logfile_by_number = get_logfile_by_number(v3);
if ( !*(_BYTE *)(logfile_by_number + 81) )
{
v8 = logfile_by_number;
v9 = *(_DWORD *)(logfile_by_number + 24);
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v12, v9, 16LL);
if ( v10 )
{
translog_sync_files_cold_1(v10, v9, v14);
v11 = v14[0];
}
else
{
v11 = my_sync(v9, 16LL);
}
if ( v11 )
{
translog_status = 2 * (translog_status != 3);
LOBYTE(word_BFF690) = 1;
dword_3FE7CC = 0;
return 1;
}
++translog_syncs;
*(_BYTE *)(v8 + 81) = 1;
}
++v3;
}
while ( v3 <= a2 );
}
if ( !(_BYTE)v13 )
return 0;
v4 = dword_3FEAB0;
v5 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v12, (unsigned int)dword_3FEAB0, 16LL);
if ( v5 )
{
translog_sync_files_cold_2(v5, v4, v14);
result = v14[0];
}
else
{
result = my_sync(v4, 48LL);
}
if ( !result )
{
++translog_syncs;
return 0;
}
return result;
}
|
translog_sync_files:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x30],EDX
MOV R14D,ESI
MOV R15D,EDI
CMP dword ptr [0x00cff6e4],0x0
JZ 0x0014d1f2
CALL 0x0019e0ac
SHR RAX,0x3
MOV RCX,0x20c49ba5e353f7cf
MUL RCX
SHR RDX,0x4
MOV qword ptr [0x00cff6d0],RDX
LAB_0014d1f2:
CMP R15D,R14D
JBE 0x0014d249
LAB_0014d1f7:
CMP byte ptr [RBP + -0x30],0x0
JZ 0x0014d242
MOV EBX,dword ptr [0x004feab0]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,EBX
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014d2f2
MOV ESI,0x30
MOV EDI,EBX
CALL 0x001a0ff4
LAB_0014d233:
TEST AL,AL
JNZ 0x0014d2e3
INC qword ptr [0x004fd5b8]
LAB_0014d242:
XOR EAX,EAX
JMP 0x0014d2e3
LAB_0014d249:
LEA R12,[RBP + -0x78]
LAB_0014d24d:
MOV EDI,R15D
CALL 0x0014e906
CMP byte ptr [RAX + 0x51],0x0
JNZ 0x0014d29c
MOV R13,RAX
MOV EBX,dword ptr [RAX + 0x18]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R12
MOV ESI,EBX
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014d2a9
MOV ESI,0x10
MOV EDI,EBX
CALL 0x001a0ff4
LAB_0014d28c:
TEST EAX,EAX
JNZ 0x0014d2bc
INC qword ptr [0x004fd5b8]
MOV byte ptr [R13 + 0x51],0x1
LAB_0014d29c:
INC R15D
CMP R15D,R14D
JBE 0x0014d24d
JMP 0x0014d1f7
LAB_0014d2a9:
MOV RDI,RAX
MOV ESI,EBX
LEA RDX,[RBP + -0x2c]
CALL 0x0012cb15
MOV EAX,dword ptr [RBP + -0x2c]
JMP 0x0014d28c
LAB_0014d2bc:
XOR EAX,EAX
CMP dword ptr [0x004fd5b0],0x3
SETNZ AL
ADD EAX,EAX
MOV dword ptr [0x004fd5b0],EAX
MOV byte ptr [0x00cff690],0x1
MOV dword ptr [0x004fe7cc],0x0
MOV AL,0x1
LAB_0014d2e3:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014d2f2:
LEA R14,[RBP + -0x2c]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012cb6e
MOV EAX,dword ptr [R14]
JMP 0x0014d233
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong translog_sync_files(uint param_1,uint param_2,int4 param_3)
{
int4 uVar1;
uint uVar2;
ulong uVar3;
long lVar4;
long lVar5;
int1 local_80 [72];
int4 local_38;
uint local_34;
local_38 = param_3;
if (group_commit_wait != 0) {
uVar3 = my_interval_timer();
flush_start = uVar3 / 1000;
}
if (param_1 <= param_2) {
do {
lVar4 = get_logfile_by_number(param_1);
if (*(char *)(lVar4 + 0x51) == '\0') {
uVar1 = *(int4 *)(lVar4 + 0x18);
lVar5 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,0x10);
if (lVar5 == 0) {
uVar2 = my_sync(uVar1,0x10);
}
else {
translog_sync_files_cold_1(lVar5,uVar1,&local_34);
uVar2 = local_34;
}
if (uVar2 != 0) {
translog_status = (uint)(translog_status != 3) * 2;
_DAT_004fe7cc = 0;
DAT_00cff690 = 1;
return 1;
}
translog_syncs = translog_syncs + 1;
*(int1 *)(lVar4 + 0x51) = 1;
}
param_1 = param_1 + 1;
} while (param_1 <= param_2);
}
uVar1 = DAT_004feab0;
if ((char)local_38 != '\0') {
lVar4 = (**(code **)(PSI_server + 0x158))(local_80,DAT_004feab0,0x10);
if (lVar4 == 0) {
uVar3 = my_sync(uVar1,0x30);
}
else {
translog_sync_files_cold_2(lVar4,uVar1,&local_34);
uVar3 = (ulong)local_34;
}
if ((char)uVar3 != '\0') {
return uVar3;
}
translog_syncs = translog_syncs + 1;
}
return 0;
}
|
|
9,503 |
minja::Value::to_str[abi:cxx11]() const
|
monkey531[P]llama/common/minja.hpp
|
std::string to_str() const {
if (is_string()) return get<std::string>();
if (is_number_integer()) return std::to_string(get<int64_t>());
if (is_number_float()) return std::to_string(get<double>());
if (is_boolean()) return get<bool>() ? "True" : "False";
if (is_null()) return "None";
return dump();
}
|
O2
|
cpp
|
minja::Value::to_str[abi:cxx11]() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x40(%rsi), %eax
cmpl $0x3, %eax
jne 0x7063f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63d54
jmp 0x706cd
leal -0x5(%rax), %ecx
cmpb $0x1, %cl
ja 0x7065c
movq %r14, %rdi
callq 0x63168
movq %rbx, %rdi
movq %rax, %rsi
callq 0x70f48
jmp 0x706cd
cmpl $0x4, %eax
je 0x70678
cmpl $0x7, %eax
jne 0x7069b
movq %r14, %rdi
callq 0x6323c
movq %rbx, %rdi
callq 0x70fa8
jmp 0x706cd
movq %r14, %rdi
callq 0x63c9e
leaq 0x45415(%rip), %rcx # 0xb5a9c
leaq 0x45413(%rip), %rsi # 0xb5aa1
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x7(%rsp), %rdx
jmp 0x706b3
movq %r14, %rdi
callq 0x6390a
testb %al, %al
je 0x706bd
leaq 0x4580e(%rip), %rsi # 0xb5ebc
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x27852
jmp 0x706cd
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x63320
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZNK5minja5Value6to_strB5cxx11Ev:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
movzx eax, byte ptr [rsi+40h]
cmp eax, 3
jnz short loc_7063F
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
jmp loc_706CD
loc_7063F:
lea ecx, [rax-5]
cmp cl, 1
ja short loc_7065C
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rdi, rbx; this
mov rsi, rax; __int64
call _ZNSt7__cxx119to_stringEl; std::to_string(long)
jmp short loc_706CD
loc_7065C:
cmp eax, 4
jz short loc_70678
cmp eax, 7
jnz short loc_7069B
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
mov rdi, rbx; this
call _ZNSt7__cxx119to_stringEd; std::to_string(double)
jmp short loc_706CD
loc_70678:
mov rdi, r14
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
lea rdx, [rsp+18h+var_11]
jmp short loc_706B3
loc_7069B:
mov rdi, r14; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_706BD
lea rsi, aNone_0; "None"
lea rdx, [rsp+18h+var_12]
loc_706B3:
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short loc_706CD
loc_706BD:
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
loc_706CD:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
std::__cxx11 * minja::Value::to_str[abi:cxx11](std::__cxx11 *this, minja::Value *a2, double a3)
{
int v3; // eax
long long v4; // rax
char v5; // al
const char *v6; // rsi
v3 = *((unsigned __int8 *)a2 + 64);
if ( v3 == 3 )
{
minja::Value::get<std::string>((long long)this, a2);
}
else
{
if ( (unsigned __int8)(v3 - 5) > 1u )
{
if ( v3 == 4 )
{
v5 = minja::Value::get<bool>(a2);
v6 = "False";
if ( v5 )
v6 = "True";
}
else
{
if ( v3 == 7 )
{
minja::Value::get<double>(a2);
std::to_string(this, a3);
return this;
}
if ( !minja::Value::is_null(a2) )
{
minja::Value::dump[abi:cxx11]((long long)this, (long long)a2, 0xFFFFFFFF, 0);
return this;
}
v6 = "None";
}
std::string::basic_string<std::allocator<char>>(this, (long long)v6);
return this;
}
v4 = minja::Value::get<long>(a2);
std::to_string(this, v4);
}
return this;
}
|
to_str[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOVZX EAX,byte ptr [RSI + 0x40]
CMP EAX,0x3
JNZ 0x0017063f
MOV RDI,RBX
MOV RSI,R14
CALL 0x00163d54
JMP 0x001706cd
LAB_0017063f:
LEA ECX,[RAX + -0x5]
CMP CL,0x1
JA 0x0017065c
MOV RDI,R14
CALL 0x00163168
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00170f48
JMP 0x001706cd
LAB_0017065c:
CMP EAX,0x4
JZ 0x00170678
CMP EAX,0x7
JNZ 0x0017069b
MOV RDI,R14
CALL 0x0016323c
MOV RDI,RBX
CALL 0x00170fa8
JMP 0x001706cd
LAB_00170678:
MOV RDI,R14
CALL 0x00163c9e
LEA RCX,[0x1b5a9c]
LEA RSI,[0x1b5aa1]
TEST AL,AL
CMOVNZ RSI,RCX
LEA RDX,[RSP + 0x7]
JMP 0x001706b3
LAB_0017069b:
MOV RDI,R14
CALL 0x0016390a
TEST AL,AL
JZ 0x001706bd
LEA RSI,[0x1b5ebc]
LEA RDX,[RSP + 0x6]
LAB_001706b3:
MOV RDI,RBX
CALL 0x00127852
JMP 0x001706cd
LAB_001706bd:
PUSH -0x1
POP RDX
MOV RDI,RBX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00163320
LAB_001706cd:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Value::to_str[abi:cxx11]() const */
void minja::Value::to_str_abi_cxx11_(void)
{
Value VVar1;
bool bVar2;
char cVar3;
long lVar4;
allocator *paVar5;
Value *in_RSI;
char *pcVar6;
__cxx11 *in_RDI;
double dVar7;
allocator local_12;
allocator local_11;
VVar1 = in_RSI[0x40];
if (VVar1 == (Value)0x3) {
get<std::__cxx11::string>();
}
else if ((byte)((char)VVar1 - 5U) < 2) {
lVar4 = get<long>(in_RSI);
std::__cxx11::to_string(in_RDI,lVar4);
}
else {
if (VVar1 == (Value)0x4) {
bVar2 = get<bool>(in_RSI);
pcVar6 = "False";
if (bVar2) {
pcVar6 = "True";
}
paVar5 = &local_11;
}
else {
if (VVar1 == (Value)0x7) {
dVar7 = get<double>(in_RSI);
std::__cxx11::to_string(dVar7);
return;
}
cVar3 = is_null(in_RSI);
if (cVar3 == '\0') {
dump_abi_cxx11_((int)in_RDI,SUB81(in_RSI,0));
return;
}
pcVar6 = "None";
paVar5 = &local_12;
}
std::__cxx11::string::string<std::allocator<char>>((string *)in_RDI,pcVar6,paVar5);
}
return;
}
|
|
9,504 |
test_mopts5
|
eloqsql/unittest/mysys/my_getopt-t.c
|
void test_mopts5()
{
int rc;
char **av= (char **)mopts5_argv;
rc= handle_options(&mopts5_argc, &av, mopts_options, &dummy_get_one_option);
ok( (rc == 0), "%s", "test_mopts5 call");
ok( (mopts_num == 1000000L), "%s", "test_mopts5 num");
ok( (strncmp(mopts_str, "ddd", 4) == 0), "%s", "test_mopts5 str");
ok( (mopts_bool == 0), "%s", "test_mopts5 bool");
}
|
O0
|
c
|
test_mopts5:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1b3691(%rip), %rax # 0x1d9370
movq %rax, -0x10(%rbp)
leaq 0x1b367e(%rip), %rdi # 0x1d9368
leaq -0x10(%rbp), %rsi
leaq 0x1b331b(%rip), %rdx # 0x1d9010
leaq -0x58c(%rip), %rcx # 0x25770
callq 0x27640
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x60376(%rip), %rsi # 0x8608d
leaq 0x5c4a6(%rip), %rdx # 0x821c4
movb $0x0, %al
callq 0x26ba0
cmpq $0xf4240, 0x36b600(%rip) # imm = 0xF4240
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x6034e(%rip), %rsi # 0x8608d
leaq 0x5c48f(%rip), %rdx # 0x821d5
movb $0x0, %al
callq 0x26ba0
movq 0x36b5e4(%rip), %rdi # 0x391338
leaq 0x5c352(%rip), %rsi # 0x820ad
movl $0x4, %edx
callq 0x25150
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x60316(%rip), %rsi # 0x8608d
leaq 0x5c467(%rip), %rdx # 0x821e5
movb $0x0, %al
callq 0x26ba0
movsbl 0x36b5b4(%rip), %eax # 0x391340
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x602ef(%rip), %rsi # 0x8608d
leaq 0x5c450(%rip), %rdx # 0x821f5
movb $0x0, %al
callq 0x26ba0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
test_mopts5:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, mopts5_argv
mov [rbp+var_10], rax
lea rdi, mopts5_argc
lea rsi, [rbp+var_10]
lea rdx, mopts_options
lea rcx, dummy_get_one_option
call handle_options
mov [rbp+var_4], eax
cmp [rbp+var_4], 0
setz al
and al, 1
movzx edi, al
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aTestMopts5Call; "test_mopts5 call"
mov al, 0
call ok
cmp cs:mopts_num, offset unk_F4240
setz al
and al, 1
movzx edi, al
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aTestMopts5Num; "test_mopts5 num"
mov al, 0
call ok
mov rdi, cs:mopts_str
lea rsi, aDdd; "ddd"
mov edx, 4
call _strncmp
cmp eax, 0
setz al
and al, 1
movzx edi, al
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aTestMopts5Str; "test_mopts5 str"
mov al, 0
call ok
movsx eax, cs:mopts_bool
cmp eax, 0
setz al
and al, 1
movzx edi, al
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aTestMopts5Bool; "test_mopts5 bool"
mov al, 0
call ok
add rsp, 10h
pop rbp
retn
|
long long test_mopts5()
{
int v0; // ecx
int v1; // r8d
int v2; // r9d
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // eax
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // ecx
int v11; // r8d
int v12; // r9d
char **v14; // [rsp+0h] [rbp-10h] BYREF
int v15; // [rsp+Ch] [rbp-4h]
v14 = mopts5_argv;
v15 = handle_options(&mopts5_argc, &v14, &mopts_options, dummy_get_one_option);
ok(v15 == 0, (unsigned int)"%s", (unsigned int)"test_mopts5 call", v0, v1, v2, (char)v14);
ok(mopts_num == (_QWORD)&unk_F4240, (unsigned int)"%s", (unsigned int)"test_mopts5 num", v3, v4, v5, (char)v14);
v6 = strncmp(mopts_str, "ddd", 4LL);
ok(v6 == 0, (unsigned int)"%s", (unsigned int)"test_mopts5 str", v7, v8, v9, (char)v14);
return ok(mopts_bool == 0, (unsigned int)"%s", (unsigned int)"test_mopts5 bool", v10, v11, v12, (char)v14);
}
|
test_mopts5:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[0x2d9370]
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[0x2d9368]
LEA RSI,[RBP + -0x10]
LEA RDX,[0x2d9010]
LEA RCX,[0x125770]
CALL 0x00127640
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
SETZ AL
AND AL,0x1
MOVZX EDI,AL
LEA RSI,[0x18608d]
LEA RDX,[0x1821c4]
MOV AL,0x0
CALL 0x00126ba0
CMP qword ptr [0x00491330],0xf4240
SETZ AL
AND AL,0x1
MOVZX EDI,AL
LEA RSI,[0x18608d]
LEA RDX,[0x1821d5]
MOV AL,0x0
CALL 0x00126ba0
MOV RDI,qword ptr [0x00491338]
LEA RSI,[0x1820ad]
MOV EDX,0x4
CALL 0x00125150
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EDI,AL
LEA RSI,[0x18608d]
LEA RDX,[0x1821e5]
MOV AL,0x0
CALL 0x00126ba0
MOVSX EAX,byte ptr [0x00491340]
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EDI,AL
LEA RSI,[0x18608d]
LEA RDX,[0x1821f5]
MOV AL,0x0
CALL 0x00126ba0
ADD RSP,0x10
POP RBP
RET
|
void test_mopts5(void)
{
int iVar1;
int1 *local_18;
int local_c;
local_18 = mopts5_argv;
local_c = handle_options(&mopts5_argc,&local_18,mopts_options,dummy_get_one_option);
ok(local_c == 0,"%s","test_mopts5 call");
ok(mopts_num == 1000000,"%s","test_mopts5 num");
iVar1 = strncmp(mopts_str,"ddd",4);
ok(iVar1 == 0,"%s","test_mopts5 str");
ok(mopts_bool == '\0',"%s","test_mopts5 bool");
return;
}
|
|
9,505 |
fill_and_get_bits
|
eloqsql/storage/myisam/mi_packrec.c
|
static uint fill_and_get_bits(MI_BIT_BUFF *bit_buff, uint count)
{
uint tmp;
count-=bit_buff->bits;
tmp=(bit_buff->current_byte & mask[bit_buff->bits]) << count;
fill_buffer(bit_buff);
bit_buff->bits=BITS_SAVED - count;
return tmp+(bit_buff->current_byte >> (BITS_SAVED - count));
}
|
O0
|
c
|
fill_and_get_bits:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, %edx
leaq 0x20424c(%rip), %rcx # 0x2c0640
andl (%rcx,%rdx,4), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbdc10
movl $0x20, %ecx
subl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %edx
movl $0x20, %ecx
subl -0xc(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
fill_and_get_bits_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
mov ecx, [rax+4]
mov eax, [rbp+var_C]
sub eax, ecx
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov ecx, [rcx+4]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov ecx, [rbp+var_C]
shl eax, cl
mov [rbp+var_10], eax
mov rdi, [rbp+var_8]
call fill_buffer_0
mov ecx, 20h ; ' '
sub ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+4], ecx
mov eax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov edx, [rcx]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_C]
shr edx, cl
mov ecx, edx
add eax, ecx
add rsp, 10h
pop rbp
retn
|
long long fill_and_get_bits_0(_DWORD *a1, int a2)
{
int v3; // [rsp+0h] [rbp-10h]
int v4; // [rsp+4h] [rbp-Ch]
v4 = a2 - a1[1];
v3 = (mask_0[a1[1]] & *a1) << v4;
fill_buffer_0(a1);
a1[1] = 32 - v4;
return (unsigned int)((*a1 >> (32 - v4)) + v3);
}
|
fill_and_get_bits:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x4]
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,ECX
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x4]
MOV EDX,ECX
LEA RCX,[0x3c0640]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV ECX,dword ptr [RBP + -0xc]
SHL EAX,CL
MOV dword ptr [RBP + -0x10],EAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001bdc10
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x4],ECX
MOV EAX,dword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RCX]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0xc]
SHR EDX,CL
MOV ECX,EDX
ADD EAX,ECX
ADD RSP,0x10
POP RBP
RET
|
int fill_and_get_bits(uint *param_1,int param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
uVar1 = param_1[1];
uVar2 = *param_1;
uVar3 = *(uint *)(mask + (ulong)param_1[1] * 4);
bVar4 = (byte)(param_2 - uVar1);
fill_buffer(param_1);
param_1[1] = 0x20 - (param_2 - uVar1);
return ((uVar2 & uVar3) << (bVar4 & 0x1f)) + (*param_1 >> (0x20 - bVar4 & 0x1f));
}
|
|
9,506 |
minja::IfTemplateToken::~IfTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
IfTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::If, location, pre, post), condition(std::move(c)) {}
|
O1
|
cpp
|
minja::IfTemplateToken::~IfTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x94325(%rip), %rax # 0x12db40
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x99830
callq 0x6e1aa
leaq 0x93ac1(%rip), %rax # 0x12d2f8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9984c
callq 0x6e1aa
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1b8f0
|
_ZN5minja15IfTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja15IfTemplateTokenE; `vtable for'minja::IfTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_99830
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_99830:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9984C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9984C:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::IfTemplateToken::~IfTemplateToken(minja::IfTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::IfTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~IfTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22db40]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00199830
CALL 0x0016e1aa
LAB_00199830:
LEA RAX,[0x22d2f8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019984c
CALL 0x0016e1aa
LAB_0019984c:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011b8f0
|
/* minja::IfTemplateToken::~IfTemplateToken() */
void __thiscall minja::IfTemplateToken::~IfTemplateToken(IfTemplateToken *this)
{
*(int ***)this = &PTR__IfTemplateToken_0022db50;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022d308;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
9,507 |
minja::IfTemplateToken::~IfTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
IfTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::If, location, pre, post), condition(std::move(c)) {}
|
O3
|
cpp
|
minja::IfTemplateToken::~IfTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x929ff(%rip), %rax # 0x12ab40
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x98156
callq 0x6d9b6
leaq 0x9219b(%rip), %rax # 0x12a2f8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x98172
callq 0x6d9b6
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8f0
|
_ZN5minja15IfTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja15IfTemplateTokenE; `vtable for'minja::IfTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_98156
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98156:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_98172
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98172:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::IfTemplateToken::~IfTemplateToken(minja::IfTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::IfTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~IfTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22ab40]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00198156
CALL 0x0016d9b6
LAB_00198156:
LEA RAX,[0x22a2f8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x00198172
CALL 0x0016d9b6
LAB_00198172:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011a8f0
|
/* minja::IfTemplateToken::~IfTemplateToken() */
void __thiscall minja::IfTemplateToken::~IfTemplateToken(IfTemplateToken *this)
{
*(int ***)this = &PTR__IfTemplateToken_0022ab50;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022a308;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
9,508 |
init_tree
|
eloqsql/mysys/tree.c
|
void init_tree(TREE *tree, size_t default_alloc_size, size_t memory_limit,
int size, qsort_cmp2 compare,
tree_element_free free_element, void *custom_arg,
myf my_flags)
{
DBUG_ENTER("init_tree");
DBUG_PRINT("enter",("tree: %p size: %d", tree, size));
if (default_alloc_size < DEFAULT_ALLOC_SIZE)
default_alloc_size= DEFAULT_ALLOC_SIZE;
default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
tree->root= &null_element;
tree->compare=compare;
tree->size_of_element= size > 0 ? (uint) size : 0;
tree->memory_limit=memory_limit;
tree->free=free_element;
tree->allocated=0;
tree->elements_in_tree=0;
tree->custom_arg = custom_arg;
tree->my_flags= my_flags;
tree->flag= 0;
if (!free_element && size >= 0 &&
((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
{
/*
We know that the data doesn't have to be aligned (like if the key
contains a double), so we can store the data combined with the
TREE_ELEMENT.
*/
tree->offset_to_key=sizeof(TREE_ELEMENT); /* Put key after element */
/* Fix allocation size so that we don't lose any memory */
default_alloc_size/=(sizeof(TREE_ELEMENT)+size);
if (!default_alloc_size)
default_alloc_size=1;
default_alloc_size*=(sizeof(TREE_ELEMENT)+size);
}
else
{
tree->offset_to_key=0; /* use key through pointer */
tree->size_of_element+=sizeof(void*);
}
if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE)))
{
init_alloc_root(key_memory_TREE, &tree->mem_root, default_alloc_size, 0,
MYF(my_flags));
tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element;
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
init_tree:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rdi, %rbx
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %rdi
cmpq $0x2001, %rsi # imm = 0x2001
movl $0x2000, %r10d # imm = 0x2000
cmovaeq %rsi, %r10
addq $0x1fff, %r10 # imm = 0x1FFF
andq $-0x2000, %r10 # imm = 0xE000
leaq 0x2e13d6(%rip), %rsi # 0x385bc0
movq %rsi, (%rbx)
movq %rax, 0x228(%rbx)
testq %r9, %r9
setne %sil
xorl %r11d, %r11d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movl %eax, 0x210(%rbx)
movq %rdx, 0x218(%rbx)
movq %r9, 0x280(%rbx)
movq $0x0, 0x220(%rbx)
movl %r11d, 0x20c(%rbx)
movq %rdi, 0x230(%rbx)
movq %r8, 0x288(%rbx)
movl %r11d, 0x290(%rbx)
sets %dl
orb %sil, %dl
jne 0xa485d
cmpl $0x9, %ecx
setae %dl
testb $0x7, %cl
sete %sil
testb %sil, %dl
je 0xa4872
movl $0x0, 0x208(%rbx)
addl $0x8, %eax
movl %eax, 0x210(%rbx)
jmp 0xa4898
movl $0x18, 0x208(%rbx)
addl $0x18, %ecx
movq %r10, %rax
xorl %edx, %edx
divq %rcx
cmpq %rcx, %r10
movl $0x1, %r10d
cmovaeq %rax, %r10
imulq %rcx, %r10
movl %r8d, %eax
shrl $0x12, %eax
andb $0x1, %al
movb %al, 0x278(%rbx)
jne 0xa48d3
leaq 0xb63dbd(%rip), %rax # 0xc0866c
movl (%rax), %edi
leaq 0x238(%rbx), %rsi
movq %r10, %rdx
xorl %ecx, %ecx
callq 0x9cb10
movl 0x210(%rbx), %eax
addq $0x18, %rax
movq %rax, 0x250(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
init_tree:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, r8
mov rbx, rdi
mov r8, [rbp+arg_8]
mov rdi, [rbp+arg_0]
cmp rsi, 2001h
mov r10d, 2000h
cmovnb r10, rsi
add r10, 1FFFh
and r10, 0FFFFFFFFFFFFE000h
lea rsi, null_element
mov [rbx], rsi
mov [rbx+228h], rax
test r9, r9
setnz sil
xor r11d, r11d
test ecx, ecx
mov eax, 0
cmovg eax, ecx
mov [rbx+210h], eax
mov [rbx+218h], rdx
mov [rbx+280h], r9
mov qword ptr [rbx+220h], 0
mov [rbx+20Ch], r11d
mov [rbx+230h], rdi
mov [rbx+288h], r8
mov [rbx+290h], r11d
sets dl
or dl, sil
jnz short loc_A485D
cmp ecx, 9
setnb dl
test cl, 7
setz sil
test dl, sil
jz short loc_A4872
loc_A485D:
mov dword ptr [rbx+208h], 0
add eax, 8
mov [rbx+210h], eax
jmp short loc_A4898
loc_A4872:
mov dword ptr [rbx+208h], 18h
add ecx, 18h
mov rax, r10
xor edx, edx
div rcx
cmp r10, rcx
mov r10d, 1
cmovnb r10, rax
imul r10, rcx
loc_A4898:
mov eax, r8d
shr eax, 12h
and al, 1
mov [rbx+278h], al
jnz short loc_A48D3
lea rax, key_memory_TREE
mov edi, [rax]
lea rsi, [rbx+238h]
mov rdx, r10
xor ecx, ecx
call init_alloc_root
mov eax, [rbx+210h]
add rax, 18h
mov [rbx+250h], rax
loc_A48D3:
add rsp, 8
pop rbx
pop rbp
retn
|
char init_tree(
long long a1,
unsigned long long a2,
long long a3,
int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long v8; // r10
unsigned long long v9; // r10
int v10; // eax
unsigned long long v11; // rcx
unsigned long long v12; // rax
bool v13; // cf
long long v14; // r10
long long v15; // rax
v8 = 0x2000LL;
if ( a2 >= 0x2001 )
v8 = a2;
v9 = (v8 + 0x1FFF) & 0xFFFFFFFFFFFFE000LL;
*(_QWORD *)a1 = &null_element;
*(_QWORD *)(a1 + 552) = a5;
v10 = 0;
if ( a4 > 0 )
v10 = a4;
*(_DWORD *)(a1 + 528) = v10;
*(_QWORD *)(a1 + 536) = a3;
*(_QWORD *)(a1 + 640) = a6;
*(_QWORD *)(a1 + 544) = 0LL;
*(_DWORD *)(a1 + 524) = 0;
*(_QWORD *)(a1 + 560) = a7;
*(_QWORD *)(a1 + 648) = a8;
*(_DWORD *)(a1 + 656) = 0;
if ( a6 != 0 || a4 < 0 || (a4 & 7) == 0 && (unsigned int)a4 >= 9 )
{
*(_DWORD *)(a1 + 520) = 0;
*(_DWORD *)(a1 + 528) = v10 + 8;
}
else
{
*(_DWORD *)(a1 + 520) = 24;
v11 = (unsigned int)(a4 + 24);
v12 = v9 / v11;
v13 = v9 < v11;
v14 = 1LL;
if ( !v13 )
v14 = v12;
v9 = v11 * v14;
}
LOBYTE(v15) = (a8 & 0x40000) != 0;
*(_BYTE *)(a1 + 632) = v15;
if ( (a8 & 0x40000) == 0 )
{
init_alloc_root(key_memory_TREE, (long long *)(a1 + 568), v9, 0LL, a8);
v15 = *(unsigned int *)(a1 + 528) + 24LL;
*(_QWORD *)(a1 + 592) = v15;
}
return v15;
}
|
init_tree:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,R8
MOV RBX,RDI
MOV R8,qword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
CMP RSI,0x2001
MOV R10D,0x2000
CMOVNC R10,RSI
ADD R10,0x1fff
AND R10,-0x2000
LEA RSI,[0x485bc0]
MOV qword ptr [RBX],RSI
MOV qword ptr [RBX + 0x228],RAX
TEST R9,R9
SETNZ SIL
XOR R11D,R11D
TEST ECX,ECX
MOV EAX,0x0
CMOVG EAX,ECX
MOV dword ptr [RBX + 0x210],EAX
MOV qword ptr [RBX + 0x218],RDX
MOV qword ptr [RBX + 0x280],R9
MOV qword ptr [RBX + 0x220],0x0
MOV dword ptr [RBX + 0x20c],R11D
MOV qword ptr [RBX + 0x230],RDI
MOV qword ptr [RBX + 0x288],R8
MOV dword ptr [RBX + 0x290],R11D
SETS DL
OR DL,SIL
JNZ 0x001a485d
CMP ECX,0x9
SETNC DL
TEST CL,0x7
SETZ SIL
TEST DL,SIL
JZ 0x001a4872
LAB_001a485d:
MOV dword ptr [RBX + 0x208],0x0
ADD EAX,0x8
MOV dword ptr [RBX + 0x210],EAX
JMP 0x001a4898
LAB_001a4872:
MOV dword ptr [RBX + 0x208],0x18
ADD ECX,0x18
MOV RAX,R10
XOR EDX,EDX
DIV RCX
CMP R10,RCX
MOV R10D,0x1
CMOVNC R10,RAX
IMUL R10,RCX
LAB_001a4898:
MOV EAX,R8D
SHR EAX,0x12
AND AL,0x1
MOV byte ptr [RBX + 0x278],AL
JNZ 0x001a48d3
LEA RAX,[0xd0866c]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBX + 0x238]
MOV RDX,R10
XOR ECX,ECX
CALL 0x0019cb10
MOV EAX,dword ptr [RBX + 0x210]
ADD RAX,0x18
MOV qword ptr [RBX + 0x250],RAX
LAB_001a48d3:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void init_tree(int8 *param_1,ulong param_2,int8 param_3,uint param_4,int8 param_5,
long param_6,int8 param_7,ulong param_8)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
uVar3 = 0x2000;
if (0x2000 < param_2) {
uVar3 = param_2;
}
uVar3 = uVar3 + 0x1fff & 0xffffffffffffe000;
*param_1 = null_element;
param_1[0x45] = param_5;
uVar1 = 0;
if (0 < (int)param_4) {
uVar1 = param_4;
}
*(uint *)(param_1 + 0x42) = uVar1;
param_1[0x43] = param_3;
param_1[0x50] = param_6;
param_1[0x44] = 0;
*(int4 *)((long)param_1 + 0x20c) = 0;
param_1[0x46] = param_7;
param_1[0x51] = param_8;
*(int4 *)(param_1 + 0x52) = 0;
if (((int)param_4 < 0 || param_6 != 0) || (8 < param_4 && (param_4 & 7) == 0)) {
*(int4 *)(param_1 + 0x41) = 0;
*(uint *)(param_1 + 0x42) = uVar1 + 8;
}
else {
*(int4 *)(param_1 + 0x41) = 0x18;
uVar2 = (ulong)(param_4 + 0x18);
uVar4 = 1;
if (uVar2 <= uVar3) {
uVar4 = uVar3 / uVar2;
}
uVar3 = uVar4 * uVar2;
}
*(byte *)(param_1 + 0x4f) = (byte)(param_8 >> 0x12) & 1;
if ((param_8 >> 0x12 & 1) == 0) {
init_alloc_root(key_memory_TREE,param_1 + 0x47,uVar3,0);
param_1[0x4a] = (ulong)*(uint *)(param_1 + 0x42) + 0x18;
}
return;
}
|
|
9,509 |
QuaternionToEuler
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI Vector3 QuaternionToEuler(Quaternion q)
{
Vector3 result = { 0 };
// Roll (x-axis rotation)
float x0 = 2.0f*(q.w*q.x + q.y*q.z);
float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y);
result.x = atan2f(x0, x1);
// Pitch (y-axis rotation)
float y0 = 2.0f*(q.w*q.y - q.z*q.x);
y0 = y0 > 1.0f ? 1.0f : y0;
y0 = y0 < -1.0f ? -1.0f : y0;
result.y = asinf(y0);
// Yaw (z-axis rotation)
float z0 = 2.0f*(q.w*q.z + q.x*q.y);
float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z);
result.z = atan2f(z0, z1);
return result;
}
|
O3
|
c
|
QuaternionToEuler:
subq $0x78, %rsp
movaps %xmm0, %xmm4
movaps %xmm0, (%rsp)
movaps %xmm1, %xmm0
movaps %xmm1, 0x30(%rsp)
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, 0x20(%rsp)
movaps %xmm4, %xmm2
shufps $0x55, %xmm4, %xmm2 # xmm2 = xmm2[1,1],xmm4[1,1]
movaps %xmm2, %xmm1
movaps %xmm2, 0x10(%rsp)
mulss %xmm0, %xmm1
movaps %xmm3, %xmm0
mulss %xmm4, %xmm0
addss %xmm1, %xmm0
addss %xmm0, %xmm0
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
movaps %xmm1, 0x50(%rsp)
mulss %xmm4, %xmm4
addss %xmm1, %xmm4
addss %xmm4, %xmm4
movss 0x69ae6(%rip), %xmm1 # 0xd3b1c
subss %xmm4, %xmm1
callq 0xa730
movaps %xmm0, 0x60(%rsp)
movaps (%rsp), %xmm0
mulss 0x30(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
subss %xmm0, %xmm1
addss %xmm1, %xmm1
movss 0x69ab3(%rip), %xmm2 # 0xd3b1c
minss %xmm1, %xmm2
movss 0x69aab(%rip), %xmm0 # 0xd3b20
maxss %xmm2, %xmm0
callq 0xa8d0
movaps %xmm0, 0x40(%rsp)
movaps 0x10(%rsp), %xmm2
mulss (%rsp), %xmm2
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
addss %xmm0, %xmm0
mulss %xmm1, %xmm1
addss 0x50(%rsp), %xmm1
addss %xmm1, %xmm1
movss 0x69a63(%rip), %xmm2 # 0xd3b1c
subss %xmm1, %xmm2
movaps %xmm2, %xmm1
callq 0xa730
movaps %xmm0, %xmm1
movaps 0x60(%rsp), %xmm0
unpcklps 0x40(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
addq $0x78, %rsp
retq
|
QuaternionToEuler:
sub rsp, 78h
movaps xmm4, xmm0
movaps [rsp+78h+var_78], xmm0
movaps xmm0, xmm1
movaps [rsp+78h+var_48], xmm1
movaps xmm3, xmm1
shufps xmm3, xmm1, 55h ; 'U'
movaps [rsp+78h+var_58], xmm3
movaps xmm2, xmm4
shufps xmm2, xmm4, 55h ; 'U'
movaps xmm1, xmm2
movaps [rsp+78h+var_68], xmm2
mulss xmm1, xmm0
movaps xmm0, xmm3
mulss xmm0, xmm4
addss xmm0, xmm1
addss xmm0, xmm0
movaps xmm1, xmm2
mulss xmm1, xmm2
movaps [rsp+78h+var_28], xmm1
mulss xmm4, xmm4
addss xmm4, xmm1
addss xmm4, xmm4
movss xmm1, cs:dword_D3B1C
subss xmm1, xmm4
call _atan2f
movaps [rsp+78h+var_18], xmm0
movaps xmm0, [rsp+78h+var_78]
mulss xmm0, dword ptr [rsp+78h+var_48]
movaps xmm1, [rsp+78h+var_58]
mulss xmm1, dword ptr [rsp+78h+var_68]
subss xmm1, xmm0
addss xmm1, xmm1
movss xmm2, cs:dword_D3B1C
minss xmm2, xmm1
movss xmm0, cs:dword_D3B20
maxss xmm0, xmm2
call _asinf
movaps [rsp+78h+var_38], xmm0
movaps xmm2, [rsp+78h+var_68]
mulss xmm2, dword ptr [rsp+78h+var_78]
movaps xmm0, [rsp+78h+var_58]
movaps xmm1, [rsp+78h+var_48]
mulss xmm0, xmm1
addss xmm0, xmm2
addss xmm0, xmm0
mulss xmm1, xmm1
addss xmm1, dword ptr [rsp+78h+var_28]
addss xmm1, xmm1
movss xmm2, cs:dword_D3B1C
subss xmm2, xmm1
movaps xmm1, xmm2
call _atan2f
movaps xmm1, xmm0
movaps xmm0, [rsp+78h+var_18]
unpcklps xmm0, [rsp+78h+var_38]
add rsp, 78h
retn
|
__m128 QuaternionToEuler(__m128 a1, __m128 a2)
{
__m128 v3; // xmm0
__m128 v4; // xmm0
float v6; // [rsp+0h] [rbp-78h]
float v7; // [rsp+10h] [rbp-68h]
__m128 v8; // [rsp+20h] [rbp-58h]
float v9; // [rsp+30h] [rbp-48h]
__m128 v10; // [rsp+40h] [rbp-38h]
__m128 v11; // [rsp+60h] [rbp-18h]
v6 = a1.m128_f32[0];
v9 = a2.m128_f32[0];
v8 = _mm_shuffle_ps(a2, a2, 85);
v7 = _mm_shuffle_ps(a1, a1, 85).m128_f32[0];
v3.m128_u64[1] = v8.m128_u64[1];
*(double *)v3.m128_u64 = atan2f(
(float)((float)(v8.m128_f32[0] * a1.m128_f32[0]) + (float)(v7 * a2.m128_f32[0]))
+ (float)((float)(v8.m128_f32[0] * a1.m128_f32[0]) + (float)(v7 * a2.m128_f32[0])),
COERCE_DOUBLE((unsigned long long)COERCE_UNSIGNED_INT(
1.0
- (float)((float)((float)(a1.m128_f32[0] * a1.m128_f32[0])
+ (float)(v7 * v7))
+ (float)((float)(a1.m128_f32[0] * a1.m128_f32[0])
+ (float)(v7 * v7))))));
v11 = v3;
v4 = (__m128)0xBF800000;
*(double *)v4.m128_u64 = asinf(
fmaxf(
-1.0,
fminf(
1.0,
(float)((float)(v8.m128_f32[0] * v7) - (float)(v6 * v9))
+ (float)((float)(v8.m128_f32[0] * v7) - (float)(v6 * v9)))));
v10 = v4;
atan2f(
(float)((float)(v8.m128_f32[0] * v9) + (float)(v7 * v6)) + (float)((float)(v8.m128_f32[0] * v9) + (float)(v7 * v6)),
COERCE_DOUBLE((unsigned long long)COERCE_UNSIGNED_INT(
1.0
- (float)((float)((float)(v9 * v9) + (float)(v7 * v7))
+ (float)((float)(v9 * v9) + (float)(v7 * v7))))));
return _mm_unpacklo_ps(v11, v10);
}
|
QuaternionToEuler:
SUB RSP,0x78
MOVAPS XMM4,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS XMM0,XMM1
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOVAPS XMM3,XMM1
SHUFPS XMM3,XMM1,0x55
MOVAPS xmmword ptr [RSP + 0x20],XMM3
MOVAPS XMM2,XMM4
SHUFPS XMM2,XMM4,0x55
MOVAPS XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x10],XMM2
MULSS XMM1,XMM0
MOVAPS XMM0,XMM3
MULSS XMM0,XMM4
ADDSS XMM0,XMM1
ADDSS XMM0,XMM0
MOVAPS XMM1,XMM2
MULSS XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MULSS XMM4,XMM4
ADDSS XMM4,XMM1
ADDSS XMM4,XMM4
MOVSS XMM1,dword ptr [0x001d3b1c]
SUBSS XMM1,XMM4
CALL 0x0010a730
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS XMM0,xmmword ptr [RSP]
MULSS XMM0,dword ptr [RSP + 0x30]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MULSS XMM1,dword ptr [RSP + 0x10]
SUBSS XMM1,XMM0
ADDSS XMM1,XMM1
MOVSS XMM2,dword ptr [0x001d3b1c]
MINSS XMM2,XMM1
MOVSS XMM0,dword ptr [0x001d3b20]
MAXSS XMM0,XMM2
CALL 0x0010a8d0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS XMM2,xmmword ptr [RSP + 0x10]
MULSS XMM2,dword ptr [RSP]
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
MULSS XMM0,XMM1
ADDSS XMM0,XMM2
ADDSS XMM0,XMM0
MULSS XMM1,XMM1
ADDSS XMM1,dword ptr [RSP + 0x50]
ADDSS XMM1,XMM1
MOVSS XMM2,dword ptr [0x001d3b1c]
SUBSS XMM2,XMM1
MOVAPS XMM1,XMM2
CALL 0x0010a730
MOVAPS XMM1,XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x60]
UNPCKLPS XMM0,xmmword ptr [RSP + 0x40]
ADD RSP,0x78
RET
|
int8 QuaternionToEuler(int8 param_1,int8 param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
fVar6 = (float)((ulong)param_2 >> 0x20);
fVar3 = (float)param_2;
fVar5 = (float)((ulong)param_1 >> 0x20);
fVar2 = (float)param_1;
fVar1 = fVar6 * fVar2 + fVar5 * fVar3;
fVar7 = fVar2 * fVar2 + fVar5 * fVar5;
fVar7 = atan2f(fVar1 + fVar1,DAT_001d3b1c - (fVar7 + fVar7));
fVar4 = fVar6 * fVar5 - fVar2 * fVar3;
fVar4 = fVar4 + fVar4;
fVar1 = DAT_001d3b1c;
if (fVar4 <= DAT_001d3b1c) {
fVar1 = fVar4;
}
fVar4 = DAT_001d3b20;
if (DAT_001d3b20 <= fVar1) {
fVar4 = fVar1;
}
fVar1 = asinf(fVar4);
fVar2 = fVar6 * fVar3 + fVar5 * fVar2;
fVar5 = fVar3 * fVar3 + fVar5 * fVar5;
atan2f(fVar2 + fVar2,DAT_001d3b1c - (fVar5 + fVar5));
return CONCAT44(fVar1,fVar7);
}
|
|
9,510 |
ma_alloc_buffer
|
eloqsql/storage/maria/ma_open.c
|
my_bool _ma_alloc_buffer(uchar **old_addr, size_t *old_size,
size_t new_size, myf flag)
{
if (*old_size < new_size)
{
uchar *addr;
if (!(addr= (uchar*) my_realloc(PSI_INSTRUMENT_ME, *old_addr, new_size,
MYF(MY_ALLOW_ZERO_PTR | flag))))
return 1;
*old_addr= addr;
*old_size= new_size;
}
return 0;
}
|
O0
|
c
|
ma_alloc_buffer:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x31995
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
orq $0x40, %rcx
xorl %edi, %edi
callq 0xf71c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3197f
movb $0x1, -0x1(%rbp)
jmp 0x31999
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_alloc_buffer:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov rax, [rax]
cmp rax, [rbp+var_20]
jnb short loc_31995
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
or rcx, 40h
xor edi, edi
call my_realloc
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_3197F
mov [rbp+var_1], 1
jmp short loc_31999
loc_3197F:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rax], rcx
loc_31995:
mov [rbp+var_1], 0
loc_31999:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char ma_alloc_buffer(long long *a1, unsigned long long *a2, unsigned long long a3, long long a4)
{
long long v5; // [rsp+0h] [rbp-30h]
if ( *a2 >= a3 )
return 0;
v5 = my_realloc(0LL, *a1, a3, a4 | 0x40);
if ( v5 )
{
*a1 = v5;
*a2 = a3;
return 0;
}
return 1;
}
|
_ma_alloc_buffer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00131995
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
OR RCX,0x40
XOR EDI,EDI
CALL 0x001f71c0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x0013197f
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00131999
LAB_0013197f:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
LAB_00131995:
MOV byte ptr [RBP + -0x1],0x0
LAB_00131999:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 _ma_alloc_buffer(long *param_1,ulong *param_2,ulong param_3,ulong param_4)
{
long lVar1;
if (*param_2 < param_3) {
lVar1 = my_realloc(0,*param_1,param_3,param_4 | 0x40);
if (lVar1 == 0) {
return 1;
}
*param_1 = lVar1;
*param_2 = param_3;
}
return 0;
}
|
|
9,511 |
ggml_compute_forward_argsort
|
ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp
|
void ggml_compute_forward_argsort(
const ggml_compute_params * params,
ggml_tensor * dst) {
const ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_argsort_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
}
|
O2
|
cpp
|
ggml_compute_forward_argsort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x98(%rsi), %rax
movq %rax, (%rsp)
cmpl $0x0, (%rax)
jne 0x3eb4f
cmpq $0x4, 0x30(%rsi)
jne 0x3eb69
movq (%rsp), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rsi), %r12
movq 0x38(%rsi), %r14
movslq (%rdi), %rbp
movslq 0x4(%rdi), %r15
movq %rax, %rdi
movq %rsi, %rbx
callq 0xbb10
movq %rax, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
movl 0x54(%rbx), %ecx
movq %r12, %rdx
sarq $0x3f, %rdx
andnq %r12, %rdx, %rdx
movq %r14, %rsi
imulq %rbp, %rsi
movq %r14, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rax
imulq %r15, %rdi
cmpq 0x20(%rsp), %rbp
jge 0x3eb40
movq 0x18(%rsp), %r8
movq 0xf8(%r8), %r8
movq %rbp, %r9
imulq 0x8(%rsp), %r9
addq %r8, %r9
movq (%rsp), %r10
movq 0xf8(%r10), %r10
addq %rsi, %r8
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0x3eacc
movl %r11d, (%r8,%r11,4)
incq %r11
jmp 0x3eabe
movq %rbp, %r11
imulq 0x10(%rsp), %r11
addq %r11, %r10
xorl %r11d, %r11d
cmpq %rdx, %r11
je 0x3eb35
leaq 0x1(%r11), %r15
movq %r15, %r14
cmpq %r12, %r14
jge 0x3eb30
cmpl $0x1, %ecx
je 0x3eb18
testl %ecx, %ecx
jne 0x3eb13
movslq (%r9,%r11,4), %rbx
vmovss (%r10,%rbx,4), %xmm0
movslq (%r8,%r14,4), %r13
vucomiss (%r10,%r13,4), %xmm0
jbe 0x3eb13
movl %r13d, (%r9,%r11,4)
movl %ebx, (%r8,%r14,4)
incq %r14
jmp 0x3eae7
movslq (%r9,%r11,4), %rbx
movslq (%r8,%r14,4), %r13
vmovss (%r10,%r13,4), %xmm0
vucomiss (%r10,%rbx,4), %xmm0
ja 0x3eb0b
jmp 0x3eb13
movq %r15, %r11
jmp 0x3eadb
addq %rax, %rbp
addq %rdi, %rsi
jmp 0x3ea8a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfaaa(%rip), %rdi # 0x4e600
leaq 0x5a6b(%rip), %rdx # 0x445c8
movl $0x1ac3, %esi # imm = 0x1AC3
xorl %eax, %eax
callq 0xc040
leaq 0xfa90(%rip), %rdi # 0x4e600
leaq 0x593b(%rip), %rdx # 0x444b2
leaq 0x5d70(%rip), %rcx # 0x448ee
movl $0x1a97, %esi # imm = 0x1A97
xorl %eax, %eax
callq 0xc040
|
ggml_compute_forward_argsort:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+98h]
mov [rsp+58h+var_58], rax
cmp dword ptr [rax], 0
jnz loc_3EB4F
cmp qword ptr [rsi+30h], 4
jnz loc_3EB69
mov rax, [rsp+58h+var_58]
mov rcx, [rax+38h]
mov [rsp+58h+var_48], rcx
mov r12, [rsi+10h]
mov r14, [rsi+38h]
movsxd rbp, dword ptr [rdi]
movsxd r15, dword ptr [rdi+4]
mov rdi, rax
mov rbx, rsi
call _ggml_nrows
mov [rsp+58h+var_38], rax
mov [rsp+58h+var_40], rbx
mov ecx, [rbx+54h]
mov rdx, r12
sar rdx, 3Fh
andn rdx, rdx, r12
mov rsi, r14
imul rsi, rbp
mov [rsp+58h+var_50], r14
mov rdi, r14
mov rax, r15
imul rdi, r15
loc_3EA8A:
cmp rbp, [rsp+58h+var_38]
jge loc_3EB40
mov r8, [rsp+58h+var_40]
mov r8, [r8+0F8h]
mov r9, rbp
imul r9, [rsp+58h+var_50]
add r9, r8
mov r10, [rsp+58h+var_58]
mov r10, [r10+0F8h]
add r8, rsi
xor r11d, r11d
loc_3EABE:
cmp rdx, r11
jz short loc_3EACC
mov [r8+r11*4], r11d
inc r11
jmp short loc_3EABE
loc_3EACC:
mov r11, rbp
imul r11, [rsp+58h+var_48]
add r10, r11
xor r11d, r11d
loc_3EADB:
cmp r11, rdx
jz short loc_3EB35
lea r15, [r11+1]
mov r14, r15
loc_3EAE7:
cmp r14, r12
jge short loc_3EB30
cmp ecx, 1
jz short loc_3EB18
test ecx, ecx
jnz short loc_3EB13
movsxd rbx, dword ptr [r9+r11*4]
vmovss xmm0, dword ptr [r10+rbx*4]
movsxd r13, dword ptr [r8+r14*4]
vucomiss xmm0, dword ptr [r10+r13*4]
jbe short loc_3EB13
loc_3EB0B:
mov [r9+r11*4], r13d
mov [r8+r14*4], ebx
loc_3EB13:
inc r14
jmp short loc_3EAE7
loc_3EB18:
movsxd rbx, dword ptr [r9+r11*4]
movsxd r13, dword ptr [r8+r14*4]
vmovss xmm0, dword ptr [r10+r13*4]
vucomiss xmm0, dword ptr [r10+rbx*4]
ja short loc_3EB0B
jmp short loc_3EB13
loc_3EB30:
mov r11, r15
jmp short loc_3EADB
loc_3EB35:
add rbp, rax
add rsi, rdi
jmp loc_3EA8A
loc_3EB40:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3EB4F:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aFatalError; "fatal error"
mov esi, 1AC3h
xor eax, eax
call _ggml_abort
loc_3EB69:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNb0SizeofFloat; "nb0 == sizeof(float)"
mov esi, 1A97h
xor eax, eax
call _ggml_abort
|
long long ggml_compute_forward_argsort(int *a1, long long a2)
{
long long v2; // r12
long long v3; // r14
long long v4; // rbp
long long v5; // r15
int v6; // ecx
long long v7; // rdx
long long v8; // rsi
long long result; // rax
long long v10; // rdi
long long v11; // r8
long long v12; // r9
long long v13; // r10
long long v14; // r8
long long i; // r11
long long j; // r11
long long k; // r14
long long v25; // [rsp+0h] [rbp-58h]
long long v26; // [rsp+8h] [rbp-50h]
long long v27; // [rsp+10h] [rbp-48h]
long long v29; // [rsp+20h] [rbp-38h]
v25 = *(_QWORD *)(a2 + 152);
if ( *(_DWORD *)v25 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
6851LL,
"fatal error");
goto LABEL_21;
}
if ( *(_QWORD *)(a2 + 48) != 4LL )
{
LABEL_21:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
6807LL,
"GGML_ASSERT(%s) failed",
"nb0 == sizeof(float)");
return ggml_compute_forward_flash_attn_ext();
}
v27 = *(_QWORD *)(v25 + 56);
v2 = *(_QWORD *)(a2 + 16);
v3 = *(_QWORD *)(a2 + 56);
v4 = *a1;
v5 = a1[1];
v29 = ggml_nrows(v25);
v6 = *(_DWORD *)(a2 + 84);
v7 = v2 & ~(v2 >> 63);
v8 = v4 * v3;
v26 = v3;
result = v5;
v10 = v5 * v3;
while ( v4 < v29 )
{
v11 = *(_QWORD *)(a2 + 248);
v12 = v11 + v26 * v4;
v13 = *(_QWORD *)(v25 + 248);
v14 = v8 + v11;
for ( i = 0LL; v7 != i; ++i )
*(_DWORD *)(v14 + 4 * i) = i;
_R10 = v27 * v4 + v13;
for ( j = 0LL; j != v7; ++j )
{
for ( k = j + 1; k < v2; ++k )
{
if ( v6 == 1 )
{
_RBX = *(int *)(v12 + 4 * j);
_R13 = *(int *)(v14 + 4 * k);
__asm
{
vmovss xmm0, dword ptr [r10+r13*4]
vucomiss xmm0, dword ptr [r10+rbx*4]
}
}
else if ( !v6 )
{
_RBX = *(int *)(v12 + 4 * j);
__asm { vmovss xmm0, dword ptr [r10+rbx*4] }
_R13 = *(int *)(v14 + 4 * k);
__asm { vucomiss xmm0, dword ptr [r10+r13*4] }
}
}
}
v4 += v5;
v8 += v10;
}
return result;
}
|
ggml_compute_forward_argsort:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x98]
MOV qword ptr [RSP],RAX
CMP dword ptr [RAX],0x0
JNZ 0x0013eb4f
CMP qword ptr [RSI + 0x30],0x4
JNZ 0x0013eb69
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0x10],RCX
MOV R12,qword ptr [RSI + 0x10]
MOV R14,qword ptr [RSI + 0x38]
MOVSXD RBP,dword ptr [RDI]
MOVSXD R15,dword ptr [RDI + 0x4]
MOV RDI,RAX
MOV RBX,RSI
CALL 0x0010bb10
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x18],RBX
MOV ECX,dword ptr [RBX + 0x54]
MOV RDX,R12
SAR RDX,0x3f
ANDN RDX,RDX,R12
MOV RSI,R14
IMUL RSI,RBP
MOV qword ptr [RSP + 0x8],R14
MOV RDI,R14
MOV RAX,R15
IMUL RDI,R15
LAB_0013ea8a:
CMP RBP,qword ptr [RSP + 0x20]
JGE 0x0013eb40
MOV R8,qword ptr [RSP + 0x18]
MOV R8,qword ptr [R8 + 0xf8]
MOV R9,RBP
IMUL R9,qword ptr [RSP + 0x8]
ADD R9,R8
MOV R10,qword ptr [RSP]
MOV R10,qword ptr [R10 + 0xf8]
ADD R8,RSI
XOR R11D,R11D
LAB_0013eabe:
CMP RDX,R11
JZ 0x0013eacc
MOV dword ptr [R8 + R11*0x4],R11D
INC R11
JMP 0x0013eabe
LAB_0013eacc:
MOV R11,RBP
IMUL R11,qword ptr [RSP + 0x10]
ADD R10,R11
XOR R11D,R11D
LAB_0013eadb:
CMP R11,RDX
JZ 0x0013eb35
LEA R15,[R11 + 0x1]
MOV R14,R15
LAB_0013eae7:
CMP R14,R12
JGE 0x0013eb30
CMP ECX,0x1
JZ 0x0013eb18
TEST ECX,ECX
JNZ 0x0013eb13
MOVSXD RBX,dword ptr [R9 + R11*0x4]
VMOVSS XMM0,dword ptr [R10 + RBX*0x4]
MOVSXD R13,dword ptr [R8 + R14*0x4]
VUCOMISS XMM0,dword ptr [R10 + R13*0x4]
JBE 0x0013eb13
LAB_0013eb0b:
MOV dword ptr [R9 + R11*0x4],R13D
MOV dword ptr [R8 + R14*0x4],EBX
LAB_0013eb13:
INC R14
JMP 0x0013eae7
LAB_0013eb18:
MOVSXD RBX,dword ptr [R9 + R11*0x4]
MOVSXD R13,dword ptr [R8 + R14*0x4]
VMOVSS XMM0,dword ptr [R10 + R13*0x4]
VUCOMISS XMM0,dword ptr [R10 + RBX*0x4]
JA 0x0013eb0b
JMP 0x0013eb13
LAB_0013eb30:
MOV R11,R15
JMP 0x0013eadb
LAB_0013eb35:
ADD RBP,RAX
ADD RSI,RDI
JMP 0x0013ea8a
LAB_0013eb40:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013eb4f:
LEA RDI,[0x14e600]
LEA RDX,[0x1445c8]
MOV ESI,0x1ac3
XOR EAX,EAX
CALL 0x0010c040
LAB_0013eb69:
LEA RDI,[0x14e600]
LEA RDX,[0x1444b2]
LEA RCX,[0x1448ee]
MOV ESI,0x1a97
XOR EAX,EAX
CALL 0x0010c040
|
void ggml_compute_forward_argsort(int *param_1,long param_2)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
ulong uVar5;
long lVar6;
long lVar7;
ulong uVar8;
int iVar9;
long lVar10;
long lVar11;
long lVar12;
long lVar13;
long lVar14;
ulong uVar15;
ulong uVar16;
int iVar17;
ulong uVar18;
piVar3 = *(int **)(param_2 + 0x98);
if (*piVar3 != 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x1ac3,"fatal error");
}
if (*(long *)(param_2 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x1a97,"GGML_ASSERT(%s) failed","nb0 == sizeof(float)");
}
lVar4 = *(long *)(piVar3 + 0xe);
uVar5 = *(ulong *)(param_2 + 0x10);
lVar6 = *(long *)(param_2 + 0x38);
lVar10 = (long)*param_1;
iVar1 = param_1[1];
lVar7 = ggml_nrows(piVar3);
iVar2 = *(int *)(param_2 + 0x54);
uVar8 = ~((long)uVar5 >> 0x3f) & uVar5;
lVar11 = lVar6 * lVar10;
do {
if (lVar7 <= lVar10) {
return;
}
lVar13 = lVar10 * lVar6 + *(long *)(param_2 + 0xf8);
lVar14 = *(long *)(piVar3 + 0x3e);
lVar12 = *(long *)(param_2 + 0xf8) + lVar11;
for (uVar15 = 0; uVar8 != uVar15; uVar15 = uVar15 + 1) {
*(int *)(lVar12 + uVar15 * 4) = (int)uVar15;
}
lVar14 = lVar14 + lVar10 * lVar4;
uVar15 = 0;
while (uVar16 = uVar15, uVar16 != uVar8) {
for (uVar18 = uVar16 + 1; uVar15 = uVar16 + 1, (long)uVar18 < (long)uVar5; uVar18 = uVar18 + 1
) {
if (iVar2 == 1) {
iVar9 = *(int *)(lVar13 + uVar16 * 4);
iVar17 = *(int *)(lVar12 + uVar18 * 4);
if (*(float *)(lVar14 + (long)iVar9 * 4) < *(float *)(lVar14 + (long)iVar17 * 4)) {
LAB_0013eb0b:
*(int *)(lVar13 + uVar16 * 4) = iVar17;
*(int *)(lVar12 + uVar18 * 4) = iVar9;
}
}
else if (iVar2 == 0) {
iVar9 = *(int *)(lVar13 + uVar16 * 4);
iVar17 = *(int *)(lVar12 + uVar18 * 4);
if (*(float *)(lVar14 + (long)iVar17 * 4) < *(float *)(lVar14 + (long)iVar9 * 4))
goto LAB_0013eb0b;
}
}
}
lVar10 = lVar10 + iVar1;
lVar11 = lVar11 + lVar6 * iVar1;
} while( true );
}
|
|
9,512 |
ggml_compute_forward_argsort
|
ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp
|
void ggml_compute_forward_argsort(
const ggml_compute_params * params,
ggml_tensor * dst) {
const ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_argsort_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
}
|
O3
|
cpp
|
ggml_compute_forward_argsort:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x98(%rsi), %r14
cmpl $0x0, (%r14)
jne 0x42147
movq %rsi, %rbx
cmpq $0x4, 0x30(%rsi)
jne 0x42161
movq 0x38(%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rbx), %r12
movq 0x38(%rbx), %rax
movq %rax, 0x8(%rsp)
movslq (%rdi), %rbp
movslq 0x4(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0xaa40
movq %rax, 0x30(%rsp)
cmpq %rbp, %rax
jle 0x42135
movl 0x54(%rbx), %ecx
movq 0xf8(%rbx), %rdx
movq 0xf8(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x7(%r12), %rdi
andq $-0x8, %rdi
leaq -0x1(%r12), %rax
vpbroadcastq %rax, %ymm0
movq 0x8(%rsp), %rax
movq %rax, %r8
imulq %rbp, %r8
movq %rdx, 0x20(%rsp)
addq %rdx, %r8
imulq 0x10(%rsp), %rax
vpmovsxbq 0x6057(%rip), %ymm1 # 0x48080
vpmovsxbq 0x6052(%rip), %ymm2 # 0x48084
vpmovsxbd 0x6ee5(%rip), %ymm3 # 0x48f20
vpbroadcastq 0x6f0c(%rip), %ymm4 # 0x48f50
vpbroadcastd 0x6d97(%rip), %ymm5 # 0x48de4
testq %r12, %r12
jle 0x42122
movq %rbp, %r10
imulq 0x8(%rsp), %r10
addq 0x20(%rsp), %r10
movq %rbp, %r11
imulq 0x28(%rsp), %r11
addq 0x18(%rsp), %r11
xorl %edx, %edx
vmovdqa %ymm2, %ymm6
vmovdqa %ymm1, %ymm7
vmovdqa %ymm3, %ymm8
vpcmpleuq %ymm0, %ymm6, %k0
vpcmpleuq %ymm0, %ymm7, %k1
kshiftlb $0x4, %k1, %k1
korb %k1, %k0, %k1
vmovdqu32 %ymm8, (%r8,%rdx,4) {%k1}
addq $0x8, %rdx
vpaddq %ymm4, %ymm6, %ymm6
vpaddq %ymm4, %ymm7, %ymm7
vpaddd %ymm5, %ymm8, %ymm8
cmpq %rdx, %rdi
jne 0x42080
movq %r12, %rbx
movq %r8, %r14
xorl %edx, %edx
movq %rdx, %rsi
incq %rdx
cmpq %r12, %rdx
jge 0x42116
movl $0x1, %r13d
cmpl $0x1, %ecx
je 0x420fe
testl %ecx, %ecx
jne 0x420f4
movslq (%r10,%rsi,4), %r15
vmovss (%r11,%r15,4), %xmm6
movslq (%r14,%r13,4), %r9
vucomiss (%r11,%r9,4), %xmm6
jbe 0x420f4
movl %r9d, (%r10,%rsi,4)
movl %r15d, (%r14,%r13,4)
incq %r13
cmpq %r13, %rbx
jne 0x420cd
jmp 0x42116
movslq (%r10,%rsi,4), %r15
movslq (%r14,%r13,4), %r9
vmovss (%r11,%r9,4), %xmm6
vucomiss (%r11,%r15,4), %xmm6
ja 0x420ec
jmp 0x420f4
addq $0x4, %r14
decq %rbx
cmpq %r12, %rdx
jne 0x420bc
addq 0x10(%rsp), %rbp
addq %rax, %r8
cmpq 0x30(%rsp), %rbp
jl 0x4204d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x10952(%rip), %rdi # 0x52aa0
leaq 0x652b(%rip), %rdx # 0x48680
movl $0x1ac3, %esi # imm = 0x1AC3
xorl %eax, %eax
callq 0xaf40
leaq 0x10938(%rip), %rdi # 0x52aa0
leaq 0x63fb(%rip), %rdx # 0x4856a
leaq 0x6830(%rip), %rcx # 0x489a6
movl $0x1a97, %esi # imm = 0x1A97
xorl %eax, %eax
callq 0xaf40
|
ggml_compute_forward_argsort:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, [rsi+98h]
cmp dword ptr [r14], 0
jnz loc_42147
mov rbx, rsi
cmp qword ptr [rsi+30h], 4
jnz loc_42161
mov rax, [r14+38h]
mov [rsp+68h+var_40], rax
mov r12, [rbx+10h]
mov rax, [rbx+38h]
mov [rsp+68h+var_60], rax
movsxd rbp, dword ptr [rdi]
movsxd rax, dword ptr [rdi+4]
mov [rsp+68h+var_58], rax
mov rdi, r14
call _ggml_nrows
mov [rsp+68h+var_38], rax
cmp rax, rbp
jle loc_42135
mov ecx, [rbx+54h]
mov rdx, [rbx+0F8h]
mov rax, [r14+0F8h]
mov [rsp+68h+var_50], rax
lea rdi, [r12+7]
and rdi, 0FFFFFFFFFFFFFFF8h
lea rax, [r12-1]
vpbroadcastq ymm0, rax
mov rax, [rsp+68h+var_60]
mov r8, rax
imul r8, rbp
mov [rsp+68h+var_48], rdx
add r8, rdx
imul rax, [rsp+68h+var_58]
vpmovsxbq ymm1, cs:dword_48080
vpmovsxbq ymm2, cs:dword_48084
vpmovsxbd ymm3, cs:qword_48F20
vpbroadcastq ymm4, cs:qword_48F50
vpbroadcastd ymm5, dword ptr cs:xmmword_48DE0+4
loc_4204D:
test r12, r12
jle loc_42122
mov r10, rbp
imul r10, [rsp+68h+var_60]
add r10, [rsp+68h+var_48]
mov r11, rbp
imul r11, [rsp+68h+var_40]
add r11, [rsp+68h+var_50]
xor edx, edx
vmovdqa ymm6, ymm2
vmovdqa ymm7, ymm1
vmovdqa ymm8, ymm3
loc_42080:
vpcmpleuq k0, ymm6, ymm0
vpcmpleuq k1, ymm7, ymm0
kshiftlb k1, k1, 4
korb k1, k0, k1
vmovdqu32 ymmword ptr [r8+rdx*4]{k1}, ymm8
add rdx, 8
vpaddq ymm6, ymm6, ymm4
vpaddq ymm7, ymm7, ymm4
vpaddd ymm8, ymm8, ymm5
cmp rdi, rdx
jnz short loc_42080
mov rbx, r12
mov r14, r8
xor edx, edx
loc_420BC:
mov rsi, rdx
inc rdx
cmp rdx, r12
jge short loc_42116
mov r13d, 1
loc_420CD:
cmp ecx, 1
jz short loc_420FE
test ecx, ecx
jnz short loc_420F4
movsxd r15, dword ptr [r10+rsi*4]
vmovss xmm6, dword ptr [r11+r15*4]
movsxd r9, dword ptr [r14+r13*4]
vucomiss xmm6, dword ptr [r11+r9*4]
jbe short loc_420F4
loc_420EC:
mov [r10+rsi*4], r9d
mov [r14+r13*4], r15d
loc_420F4:
inc r13
cmp rbx, r13
jnz short loc_420CD
jmp short loc_42116
loc_420FE:
movsxd r15, dword ptr [r10+rsi*4]
movsxd r9, dword ptr [r14+r13*4]
vmovss xmm6, dword ptr [r11+r9*4]
vucomiss xmm6, dword ptr [r11+r15*4]
ja short loc_420EC
jmp short loc_420F4
loc_42116:
add r14, 4
dec rbx
cmp rdx, r12
jnz short loc_420BC
loc_42122:
add rbp, [rsp+68h+var_58]
add r8, rax
cmp rbp, [rsp+68h+var_38]
jl loc_4204D
loc_42135:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
loc_42147:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aFatalError; "fatal error"
mov esi, 1AC3h
xor eax, eax
call _ggml_abort
loc_42161:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNb0SizeofFloat; "nb0 == sizeof(float)"
mov esi, 1A97h
xor eax, eax
call _ggml_abort
|
long long ggml_compute_forward_argsort(int *a1, long long a2)
{
long long v2; // r14
long long v3; // r12
long long v4; // rbp
long long result; // rax
int v6; // ecx
long long v15; // r10
long long v21; // rbx
long long v22; // r14
long long v23; // rdx
long long v24; // rsi
long long v25; // r13
long long v32; // [rsp+8h] [rbp-60h]
long long v33; // [rsp+10h] [rbp-58h]
long long v34; // [rsp+18h] [rbp-50h]
long long v35; // [rsp+20h] [rbp-48h]
long long v36; // [rsp+28h] [rbp-40h]
long long v37; // [rsp+30h] [rbp-38h]
v2 = *(_QWORD *)(a2 + 152);
if ( *(_DWORD *)v2 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
6851LL,
"fatal error");
goto LABEL_21;
}
if ( *(_QWORD *)(a2 + 48) != 4LL )
{
LABEL_21:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
6807LL,
"GGML_ASSERT(%s) failed",
"nb0 == sizeof(float)");
return ggml_compute_forward_flash_attn_ext();
}
v36 = *(_QWORD *)(v2 + 56);
v3 = *(_QWORD *)(a2 + 16);
v32 = *(_QWORD *)(a2 + 56);
v4 = *a1;
v33 = a1[1];
result = ggml_nrows(v2);
v37 = result;
if ( result > v4 )
{
v6 = *(_DWORD *)(a2 + 84);
v34 = *(_QWORD *)(v2 + 248);
_RAX = v3 - 1;
__asm { vpbroadcastq ymm0, rax }
v35 = *(_QWORD *)(a2 + 248);
_R8 = v35 + v4 * v32;
result = v33 * v32;
__asm
{
vpmovsxbq ymm1, cs:dword_48080
vpmovsxbq ymm2, cs:dword_48084
vpmovsxbd ymm3, cs:qword_48F20
vpbroadcastq ymm4, cs:qword_48F50
vpbroadcastd ymm5, dword ptr cs:xmmword_48DE0+4
}
do
{
if ( v3 > 0 )
{
v15 = v35 + v32 * v4;
_R11 = v34 + v36 * v4;
_RDX = 0LL;
__asm
{
vmovdqa ymm6, ymm2
vmovdqa ymm7, ymm1
vmovdqa ymm8, ymm3
}
do
{
__asm
{
vpcmpleuq k0, ymm6, ymm0
vpcmpleuq k1, ymm7, ymm0
kshiftlb k1, k1, 4
korb k1, k0, k1
vmovdqu32 ymmword ptr [r8+rdx*4]{k1}, ymm8
}
_RDX += 8LL;
__asm
{
vpaddq ymm6, ymm6, ymm4
vpaddq ymm7, ymm7, ymm4
vpaddd ymm8, ymm8, ymm5
}
}
while ( ((v3 + 7) & 0xFFFFFFFFFFFFFFF8LL) != _RDX );
v21 = v3;
v22 = _R8;
v23 = 0LL;
do
{
v24 = v23++;
if ( v23 < v3 )
{
v25 = 1LL;
do
{
if ( v6 == 1 )
{
_R15 = *(int *)(v15 + 4 * v24);
_R9 = *(int *)(v22 + 4 * v25);
__asm
{
vmovss xmm6, dword ptr [r11+r9*4]
vucomiss xmm6, dword ptr [r11+r15*4]
}
}
else if ( !v6 )
{
_R15 = *(int *)(v15 + 4 * v24);
__asm { vmovss xmm6, dword ptr [r11+r15*4] }
_R9 = *(int *)(v22 + 4 * v25);
__asm { vucomiss xmm6, dword ptr [r11+r9*4] }
}
++v25;
}
while ( v21 != v25 );
}
v22 += 4LL;
--v21;
}
while ( v23 != v3 );
}
v4 += v33;
_R8 += result;
}
while ( v4 < v37 );
}
__asm { vzeroupper }
return result;
}
|
ggml_compute_forward_argsort:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,qword ptr [RSI + 0x98]
CMP dword ptr [R14],0x0
JNZ 0x00142147
MOV RBX,RSI
CMP qword ptr [RSI + 0x30],0x4
JNZ 0x00142161
MOV RAX,qword ptr [R14 + 0x38]
MOV qword ptr [RSP + 0x28],RAX
MOV R12,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RBP,dword ptr [RDI]
MOVSXD RAX,dword ptr [RDI + 0x4]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,R14
CALL 0x0010aa40
MOV qword ptr [RSP + 0x30],RAX
CMP RAX,RBP
JLE 0x00142135
MOV ECX,dword ptr [RBX + 0x54]
MOV RDX,qword ptr [RBX + 0xf8]
MOV RAX,qword ptr [R14 + 0xf8]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[R12 + 0x7]
AND RDI,-0x8
LEA RAX,[R12 + -0x1]
VPBROADCASTQ YMM0
MOV RAX,qword ptr [RSP + 0x8]
MOV R8,RAX
IMUL R8,RBP
MOV qword ptr [RSP + 0x20],RDX
ADD R8,RDX
IMUL RAX,qword ptr [RSP + 0x10]
VPMOVSXBQ YMM1,dword ptr [0x00148080]
VPMOVSXBQ YMM2,dword ptr [0x00148084]
VPMOVSXBD YMM3,qword ptr [0x00148f20]
VPBROADCASTQ YMM4,qword ptr [0x00148f50]
VPBROADCASTD YMM5,dword ptr [0x00148de4]
LAB_0014204d:
TEST R12,R12
JLE 0x00142122
MOV R10,RBP
IMUL R10,qword ptr [RSP + 0x8]
ADD R10,qword ptr [RSP + 0x20]
MOV R11,RBP
IMUL R11,qword ptr [RSP + 0x28]
ADD R11,qword ptr [RSP + 0x18]
XOR EDX,EDX
VMOVDQA YMM6,YMM2
VMOVDQA YMM7,YMM1
VMOVDQA YMM8,YMM3
VPCMPUQ K0 {K0},YMM6,YMM0,0x2
VPCMPUQ K1 {K0},YMM7,YMM0,0x2
KSHIFTLB K1,K1,0x4
LAB_00142122:
ADD RBP,qword ptr [RSP + 0x10]
ADD R8,RAX
CMP RBP,qword ptr [RSP + 0x30]
JL 0x0014204d
LAB_00142135:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
LAB_00142147:
LEA RDI,[0x152aa0]
LEA RDX,[0x148680]
MOV ESI,0x1ac3
XOR EAX,EAX
CALL 0x0010af40
LAB_00142161:
LEA RDI,[0x152aa0]
LEA RDX,[0x14856a]
LEA RCX,[0x1489a6]
MOV ESI,0x1a97
XOR EAX,EAX
CALL 0x0010af40
|
/* WARNING: Control flow encountered bad instruction data */
long ggml_compute_forward_argsort(int *param_1,long param_2)
{
int1 auVar1 [16];
int iVar2;
long lVar3;
long lVar4;
int1 auVar5 [32];
int1 auVar6 [32];
long lVar7;
long lVar8;
long lVar9;
int1 auVar10 [32];
if (**(int **)(param_2 + 0x98) != 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp"
,0x1ac3,"fatal error");
}
if (*(long *)(param_2 + 0x30) == 4) {
lVar3 = *(long *)(param_2 + 0x10);
lVar4 = *(long *)(param_2 + 0x38);
lVar9 = (long)*param_1;
iVar2 = param_1[1];
lVar7 = ggml_nrows(*(int **)(param_2 + 0x98));
lVar8 = lVar7;
if (lVar9 < lVar7) {
auVar10 = vpbroadcastq_avx512vl();
lVar8 = lVar4 * iVar2;
auVar5 = vpmovsxbq_avx2(ZEXT416(DAT_00148080));
auVar6 = vpmovsxbq_avx2(ZEXT416(DAT_00148084));
auVar1._8_8_ = 0;
auVar1._0_8_ = DAT_00148f20;
vpmovsxbd_avx2(auVar1);
do {
if (0 < lVar3) {
vpcmpuq_avx512vl(auVar6,auVar10,2);
vpcmpuq_avx512vl(auVar5,auVar10,2);
/* WARNING: Bad instruction - Truncating control flow here */
halt_baddata();
}
lVar9 = lVar9 + iVar2;
} while (lVar9 < lVar7);
}
return lVar8;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ops.cpp",
0x1a97,"GGML_ASSERT(%s) failed","nb0 == sizeof(float)");
}
|
|
9,513 |
my_lock
|
eloqsql/mysys/my_lock.c
|
int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
myf MyFlags)
{
#ifdef HAVE_FCNTL
int value;
ALARM_VARIABLES;
#endif
DBUG_ENTER("my_lock");
DBUG_PRINT("my",("fd: %d Op: %d start: %ld Length: %ld MyFlags: %lu",
fd,locktype,(long) start,(long) length,MyFlags));
if (my_disable_locking && ! (MyFlags & MY_FORCE_LOCK))
DBUG_RETURN(0);
#if defined(_WIN32)
{
int timeout_sec;
if (MyFlags & MY_NO_WAIT)
timeout_sec= 0;
else
timeout_sec= WIN_LOCK_INFINITE;
if (win_lock(fd, locktype, start, length, timeout_sec) == 0)
DBUG_RETURN(0);
}
#else
#if defined(HAVE_FCNTL)
{
struct flock lock;
lock.l_type= (short) locktype;
lock.l_whence= SEEK_SET;
lock.l_start= (off_t) start;
lock.l_len= (off_t) length;
if (MyFlags & (MY_NO_WAIT | MY_SHORT_WAIT))
{
if (fcntl(fd,F_SETLK,&lock) != -1) /* Check if we can lock */
DBUG_RETURN(0); /* Ok, file locked */
if (MyFlags & MY_NO_WAIT)
{
my_errno= (errno == EACCES) ? EAGAIN : errno ? errno : -1;
DBUG_RETURN(-1);
}
DBUG_PRINT("info",("Was locked, trying with alarm"));
ALARM_INIT;
while ((value=fcntl(fd,F_SETLKW,&lock)) && ! ALARM_TEST &&
errno == EINTR)
{ /* Setup again so we don`t miss it */
ALARM_REINIT;
}
ALARM_END;
if (value != -1)
DBUG_RETURN(0);
if (errno == EINTR)
errno=EAGAIN;
}
else if (fcntl(fd,F_SETLKW,&lock) != -1) /* Wait until a lock */
DBUG_RETURN(0);
}
#else
if (MyFlags & MY_SEEK_NOT_DONE)
{
if (my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE))
== MY_FILEPOS_ERROR)
{
/*
If an error has occurred in my_seek then we will already
have an error code in my_errno; Just return error code.
*/
DBUG_RETURN(-1);
}
}
if (lockf(fd,locktype,length) != -1)
DBUG_RETURN(0);
#endif /* HAVE_FCNTL */
#endif /* _WIN32 */
/* We got an error. We don't want EACCES errors */
my_errno=(errno == EACCES) ? EAGAIN : errno ? errno : -1;
if (MyFlags & MY_WME)
{
if (locktype == F_UNLCK)
my_error(EE_CANTUNLOCK,MYF(ME_BELL),my_errno);
else
my_error(EE_CANTLOCK,MYF(ME_BELL),my_errno);
}
DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno));
DBUG_RETURN(-1);
}
|
O0
|
c
|
my_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0xf4e8e
leaq 0xb90473(%rip), %rax # 0xc85308
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xf4ebb
movq -0x28(%rbp), %rax
andq $0x80, %rax
cmpq $0x0, %rax
jne 0xf4ebb
jmp 0xf4eaf
movl $0x0, -0x4(%rbp)
jmp 0xf5126
movl -0xc(%rbp), %eax
movw %ax, -0x58(%rbp)
movw $0x0, -0x56(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
andq $0x140, %rax # imm = 0x140
cmpq $0x0, %rax
je 0xf505f
movl -0x8(%rbp), %edi
movl $0x6, %esi
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x29130
cmpl $-0x1, %eax
je 0xf4f12
jmp 0xf4f06
movl $0x0, -0x4(%rbp)
jmp 0xf5126
movq -0x28(%rbp), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0xf4f78
callq 0x296d0
cmpl $0xd, (%rax)
jne 0xf4f36
movl $0xb, %eax
movl %eax, -0x5c(%rbp)
jmp 0xf4f5c
callq 0x296d0
cmpl $0x0, (%rax)
je 0xf4f4c
callq 0x296d0
movl (%rax), %eax
movl %eax, -0x60(%rbp)
jmp 0xf4f56
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x60(%rbp)
jmp 0xf4f56
movl -0x60(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0xf7b30
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf5126
jmp 0xf4f7a
jmp 0xf4f7c
leaq 0xb90375(%rip), %rax # 0xc852f8
movl $0x0, (%rax)
leaq 0x1cbba8(%rip), %rax # 0x2c0b38
movq (%rax), %rax
movl %eax, %edi
callq 0x29210
movl %eax, -0x30(%rbp)
movl $0xe, %edi
leaq 0xec87(%rip), %rsi # 0x103c30
callq 0x292c0
movq %rax, -0x38(%rbp)
movl -0x8(%rbp), %edi
movl $0x7, %esi
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x29130
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x65(%rbp)
je 0xf4ff5
leaq 0xb9031d(%rip), %rax # 0xc852f8
movl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x65(%rbp)
jne 0xf4ff5
callq 0x296d0
cmpl $0x4, (%rax)
sete %al
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
testb $0x1, %al
jne 0xf4ffe
jmp 0xf501e
leaq 0x1cbb33(%rip), %rax # 0x2c0b38
movq (%rax), %rax
movl %eax, %edi
callq 0x29210
leaq 0xb902e2(%rip), %rax # 0xc852f8
movl $0x0, (%rax)
jmp 0xf4fb2
movq -0x38(%rbp), %rsi
movl $0xe, %edi
callq 0x292c0
movl -0x30(%rbp), %edi
callq 0x29210
cmpl $-0x1, -0x2c(%rbp)
je 0xf5048
jmp 0xf503c
movl $0x0, -0x4(%rbp)
jmp 0xf5126
callq 0x296d0
cmpl $0x4, (%rax)
jne 0xf505d
callq 0x296d0
movl $0xb, (%rax)
jmp 0xf5087
movl -0x8(%rbp), %edi
movl $0x7, %esi
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x29130
cmpl $-0x1, %eax
je 0xf5085
jmp 0xf5079
movl $0x0, -0x4(%rbp)
jmp 0xf5126
jmp 0xf5087
callq 0x296d0
cmpl $0xd, (%rax)
jne 0xf509b
movl $0xb, %eax
movl %eax, -0x6c(%rbp)
jmp 0xf50c1
callq 0x296d0
cmpl $0x0, (%rax)
je 0xf50b1
callq 0x296d0
movl (%rax), %eax
movl %eax, -0x70(%rbp)
jmp 0xf50bb
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x70(%rbp)
jmp 0xf50bb
movl -0x70(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x74(%rbp)
callq 0xf7b30
movl -0x74(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xf5119
cmpl $0x2, -0xc(%rbp)
jne 0xf50ff
callq 0xf7b30
movl (%rax), %edx
movl $0xb, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xf14a0
jmp 0xf5117
callq 0xf7b30
movl (%rax), %edx
movl $0xa, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xf14a0
jmp 0xf5119
jmp 0xf511b
jmp 0xf511d
jmp 0xf511f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
my_lock:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], edi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], 0
mov [rbp+var_38], 0
jmp short $+2
loc_F4E8E:
lea rax, my_disable_locking
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_F4EBB
mov rax, [rbp+var_28]
and rax, 80h
cmp rax, 0
jnz short loc_F4EBB
jmp short $+2
loc_F4EAF:
mov [rbp+var_4], 0
jmp loc_F5126
loc_F4EBB:
mov eax, [rbp+var_C]
mov [rbp+var_58], ax
mov [rbp+var_56], 0
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
and rax, 140h
cmp rax, 0
jz loc_F505F
mov edi, [rbp+var_8]
mov esi, 6
lea rdx, [rbp+var_58]
mov al, 0
call _fcntl64
cmp eax, 0FFFFFFFFh
jz short loc_F4F12
jmp short $+2
loc_F4F06:
mov [rbp+var_4], 0
jmp loc_F5126
loc_F4F12:
mov rax, [rbp+var_28]
and rax, 100h
cmp rax, 0
jz short loc_F4F78
call ___errno_location
cmp dword ptr [rax], 0Dh
jnz short loc_F4F36
mov eax, 0Bh
mov [rbp+var_5C], eax
jmp short loc_F4F5C
loc_F4F36:
call ___errno_location
cmp dword ptr [rax], 0
jz short loc_F4F4C
call ___errno_location
mov eax, [rax]
mov [rbp+var_60], eax
jmp short loc_F4F56
loc_F4F4C:
mov eax, 0FFFFFFFFh
mov [rbp+var_60], eax
jmp short $+2
loc_F4F56:
mov eax, [rbp+var_60]
mov [rbp+var_5C], eax
loc_F4F5C:
mov eax, [rbp+var_5C]
mov [rbp+var_64], eax
call _my_thread_var
mov ecx, [rbp+var_64]
mov [rax], ecx
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_F5126
loc_F4F78:
jmp short $+2
loc_F4F7A:
jmp short $+2
loc_F4F7C:
lea rax, my_have_got_alarm
mov dword ptr [rax], 0
lea rax, my_time_to_wait_for_lock
mov rax, [rax]
mov edi, eax
call _alarm
mov [rbp+var_30], eax
mov edi, 0Eh
lea rsi, my_set_alarm_variable
call _signal
mov [rbp+var_38], rax
loc_F4FB2:
mov edi, [rbp+var_8]
mov esi, 7
lea rdx, [rbp+var_58]
mov al, 0
call _fcntl64
mov ecx, eax
mov [rbp+var_2C], ecx
xor eax, eax
cmp ecx, 0
mov [rbp+var_65], al
jz short loc_F4FF5
lea rax, my_have_got_alarm
mov ecx, [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_65], al
jnz short loc_F4FF5
call ___errno_location
cmp dword ptr [rax], 4
setz al
mov [rbp+var_65], al
loc_F4FF5:
mov al, [rbp+var_65]
test al, 1
jnz short loc_F4FFE
jmp short loc_F501E
loc_F4FFE:
lea rax, my_time_to_wait_for_lock
mov rax, [rax]
mov edi, eax
call _alarm
lea rax, my_have_got_alarm
mov dword ptr [rax], 0
jmp short loc_F4FB2
loc_F501E:
mov rsi, [rbp+var_38]
mov edi, 0Eh
call _signal
mov edi, [rbp+var_30]
call _alarm
cmp [rbp+var_2C], 0FFFFFFFFh
jz short loc_F5048
jmp short $+2
loc_F503C:
mov [rbp+var_4], 0
jmp loc_F5126
loc_F5048:
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_F505D
call ___errno_location
mov dword ptr [rax], 0Bh
loc_F505D:
jmp short loc_F5087
loc_F505F:
mov edi, [rbp+var_8]
mov esi, 7
lea rdx, [rbp+var_58]
mov al, 0
call _fcntl64
cmp eax, 0FFFFFFFFh
jz short loc_F5085
jmp short $+2
loc_F5079:
mov [rbp+var_4], 0
jmp loc_F5126
loc_F5085:
jmp short $+2
loc_F5087:
call ___errno_location
cmp dword ptr [rax], 0Dh
jnz short loc_F509B
mov eax, 0Bh
mov [rbp+var_6C], eax
jmp short loc_F50C1
loc_F509B:
call ___errno_location
cmp dword ptr [rax], 0
jz short loc_F50B1
call ___errno_location
mov eax, [rax]
mov [rbp+var_70], eax
jmp short loc_F50BB
loc_F50B1:
mov eax, 0FFFFFFFFh
mov [rbp+var_70], eax
jmp short $+2
loc_F50BB:
mov eax, [rbp+var_70]
mov [rbp+var_6C], eax
loc_F50C1:
mov eax, [rbp+var_6C]
mov [rbp+var_74], eax
call _my_thread_var
mov ecx, [rbp+var_74]
mov [rax], ecx
mov rax, [rbp+var_28]
and rax, 10h
cmp rax, 0
jz short loc_F5119
cmp [rbp+var_C], 2
jnz short loc_F50FF
call _my_thread_var
mov edx, [rax]
mov edi, 0Bh
mov esi, 4
mov al, 0
call my_error
jmp short loc_F5117
loc_F50FF:
call _my_thread_var
mov edx, [rax]
mov edi, 0Ah
mov esi, 4
mov al, 0
call my_error
loc_F5117:
jmp short $+2
loc_F5119:
jmp short $+2
loc_F511B:
jmp short $+2
loc_F511D:
jmp short $+2
loc_F511F:
mov [rbp+var_4], 0FFFFFFFFh
loc_F5126:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long my_lock(unsigned int a1, int a2, long long a3, long long a4, long long a5)
{
long long v5; // rdi
const char *v6; // rsi
long long v7; // rdi
unsigned int *v8; // rax
unsigned int *v9; // rax
int v11; // [rsp+10h] [rbp-70h]
int v12; // [rsp+14h] [rbp-6Ch]
bool v13; // [rsp+1Bh] [rbp-65h]
int v14; // [rsp+20h] [rbp-60h]
int v15; // [rsp+24h] [rbp-5Ch]
_WORD v16[4]; // [rsp+28h] [rbp-58h] BYREF
long long v17; // [rsp+30h] [rbp-50h]
long long v18; // [rsp+38h] [rbp-48h]
long long v19; // [rsp+48h] [rbp-38h]
unsigned int v20; // [rsp+50h] [rbp-30h]
int v21; // [rsp+54h] [rbp-2Ch]
long long v22; // [rsp+58h] [rbp-28h]
long long v23; // [rsp+60h] [rbp-20h]
long long v24; // [rsp+68h] [rbp-18h]
int v25; // [rsp+74h] [rbp-Ch]
unsigned int v26; // [rsp+78h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v22 = a5;
v20 = 0;
v19 = 0LL;
if ( my_disable_locking && (v22 & 0x80) == 0 )
return 0;
v16[0] = v25;
v16[1] = 0;
v17 = v24;
v18 = v23;
if ( (v22 & 0x140) != 0 )
{
v5 = v26;
if ( (unsigned int)fcntl64(v26, 6LL, v16) != -1 )
return 0;
if ( (v22 & 0x100) != 0 )
{
if ( *(_DWORD *)__errno_location() == 13 )
{
v15 = 11;
}
else
{
if ( *(_DWORD *)__errno_location() )
v14 = *(_DWORD *)__errno_location();
else
v14 = -1;
v15 = v14;
}
*(_DWORD *)my_thread_var(v5, &byte_6) = v15;
return (unsigned int)-1;
}
my_have_got_alarm = 0;
v20 = alarm((unsigned int)my_time_to_wait_for_lock);
v19 = signal(14LL, my_set_alarm_variable);
while ( 1 )
{
v21 = fcntl64(v26, 7LL, v16);
v13 = 0;
if ( v21 )
{
v13 = 0;
if ( !my_have_got_alarm )
v13 = *(_DWORD *)__errno_location() == 4;
}
if ( !v13 )
break;
alarm((unsigned int)my_time_to_wait_for_lock);
my_have_got_alarm = 0;
}
v6 = (const char *)v19;
signal(14LL, v19);
v7 = v20;
alarm(v20);
if ( v21 != -1 )
return 0;
if ( *(_DWORD *)__errno_location() == 4 )
*(_DWORD *)__errno_location() = 11;
}
else
{
v7 = v26;
v6 = &byte_7;
if ( (unsigned int)fcntl64(v26, 7LL, v16) != -1 )
return 0;
}
if ( *(_DWORD *)__errno_location() == 13 )
{
v12 = 11;
}
else
{
if ( *(_DWORD *)__errno_location() )
v11 = *(_DWORD *)__errno_location();
else
v11 = -1;
v12 = v11;
}
*(_DWORD *)my_thread_var(v7, v6) = v12;
if ( (v22 & 0x10) != 0 )
{
if ( v25 == 2 )
{
v8 = (unsigned int *)my_thread_var(v7, v6);
my_error(0xBu, 4LL, *v8);
}
else
{
v9 = (unsigned int *)my_thread_var(v7, v6);
my_error(0xAu, 4LL, *v9);
}
}
return (unsigned int)-1;
}
|
my_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x38],0x0
JMP 0x001f4e8e
LAB_001f4e8e:
LEA RAX,[0xd85308]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001f4ebb
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x80
CMP RAX,0x0
JNZ 0x001f4ebb
JMP 0x001f4eaf
LAB_001f4eaf:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001f5126
LAB_001f4ebb:
MOV EAX,dword ptr [RBP + -0xc]
MOV word ptr [RBP + -0x58],AX
MOV word ptr [RBP + -0x56],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x140
CMP RAX,0x0
JZ 0x001f505f
MOV EDI,dword ptr [RBP + -0x8]
MOV ESI,0x6
LEA RDX,[RBP + -0x58]
MOV AL,0x0
CALL 0x00129130
CMP EAX,-0x1
JZ 0x001f4f12
JMP 0x001f4f06
LAB_001f4f06:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001f5126
LAB_001f4f12:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x100
CMP RAX,0x0
JZ 0x001f4f78
CALL 0x001296d0
CMP dword ptr [RAX],0xd
JNZ 0x001f4f36
MOV EAX,0xb
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x001f4f5c
LAB_001f4f36:
CALL 0x001296d0
CMP dword ptr [RAX],0x0
JZ 0x001f4f4c
CALL 0x001296d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x60],EAX
JMP 0x001f4f56
LAB_001f4f4c:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x60],EAX
JMP 0x001f4f56
LAB_001f4f56:
MOV EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x5c],EAX
LAB_001f4f5c:
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x64],EAX
CALL 0x001f7b30
MOV ECX,dword ptr [RBP + -0x64]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001f5126
LAB_001f4f78:
JMP 0x001f4f7a
LAB_001f4f7a:
JMP 0x001f4f7c
LAB_001f4f7c:
LEA RAX,[0xd852f8]
MOV dword ptr [RAX],0x0
LEA RAX,[0x3c0b38]
MOV RAX,qword ptr [RAX]
MOV EDI,EAX
CALL 0x00129210
MOV dword ptr [RBP + -0x30],EAX
MOV EDI,0xe
LEA RSI,[0x203c30]
CALL 0x001292c0
MOV qword ptr [RBP + -0x38],RAX
LAB_001f4fb2:
MOV EDI,dword ptr [RBP + -0x8]
MOV ESI,0x7
LEA RDX,[RBP + -0x58]
MOV AL,0x0
CALL 0x00129130
MOV ECX,EAX
MOV dword ptr [RBP + -0x2c],ECX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x65],AL
JZ 0x001f4ff5
LEA RAX,[0xd852f8]
MOV ECX,dword ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x65],AL
JNZ 0x001f4ff5
CALL 0x001296d0
CMP dword ptr [RAX],0x4
SETZ AL
MOV byte ptr [RBP + -0x65],AL
LAB_001f4ff5:
MOV AL,byte ptr [RBP + -0x65]
TEST AL,0x1
JNZ 0x001f4ffe
JMP 0x001f501e
LAB_001f4ffe:
LEA RAX,[0x3c0b38]
MOV RAX,qword ptr [RAX]
MOV EDI,EAX
CALL 0x00129210
LEA RAX,[0xd852f8]
MOV dword ptr [RAX],0x0
JMP 0x001f4fb2
LAB_001f501e:
MOV RSI,qword ptr [RBP + -0x38]
MOV EDI,0xe
CALL 0x001292c0
MOV EDI,dword ptr [RBP + -0x30]
CALL 0x00129210
CMP dword ptr [RBP + -0x2c],-0x1
JZ 0x001f5048
JMP 0x001f503c
LAB_001f503c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001f5126
LAB_001f5048:
CALL 0x001296d0
CMP dword ptr [RAX],0x4
JNZ 0x001f505d
CALL 0x001296d0
MOV dword ptr [RAX],0xb
LAB_001f505d:
JMP 0x001f5087
LAB_001f505f:
MOV EDI,dword ptr [RBP + -0x8]
MOV ESI,0x7
LEA RDX,[RBP + -0x58]
MOV AL,0x0
CALL 0x00129130
CMP EAX,-0x1
JZ 0x001f5085
JMP 0x001f5079
LAB_001f5079:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001f5126
LAB_001f5085:
JMP 0x001f5087
LAB_001f5087:
CALL 0x001296d0
CMP dword ptr [RAX],0xd
JNZ 0x001f509b
MOV EAX,0xb
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001f50c1
LAB_001f509b:
CALL 0x001296d0
CMP dword ptr [RAX],0x0
JZ 0x001f50b1
CALL 0x001296d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x70],EAX
JMP 0x001f50bb
LAB_001f50b1:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x70],EAX
JMP 0x001f50bb
LAB_001f50bb:
MOV EAX,dword ptr [RBP + -0x70]
MOV dword ptr [RBP + -0x6c],EAX
LAB_001f50c1:
MOV EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x74],EAX
CALL 0x001f7b30
MOV ECX,dword ptr [RBP + -0x74]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001f5119
CMP dword ptr [RBP + -0xc],0x2
JNZ 0x001f50ff
CALL 0x001f7b30
MOV EDX,dword ptr [RAX]
MOV EDI,0xb
MOV ESI,0x4
MOV AL,0x0
CALL 0x001f14a0
JMP 0x001f5117
LAB_001f50ff:
CALL 0x001f7b30
MOV EDX,dword ptr [RAX]
MOV EDI,0xa
MOV ESI,0x4
MOV AL,0x0
CALL 0x001f14a0
LAB_001f5117:
JMP 0x001f5119
LAB_001f5119:
JMP 0x001f511b
LAB_001f511b:
JMP 0x001f511d
LAB_001f511d:
JMP 0x001f511f
LAB_001f511f:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001f5126:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
my_lock(int4 param_1,int param_2,int8 param_3,int8 param_4,ulong param_5)
{
int iVar1;
int *piVar2;
int4 *puVar3;
bool bVar4;
int local_78;
int local_74;
int local_68;
int local_64;
int2 local_60;
int2 local_5e;
int8 local_58;
int8 local_50;
__sighandler_t local_40;
uint local_38;
int local_34;
ulong local_30;
int8 local_28;
int8 local_20;
int local_14;
int4 local_10;
local_38 = 0;
local_40 = (__sighandler_t)0x0;
if ((my_disable_locking != '\0') && ((param_5 & 0x80) == 0)) {
return 0;
}
local_60 = (int2)param_2;
local_5e = 0;
local_58 = param_3;
local_50 = param_4;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
if ((param_5 & 0x140) == 0) {
iVar1 = fcntl64(param_1,7,&local_60);
if (iVar1 != -1) {
return 0;
}
}
else {
iVar1 = fcntl64(param_1,6,&local_60);
if (iVar1 != -1) {
return 0;
}
if ((local_30 & 0x100) != 0) {
piVar2 = __errno_location();
if (*piVar2 == 0xd) {
local_64 = 0xb;
}
else {
piVar2 = __errno_location();
if (*piVar2 == 0) {
local_68 = -1;
}
else {
piVar2 = __errno_location();
local_68 = *piVar2;
}
local_64 = local_68;
}
piVar2 = (int *)_my_thread_var();
*piVar2 = local_64;
return 0xffffffff;
}
my_have_got_alarm = 0;
local_38 = alarm((uint)my_time_to_wait_for_lock);
local_40 = signal(0xe,my_set_alarm_variable);
while( true ) {
local_34 = fcntl64(local_10,7,&local_60);
bVar4 = false;
if ((local_34 != 0) && (bVar4 = false, my_have_got_alarm == 0)) {
piVar2 = __errno_location();
bVar4 = *piVar2 == 4;
}
if (!bVar4) break;
alarm((uint)my_time_to_wait_for_lock);
my_have_got_alarm = 0;
}
signal(0xe,local_40);
alarm(local_38);
if (local_34 != -1) {
return 0;
}
piVar2 = __errno_location();
if (*piVar2 == 4) {
piVar2 = __errno_location();
*piVar2 = 0xb;
}
}
piVar2 = __errno_location();
if (*piVar2 == 0xd) {
local_74 = 0xb;
}
else {
piVar2 = __errno_location();
if (*piVar2 == 0) {
local_78 = -1;
}
else {
piVar2 = __errno_location();
local_78 = *piVar2;
}
local_74 = local_78;
}
piVar2 = (int *)_my_thread_var();
*piVar2 = local_74;
if ((local_30 & 0x10) != 0) {
if (local_14 == 2) {
puVar3 = (int4 *)_my_thread_var();
my_error(0xb,4,*puVar3);
}
else {
puVar3 = (int4 *)_my_thread_var();
my_error(10,4,*puVar3);
}
}
return 0xffffffff;
}
|
|
9,514 |
get_internal_charset
|
eloqsql/mysys/charset.c
|
static CHARSET_INFO *
get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)
{
char buf[FN_REFLEN];
struct charset_info_st *cs;
DBUG_ASSERT(cs_number < array_elements(all_charsets));
if ((cs= (struct charset_info_st*) all_charsets[cs_number]))
{
if (cs->state & MY_CS_READY) /* if CS is already initialized */
{
my_collation_statistics_inc_use_count(cs_number);
return cs;
}
/*
To make things thread safe we are not allowing other threads to interfere
while we may changing the cs_info_table
*/
mysql_mutex_lock(&THR_LOCK_charset);
if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */
{
MY_CHARSET_LOADER loader;
strxmov(get_charsets_dir(buf), cs->cs_name.str, ".xml", NullS);
my_charset_loader_init_mysys(&loader);
my_read_charset_file(&loader, buf, flags);
}
if (cs->state & MY_CS_AVAILABLE)
{
if (!(cs->state & MY_CS_READY))
{
if (!simple_8bit_charset_data_is_full(cs))
{
CHARSET_INFO *refcs= find_charset_data_inheritance_source(cs);
if (refcs)
inherit_charset_data(cs, refcs);
}
if (!simple_8bit_collation_data_is_full(cs))
{
CHARSET_INFO *refcl= find_collation_data_inheritance_source(cs, flags);
if (refcl)
inherit_collation_data(cs, refcl);
}
if (my_ci_init_charset(cs, loader) ||
my_ci_init_collation(cs, loader))
{
cs= NULL;
}
else
cs->state|= MY_CS_READY;
}
my_collation_statistics_inc_use_count(cs_number);
}
else
cs= NULL;
mysql_mutex_unlock(&THR_LOCK_charset);
}
return cs;
}
|
O3
|
c
|
get_internal_charset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl %esi, %r13d
leaq 0xb6cd4b(%rip), %r12 # 0xc02810
movq (%r12,%r13,8), %rbx
testq %rbx, %rbx
je 0x95bae
testb $0x1, 0xd(%rbx)
jne 0x95bb5
movq %rdx, %r15
movq %rdi, %r14
leaq 0xb75b47(%rip), %rax # 0xc0b630
cmpq $0x0, 0x40(%rax)
jne 0x95d97
leaq 0xb75b35(%rip), %rdi # 0xc0b630
callq 0x291d0
movl 0xc(%rbx), %eax
testb $0x9, %al
jne 0x95ba1
leaq -0x230(%rbp), %rdi
callq 0x953cb
movq 0x10(%rbx), %rsi
leaq 0x485aa(%rip), %rdx # 0xde0cc
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xda018
leaq -0x2e0(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0xd01(%rip), %rax # 0x94e3e
movq %rax, 0x80(%rdi)
leaq -0xd00(%rip), %rax # 0x94e4d
movq %rax, 0x88(%rdi)
leaq -0xcf3(%rip), %rax # 0x94e68
movq %rax, 0x90(%rdi)
leaq 0xd335(%rip), %rax # 0xa2e9e
movq %rax, 0x98(%rdi)
leaq 0x2f2bc1(%rip), %rax # 0x388738
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0xd02(%rip), %rax # 0x94e86
movq %rax, 0xa8(%rdi)
leaq -0x230(%rbp), %rsi
movq %r15, %rdx
callq 0x96774
movl 0xc(%rbx), %eax
btl $0x9, %eax
jb 0x95bc5
xorl %ebx, %ebx
jmp 0x95d57
xorl %ebx, %ebx
jmp 0x95d73
leaq 0xb70cc4(%rip), %rax # 0xc06880
incq (%rax,%r13,8)
jmp 0x95d73
btl $0x8, %eax
jb 0x95d4c
cmpq $0x0, 0x40(%rbx)
je 0x95beb
cmpq $0x0, 0x50(%rbx)
je 0x95beb
cmpq $0x0, 0x48(%rbx)
je 0x95beb
cmpq $0x0, 0x68(%rbx)
jne 0x95c1a
movq 0x10(%rbx), %rdi
movl $0x20, %esi
callq 0x9587c
testl %eax, %eax
je 0x95c1a
cmpl %eax, (%rbx)
je 0x95c1a
movl %eax, %eax
movq (%r12,%rax,8), %rsi
testq %rsi, %rsi
je 0x95c1a
testb $0x2, 0xd(%rsi)
je 0x95c1a
movq %rbx, %rdi
callq 0x969bd
cmpq $0x0, 0x58(%rbx)
jne 0x95d0e
testb $0x10, 0xc(%rbx)
jne 0x95d0e
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x95d0e
leaq 0x4850f(%rip), %rsi # 0xde152
movl $0x8, %edx
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rdi
callq 0x29190
movq -0x2e8(%rbp), %rcx
testl %eax, %eax
jne 0x95d0e
leaq 0x8(%rcx), %rdi
movq %rdi, -0x2f0(%rbp)
movl $0x5d, %esi
callq 0x293e0
testq %rax, %rax
setne %dl
movq -0x2e8(%rbp), %rcx
addq $0x28, %rcx
cmpq %rax, %rcx
seta %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x95d0e
movq -0x2f0(%rbp), %rsi
subq %rsi, %rax
leaq -0x2e0(%rbp), %rdi
movl $0x21, %ecx
movq %rax, %rdx
movq %rax, -0x2e8(%rbp)
callq 0x293c0
movq -0x2e8(%rbp), %rax
movb $0x0, -0x2e0(%rbp,%rax)
leaq -0x2e0(%rbp), %rdi
movq %r15, %rsi
callq 0x9555f
testl %eax, %eax
je 0x95d0e
cmpl %eax, (%rbx)
je 0x95d0e
movl %eax, %eax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0x95d0e
testb $0x2, 0xd(%rax)
je 0x95d0e
cmpq $0x0, 0x58(%rbx)
jne 0x95d0e
testb $0x10, 0xc(%rbx)
jne 0x95d0e
movq 0x58(%rax), %rax
movq %rax, 0x58(%rbx)
movq 0xb8(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x95d29
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testb %al, %al
jne 0x95d44
movq 0xc0(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x95d48
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testb %al, %al
je 0x95d48
xorl %ebx, %ebx
jmp 0x95d4c
orb $0x1, 0xd(%rbx)
leaq 0xb70b2d(%rip), %rax # 0xc06880
incq (%rax,%r13,8)
leaq 0xb758d2(%rip), %rax # 0xc0b630
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0x95da1
leaq 0xb758c2(%rip), %rdi # 0xc0b630
callq 0x291a0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x95db3
movq %rbx, %rax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2eb23
jmp 0x95b00
leaq 0x2f32a8(%rip), %rax # 0x389050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x95d67
callq 0x29220
|
get_internal_charset:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2C8h
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13d, esi
lea r12, all_charsets
mov rbx, [r12+r13*8]
test rbx, rbx
jz loc_95BAE
test byte ptr [rbx+0Dh], 1
jnz loc_95BB5
mov r15, rdx
mov r14, rdi
lea rax, THR_LOCK_charset
cmp qword ptr [rax+40h], 0
jnz loc_95D97
lea rdi, THR_LOCK_charset
call _pthread_mutex_lock
loc_95B00:
mov eax, [rbx+0Ch]
test al, 9
jnz loc_95BA1
lea rdi, [rbp+var_230]
call get_charsets_dir
mov rsi, [rbx+10h]
lea rdx, aIndexXml+5; ".xml"
mov rdi, rax
xor ecx, ecx
xor eax, eax
call strxmov
lea rdi, [rbp+var_2E0]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
lea rsi, [rbp+var_230]
mov rdx, r15
call my_read_charset_file
mov eax, [rbx+0Ch]
loc_95BA1:
bt eax, 9
jb short loc_95BC5
xor ebx, ebx
jmp loc_95D57
loc_95BAE:
xor ebx, ebx
jmp loc_95D73
loc_95BB5:
lea rax, my_collation_statistics
inc qword ptr [rax+r13*8]
jmp loc_95D73
loc_95BC5:
bt eax, 8
jb loc_95D4C
cmp qword ptr [rbx+40h], 0
jz short loc_95BEB
cmp qword ptr [rbx+50h], 0
jz short loc_95BEB
cmp qword ptr [rbx+48h], 0
jz short loc_95BEB
cmp qword ptr [rbx+68h], 0
jnz short loc_95C1A
loc_95BEB:
mov rdi, [rbx+10h]
mov esi, 20h ; ' '
call get_charset_number_internal
test eax, eax
jz short loc_95C1A
cmp [rbx], eax
jz short loc_95C1A
mov eax, eax
mov rsi, [r12+rax*8]
test rsi, rsi
jz short loc_95C1A
test byte ptr [rsi+0Dh], 2
jz short loc_95C1A
mov rdi, rbx
call inherit_charset_data
loc_95C1A:
cmp qword ptr [rbx+58h], 0
jnz loc_95D0E
test byte ptr [rbx+0Ch], 10h
jnz loc_95D0E
mov rax, [rbx+38h]
test rax, rax
jz loc_95D0E
lea rsi, aImport; "[import "
mov edx, 8
mov [rbp+var_2E8], rax
mov rdi, [rbp+var_2E8]
call _strncmp
mov rcx, [rbp+var_2E8]
test eax, eax
jnz loc_95D0E
lea rdi, [rcx+8]
mov [rbp+var_2F0], rdi
mov esi, 5Dh ; ']'
call _strchr
test rax, rax
setnz dl
mov rcx, [rbp+var_2E8]
add rcx, 28h ; '('
cmp rcx, rax
setnbe cl
and cl, dl
cmp cl, 1
jnz short loc_95D0E
mov rsi, [rbp+var_2F0]
sub rax, rsi
lea rdi, [rbp+var_2E0]
mov ecx, 21h ; '!'
mov rdx, rax
mov [rbp+var_2E8], rax
call ___memcpy_chk
mov rax, [rbp+var_2E8]
mov [rbp+rax+var_2E0], 0
lea rdi, [rbp+var_2E0]
mov rsi, r15
call get_collation_number
test eax, eax
jz short loc_95D0E
cmp [rbx], eax
jz short loc_95D0E
mov eax, eax
mov rax, [r12+rax*8]
test rax, rax
jz short loc_95D0E
test byte ptr [rax+0Dh], 2
jz short loc_95D0E
cmp qword ptr [rbx+58h], 0
jnz short loc_95D0E
test byte ptr [rbx+0Ch], 10h
jnz short loc_95D0E
mov rax, [rax+58h]
mov [rbx+58h], rax
loc_95D0E:
mov rax, [rbx+0B8h]
mov rax, [rax]
test rax, rax
jz short loc_95D29
mov rdi, rbx
mov rsi, r14
call rax
test al, al
jnz short loc_95D44
loc_95D29:
mov rax, [rbx+0C0h]
mov rax, [rax]
test rax, rax
jz short loc_95D48
mov rdi, rbx
mov rsi, r14
call rax
test al, al
jz short loc_95D48
loc_95D44:
xor ebx, ebx
jmp short loc_95D4C
loc_95D48:
or byte ptr [rbx+0Dh], 1
loc_95D4C:
lea rax, my_collation_statistics
inc qword ptr [rax+r13*8]
loc_95D57:
lea rax, THR_LOCK_charset
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_95DA1
loc_95D67:
lea rdi, THR_LOCK_charset
call _pthread_mutex_unlock
loc_95D73:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_95DB3
mov rax, rbx
add rsp, 2C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_95D97:
call get_internal_charset_cold_1
jmp loc_95B00
loc_95DA1:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_95D67
loc_95DB3:
call ___stack_chk_fail
|
long long get_internal_charset(long long a1, unsigned int a2, long long a3)
{
long long v3; // r13
long long v4; // rbx
long long v6; // rdx
long long v7; // rcx
int v8; // eax
int charsets_dir; // eax
int v10; // r8d
int v11; // r9d
int charset_number_internal; // eax
long long v13; // rsi
long long v14; // rax
int v15; // eax
unsigned long long v16; // rax
int collation_number; // eax
long long v18; // rax
unsigned __int8 ( *v19)(long long, long long, long long, long long); // rax
unsigned __int8 ( *v20)(long long, long long, long long, long long); // rax
long long v22; // [rsp+0h] [rbp-2F0h]
long long v23; // [rsp+8h] [rbp-2E8h]
_BYTE v24[128]; // [rsp+10h] [rbp-2E0h] BYREF
long long ( *v25)(long long); // [rsp+90h] [rbp-260h]
long long ( *v26)(long long); // [rsp+98h] [rbp-258h]
long long ( *v27)(long long, long long); // [rsp+A0h] [rbp-250h]
long long ( *v28)(_QWORD); // [rsp+A8h] [rbp-248h]
long long ( *v29)(); // [rsp+B0h] [rbp-240h]
long long ( *v30)(unsigned int *); // [rsp+B8h] [rbp-238h]
_BYTE v31[512]; // [rsp+C0h] [rbp-230h] BYREF
unsigned long long v32; // [rsp+2C0h] [rbp-30h]
v32 = __readfsqword(0x28u);
v3 = a2;
v4 = all_charsets[a2];
if ( !v4 )
return 0LL;
if ( (*(_BYTE *)(v4 + 13) & 1) != 0 )
{
++my_collation_statistics[a2];
}
else
{
if ( THR_LOCK_charset[8] )
get_internal_charset_cold_1();
else
pthread_mutex_lock(THR_LOCK_charset);
v8 = *(_DWORD *)(v4 + 12);
if ( (v8 & 9) == 0 )
{
charsets_dir = get_charsets_dir((long long)v31);
strxmov(charsets_dir, *(_QWORD *)(v4 + 16), (unsigned int)".xml", 0, v10, v11);
v24[0] = 0;
v25 = my_once_alloc_c;
v26 = my_malloc_c;
v27 = my_realloc_c;
v28 = my_free;
v29 = my_charset_error_reporter;
v30 = add_collation;
my_read_charset_file(v24, v31, a3);
v8 = *(_DWORD *)(v4 + 12);
}
if ( (v8 & 0x200) != 0 )
{
if ( (v8 & 0x100) == 0 )
{
if ( !*(_QWORD *)(v4 + 64) || !*(_QWORD *)(v4 + 80) || !*(_QWORD *)(v4 + 72) || !*(_QWORD *)(v4 + 104) )
{
charset_number_internal = get_charset_number_internal(*(_QWORD *)(v4 + 16), 32);
if ( charset_number_internal )
{
if ( *(_DWORD *)v4 != charset_number_internal )
{
v13 = all_charsets[charset_number_internal];
if ( v13 )
{
if ( (*(_BYTE *)(v13 + 13) & 2) != 0 )
inherit_charset_data(v4);
}
}
}
}
if ( !*(_QWORD *)(v4 + 88) && (*(_BYTE *)(v4 + 12) & 0x10) == 0 )
{
v14 = *(_QWORD *)(v4 + 56);
if ( v14 )
{
v23 = *(_QWORD *)(v4 + 56);
v15 = strncmp(v14, "[import ", 8LL);
v7 = v23;
if ( !v15 )
{
v22 = v23 + 8;
v16 = strchr(v23 + 8, 93LL);
LOBYTE(v6) = v16 != 0;
v7 = v23 + 40;
LOBYTE(v7) = v16 != 0 && v23 + 40 > v16;
if ( (_BYTE)v7 == 1 )
{
v23 = v16 - v22;
__memcpy_chk(v24, v22, v16 - v22, 33LL);
v24[v23] = 0;
collation_number = get_collation_number((long long)v24, a3);
if ( collation_number )
{
if ( *(_DWORD *)v4 != collation_number )
{
v18 = all_charsets[collation_number];
if ( v18 )
{
if ( (*(_BYTE *)(v18 + 13) & 2) != 0 && !*(_QWORD *)(v4 + 88) && (*(_BYTE *)(v4 + 12) & 0x10) == 0 )
*(_QWORD *)(v4 + 88) = *(_QWORD *)(v18 + 88);
}
}
}
}
}
}
}
v19 = **(unsigned __int8 ( ***)(long long, long long, long long, long long))(v4 + 184);
if ( v19 && v19(v4, a1, v6, v7)
|| (v20 = **(unsigned __int8 ( ***)(long long, long long, long long, long long))(v4 + 192)) != 0LL
&& v20(v4, a1, v6, v7) )
{
v4 = 0LL;
}
else
{
*(_BYTE *)(v4 + 13) |= 1u;
}
}
++my_collation_statistics[v3];
}
else
{
v4 = 0LL;
}
if ( THR_LOCK_charset[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_charset);
}
return v4;
}
|
get_internal_charset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2c8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13D,ESI
LEA R12,[0xd02810]
MOV RBX,qword ptr [R12 + R13*0x8]
TEST RBX,RBX
JZ 0x00195bae
TEST byte ptr [RBX + 0xd],0x1
JNZ 0x00195bb5
MOV R15,RDX
MOV R14,RDI
LEA RAX,[0xd0b630]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00195d97
LEA RDI,[0xd0b630]
CALL 0x001291d0
LAB_00195b00:
MOV EAX,dword ptr [RBX + 0xc]
TEST AL,0x9
JNZ 0x00195ba1
LEA RDI,[RBP + -0x230]
CALL 0x001953cb
MOV RSI,qword ptr [RBX + 0x10]
LEA RDX,[0x1de0cc]
MOV RDI,RAX
XOR ECX,ECX
XOR EAX,EAX
CALL 0x001da018
LEA RDI,[RBP + -0x2e0]
MOV byte ptr [RDI],0x0
LEA RAX,[0x194e3e]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x194e4d]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x194e68]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x1a2e9e]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x488738]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x194e86]
MOV qword ptr [RDI + 0xa8],RAX
LEA RSI,[RBP + -0x230]
MOV RDX,R15
CALL 0x00196774
MOV EAX,dword ptr [RBX + 0xc]
LAB_00195ba1:
BT EAX,0x9
JC 0x00195bc5
XOR EBX,EBX
JMP 0x00195d57
LAB_00195bae:
XOR EBX,EBX
JMP 0x00195d73
LAB_00195bb5:
LEA RAX,[0xd06880]
INC qword ptr [RAX + R13*0x8]
JMP 0x00195d73
LAB_00195bc5:
BT EAX,0x8
JC 0x00195d4c
CMP qword ptr [RBX + 0x40],0x0
JZ 0x00195beb
CMP qword ptr [RBX + 0x50],0x0
JZ 0x00195beb
CMP qword ptr [RBX + 0x48],0x0
JZ 0x00195beb
CMP qword ptr [RBX + 0x68],0x0
JNZ 0x00195c1a
LAB_00195beb:
MOV RDI,qword ptr [RBX + 0x10]
MOV ESI,0x20
CALL 0x0019587c
TEST EAX,EAX
JZ 0x00195c1a
CMP dword ptr [RBX],EAX
JZ 0x00195c1a
MOV EAX,EAX
MOV RSI,qword ptr [R12 + RAX*0x8]
TEST RSI,RSI
JZ 0x00195c1a
TEST byte ptr [RSI + 0xd],0x2
JZ 0x00195c1a
MOV RDI,RBX
CALL 0x001969bd
LAB_00195c1a:
CMP qword ptr [RBX + 0x58],0x0
JNZ 0x00195d0e
TEST byte ptr [RBX + 0xc],0x10
JNZ 0x00195d0e
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x00195d0e
LEA RSI,[0x1de152]
MOV EDX,0x8
MOV qword ptr [RBP + -0x2e8],RAX
MOV RDI,qword ptr [RBP + -0x2e8]
CALL 0x00129190
MOV RCX,qword ptr [RBP + -0x2e8]
TEST EAX,EAX
JNZ 0x00195d0e
LEA RDI,[RCX + 0x8]
MOV qword ptr [RBP + -0x2f0],RDI
MOV ESI,0x5d
CALL 0x001293e0
TEST RAX,RAX
SETNZ DL
MOV RCX,qword ptr [RBP + -0x2e8]
ADD RCX,0x28
CMP RCX,RAX
SETA CL
AND CL,DL
CMP CL,0x1
JNZ 0x00195d0e
MOV RSI,qword ptr [RBP + -0x2f0]
SUB RAX,RSI
LEA RDI,[RBP + -0x2e0]
MOV ECX,0x21
MOV RDX,RAX
MOV qword ptr [RBP + -0x2e8],RAX
CALL 0x001293c0
MOV RAX,qword ptr [RBP + -0x2e8]
MOV byte ptr [RBP + RAX*0x1 + -0x2e0],0x0
LEA RDI,[RBP + -0x2e0]
MOV RSI,R15
CALL 0x0019555f
TEST EAX,EAX
JZ 0x00195d0e
CMP dword ptr [RBX],EAX
JZ 0x00195d0e
MOV EAX,EAX
MOV RAX,qword ptr [R12 + RAX*0x8]
TEST RAX,RAX
JZ 0x00195d0e
TEST byte ptr [RAX + 0xd],0x2
JZ 0x00195d0e
CMP qword ptr [RBX + 0x58],0x0
JNZ 0x00195d0e
TEST byte ptr [RBX + 0xc],0x10
JNZ 0x00195d0e
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBX + 0x58],RAX
LAB_00195d0e:
MOV RAX,qword ptr [RBX + 0xb8]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00195d29
MOV RDI,RBX
MOV RSI,R14
CALL RAX
TEST AL,AL
JNZ 0x00195d44
LAB_00195d29:
MOV RAX,qword ptr [RBX + 0xc0]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00195d48
MOV RDI,RBX
MOV RSI,R14
CALL RAX
TEST AL,AL
JZ 0x00195d48
LAB_00195d44:
XOR EBX,EBX
JMP 0x00195d4c
LAB_00195d48:
OR byte ptr [RBX + 0xd],0x1
LAB_00195d4c:
LEA RAX,[0xd06880]
INC qword ptr [RAX + R13*0x8]
LAB_00195d57:
LEA RAX,[0xd0b630]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x00195da1
LAB_00195d67:
LEA RDI,[0xd0b630]
CALL 0x001291a0
LAB_00195d73:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00195db3
MOV RAX,RBX
ADD RSP,0x2c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00195d97:
CALL 0x0012eb23
JMP 0x00195b00
LAB_00195da1:
LEA RAX,[0x489050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00195d67
LAB_00195db3:
CALL 0x00129220
|
uint * get_internal_charset(int8 param_1,ulong param_2,int8 param_3)
{
char *__s;
char *__s1;
long lVar1;
char cVar2;
uint uVar3;
int iVar4;
int8 uVar5;
char *pcVar6;
uint *puVar7;
long in_FS_OFFSET;
int1 local_2e8 [128];
code *local_268;
code *local_260;
code *local_258;
code *local_250;
int *local_248;
code *local_240;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
param_2 = param_2 & 0xffffffff;
puVar7 = (uint *)(&all_charsets)[param_2];
if (puVar7 == (uint *)0x0) {
puVar7 = (uint *)0x0;
goto LAB_00195d73;
}
if ((*(byte *)((long)puVar7 + 0xd) & 1) != 0) {
*(long *)(my_collation_statistics + param_2 * 8) =
*(long *)(my_collation_statistics + param_2 * 8) + 1;
goto LAB_00195d73;
}
if (THR_LOCK_charset._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_charset);
}
else {
get_internal_charset_cold_1();
}
uVar3 = puVar7[3];
if ((uVar3 & 9) == 0) {
uVar5 = get_charsets_dir(local_238);
strxmov(uVar5,*(int8 *)(puVar7 + 4),".xml",0);
local_2e8[0] = 0;
local_268 = my_once_alloc_c;
local_260 = my_malloc_c;
local_258 = my_realloc_c;
local_250 = my_free;
local_248 = my_charset_error_reporter;
local_240 = add_collation;
my_read_charset_file(local_2e8,local_238,param_3);
uVar3 = puVar7[3];
}
if ((uVar3 >> 9 & 1) == 0) {
puVar7 = (uint *)0x0;
}
else {
if ((uVar3 >> 8 & 1) == 0) {
if ((((*(long *)(puVar7 + 0x10) == 0) || (*(long *)(puVar7 + 0x14) == 0)) ||
(*(long *)(puVar7 + 0x12) == 0)) || (*(long *)(puVar7 + 0x1a) == 0)) {
uVar3 = get_charset_number_internal(*(int8 *)(puVar7 + 4),0x20);
if (((uVar3 != 0) && (*puVar7 != uVar3)) &&
(((&all_charsets)[uVar3] != 0 && ((*(byte *)((&all_charsets)[uVar3] + 0xd) & 2) != 0))))
{
inherit_charset_data(puVar7);
}
}
if (((*(long *)(puVar7 + 0x16) == 0) && ((puVar7[3] & 0x10) == 0)) &&
(__s1 = *(char **)(puVar7 + 0xe), __s1 != (char *)0x0)) {
iVar4 = strncmp(__s1,"[import ",8);
if (iVar4 == 0) {
__s = __s1 + 8;
pcVar6 = strchr(__s,0x5d);
if (pcVar6 < __s1 + 0x28 && pcVar6 != (char *)0x0) {
__memcpy_chk(local_2e8,__s,(long)pcVar6 - (long)__s,0x21);
local_2e8[(long)pcVar6 - (long)__s] = 0;
uVar3 = get_collation_number(local_2e8,param_3);
if (((((uVar3 != 0) && (*puVar7 != uVar3)) &&
(lVar1 = (&all_charsets)[uVar3], lVar1 != 0)) &&
(((*(byte *)(lVar1 + 0xd) & 2) != 0 && (*(long *)(puVar7 + 0x16) == 0)))) &&
((puVar7[3] & 0x10) == 0)) {
*(int8 *)(puVar7 + 0x16) = *(int8 *)(lVar1 + 0x58);
}
}
}
}
if ((code *)**(int8 **)(puVar7 + 0x2e) == (code *)0x0) {
LAB_00195d29:
if ((code *)**(int8 **)(puVar7 + 0x30) != (code *)0x0) {
cVar2 = (*(code *)**(int8 **)(puVar7 + 0x30))(puVar7,param_1);
if (cVar2 != '\0') goto LAB_00195d44;
}
*(byte *)((long)puVar7 + 0xd) = *(byte *)((long)puVar7 + 0xd) | 1;
}
else {
cVar2 = (*(code *)**(int8 **)(puVar7 + 0x2e))(puVar7,param_1);
if (cVar2 == '\0') goto LAB_00195d29;
LAB_00195d44:
puVar7 = (uint *)0x0;
}
}
*(long *)(my_collation_statistics + param_2 * 8) =
*(long *)(my_collation_statistics + param_2 * 8) + 1;
}
if (THR_LOCK_charset._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_charset);
LAB_00195d73:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return puVar7;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
9,515 |
ftxui::(anonymous namespace)::Focus::Render(ftxui::Screen&)
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/dom/frame.cpp
|
void Render(Screen& screen) override {
Select::Render(screen);
// Setting the cursor to the right position allow folks using CJK (China,
// Japanese, Korean, ...) characters to see their [input method editor]
// displayed at the right location. See [issue].
//
// [input method editor]:
// https://en.wikipedia.org/wiki/Input_method
//
// [issue]:
// https://github.com/ArthurSonzogni/FTXUI/issues/2#issuecomment-505282355
//
// Unfortunately, Microsoft terminal do not handle properly hidding the
// cursor. Instead the character under the cursor is hidden, which is a big
// problem. As a result, we can't enable setting cursor to the right
// location. It will be displayed at the bottom right corner.
// See:
// https://github.com/microsoft/terminal/issues/1203
// https://github.com/microsoft/terminal/issues/3093
#if !defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
screen.SetCursor(Screen::Cursor{
box_.x_min,
box_.y_min,
Screen::Cursor::Shape::Hidden,
});
#endif
}
|
O0
|
cpp
|
ftxui::(anonymous namespace)::Focus::Render(ftxui::Screen&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x446a0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x4c(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x54(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x2c(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x85130
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZN5ftxui12_GLOBAL__N_15Focus6RenderERNS_6ScreenE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; this
mov [rbp+var_38], rdi
mov rsi, [rbp+var_10]; ftxui::Screen *
call _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
mov rax, [rbp+var_38]
mov rdi, [rbp+var_10]
mov ecx, [rax+4Ch]
mov dword ptr [rbp+var_1C], ecx
mov eax, [rax+54h]
mov dword ptr [rbp+var_1C+4], eax
mov [rbp+var_14], 0
mov rax, [rbp+var_1C]
mov [rbp+var_2C], rax
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
mov rsi, [rbp+var_2C]
mov edx, [rbp+var_24]
call _ZN5ftxui6Screen9SetCursorENS0_6CursorE; ftxui::Screen::SetCursor(ftxui::Screen::Cursor)
add rsp, 40h
pop rbp
retn
|
long long ftxui::`anonymous namespace'::Focus::Render(
ftxui::_anonymous_namespace_::Focus *this,
ftxui::Screen *a2)
{
long long v3; // [rsp+24h] [rbp-1Ch]
ftxui::Node::Render(this, a2);
LODWORD(v3) = *((_DWORD *)this + 19);
HIDWORD(v3) = *((_DWORD *)this + 21);
return ftxui::Screen::SetCursor(a2, v3, 0LL);
}
|
Render:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001446a0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4c]
MOV dword ptr [RBP + -0x1c],ECX
MOV EAX,dword ptr [RAX + 0x54]
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x2c],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
MOV RSI,qword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x24]
CALL 0x00185130
ADD RSP,0x40
POP RBP
RET
|
/* ftxui::(anonymous namespace)::Focus::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::Focus::Render(Focus *this,Screen *param_1)
{
Node::Render((Node *)this,param_1);
Screen::SetCursor(param_1,CONCAT44(*(int4 *)(this + 0x54),*(int4 *)(this + 0x4c)),0);
return;
}
|
|
9,516 |
pvio_socket_change_timeout
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
my_bool pvio_socket_change_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct timeval tm;
int rc= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
if (!(csock= (struct st_pvio_socket *)pvio->data))
return 1;
tm.tv_sec= timeout / 1000;
tm.tv_usec= (timeout % 1000) * 1000;
switch(type)
{
case PVIO_WRITE_TIMEOUT:
#ifndef _WIN32
rc= setsockopt(csock->socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tm, sizeof(tm));
#else
rc= setsockopt(csock->socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(int));
#endif
break;
case PVIO_READ_TIMEOUT:
#ifndef _WIN32
rc= setsockopt(csock->socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tm, sizeof(tm));
#else
rc= setsockopt(csock->socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(int));
#endif
break;
default:
break;
}
return rc;
}
|
O3
|
c
|
pvio_socket_change_timeout:
movb $0x1, %al
testq %rdi, %rdi
je 0x2ffb2
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2ffb2
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq %edx, %rax
imulq $0x10624dd3, %rax, %rdx # imm = 0x10624DD3
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x26, %rdx
addl %edi, %edx
movslq %edx, %rdx
movq %rdx, -0x10(%rbp)
imull $0x3e8, %edx, %edx # imm = 0x3E8
subl %edx, %eax
imull $0x3e8, %eax, %eax # imm = 0x3E8
cltq
movq %rax, -0x8(%rbp)
cmpl $0x2, %esi
je 0x2ff8e
cmpl $0x1, %esi
jne 0x2ffab
movl $0x14, %edx
jmp 0x2ff93
movl $0x15, %edx
movl (%rcx), %edi
leaq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x10, %r8d
callq 0x137b0
jmp 0x2ffad
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
|
pvio_socket_change_timeout:
mov al, 1
test rdi, rdi
jz short locret_2FFB2
mov rcx, [rdi]
test rcx, rcx
jz short locret_2FFB2
push rbp
mov rbp, rsp
sub rsp, 10h
movsxd rax, edx
imul rdx, rax, 10624DD3h
mov rdi, rdx
shr rdi, 3Fh
sar rdx, 26h
add edx, edi
movsxd rdx, edx
mov [rbp-10h], rdx
imul edx, 3E8h
sub eax, edx
imul eax, 3E8h
cdqe
mov [rbp-8], rax
cmp esi, 2
jz short loc_2FF8E
cmp esi, 1
jnz short loc_2FFAB
mov edx, 14h
jmp short loc_2FF93
loc_2FF8E:
mov edx, 15h
loc_2FF93:
mov edi, [rcx]
lea rcx, [rbp-10h]
mov esi, 1
mov r8d, 10h
call _setsockopt
jmp short loc_2FFAD
loc_2FFAB:
xor eax, eax
loc_2FFAD:
add rsp, 10h
pop rbp
locret_2FFB2:
retn
|
char pvio_socket_change_timeout(unsigned int **a1, int a2, int a3)
{
char result; // al
unsigned int *v4; // rcx
long long v5; // rdx
_QWORD v6[3]; // [rsp-18h] [rbp-18h] BYREF
result = 1;
if ( a1 )
{
v4 = *a1;
if ( *a1 )
{
v6[0] = a3 / 1000;
v6[1] = 1000 * (a3 % 1000);
if ( a2 == 2 )
{
v5 = 21LL;
return setsockopt(*v4, 1LL, v5, v6, 16LL);
}
if ( a2 == 1 )
{
v5 = 20LL;
return setsockopt(*v4, 1LL, v5, v6, 16LL);
}
return 0;
}
}
return result;
}
|
pvio_socket_change_timeout:
MOV AL,0x1
TEST RDI,RDI
JZ 0x0012ffb2
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x0012ffb2
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSXD RAX,EDX
IMUL RDX,RAX,0x10624dd3
MOV RDI,RDX
SHR RDI,0x3f
SAR RDX,0x26
ADD EDX,EDI
MOVSXD RDX,EDX
MOV qword ptr [RBP + -0x10],RDX
IMUL EDX,EDX,0x3e8
SUB EAX,EDX
IMUL EAX,EAX,0x3e8
CDQE
MOV qword ptr [RBP + -0x8],RAX
CMP ESI,0x2
JZ 0x0012ff8e
CMP ESI,0x1
JNZ 0x0012ffab
MOV EDX,0x14
JMP 0x0012ff93
LAB_0012ff8e:
MOV EDX,0x15
LAB_0012ff93:
MOV EDI,dword ptr [RCX]
LEA RCX,[RBP + -0x10]
MOV ESI,0x1
MOV R8D,0x10
CALL 0x001137b0
JMP 0x0012ffad
LAB_0012ffab:
XOR EAX,EAX
LAB_0012ffad:
ADD RSP,0x10
POP RBP
LAB_0012ffb2:
RET
|
int pvio_socket_change_timeout(int8 *param_1,int param_2,int param_3)
{
int iVar1;
long local_18;
long local_10;
iVar1 = 1;
if ((param_1 != (int8 *)0x0) && ((int *)*param_1 != (int *)0x0)) {
local_18 = (long)(param_3 / 1000);
local_10 = (long)((param_3 % 1000) * 1000);
if (param_2 == 2) {
iVar1 = 0x15;
}
else {
if (param_2 != 1) {
return 0;
}
iVar1 = 0x14;
}
iVar1 = setsockopt(*(int *)*param_1,1,iVar1,&local_18,0x10);
}
return iVar1;
}
|
|
9,517 |
my_strnncoll_tis620
|
eloqsql/strings/ctype-tis620.c
|
static
int my_strnncoll_tis620(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
uchar buf[80] ;
uchar *tc1, *tc2;
int i;
if (s2_is_prefix && len1 > len2)
len1= len2;
tc1= buf;
if ((len1 + len2 +2) > (int) sizeof(buf))
tc1= (uchar*) my_malloc(PSI_INSTRUMENT_ME, len1+len2+2, MYF(MY_FAE));
tc2= tc1 + len1+1;
memcpy((char*) tc1, (char*) s1, len1);
tc1[len1]= 0; /* if length(s1)> len1, need to put 'end of string' */
memcpy((char *)tc2, (char *)s2, len2);
tc2[len2]= 0; /* put end of string */
thai2sortable(tc1, len1);
thai2sortable(tc2, len2);
i= strcmp((char*)tc1, (char*)tc2);
if (tc1 != buf)
my_free(tc1);
return i;
}
|
O0
|
c
|
my_strnncoll_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r9b, %al
movq %fs:0x28, %r9
movq %r9, -0x8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movb %al, -0x89(%rbp)
movsbl -0x89(%rbp), %eax
cmpl $0x0, %eax
je 0x4e24c
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0x4e24c
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
addq -0x88(%rbp), %rax
addq $0x2, %rax
cmpq $0x50, %rax
jbe 0x4e28e
movq -0x78(%rbp), %rsi
addq -0x88(%rbp), %rsi
addq $0x2, %rsi
xorl %edi, %edi
movl $0x8, %edx
callq 0x2e7a0
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
addq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x24200
movq -0x98(%rbp), %rax
movq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x24200
movq -0xa0(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4e770
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4e770
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x24410
movl %eax, -0xa4(%rbp)
movq -0x98(%rbp), %rax
leaq -0x60(%rbp), %rcx
cmpq %rcx, %rax
je 0x4e348
movq -0x98(%rbp), %rdi
callq 0x2eb20
movl -0xa4(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4e375
movl -0xa8(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x24300
nopw (%rax,%rax)
|
my_strnncoll_tis620:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov al, r9b
mov r9, fs:28h
mov [rbp+var_8], r9
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+var_80], rcx
mov [rbp+var_88], r8
mov [rbp+var_89], al
movsx eax, [rbp+var_89]
cmp eax, 0
jz short loc_4E24C
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jbe short loc_4E24C
mov rax, [rbp+var_88]
mov [rbp+var_78], rax
loc_4E24C:
lea rax, [rbp+var_60]
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
add rax, [rbp+var_88]
add rax, 2
cmp rax, 50h ; 'P'
jbe short loc_4E28E
mov rsi, [rbp+var_78]
add rsi, [rbp+var_88]
add rsi, 2
xor edi, edi
mov edx, 8
call my_malloc
mov [rbp+var_98], rax
loc_4E28E:
mov rax, [rbp+var_98]
add rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_70]
mov rdx, [rbp+var_78]
call _memcpy
mov rax, [rbp+var_98]
mov rcx, [rbp+var_78]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_88]
call _memcpy
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_88]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_78]
call thai2sortable
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_88]
call thai2sortable
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_A0]
call _strcmp
mov [rbp+var_A4], eax
mov rax, [rbp+var_98]
lea rcx, [rbp+var_60]
cmp rax, rcx
jz short loc_4E348
mov rdi, [rbp+var_98]
call my_free
loc_4E348:
mov eax, [rbp+var_A4]
mov [rbp+var_A8], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4E375
mov eax, [rbp+var_A8]
add rsp, 0B0h
pop rbp
retn
loc_4E375:
call ___stack_chk_fail
|
long long my_strnncoll_tis620(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
unsigned int v7; // [rsp+Ch] [rbp-A4h]
long long v8; // [rsp+10h] [rbp-A0h]
_BYTE *v9; // [rsp+18h] [rbp-98h]
unsigned long long v12; // [rsp+38h] [rbp-78h]
_BYTE v13[88]; // [rsp+50h] [rbp-60h] BYREF
unsigned long long v14; // [rsp+A8h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a3;
if ( a6 && a3 > a5 )
v12 = a5;
v9 = v13;
if ( a5 + v12 + 2 > 0x50 )
v9 = (_BYTE *)my_malloc(0, a5 + v12 + 2, 8);
v8 = (long long)&v9[v12 + 1];
memcpy(v9, a2, v12);
v9[v12] = 0;
memcpy(v8, a4, a5);
*(_BYTE *)(v8 + a5) = 0;
thai2sortable(v9, v12);
thai2sortable(v8, a5);
v7 = strcmp(v9, v8);
if ( v9 != v13 )
my_free((long long)v9);
return v7;
}
|
my_strnncoll_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV AL,R9B
MOV R9,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],R9
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x80],RCX
MOV qword ptr [RBP + -0x88],R8
MOV byte ptr [RBP + -0x89],AL
MOVSX EAX,byte ptr [RBP + -0x89]
CMP EAX,0x0
JZ 0x0014e24c
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JBE 0x0014e24c
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x78],RAX
LAB_0014e24c:
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,qword ptr [RBP + -0x88]
ADD RAX,0x2
CMP RAX,0x50
JBE 0x0014e28e
MOV RSI,qword ptr [RBP + -0x78]
ADD RSI,qword ptr [RBP + -0x88]
ADD RSI,0x2
XOR EDI,EDI
MOV EDX,0x8
CALL 0x0012e7a0
MOV qword ptr [RBP + -0x98],RAX
LAB_0014e28e:
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x00124200
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x00124200
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x88]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x78]
CALL 0x0014e770
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x88]
CALL 0x0014e770
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0xa0]
CALL 0x00124410
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr [RBP + -0x98]
LEA RCX,[RBP + -0x60]
CMP RAX,RCX
JZ 0x0014e348
MOV RDI,qword ptr [RBP + -0x98]
CALL 0x0012eb20
LAB_0014e348:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0xa8],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014e375
MOV EAX,dword ptr [RBP + -0xa8]
ADD RSP,0xb0
POP RBP
RET
LAB_0014e375:
CALL 0x00124300
|
int my_strnncoll_tis620(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
int iVar1;
char *__s2;
long in_FS_OFFSET;
char *local_a0;
size_t local_80;
char local_68 [88];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = param_3;
if ((param_6 != '\0') && (param_5 < param_3)) {
local_80 = param_5;
}
local_a0 = local_68;
if (0x50 < local_80 + param_5 + 2) {
local_a0 = (char *)my_malloc(0,local_80 + param_5 + 2,8);
}
__s2 = local_a0 + local_80 + 1;
memcpy(local_a0,param_2,local_80);
local_a0[local_80] = '\0';
memcpy(__s2,param_4,param_5);
__s2[param_5] = '\0';
thai2sortable(local_a0,local_80);
thai2sortable(__s2,param_5);
iVar1 = strcmp(local_a0,__s2);
if (local_a0 != local_68) {
my_free(local_a0);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
9,518 |
mi_enable_indexes
|
eloqsql/storage/myisam/mi_open.c
|
int mi_enable_indexes(MI_INFO *info)
{
int error= 0;
MYISAM_SHARE *share= info->s;
if (share->state.state.data_file_length ||
(share->state.state.key_file_length != share->base.keystart))
{
mi_print_error(info->s, HA_ERR_CRASHED);
error= HA_ERR_CRASHED;
}
else
mi_set_all_keys_active(share->state.key_map, share->base.keys);
return error;
}
|
O3
|
c
|
mi_enable_indexes:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq $0x0, 0x40(%rax)
jne 0x80725
movq 0x38(%rax), %rcx
cmpq 0x108(%rax), %rcx
jne 0x80725
movl 0x180(%rax), %ecx
movq $-0x1, %rdx
shlq %cl, %rdx
movq $-0x1, %rsi
cmpl $0x40, %ecx
notq %rdx
cmovaeq %rsi, %rdx
movq %rdx, 0xc0(%rax)
xorl %ebx, %ebx
jmp 0x8073b
movq 0x268(%rax), %rsi
movl $0x7e, %ebx
movl $0x7e, %edi
callq 0x7ad4a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mi_enable_indexes:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
cmp qword ptr [rax+40h], 0
jnz short loc_80725
mov rcx, [rax+38h]
cmp rcx, [rax+108h]
jnz short loc_80725
mov ecx, [rax+180h]
mov rdx, 0FFFFFFFFFFFFFFFFh
shl rdx, cl
mov rsi, 0FFFFFFFFFFFFFFFFh
cmp ecx, 40h ; '@'
not rdx
cmovnb rdx, rsi
mov [rax+0C0h], rdx
xor ebx, ebx
jmp short loc_8073B
loc_80725:
mov rsi, [rax+268h]
mov ebx, 7Eh ; '~'
mov edi, 7Eh ; '~'
call mi_report_error
loc_8073B:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
|
long long mi_enable_indexes(long long *a1)
{
long long v1; // rax
unsigned int v2; // ecx
long long v3; // rdx
unsigned int v4; // ebx
v1 = *a1;
if ( *(_QWORD *)(*a1 + 64) || *(_QWORD *)(v1 + 56) != *(_QWORD *)(v1 + 264) )
{
v4 = 126;
mi_report_error(126, *(_QWORD *)(v1 + 616));
}
else
{
v2 = *(_DWORD *)(v1 + 384);
v3 = ~(-1LL << v2);
if ( v2 >= 0x40 )
v3 = -1LL;
*(_QWORD *)(v1 + 192) = v3;
return 0;
}
return v4;
}
|
mi_enable_indexes:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00180725
MOV RCX,qword ptr [RAX + 0x38]
CMP RCX,qword ptr [RAX + 0x108]
JNZ 0x00180725
MOV ECX,dword ptr [RAX + 0x180]
MOV RDX,-0x1
SHL RDX,CL
MOV RSI,-0x1
CMP ECX,0x40
NOT RDX
CMOVNC RDX,RSI
MOV qword ptr [RAX + 0xc0],RDX
XOR EBX,EBX
JMP 0x0018073b
LAB_00180725:
MOV RSI,qword ptr [RAX + 0x268]
MOV EBX,0x7e
MOV EDI,0x7e
CALL 0x0017ad4a
LAB_0018073b:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 mi_enable_indexes(long *param_1)
{
long lVar1;
ulong uVar2;
int8 uVar3;
lVar1 = *param_1;
if ((*(long *)(lVar1 + 0x40) == 0) && (*(long *)(lVar1 + 0x38) == *(long *)(lVar1 + 0x108))) {
uVar2 = ~(-1L << ((byte)*(uint *)(lVar1 + 0x180) & 0x3f));
if (0x3f < *(uint *)(lVar1 + 0x180)) {
uVar2 = 0xffffffffffffffff;
}
*(ulong *)(lVar1 + 0xc0) = uVar2;
uVar3 = 0;
}
else {
uVar3 = 0x7e;
mi_report_error(0x7e,*(int8 *)(lVar1 + 0x268));
}
return uVar3;
}
|
|
9,519 |
settings::add_input(int, ConfigUnsigned&, settings_location, char const*, bool)
|
untodesu[P]voxelius/game/client/settings.cc
|
void settings::add_input(int priority, ConfigUnsigned &value, settings_location location, const char *name, bool tooltip)
{
auto setting_value = new SettingValue_InputUnsigned;
setting_value->type = setting_type::INPUT_UINT;
setting_value->priority = priority;
setting_value->has_tooltip = tooltip;
setting_value->value = &value;
setting_value->name = name;
setting_value->wid = fmt::format("###{}", static_cast<const void *>(setting_value->value));
values[static_cast<unsigned int>(location)].push_back(setting_value);
values_all.push_back(setting_value);
}
|
O1
|
cpp
|
settings::add_input(int, ConfigUnsigned&, settings_location, char const*, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movq %rcx, %r14
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movl %edi, %ebp
movl $0xa0, %edi
callq 0x268b0
movq %rax, %rbx
addq $0x20, %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movb %al, 0x20(%rbx)
leaq 0x40(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movb %al, 0x40(%rbx)
leaq 0x50(%rbx), %r15
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x88(%rbx), %rcx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movb %al, 0x88(%rbx)
leaq 0x1eb03b(%rip), %rax # 0x2551b8
movq %rax, (%rbx)
movl $0x3, 0x8(%rbx)
movl %ebp, 0x74(%rbx)
movb %r12b, 0x70(%rbx)
movq %r13, 0x98(%rbx)
movq %r14, %rdi
callq 0x26330
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x26db0
movq 0x98(%rbx), %rax
leaq 0x30(%rsp), %r8
movq %rax, (%r8)
leaq 0x133fd8(%rip), %rsi # 0x19e19d
leaq 0x10(%rsp), %r14
movl $0x5, %edx
movl $0xe, %ecx
movq %r14, %rdi
callq 0x147c0b
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x26ac0
movq (%r14), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x6a203
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x268d0
movl 0x4(%rsp), %eax
leaq (%rax,%rax,2), %rax
leaq 0x1f55ee(%rip), %rcx # 0x25f800
leaq (%rcx,%rax,8), %rdi
leaq 0x10(%rsp), %r14
movq %rbx, (%r14)
movq %r14, %rsi
callq 0x6bf28
movq %rbx, (%r14)
leaq 0x1f55b8(%rip), %rdi # 0x25f7e8
leaq 0x10(%rsp), %rsi
callq 0x6bf28
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN8settings9add_inputEiR14ConfigUnsigned17settings_locationPKcb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r12d, r8d
mov r14, rcx
mov [rsp+78h+var_74], edx
mov r13, rsi
mov ebp, edi
mov edi, 0A0h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
add rax, 20h ; ' '
mov [rbx+10h], rax
xor eax, eax
mov [rbx+18h], rax
mov [rbx+20h], al
lea rcx, [rbx+40h]
mov [rbx+30h], rcx
mov [rbx+38h], rax
mov [rbx+40h], al
lea r15, [rbx+50h]
lea rcx, [rbx+60h]
mov [rbx+50h], rcx
mov [rbx+58h], rax
mov [rbx+60h], al
lea rcx, [rbx+78h]
mov [rsp+78h+var_70], rcx
lea rcx, [rbx+88h]
mov [rbx+78h], rcx
mov [rbx+80h], rax
mov [rbx+88h], al
lea rax, off_2551B8
mov [rbx], rax
mov dword ptr [rbx+8], 3
mov [rbx+74h], ebp
mov [rbx+70h], r12b
mov [rbx+98h], r13
mov rdi, r14
call _strlen
mov rdi, r15
xor esi, esi
xor edx, edx
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rax, [rbx+98h]
lea r8, [rsp+78h+var_48]
mov [r8], rax
lea rsi, asc_19E19A+3; "###{}"
lea r14, [rsp+78h+var_68]
mov edx, 5
mov ecx, 0Eh
mov rdi, r14
call _ZN3fmt3v117vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_7contextEEE; fmt::v11::vformat(fmt::v11::basic_string_view<char>,fmt::v11::basic_format_args<fmt::v11::context>)
mov rdi, [rsp+78h+var_70]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
lea rax, [rsp+78h+var_58]
cmp rdi, rax
jz short loc_6A203
mov rsi, [rsp+78h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6A203:
mov eax, [rsp+78h+var_74]
lea rax, [rax+rax*2]
lea rcx, _ZL6values; values
lea rdi, [rcx+rax*8]
lea r14, [rsp+78h+var_68]
mov [r14], rbx
mov rsi, r14
call _ZNSt6vectorIP12SettingValueSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<SettingValue *>::emplace_back<SettingValue *>(SettingValue * &&)
mov [r14], rbx
lea rdi, _ZL10values_all; values_all
lea rsi, [rsp+78h+var_68]
call _ZNSt6vectorIP12SettingValueSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<SettingValue *>::emplace_back<SettingValue *>(SettingValue * &&)
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long settings::add_input(int a1, long long a2, unsigned int a3, long long a4, char a5, double a6)
{
_QWORD *v8; // rbx
long long v9; // rax
long long v10; // r9
int v11; // r9d
void *v14[2]; // [rsp+10h] [rbp-68h] BYREF
long long v15; // [rsp+20h] [rbp-58h] BYREF
long long v16; // [rsp+30h] [rbp-48h] BYREF
v8 = (_QWORD *)operator new(0xA0uLL);
v8[2] = v8 + 4;
v8[3] = 0LL;
*((_BYTE *)v8 + 32) = 0;
v8[6] = v8 + 8;
v8[7] = 0LL;
*((_BYTE *)v8 + 64) = 0;
v8[10] = v8 + 12;
v8[11] = 0LL;
*((_BYTE *)v8 + 96) = 0;
v8[15] = v8 + 17;
v8[16] = 0LL;
*((_BYTE *)v8 + 136) = 0;
*v8 = off_2551B8;
*((_DWORD *)v8 + 2) = 3;
*((_DWORD *)v8 + 29) = a1;
*((_BYTE *)v8 + 112) = a5;
v8[19] = a2;
v9 = strlen(a4);
std::string::_M_replace(v8 + 10, 0LL, 0LL, a4, v9, v10);
v16 = v8[19];
fmt::v11::vformat[abi:cxx11]((unsigned int)v14, (unsigned int)"###{}", 5, 14, (unsigned int)&v16, v11);
std::string::operator=(v8 + 15, v14, a6);
if ( v14[0] != &v15 )
operator delete(v14[0], v15 + 1);
v14[0] = v8;
std::vector<SettingValue *>::emplace_back<SettingValue *>(&values[3 * a3], v14);
v14[0] = v8;
return std::vector<SettingValue *>::emplace_back<SettingValue *>(&values_all, v14);
}
|
add_input:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R12D,R8D
MOV R14,RCX
MOV dword ptr [RSP + 0x4],EDX
MOV R13,RSI
MOV EBP,EDI
MOV EDI,0xa0
CALL 0x001268b0
MOV RBX,RAX
ADD RAX,0x20
MOV qword ptr [RBX + 0x10],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x18],RAX
MOV byte ptr [RBX + 0x20],AL
LEA RCX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RCX
MOV qword ptr [RBX + 0x38],RAX
MOV byte ptr [RBX + 0x40],AL
LEA R15,[RBX + 0x50]
LEA RCX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RCX
MOV qword ptr [RBX + 0x58],RAX
MOV byte ptr [RBX + 0x60],AL
LEA RCX,[RBX + 0x78]
MOV qword ptr [RSP + 0x8],RCX
LEA RCX,[RBX + 0x88]
MOV qword ptr [RBX + 0x78],RCX
MOV qword ptr [RBX + 0x80],RAX
MOV byte ptr [RBX + 0x88],AL
LEA RAX,[0x3551b8]
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],0x3
MOV dword ptr [RBX + 0x74],EBP
MOV byte ptr [RBX + 0x70],R12B
MOV qword ptr [RBX + 0x98],R13
MOV RDI,R14
CALL 0x00126330
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R14
MOV R8,RAX
CALL 0x00126db0
MOV RAX,qword ptr [RBX + 0x98]
LEA R8,[RSP + 0x30]
MOV qword ptr [R8],RAX
LEA RSI,[0x29e19d]
LEA R14,[RSP + 0x10]
MOV EDX,0x5
MOV ECX,0xe
MOV RDI,R14
CALL 0x00247c0b
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
CALL 0x00126ac0
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x0016a203
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001268d0
LAB_0016a203:
MOV EAX,dword ptr [RSP + 0x4]
LEA RAX,[RAX + RAX*0x2]
LEA RCX,[0x35f800]
LEA RDI,[RCX + RAX*0x8]
LEA R14,[RSP + 0x10]
MOV qword ptr [R14],RBX
MOV RSI,R14
CALL 0x0016bf28
MOV qword ptr [R14],RBX
LEA RDI,[0x35f7e8]
LEA RSI,[RSP + 0x10]
CALL 0x0016bf28
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* settings::add_input(int, ConfigUnsigned&, settings_location, char const*, bool) */
void settings::add_input(int4 param_1,int8 param_2,uint param_3,char *param_4,
SettingValue param_5)
{
SettingValue *pSVar1;
SettingValue *local_68 [2];
long local_58 [2];
int8 local_48;
pSVar1 = (SettingValue *)operator_new(0xa0);
*(SettingValue **)(pSVar1 + 0x10) = pSVar1 + 0x20;
*(int8 *)(pSVar1 + 0x18) = 0;
pSVar1[0x20] = (SettingValue)0x0;
*(SettingValue **)(pSVar1 + 0x30) = pSVar1 + 0x40;
*(int8 *)(pSVar1 + 0x38) = 0;
pSVar1[0x40] = (SettingValue)0x0;
*(SettingValue **)(pSVar1 + 0x50) = pSVar1 + 0x60;
*(int8 *)(pSVar1 + 0x58) = 0;
pSVar1[0x60] = (SettingValue)0x0;
*(SettingValue **)(pSVar1 + 0x78) = pSVar1 + 0x88;
*(int8 *)(pSVar1 + 0x80) = 0;
pSVar1[0x88] = (SettingValue)0x0;
*(int ***)pSVar1 = &PTR__SettingValueWID_003551b8;
*(int4 *)(pSVar1 + 8) = 3;
*(int4 *)(pSVar1 + 0x74) = param_1;
pSVar1[0x70] = param_5;
*(int8 *)(pSVar1 + 0x98) = param_2;
strlen(param_4);
std::__cxx11::string::_M_replace((ulong)(pSVar1 + 0x50),0,(char *)0x0,(ulong)param_4);
local_48 = *(int8 *)(pSVar1 + 0x98);
fmt::v11::vformat_abi_cxx11_((string *)local_68,"###{}",5,0xe);
std::__cxx11::string::operator=((string *)(pSVar1 + 0x78),(string *)local_68);
if (local_68[0] != (SettingValue *)local_58) {
operator_delete(local_68[0],local_58[0] + 1);
}
local_68[0] = pSVar1;
std::vector<SettingValue*,std::allocator<SettingValue*>>::emplace_back<SettingValue*>
((vector<SettingValue*,std::allocator<SettingValue*>> *)(&values + (ulong)param_3 * 3),
local_68);
local_68[0] = pSVar1;
std::vector<SettingValue*,std::allocator<SettingValue*>>::emplace_back<SettingValue*>
((vector<SettingValue*,std::allocator<SettingValue*>> *)&values_all,local_68);
return;
}
|
|
9,520 |
server_task_result_cmpl_partial::to_json[abi:cxx11]()
|
monkey531[P]llama/examples/server/server.cpp
|
virtual json to_json() override {
switch (oaicompat) {
case OAICOMPAT_TYPE_NONE:
return to_json_non_oaicompat();
case OAICOMPAT_TYPE_COMPLETION:
return to_json_oaicompat();
case OAICOMPAT_TYPE_CHAT:
return to_json_oaicompat_chat();
default:
GGML_ASSERT(false && "Invalid oaicompat_type");
}
}
|
O2
|
cpp
|
server_task_result_cmpl_partial::to_json[abi:cxx11]():
pushq %rbx
movq %rdi, %rbx
movl 0xe4(%rsi), %eax
cmpl $0x2, %eax
je 0x8a45e
cmpl $0x1, %eax
je 0x8a454
testl %eax, %eax
jne 0x8a46b
movq %rbx, %rdi
callq 0x8a4ea
jmp 0x8a466
movq %rbx, %rdi
callq 0x8b5c8
jmp 0x8a466
movq %rbx, %rdi
callq 0x8aace
movq %rbx, %rax
popq %rbx
retq
leaq 0x684e3(%rip), %rdi # 0xf2955
leaq 0x678e9(%rip), %rdx # 0xf1d62
leaq 0x6d310(%rip), %rcx # 0xf7790
movl $0x35d, %esi # imm = 0x35D
xorl %eax, %eax
callq 0x292a0
|
_ZN31server_task_result_cmpl_partial7to_jsonB5cxx11Ev:
push rbx
mov rbx, rdi
mov eax, [rsi+0E4h]
cmp eax, 2
jz short loc_8A45E
cmp eax, 1
jz short loc_8A454
test eax, eax
jnz short loc_8A46B
mov rdi, rbx
call _ZN31server_task_result_cmpl_partial21to_json_non_oaicompatB5cxx11Ev; server_task_result_cmpl_partial::to_json_non_oaicompat(void)
jmp short loc_8A466
loc_8A454:
mov rdi, rbx
call _ZN31server_task_result_cmpl_partial22to_json_oaicompat_chatB5cxx11Ev; server_task_result_cmpl_partial::to_json_oaicompat_chat(void)
jmp short loc_8A466
loc_8A45E:
mov rdi, rbx
call _ZN31server_task_result_cmpl_partial17to_json_oaicompatB5cxx11Ev; server_task_result_cmpl_partial::to_json_oaicompat(void)
loc_8A466:
mov rax, rbx
pop rbx
retn
loc_8A46B:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseInvalidOa; "false && \"Invalid oaicompat_type\""
mov esi, 35Dh
xor eax, eax
call _ggml_abort
|
to_json[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
MOV EAX,dword ptr [RSI + 0xe4]
CMP EAX,0x2
JZ 0x0018a45e
CMP EAX,0x1
JZ 0x0018a454
TEST EAX,EAX
JNZ 0x0018a46b
MOV RDI,RBX
CALL 0x0018a4ea
JMP 0x0018a466
LAB_0018a454:
MOV RDI,RBX
CALL 0x0018b5c8
JMP 0x0018a466
LAB_0018a45e:
MOV RDI,RBX
CALL 0x0018aace
LAB_0018a466:
MOV RAX,RBX
POP RBX
RET
LAB_0018a46b:
LEA RDI,[0x1f2955]
LEA RDX,[0x1f1d62]
LEA RCX,[0x1f7790]
MOV ESI,0x35d
XOR EAX,EAX
CALL 0x001292a0
|
/* server_task_result_cmpl_partial::to_json[abi:cxx11]() */
void server_task_result_cmpl_partial::to_json_abi_cxx11_(void)
{
int iVar1;
long in_RSI;
iVar1 = *(int *)(in_RSI + 0xe4);
if (iVar1 == 2) {
to_json_oaicompat_abi_cxx11_();
}
else if (iVar1 == 1) {
to_json_oaicompat_chat_abi_cxx11_();
}
else {
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/server/server.cpp"
,0x35d,"GGML_ASSERT(%s) failed","false && \"Invalid oaicompat_type\"");
}
to_json_non_oaicompat_abi_cxx11_();
}
return;
}
|
||
9,521 |
JS_OrdinaryIsInstanceOf
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValue val,
JSValue obj)
{
JSValue obj_proto;
JSObject *proto;
const JSObject *p, *proto1;
BOOL ret;
if (!JS_IsFunction(ctx, obj))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_BOUND_FUNCTION) {
JSBoundFunction *s = p->u.bound_function;
return JS_IsInstanceOf(ctx, val, s->func_obj);
}
/* Only explicitly boxed values are instances of constructors */
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
if (!JS_IsException(obj_proto))
JS_ThrowTypeError(ctx, "operand 'prototype' property is not an object");
ret = -1;
goto done;
}
proto = JS_VALUE_GET_OBJ(obj_proto);
p = JS_VALUE_GET_OBJ(val);
for(;;) {
proto1 = p->shape->proto;
if (!proto1) {
/* slow case if proxy in the prototype chain */
if (unlikely(p->class_id == JS_CLASS_PROXY)) {
JSValue obj1;
obj1 = js_dup(JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
for(;;) {
obj1 = JS_GetPrototypeFree(ctx, obj1);
if (JS_IsException(obj1)) {
ret = -1;
break;
}
if (JS_IsNull(obj1)) {
ret = FALSE;
break;
}
if (proto == JS_VALUE_GET_OBJ(obj1)) {
JS_FreeValue(ctx, obj1);
ret = TRUE;
break;
}
/* must check for timeout to avoid infinite loop */
if (js_poll_interrupts(ctx)) {
JS_FreeValue(ctx, obj1);
ret = -1;
break;
}
}
} else {
ret = FALSE;
}
break;
}
p = proto1;
if (proto == p) {
ret = TRUE;
break;
}
}
done:
JS_FreeValue(ctx, obj_proto);
return ret;
}
|
O1
|
c
|
JS_OrdinaryIsInstanceOf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
movq %rcx, %rsi
movq %r8, %rdx
callq 0x22dbe
xorl %ebp, %ebp
testl %eax, %eax
je 0x22f0d
movq 0x10(%rsp), %rax
cmpw $0xe, 0x6(%rax)
jne 0x22e73
movq 0x30(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22bc0
cmpl $-0x1, %r15d
jne 0x22f0d
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl $0x3c, %ecx
movq %rsi, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
movq %rax, 0x18(%rsp)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x22ecf
cmpl $0x6, %r15d
je 0x22efe
leaq 0x7c142(%rip), %rsi # 0x9f005
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x22efe
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x22ef5
movq %rcx, %rax
cmpq %rcx, %r13
jne 0x22ed9
movl $0x1, %ebp
jmp 0x22efe
cmpw $0x30, 0x6(%rax)
je 0x22f1e
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d8c6
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%rax)
movq %rax, 0x8(%rsp)
movq $-0x1, %r12
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3d4a6
movq %rdx, %r12
movq %rax, 0x8(%rsp)
cmpl $0x2, %r12d
je 0x22efc
cmpl $0x6, %r12d
je 0x22efe
cmpq 0x8(%rsp), %r13
je 0x22f8d
movl 0x1d8(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1d8(%rbx)
cmpl $0x1, %eax
jg 0x22f2c
movq %rbx, %rdi
callq 0x3d4e2
testl %eax, %eax
je 0x22f2c
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r12, %rdx
callq 0x1d8c6
jmp 0x22efe
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq %r12, %rdx
callq 0x1d8c6
jmp 0x22eee
|
JS_OrdinaryIsInstanceOf:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, r8
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov [rsp+58h+var_38], rsi
mov [rsp+58h+var_48], rcx
mov rsi, rcx
mov rdx, r8
call JS_IsFunction
xor ebp, ebp
test eax, eax
jz loc_22F0D
mov rax, [rsp+58h+var_48]
cmp word ptr [rax+6], 0Eh
jnz short loc_22E73
mov rax, [rax+30h]
mov rcx, [rax]
mov r8, [rax+8]
mov rdi, rbx
mov rsi, r12
mov rdx, r15
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_IsInstanceOf
loc_22E73:
cmp r15d, 0FFFFFFFFh
jnz loc_22F0D
mov rsi, [rsp+58h+var_48]
mov rdi, rbx
mov rdx, r14
mov ecx, 3Ch ; '<'
mov r8, rsi
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r15, rdx
mov [rsp+58h+var_40], rax
mov ebp, 0FFFFFFFFh
cmp r15d, 0FFFFFFFFh
jz short loc_22ECF
cmp r15d, 6
jz short loc_22EFE
lea rsi, aOperandPrototy; "operand 'prototype' property is not an "...
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_22EFE
loc_22ECF:
mov r13, [rsp+58h+var_40]
mov rax, [rsp+58h+var_38]
loc_22ED9:
mov rcx, [rax+18h]
mov rcx, [rcx+38h]
test rcx, rcx
jz short loc_22EF5
mov rax, rcx
cmp r13, rcx
jnz short loc_22ED9
loc_22EEE:
mov ebp, 1
jmp short loc_22EFE
loc_22EF5:
cmp word ptr [rax+6], 30h ; '0'
jz short loc_22F1E
loc_22EFC:
xor ebp, ebp
loc_22EFE:
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
loc_22F0D:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_22F1E:
inc dword ptr [rax]
mov [rsp+58h+var_50], rax
mov r12, 0FFFFFFFFFFFFFFFFh
loc_22F2C:
mov rsi, [rsp+58h+var_50]
mov rdi, rbx
mov rdx, r12
call JS_GetPrototypeFree
mov r12, rdx
mov [rsp+58h+var_50], rax
cmp r12d, 2
jz short loc_22EFC
cmp r12d, 6
jz short loc_22EFE
cmp r13, [rsp+58h+var_50]
jz short loc_22F8D
mov eax, [rbx+1D8h]
lea ecx, [rax-1]
mov [rbx+1D8h], ecx
cmp eax, 1
jg short loc_22F2C
mov rdi, rbx
call __js_poll_interrupts
test eax, eax
jz short loc_22F2C
mov rsi, [rsp+58h+var_50]
mov rdi, [rbx+18h]
mov rdx, r12
call JS_FreeValueRT
jmp loc_22EFE
loc_22F8D:
mov rsi, [rsp+58h+var_50]
mov rdi, [rbx+18h]
mov rdx, r12
call JS_FreeValueRT
jmp loc_22EEE
|
long long JS_OrdinaryIsInstanceOf(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
unsigned int v18; // ebp
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
_DWORD *PropertyInternal2; // r14
__m128 v25; // xmm4
__m128 v26; // xmm5
long long v27; // r15
long long v28; // rax
_DWORD *v29; // rcx
long long v30; // r12
_DWORD *PrototypeFree; // rax
long long v32; // rdx
int v33; // eax
char v34; // [rsp+0h] [rbp-58h]
_DWORD *v35; // [rsp+8h] [rbp-50h]
v18 = 0;
if ( (unsigned int)JS_IsFunction(a1, a4, a5) )
{
if ( *(_WORD *)(a4 + 6) == 14 )
return JS_IsInstanceOf(
a1,
a2,
a3,
**(_QWORD **)(a4 + 48),
*(_QWORD *)(*(_QWORD *)(a4 + 48) + 8LL),
v15,
a6,
a7,
a8,
a9,
v16,
v17,
a12,
a13);
if ( (_DWORD)a3 == -1 )
{
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, a4, a5, 60, a4, a5, 0LL, 0);
v27 = v20;
v18 = -1;
if ( (_DWORD)v20 == -1 )
{
v28 = a2;
while ( 1 )
{
v29 = *(_DWORD **)(*(_QWORD *)(v28 + 24) + 56LL);
if ( !v29 )
break;
v28 = *(_QWORD *)(*(_QWORD *)(v28 + 24) + 56LL);
if ( PropertyInternal2 == v29 )
{
LABEL_11:
v18 = 1;
goto LABEL_14;
}
}
if ( *(_WORD *)(v28 + 6) == 48 )
{
++*(_DWORD *)v28;
v35 = (_DWORD *)v28;
v30 = -1LL;
while ( 1 )
{
PrototypeFree = (_DWORD *)JS_GetPrototypeFree(a1, v35, v30);
v30 = v32;
v35 = PrototypeFree;
if ( (_DWORD)v32 == 2 )
break;
if ( (_DWORD)v32 == 6 )
goto LABEL_14;
if ( PropertyInternal2 == PrototypeFree )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PrototypeFree, v32);
goto LABEL_11;
}
v33 = *(_DWORD *)(a1 + 472);
*(_DWORD *)(a1 + 472) = v33 - 1;
if ( v33 <= 1 && (unsigned int)_js_poll_interrupts(a1) )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v35, v30);
goto LABEL_14;
}
}
}
v18 = 0;
}
else if ( (_DWORD)v20 != 6 )
{
JS_ThrowTypeError(
a1,
(long long)"operand 'prototype' property is not an object",
v20,
v21,
v22,
v23,
a6,
a7,
a8,
a9,
v25,
v26,
a12,
a13,
v34);
}
LABEL_14:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), PropertyInternal2, v27);
}
}
return v18;
}
| |||
9,522 |
JS_OrdinaryIsInstanceOf
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_OrdinaryIsInstanceOf(JSContext *ctx, JSValue val,
JSValue obj)
{
JSValue obj_proto;
JSObject *proto;
const JSObject *p, *proto1;
BOOL ret;
if (!JS_IsFunction(ctx, obj))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id == JS_CLASS_BOUND_FUNCTION) {
JSBoundFunction *s = p->u.bound_function;
return JS_IsInstanceOf(ctx, val, s->func_obj);
}
/* Only explicitly boxed values are instances of constructors */
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
obj_proto = JS_GetProperty(ctx, obj, JS_ATOM_prototype);
if (JS_VALUE_GET_TAG(obj_proto) != JS_TAG_OBJECT) {
if (!JS_IsException(obj_proto))
JS_ThrowTypeError(ctx, "operand 'prototype' property is not an object");
ret = -1;
goto done;
}
proto = JS_VALUE_GET_OBJ(obj_proto);
p = JS_VALUE_GET_OBJ(val);
for(;;) {
proto1 = p->shape->proto;
if (!proto1) {
/* slow case if proxy in the prototype chain */
if (unlikely(p->class_id == JS_CLASS_PROXY)) {
JSValue obj1;
obj1 = js_dup(JS_MKPTR(JS_TAG_OBJECT, (JSObject *)p));
for(;;) {
obj1 = JS_GetPrototypeFree(ctx, obj1);
if (JS_IsException(obj1)) {
ret = -1;
break;
}
if (JS_IsNull(obj1)) {
ret = FALSE;
break;
}
if (proto == JS_VALUE_GET_OBJ(obj1)) {
JS_FreeValue(ctx, obj1);
ret = TRUE;
break;
}
/* must check for timeout to avoid infinite loop */
if (js_poll_interrupts(ctx)) {
JS_FreeValue(ctx, obj1);
ret = -1;
break;
}
}
} else {
ret = FALSE;
}
break;
}
p = proto1;
if (proto == p) {
ret = TRUE;
break;
}
}
done:
JS_FreeValue(ctx, obj_proto);
return ret;
}
|
O2
|
c
|
JS_OrdinaryIsInstanceOf:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rsi
movq %r8, %rdx
callq 0x1ce7d
xorl %ebp, %ebp
testl %eax, %eax
je 0x1cf8f
cmpw $0xe, 0x6(%r15)
jne 0x1cf18
movq 0x30(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ccbb
cmpl $-0x1, %r13d
jne 0x1cf8f
pushq $0x3c
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1b043
movq %rax, %r15
movq %rdx, %r14
pushq $-0x1
popq %rbp
cmpl $0x6, %r14d
je 0x1cf81
cmpl $-0x1, %r14d
jne 0x1cf63
pushq $0x1
popq %r13
movq 0x18(%r12), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1cf76
movq %rax, %r12
cmpq %r15, %rax
jne 0x1cf48
movl %r13d, %ebp
jmp 0x1cf81
leaq 0x68feb(%rip), %rsi # 0x85f55
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x1cf81
cmpw $0x30, 0x6(%r12)
je 0x1cfa0
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1801e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl (%r12)
pushq $-0x1
popq %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x35dad
cmpl $0x2, %edx
je 0x1cf7f
movq %rdx, (%rsp)
cmpl $0x6, %edx
je 0x1cf81
movq %rax, %r12
movq %rbx, %rdi
cmpq %rax, %r15
je 0x1cfed
callq 0x35de8
testl %eax, %eax
je 0x1cfab
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1801e
jmp 0x1cf81
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1801e
jmp 0x1cf5e
|
JS_OrdinaryIsInstanceOf:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rcx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov rsi, rcx
mov rdx, r8
call JS_IsFunction
xor ebp, ebp
test eax, eax
jz loc_1CF8F
cmp word ptr [r15+6], 0Eh
jnz short loc_1CF18
mov rax, [r15+30h]
mov rcx, [rax]
mov r8, [rax+8]
mov rdi, rbx
mov rsi, r12
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_IsInstanceOf
loc_1CF18:
cmp r13d, 0FFFFFFFFh
jnz short loc_1CF8F
push 3Ch ; '<'
pop rcx
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetProperty
mov r15, rax
mov r14, rdx
push 0FFFFFFFFFFFFFFFFh
pop rbp
cmp r14d, 6
jz short loc_1CF81
cmp r14d, 0FFFFFFFFh
jnz short loc_1CF63
push 1
pop r13
loc_1CF48:
mov rax, [r12+18h]
mov rax, [rax+38h]
test rax, rax
jz short loc_1CF76
mov r12, rax
cmp rax, r15
jnz short loc_1CF48
loc_1CF5E:
mov ebp, r13d
jmp short loc_1CF81
loc_1CF63:
lea rsi, aOperandPrototy; "operand 'prototype' property is not an "...
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_1CF81
loc_1CF76:
cmp word ptr [r12+6], 30h ; '0'
jz short loc_1CFA0
loc_1CF7F:
xor ebp, ebp
loc_1CF81:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
loc_1CF8F:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1CFA0:
inc dword ptr [r12]
push 0FFFFFFFFFFFFFFFFh
pop rax
mov [rsp+38h+var_38], rax
loc_1CFAB:
mov rdi, rbx
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_GetPrototypeFree
cmp edx, 2
jz short loc_1CF7F
mov [rsp+38h+var_38], rdx
cmp edx, 6
jz short loc_1CF81
mov r12, rax
mov rdi, rbx
cmp r15, rax
jz short loc_1CFED
call js_poll_interrupts
test eax, eax
jz short loc_1CFAB
mov rdi, rbx
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
jmp short loc_1CF81
loc_1CFED:
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
jmp loc_1CF5E
|
long long JS_OrdinaryIsInstanceOf(
long long a1,
long long a2,
long long a3,
long long a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
char v13; // al
long long v17; // r12
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
unsigned int v21; // ebp
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
long long Property; // r15
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v30; // r14
long long v31; // rax
long long PrototypeFree; // rax
long long v33; // rdx
char v34; // [rsp+0h] [rbp-38h]
long long v35; // [rsp+0h] [rbp-38h]
v34 = v13;
v17 = a2;
v21 = 0;
if ( (unsigned int)JS_IsFunction(a1, a4, a5) )
{
if ( *(_WORD *)(a4 + 6) == 14 )
return JS_IsInstanceOf(
a1,
a2,
a3,
**(_QWORD **)(a4 + 48),
*(_QWORD *)(*(_QWORD *)(a4 + 48) + 8LL),
v18,
a6,
a7,
a8,
a9,
v19,
v20,
a12,
a13);
if ( (_DWORD)a3 == -1 )
{
Property = JS_GetProperty(a1, a4, a5, 60);
v30 = v23;
v21 = -1;
if ( (_DWORD)v23 != 6 )
{
if ( (_DWORD)v23 == -1 )
{
while ( 1 )
{
v31 = *(_QWORD *)(*(_QWORD *)(v17 + 24) + 56LL);
if ( !v31 )
break;
v17 = *(_QWORD *)(*(_QWORD *)(v17 + 24) + 56LL);
if ( v31 == Property )
{
LABEL_9:
v21 = 1;
goto LABEL_13;
}
}
if ( *(_WORD *)(v17 + 6) == 48 )
{
++*(_DWORD *)v17;
v35 = -1LL;
while ( 1 )
{
PrototypeFree = JS_GetPrototypeFree(a1, v17, v35);
if ( (_DWORD)v33 == 2 )
break;
v35 = v33;
if ( (_DWORD)v33 == 6 )
goto LABEL_13;
v17 = PrototypeFree;
if ( Property == PrototypeFree )
{
JS_FreeValue(a1, PrototypeFree, v33);
goto LABEL_9;
}
if ( (unsigned int)js_poll_interrupts(a1) )
{
JS_FreeValue(a1, v17, v35);
goto LABEL_13;
}
}
}
v21 = 0;
}
else
{
JS_ThrowTypeError(
a1,
(long long)"operand 'prototype' property is not an object",
v23,
v24,
v25,
v26,
a6,
a7,
a8,
a9,
v28,
v29,
a12,
a13,
v34);
}
}
LABEL_13:
JS_FreeValue(a1, Property, v30);
}
}
return v21;
}
|
JS_OrdinaryIsInstanceOf:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RCX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RCX
MOV RDX,R8
CALL 0x0011ce7d
XOR EBP,EBP
TEST EAX,EAX
JZ 0x0011cf8f
CMP word ptr [R15 + 0x6],0xe
JNZ 0x0011cf18
MOV RAX,qword ptr [R15 + 0x30]
MOV RCX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011ccbb
LAB_0011cf18:
CMP R13D,-0x1
JNZ 0x0011cf8f
PUSH 0x3c
POP RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011b043
MOV R15,RAX
MOV R14,RDX
PUSH -0x1
POP RBP
CMP R14D,0x6
JZ 0x0011cf81
CMP R14D,-0x1
JNZ 0x0011cf63
PUSH 0x1
POP R13
LAB_0011cf48:
MOV RAX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [RAX + 0x38]
TEST RAX,RAX
JZ 0x0011cf76
MOV R12,RAX
CMP RAX,R15
JNZ 0x0011cf48
LAB_0011cf5e:
MOV EBP,R13D
JMP 0x0011cf81
LAB_0011cf63:
LEA RSI,[0x185f55]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x0011cf81
LAB_0011cf76:
CMP word ptr [R12 + 0x6],0x30
JZ 0x0011cfa0
LAB_0011cf7f:
XOR EBP,EBP
LAB_0011cf81:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011801e
LAB_0011cf8f:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011cfa0:
INC dword ptr [R12]
PUSH -0x1
POP RAX
MOV qword ptr [RSP],RAX
LAB_0011cfab:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x00135dad
CMP EDX,0x2
JZ 0x0011cf7f
MOV qword ptr [RSP],RDX
CMP EDX,0x6
JZ 0x0011cf81
MOV R12,RAX
MOV RDI,RBX
CMP R15,RAX
JZ 0x0011cfed
CALL 0x00135de8
TEST EAX,EAX
JZ 0x0011cfab
MOV RDI,RBX
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011801e
JMP 0x0011cf81
LAB_0011cfed:
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011801e
JMP 0x0011cf5e
|
ulong JS_OrdinaryIsInstanceOf
(int8 param_1,int *param_2,int8 param_3,long param_4,int8 param_5)
{
int iVar1;
ulong uVar2;
int *piVar3;
int1 auVar5 [16];
int1 auVar6 [16];
int8 local_38;
int *piVar4;
iVar1 = JS_IsFunction(param_1,param_4,param_5);
uVar2 = 0;
if (iVar1 == 0) goto LAB_0011cf8f;
if (*(short *)(param_4 + 6) == 0xe) {
uVar2 = JS_IsInstanceOf(param_1,param_2,param_3,**(int8 **)(param_4 + 0x30),
(*(int8 **)(param_4 + 0x30))[1]);
return uVar2;
}
if ((int)param_3 != -1) goto LAB_0011cf8f;
auVar5 = JS_GetProperty(param_1,param_4,param_5,0x3c);
piVar3 = auVar5._0_8_;
uVar2 = 0xffffffffffffffff;
if (auVar5._8_4_ != 6) {
if (auVar5._8_4_ == -1) {
do {
piVar4 = *(int **)(*(long *)(param_2 + 6) + 0x38);
if (piVar4 == (int *)0x0) {
if (*(short *)((long)param_2 + 6) != 0x30) goto LAB_0011cf7f;
*param_2 = *param_2 + 1;
auVar6._8_8_ = 0xffffffffffffffff;
auVar6._0_8_ = param_2;
goto LAB_0011cfab;
}
param_2 = piVar4;
} while (piVar4 != piVar3);
LAB_0011cf5e:
uVar2 = 1;
}
else {
JS_ThrowTypeError(param_1,"operand \'prototype\' property is not an object");
}
}
goto LAB_0011cf81;
LAB_0011cf7f:
uVar2 = 0;
goto LAB_0011cf81;
while( true ) {
if (auVar6._8_4_ == 6) goto LAB_0011cf81;
if (piVar3 == piVar4) {
JS_FreeValue(param_1,piVar4,auVar6._8_8_);
goto LAB_0011cf5e;
}
iVar1 = js_poll_interrupts();
if (iVar1 != 0) break;
LAB_0011cfab:
local_38 = auVar6._8_8_;
auVar6 = JS_GetPrototypeFree(param_1,auVar6._0_8_,local_38);
piVar4 = auVar6._0_8_;
if (auVar6._8_4_ == 2) goto LAB_0011cf7f;
}
JS_FreeValue(param_1,piVar4,auVar6._8_8_);
LAB_0011cf81:
JS_FreeValue(param_1,piVar3,auVar5._8_8_);
LAB_0011cf8f:
return uVar2 & 0xffffffff;
}
|
|
9,523 |
JS_SetPropertyFunctionList
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_SetPropertyFunctionList(JSContext *ctx, JSValue obj,
const JSCFunctionListEntry *tab, int len)
{
int i;
for (i = 0; i < len; i++) {
const JSCFunctionListEntry *e = &tab[i];
JSAtom atom = find_atom(ctx, e->name);
JS_InstantiateFunctionListItem(ctx, obj, atom, e);
JS_FreeAtom(ctx, atom);
}
}
|
O1
|
c
|
JS_SetPropertyFunctionList:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
testl %r8d, %r8d
jle 0x32f8b
movq %rcx, %rbx
movq %rdi, %r12
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rsp)
movl %r8d, %r14d
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x32fa2
movl %eax, %r13d
movzbl 0x9(%rbx), %eax
cmpq $0x9, %rax
ja 0x32f9d
movzbl 0x8(%rbx), %edx
leaq 0x69ba8(%rip), %rcx # 0x9c86c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x10(%rbx)
movl %edx, 0x1c(%rsp)
je 0x32e08
movq (%rbx), %rcx
movl $0x40, %esi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
leaq 0x6cd88(%rip), %rdx # 0x9fa7b
xorl %eax, %eax
callq 0xe2d0
xorl %eax, %eax
cmpb $0x2, 0x9(%rbx)
movq 0x10(%rbx), %rsi
sete %al
leal 0x8(,%rax,2), %r8d
movswl 0xa(%rbx), %r9d
movq 0x38(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x21006
movq %rax, %r15
movq %rdx, %rbp
movl 0x1c(%rsp), %edx
jmp 0x32e10
cmpl $0xd3, %r13d
je 0x32eb8
cmpl $0xdc, %r13d
jne 0x32ebd
xorl %edx, %edx
jmp 0x32ebd
movl %edx, 0x1c(%rsp)
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x32fa2
movl 0x18(%rbx), %ecx
cmpl $0x1, %ecx
movl %eax, 0x34(%rsp)
je 0x32ef5
testl %ecx, %ecx
je 0x32ee3
cmpl $-0x1, %ecx
jne 0x32f9d
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
jmp 0x32f15
movq 0x10(%rbx), %rbp
movl $0x7, %r15d
jmp 0x32f55
movl 0x10(%rbx), %ebp
xorl %r15d, %r15d
jmp 0x32f55
movq 0x10(%rbx), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movl %ecx, %eax
movq %xmm0, %rbp
cmoveq %rax, %rbp
movl $0x7, %r15d
movl $0x0, %eax
cmoveq %rax, %r15
jmp 0x32f55
movl $0x3, %r15d
xorl %ebp, %ebp
jmp 0x32f55
movl $0x3, %ebp
xorl %r15d, %r15d
movl $0x0, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x32e89
movq (%rbx), %rcx
movl $0x40, %esi
leaq 0x50(%rsp), %rdi
leaq 0x6cc46(%rip), %rdx # 0x9fa82
xorl %eax, %eax
callq 0xe2d0
xorl %eax, %eax
cmpb $0x2, 0x9(%rbx)
movq 0x18(%rbx), %rsi
sete %al
leal 0x9(,%rax,2), %r8d
movswl 0xa(%rbx), %r9d
movq 0x38(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
leaq 0x50(%rsp), %rdx
movl $0x1, %ecx
callq 0x21006
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl 0x1c(%rsp), %edx
movupd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
movl %edx, 0x10(%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movq %r15, %r8
movq %rbp, %r9
callq 0x26cc9
jmp 0x32f73
movl $0x1, %edx
movl %edx, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movl $0x2, %r8d
movq %rbx, %r9
callq 0x41517
jmp 0x32f73
movq 0x1a0(%r12), %rsi
movq 0x1a8(%r12), %rdx
jmp 0x32f02
movq 0x40(%r12), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r12, %rdi
movl %eax, %ecx
movq %rsi, %r8
movq %rdx, %r9
callq 0x22fa3
movq %rax, %rbp
movq %rdx, %r15
movq %r12, %rdi
movl 0x34(%rsp), %esi
callq 0x207d8
cmpl $0xd3, %r13d
je 0x32f4a
cmpl $0xdc, %r13d
jne 0x32f51
xorl %edx, %edx
jmp 0x32f55
movl $0x1, %edx
jmp 0x32f55
movl 0x1c(%rsp), %edx
movl %edx, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %ecx
movq %rbp, %r8
movq %r15, %r9
callq 0x26abb
movq %r12, %rdi
movl %r13d, %esi
callq 0x207d8
addq $0x20, %rbx
decq %r14
jne 0x32c9d
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
|
JS_SetPropertyFunctionList:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], rdx
mov [rsp+0C8h+var_A8], rsi
test r8d, r8d
jle loc_32F8B
mov rbx, rcx
mov r12, rdi
lea rax, [rdi+48h]
mov [rsp+0C8h+var_90], rax
mov r14d, r8d
loc_32C9D:
mov rsi, [rbx]
mov rdi, r12
call find_atom
mov r13d, eax
movzx eax, byte ptr [rbx+9]
cmp rax, 9; switch 10 cases
ja def_32CCB; jumptable 0000000000032CCB default case
movzx edx, byte ptr [rbx+8]
lea rcx, jpt_32CCB
movsxd rax, ds:(jpt_32CCB - 9C86Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_32CCD:
cmp qword ptr [rbx+10h], 0; jumptable 0000000000032CCB cases 1,2
mov [rsp+0C8h+var_AC], edx
jz loc_32E08
mov rcx, [rbx]
mov esi, 40h ; '@'
lea r15, [rsp+0C8h+var_78]
mov rdi, r15
lea rdx, aGetS; "get %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [rbx+9], 2
mov rsi, [rbx+10h]
setz al
lea r8d, ds:8[rax*2]
movsx r9d, word ptr [rbx+0Ah]
mov rax, [rsp+0C8h+var_90]
movups xmm0, xmmword ptr [rax]
movups [rsp+0C8h+var_C8], xmm0
mov rdi, r12
mov rdx, r15
xor ecx, ecx
call JS_NewCFunction3
mov r15, rax
mov rbp, rdx
mov edx, [rsp+0C8h+var_AC]
jmp loc_32E10
loc_32D3C:
cmp r13d, 0D3h; jumptable 0000000000032CCB case 0
jz loc_32EB8
cmp r13d, 0DCh
jnz loc_32EBD; jumptable 0000000000032CCB cases 3,8
xor edx, edx
jmp loc_32EBD; jumptable 0000000000032CCB cases 3,8
loc_32D5D:
mov [rsp+0C8h+var_AC], edx; jumptable 0000000000032CCB case 9
mov rsi, [rbx+10h]
mov rdi, r12
call find_atom
mov ecx, [rbx+18h]
cmp ecx, 1
mov [rsp+0C8h+var_94], eax
jz loc_32EF5
test ecx, ecx
jz loc_32EE3
cmp ecx, 0FFFFFFFFh
jnz def_32CCB; jumptable 0000000000032CCB default case
mov dword ptr [rsp+0C8h+var_C8+8], 0
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
jmp loc_32F15
loc_32DB0:
mov rbp, [rbx+10h]; jumptable 0000000000032CCB case 6
mov r15d, 7
jmp loc_32F55
loc_32DBF:
mov ebp, [rbx+10h]; jumptable 0000000000032CCB case 4
xor r15d, r15d
jmp loc_32F55
loc_32DCA:
mov rax, [rbx+10h]; jumptable 0000000000032CCB case 5
movsxd rcx, eax
cmp rcx, rax
xorps xmm0, xmm0
cvtsi2sd xmm0, rax
mov eax, ecx
movq rbp, xmm0
cmovz rbp, rax
mov r15d, 7
mov eax, 0
cmovz r15, rax
jmp loc_32F55
loc_32DFB:
mov r15d, 3; jumptable 0000000000032CCB case 7
xor ebp, ebp
jmp loc_32F55
loc_32E08:
mov ebp, 3
xor r15d, r15d
loc_32E10:
mov dword ptr [rsp+0C8h+var_88], 0
mov qword ptr [rsp+0C8h+var_88+8], 3
cmp qword ptr [rbx+18h], 0
jz short loc_32E89
mov rcx, [rbx]
mov esi, 40h ; '@'
lea rdi, [rsp+0C8h+var_78]
lea rdx, aSetS; "set %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [rbx+9], 2
mov rsi, [rbx+18h]
setz al
lea r8d, ds:9[rax*2]
movsx r9d, word ptr [rbx+0Ah]
mov rax, [rsp+0C8h+var_90]
movups xmm0, xmmword ptr [rax]
movups [rsp+0C8h+var_C8], xmm0
mov rdi, r12
lea rdx, [rsp+0C8h+var_78]
mov ecx, 1
call JS_NewCFunction3
mov qword ptr [rsp+0C8h+var_88], rax
mov qword ptr [rsp+0C8h+var_88+8], rdx
mov edx, [rsp+0C8h+var_AC]
loc_32E89:
movupd xmm0, [rsp+0C8h+var_88]
movupd [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B8], edx
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8, r15
mov r9, rbp
call JS_DefinePropertyGetSet
jmp loc_32F73
loc_32EB8:
mov edx, 1
loc_32EBD:
mov dword ptr [rsp+0C8h+var_C8], edx; jumptable 0000000000032CCB cases 3,8
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8d, 2
mov r9, rbx
call JS_DefineAutoInitProperty
jmp loc_32F73
loc_32EE3:
mov rsi, [r12+1A0h]
mov rdx, [r12+1A8h]
jmp short loc_32F02
loc_32EF5:
mov rcx, [r12+40h]
mov rsi, [rcx+20h]
mov rdx, [rcx+28h]
loc_32F02:
mov dword ptr [rsp+0C8h+var_C8+8], 0
mov qword ptr [rsp+0C8h+var_C8], 0
mov rdi, r12
loc_32F15:
mov ecx, eax
mov r8, rsi
mov r9, rdx
call JS_GetPropertyInternal2
mov rbp, rax
mov r15, rdx
mov rdi, r12
mov esi, [rsp+0C8h+var_94]
call JS_FreeAtom
cmp r13d, 0D3h
jz short loc_32F4A
cmp r13d, 0DCh
jnz short loc_32F51
xor edx, edx
jmp short loc_32F55
loc_32F4A:
mov edx, 1
jmp short loc_32F55
loc_32F51:
mov edx, [rsp+0C8h+var_AC]
loc_32F55:
mov dword ptr [rsp+0C8h+var_C8], edx
mov rdi, r12
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
mov ecx, r13d
mov r8, rbp
mov r9, r15
call JS_DefinePropertyValue
loc_32F73:
mov rdi, r12
mov esi, r13d
call JS_FreeAtom
add rbx, 20h ; ' '
dec r14
jnz loc_32C9D
loc_32F8B:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_32CCB:
call _abort; jumptable 0000000000032CCB default case
|
void JS_SetPropertyFunctionList(
long long a1,
unsigned long long a2,
long long a3,
const char **a4,
int a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v15; // r14
const char *v16; // rsi
const char *v17; // rdi
unsigned int atom; // r13d
__m128 v19; // xmm4
__m128 v20; // xmm5
__int128 v21; // rax
_DWORD *v22; // r15
long long v23; // rbp
int v24; // ecx
unsigned long long PropertyInternal2; // rax
long long v26; // rdx
double v27; // rbp
long long v28; // r15
const char *v29; // rax
long long v30; // rsi
long long v31; // rcx
int v32; // [rsp+1Ch] [rbp-ACh]
int v33; // [rsp+1Ch] [rbp-ACh]
int v36; // [rsp+34h] [rbp-94h]
long long *v37; // [rsp+38h] [rbp-90h]
__int128 v38; // [rsp+40h] [rbp-88h]
unsigned __int8 v39[120]; // [rsp+50h] [rbp-78h] BYREF
if ( a5 > 0 )
{
v37 = (long long *)(a1 + 72);
v15 = (unsigned int)a5;
while ( 1 )
{
v16 = *a4;
v17 = (const char *)a1;
atom = find_atom(a1, *a4);
*((_QWORD *)&v21 + 1) = *((unsigned __int8 *)a4 + 8);
switch ( *((_BYTE *)a4 + 9) )
{
case 0:
if ( atom == 211 )
{
DWORD2(v21) = 1;
}
else if ( atom == 220 )
{
DWORD2(v21) = 0;
}
goto LABEL_26;
case 1:
case 2:
v32 = *((unsigned __int8 *)a4 + 8);
if ( a4[2] )
{
snprintf(v39, 64LL, "get %s", *a4);
v22 = (_DWORD *)JS_NewCFunction3(
(_DWORD *)a1,
(long long)a4[2],
v39,
0,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 8,
*((_WORD *)a4 + 5),
*v37,
v37[1]);
v23 = *((_QWORD *)&v21 + 1);
DWORD2(v21) = v32;
}
else
{
v23 = 3LL;
v22 = 0LL;
}
LODWORD(v38) = 0;
*((_QWORD *)&v38 + 1) = 3LL;
if ( a4[3] )
{
snprintf(v39, 64LL, "set %s", *a4);
*(_QWORD *)&v21 = JS_NewCFunction3(
(_DWORD *)a1,
(long long)a4[3],
v39,
1u,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 9,
*((_WORD *)a4 + 5),
*v37,
v37[1]);
v38 = v21;
DWORD2(v21) = v32;
}
a6 = *(double *)&v38;
JS_DefinePropertyGetSet(
a1,
a2,
a3,
atom,
v22,
v23,
*(double *)&v38,
a7,
a8,
a9,
v19,
v20,
a12,
a13,
v38,
SDWORD2(v21));
goto LABEL_36;
case 3:
case 8:
LABEL_26:
JS_DefineAutoInitProperty(a1, a2, a3, atom, 2, (_DWORD)a4, DWORD2(v21));
goto LABEL_36;
case 4:
*(_QWORD *)&v27 = *((unsigned int *)a4 + 4);
v28 = 0LL;
goto LABEL_35;
case 5:
v29 = a4[2];
a6 = (double)(int)v29;
v27 = (double)(int)v29;
if ( (const char *)(int)v29 == v29 )
*(_QWORD *)&v27 = (unsigned int)v29;
v28 = 7LL;
if ( (const char *)(int)v29 == v29 )
v28 = 0LL;
goto LABEL_35;
case 6:
v27 = *((double *)a4 + 2);
v28 = 7LL;
goto LABEL_35;
case 7:
v28 = 3LL;
v27 = 0.0;
goto LABEL_35;
case 9:
v33 = *((unsigned __int8 *)a4 + 8);
v16 = a4[2];
v17 = (const char *)a1;
LODWORD(v21) = find_atom(a1, v16);
v24 = *((_DWORD *)a4 + 6);
v36 = v21;
if ( v24 == 1 )
{
v31 = *(_QWORD *)(a1 + 64);
v30 = *(_QWORD *)(v31 + 32);
*((_QWORD *)&v21 + 1) = *(_QWORD *)(v31 + 40);
goto LABEL_29;
}
if ( !v24 )
{
v30 = *(_QWORD *)(a1 + 416);
*((_QWORD *)&v21 + 1) = *(_QWORD *)(a1 + 424);
LABEL_29:
PropertyInternal2 = JS_GetPropertyInternal2(
a1,
v30,
*((long long *)&v21 + 1),
v21,
v30,
*((long long *)&v21 + 1),
0LL,
0);
goto LABEL_30;
}
if ( v24 != -1 )
LABEL_38:
abort(v17, v16, *((_QWORD *)&v21 + 1));
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, v21, a2, a3, 0LL, 0);
LABEL_30:
v27 = *(double *)&PropertyInternal2;
v28 = v26;
JS_FreeAtom(a1, v36);
if ( atom == 211 )
{
DWORD2(v21) = 1;
}
else if ( atom == 220 )
{
DWORD2(v21) = 0;
}
else
{
DWORD2(v21) = v33;
}
LABEL_35:
JS_DefinePropertyValue(
a1,
a2,
a3,
atom,
*(_DWORD **)&v27,
v28,
a6,
a7,
a8,
a9,
v19,
v20,
a12,
a13,
SDWORD2(v21));
LABEL_36:
JS_FreeAtom(a1, atom);
a4 += 4;
if ( !--v15 )
return;
break;
default:
goto LABEL_38;
}
}
}
}
| |||
9,524 |
JS_SetPropertyFunctionList
|
bluesky950520[P]quickjs/quickjs.c
|
void JS_SetPropertyFunctionList(JSContext *ctx, JSValue obj,
const JSCFunctionListEntry *tab, int len)
{
int i;
for (i = 0; i < len; i++) {
const JSCFunctionListEntry *e = &tab[i];
JSAtom atom = find_atom(ctx, e->name);
JS_InstantiateFunctionListItem(ctx, obj, atom, e);
JS_FreeAtom(ctx, atom);
}
}
|
O2
|
c
|
JS_SetPropertyFunctionList:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %r13
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %ebx
subq $0x1, %rbx
jb 0x2c6a9
movq (%r14), %rsi
movq %r13, %rdi
callq 0x2c6c0
movl %eax, %ebp
movzbl 0x9(%r14), %eax
cmpq $0x9, %rax
ja 0x2c6bb
movzbl 0x8(%r14), %edx
leaq 0x573af(%rip), %rcx # 0x8380c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x10(%r14)
movl %edx, 0x24(%rsp)
je 0x2c56b
movq (%r14), %rcx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
pushq $0x40
popq %rsi
leaq 0x5a541(%rip), %rdx # 0x869cb
xorl %eax, %eax
callq 0xe2e0
xorl %eax, %eax
cmpb $0x2, 0x9(%r14)
movq 0x10(%r14), %rsi
sete %al
leal 0x8(%rax,%rax), %r8d
movswl 0xa(%r14), %r9d
movq %r13, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1b2dd
movq %rax, %r15
movq %rdx, %r12
movl 0x24(%rsp), %edx
jmp 0x2c572
movl %edx, (%rsp)
jmp 0x2c607
pushq $0x1
popq %rax
cmpl $0xd3, %ebp
je 0x2c604
cmpl $0xdc, %ebp
jne 0x2c602
xorl %eax, %eax
jmp 0x2c604
movl %edx, 0x24(%rsp)
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x2c6c0
movl 0x18(%r14), %ecx
cmpl $0x1, %ecx
movl %eax, 0x3c(%rsp)
je 0x2c634
testl %ecx, %ecx
je 0x2c624
cmpl $-0x1, %ecx
jne 0x2c6bb
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
jmp 0x2c643
movq 0x10(%r14), %r15
pushq $0x7
jmp 0x2c564
movl 0x10(%r14), %r15d
xorl %r12d, %r12d
jmp 0x2c674
movq 0x10(%r14), %rdi
movl %edx, 0x24(%rsp)
callq 0x20a0b
movq %rax, %r15
movq %rdx, %r12
jmp 0x2c670
xorl %r15d, %r15d
pushq $0x3
popq %r12
jmp 0x2c674
xorl %r15d, %r15d
pushq $0x3
popq %r12
andl $0x0, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
cmpq $0x0, 0x18(%r14)
je 0x2c5d6
movq (%r14), %rcx
leaq 0x50(%rsp), %rdi
pushq $0x40
popq %rsi
leaq 0x5a439(%rip), %rdx # 0x869d2
xorl %eax, %eax
callq 0xe2e0
xorl %eax, %eax
cmpb $0x2, 0x9(%r14)
movq 0x18(%r14), %rsi
sete %al
leal 0x9(%rax,%rax), %r8d
movswl 0xa(%r14), %r9d
movq %r13, %rdi
leaq 0x50(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x1b2dd
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movl 0x24(%rsp), %edx
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %edx, 0x10(%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x20a89
jmp 0x2c691
movl %edx, %eax
movl %eax, (%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
pushq $0x2
popq %r8
movq %r14, %r9
callq 0x393f2
jmp 0x2c691
movq 0x1a0(%r13), %rsi
movq 0x1a8(%r13), %rdx
jmp 0x2c640
movq 0x40(%r13), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movq %r13, %rdi
movl %eax, %ecx
callq 0x1b043
movq %rax, %r15
movq %rdx, %r12
movq %r13, %rdi
movl 0x3c(%rsp), %esi
callq 0x1a995
cmpl $0xd3, %ebp
je 0x2c6a4
cmpl $0xdc, %ebp
jne 0x2c670
xorl %edx, %edx
jmp 0x2c674
movl 0x24(%rsp), %edx
movl %edx, (%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %ebp, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x20872
movq %r13, %rdi
movl %ebp, %esi
callq 0x1a995
addq $0x20, %r14
jmp 0x2c42b
pushq $0x1
popq %rdx
jmp 0x2c674
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
|
JS_SetPropertyFunctionList:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov ebx, r8d
mov r14, rcx
mov [rsp+0C8h+var_98], rdx
mov [rsp+0C8h+var_A0], rsi
mov r13, rdi
xor eax, eax
test r8d, r8d
cmovle ebx, eax
loc_2C42B:
sub rbx, 1
jb loc_2C6A9
mov rsi, [r14]
mov rdi, r13
call find_atom
mov ebp, eax
movzx eax, byte ptr [r14+9]
cmp rax, 9; switch 10 cases
ja def_2C464; jumptable 000000000002C464 default case
movzx edx, byte ptr [r14+8]
lea rcx, jpt_2C464
movsxd rax, ds:(jpt_2C464 - 8380Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2C466:
cmp qword ptr [r14+10h], 0; jumptable 000000000002C464 cases 1,2
mov [rsp+0C8h+var_A4], edx
jz loc_2C56B
mov rcx, [r14]
lea r15, [rsp+0C8h+var_78]
mov rdi, r15
push 40h ; '@'
pop rsi
lea rdx, aGetS; "get %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [r14+9], 2
mov rsi, [r14+10h]
setz al
lea r8d, [rax+rax+8]
movsx r9d, word ptr [r14+0Ah]
mov rdi, r13
mov rdx, r15
xor ecx, ecx
call JS_NewCFunction2
mov r15, rax
mov r12, rdx
mov edx, [rsp+0C8h+var_A4]
jmp loc_2C572
loc_2C4C5:
mov dword ptr [rsp+0C8h+var_C8], edx; jumptable 000000000002C464 cases 3,8
jmp loc_2C607
loc_2C4CD:
push 1; jumptable 000000000002C464 case 0
pop rax
cmp ebp, 0D3h
jz loc_2C604
cmp ebp, 0DCh
jnz loc_2C602
xor eax, eax
jmp loc_2C604
loc_2C4EF:
mov [rsp+0C8h+var_A4], edx; jumptable 000000000002C464 case 9
mov rsi, [r14+10h]
mov rdi, r13
call find_atom
mov ecx, [r14+18h]
cmp ecx, 1
mov [rsp+0C8h+var_8C], eax
jz loc_2C634
test ecx, ecx
jz loc_2C624
cmp ecx, 0FFFFFFFFh
jnz def_2C464; jumptable 000000000002C464 default case
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
jmp loc_2C643
loc_2C533:
mov r15, [r14+10h]; jumptable 000000000002C464 case 6
push 7
jmp short loc_2C564
loc_2C53B:
mov r15d, [r14+10h]; jumptable 000000000002C464 case 4
xor r12d, r12d
jmp loc_2C674
loc_2C547:
mov rdi, [r14+10h]; jumptable 000000000002C464 case 5
mov [rsp+0C8h+var_A4], edx
call js_int64
mov r15, rax
mov r12, rdx
jmp loc_2C670
loc_2C55F:
xor r15d, r15d; jumptable 000000000002C464 case 7
push 3
loc_2C564:
pop r12
jmp loc_2C674
loc_2C56B:
xor r15d, r15d
push 3
pop r12
loc_2C572:
and dword ptr [rsp+0C8h+var_88], 0
mov qword ptr [rsp+0C8h+var_88+8], 3
cmp qword ptr [r14+18h], 0
jz short loc_2C5D6
mov rcx, [r14]
lea rdi, [rsp+0C8h+var_78]
push 40h ; '@'
pop rsi
lea rdx, aSetS; "set %s"
xor eax, eax
call _snprintf
xor eax, eax
cmp byte ptr [r14+9], 2
mov rsi, [r14+18h]
setz al
lea r8d, [rax+rax+9]
movsx r9d, word ptr [r14+0Ah]
mov rdi, r13
lea rdx, [rsp+0C8h+var_78]
push 1
pop rcx
call JS_NewCFunction2
mov qword ptr [rsp+0C8h+var_88], rax
mov qword ptr [rsp+0C8h+var_88+8], rdx
mov edx, [rsp+0C8h+var_A4]
loc_2C5D6:
movups xmm0, [rsp+0C8h+var_88]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B8], edx
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
mov r8, r15
mov r9, r12
call JS_DefinePropertyGetSet
jmp loc_2C691
loc_2C602:
mov eax, edx
loc_2C604:
mov dword ptr [rsp+0C8h+var_C8], eax
loc_2C607:
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
push 2
pop r8
mov r9, r14
call JS_DefineAutoInitProperty
jmp short loc_2C691
loc_2C624:
mov rsi, [r13+1A0h]
mov rdx, [r13+1A8h]
jmp short loc_2C640
loc_2C634:
mov rcx, [r13+40h]
mov rsi, [rcx+20h]
mov rdx, [rcx+28h]
loc_2C640:
mov rdi, r13
loc_2C643:
mov ecx, eax
call JS_GetProperty
mov r15, rax
mov r12, rdx
mov rdi, r13
mov esi, [rsp+0C8h+var_8C]
call JS_FreeAtom
cmp ebp, 0D3h
jz short loc_2C6A4
cmp ebp, 0DCh
jnz short loc_2C670
xor edx, edx
jmp short loc_2C674
loc_2C670:
mov edx, [rsp+0C8h+var_A4]
loc_2C674:
mov dword ptr [rsp+0C8h+var_C8], edx
mov rdi, r13
mov rsi, [rsp+0C8h+var_A0]
mov rdx, [rsp+0C8h+var_98]
mov ecx, ebp
mov r8, r15
mov r9, r12
call JS_DefinePropertyValue
loc_2C691:
mov rdi, r13
mov esi, ebp
call JS_FreeAtom
add r14, 20h ; ' '
jmp loc_2C42B
loc_2C6A4:
push 1
pop rdx
jmp short loc_2C674
loc_2C6A9:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_2C464:
call _abort; jumptable 000000000002C464 default case
|
long long JS_SetPropertyFunctionList(
const char *a1,
long long a2,
long long a3,
const char **a4,
int a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rbx
long long result; // rax
const char *v18; // rsi
const char *v19; // rdi
unsigned int atom; // ebp
__m128 v21; // xmm4
__m128 v22; // xmm5
__int128 v23; // rax
_DWORD *v24; // r15
unsigned long long v25; // r12
int v26; // eax
int v27; // ecx
int v28; // edi
long long v29; // rsi
long long Property; // r15
long long v31; // r12
long long v32; // rdx
long long v33; // rcx
long long v34; // rdx
long long v35; // [rsp-8h] [rbp-D0h]
int v36; // [rsp+24h] [rbp-A4h]
int v37; // [rsp+24h] [rbp-A4h]
int v40; // [rsp+3Ch] [rbp-8Ch]
__int128 v41; // [rsp+40h] [rbp-88h]
_BYTE v42[120]; // [rsp+50h] [rbp-78h] BYREF
v13 = (unsigned int)a5;
result = 0LL;
if ( a5 <= 0 )
v13 = 0LL;
while ( v13-- != 0 )
{
v18 = *a4;
v19 = a1;
atom = find_atom(a1, *a4);
*((_QWORD *)&v23 + 1) = *((unsigned __int8 *)a4 + 8);
switch ( *((_BYTE *)a4 + 9) )
{
case 0:
v26 = 1;
if ( atom != 211 )
{
if ( atom == 220 )
v26 = 0;
else
v26 = *((unsigned __int8 *)a4 + 8);
}
JS_DefineAutoInitProperty((_DWORD)a1, a2, a3, atom, 2, (_DWORD)a4, v26);
goto LABEL_35;
case 1:
case 2:
v36 = *((unsigned __int8 *)a4 + 8);
if ( a4[2] )
{
snprintf(v42, 64LL, "get %s", *a4);
v24 = (_DWORD *)JS_NewCFunction2(
(long long)a1,
(int)a4[2],
(int)v42,
0,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 8,
*((__int16 *)a4 + 5));
v25 = *((_QWORD *)&v23 + 1);
DWORD2(v23) = v36;
}
else
{
v24 = 0LL;
v25 = 3LL;
}
LODWORD(v41) = 0;
*((_QWORD *)&v41 + 1) = 3LL;
if ( a4[3] )
{
snprintf(v42, 64LL, "set %s", *a4);
*(_QWORD *)&v23 = JS_NewCFunction2(
(long long)a1,
(int)a4[3],
(int)v42,
1,
2 * (unsigned int)(*((_BYTE *)a4 + 9) == 2) + 9,
*((__int16 *)a4 + 5));
v41 = v23;
DWORD2(v23) = v36;
}
a6 = *(double *)&v41;
JS_DefinePropertyGetSet(
(long long)a1,
a2,
a3,
atom,
v24,
v25,
*(double *)&v41,
a7,
a8,
a9,
v21,
v22,
a12,
a13,
v41,
SDWORD2(v23));
goto LABEL_35;
case 3:
case 8:
JS_DefineAutoInitProperty((_DWORD)a1, a2, a3, atom, 2, (_DWORD)a4, DWORD2(v23));
goto LABEL_35;
case 4:
Property = *((unsigned int *)a4 + 4);
v31 = 0LL;
goto LABEL_34;
case 5:
v37 = *((unsigned __int8 *)a4 + 8);
Property = js_int64((long long)a4[2]);
v31 = v32;
goto LABEL_33;
case 6:
Property = (long long)a4[2];
v35 = 7LL;
goto LABEL_19;
case 7:
Property = 0LL;
v35 = 3LL;
LABEL_19:
v31 = v35;
goto LABEL_34;
case 9:
v37 = *((unsigned __int8 *)a4 + 8);
v18 = a4[2];
v19 = a1;
LODWORD(v23) = find_atom(a1, v18);
v27 = *((_DWORD *)a4 + 6);
v40 = v23;
if ( v27 == 1 )
{
v33 = *((_QWORD *)a1 + 8);
v29 = *(_QWORD *)(v33 + 32);
*((_QWORD *)&v23 + 1) = *(_QWORD *)(v33 + 40);
goto LABEL_29;
}
if ( !v27 )
{
v29 = *((_QWORD *)a1 + 52);
*((_QWORD *)&v23 + 1) = *((_QWORD *)a1 + 53);
LABEL_29:
v28 = (int)a1;
goto LABEL_30;
}
if ( v27 != -1 )
LABEL_38:
abort(v19, v18, *((_QWORD *)&v23 + 1));
v28 = (int)a1;
LODWORD(v29) = a2;
DWORD2(v23) = a3;
LABEL_30:
Property = JS_GetProperty(v28, v29, SDWORD2(v23), v23);
v31 = v34;
JS_FreeAtom((long long)a1, v40);
if ( atom == 211 )
{
DWORD2(v23) = 1;
}
else if ( atom == 220 )
{
DWORD2(v23) = 0;
}
else
{
LABEL_33:
DWORD2(v23) = v37;
}
LABEL_34:
JS_DefinePropertyValue(
(long long)a1,
a2,
a3,
atom,
(_DWORD *)Property,
v31,
a6,
a7,
a8,
a9,
v21,
v22,
a12,
a13,
SDWORD2(v23));
LABEL_35:
result = JS_FreeAtom((long long)a1, atom);
a4 += 4;
break;
default:
goto LABEL_38;
}
}
return result;
}
|
JS_SetPropertyFunctionList:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV EBX,R8D
MOV R14,RCX
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x28],RSI
MOV R13,RDI
XOR EAX,EAX
TEST R8D,R8D
CMOVLE EBX,EAX
LAB_0012c42b:
SUB RBX,0x1
JC 0x0012c6a9
MOV RSI,qword ptr [R14]
MOV RDI,R13
CALL 0x0012c6c0
MOV EBP,EAX
MOVZX EAX,byte ptr [R14 + 0x9]
CMP RAX,0x9
JA 0x0012c6bb
MOVZX EDX,byte ptr [R14 + 0x8]
LEA RCX,[0x18380c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
CMP qword ptr [R14 + 0x10],0x0
MOV dword ptr [RSP + 0x24],EDX
JZ 0x0012c56b
MOV RCX,qword ptr [R14]
LEA R15,[RSP + 0x50]
MOV RDI,R15
PUSH 0x40
POP RSI
LEA RDX,[0x1869cb]
XOR EAX,EAX
CALL 0x0010e2e0
XOR EAX,EAX
CMP byte ptr [R14 + 0x9],0x2
MOV RSI,qword ptr [R14 + 0x10]
SETZ AL
LEA R8D,[RAX + RAX*0x1 + 0x8]
MOVSX R9D,word ptr [R14 + 0xa]
MOV RDI,R13
MOV RDX,R15
XOR ECX,ECX
CALL 0x0011b2dd
MOV R15,RAX
MOV R12,RDX
MOV EDX,dword ptr [RSP + 0x24]
JMP 0x0012c572
caseD_3:
MOV dword ptr [RSP],EDX
JMP 0x0012c607
caseD_0:
PUSH 0x1
POP RAX
CMP EBP,0xd3
JZ 0x0012c604
CMP EBP,0xdc
JNZ 0x0012c602
XOR EAX,EAX
JMP 0x0012c604
caseD_9:
MOV dword ptr [RSP + 0x24],EDX
MOV RSI,qword ptr [R14 + 0x10]
MOV RDI,R13
CALL 0x0012c6c0
MOV ECX,dword ptr [R14 + 0x18]
CMP ECX,0x1
MOV dword ptr [RSP + 0x3c],EAX
JZ 0x0012c634
TEST ECX,ECX
JZ 0x0012c624
CMP ECX,-0x1
JNZ 0x0012c6bb
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
JMP 0x0012c643
caseD_6:
MOV R15,qword ptr [R14 + 0x10]
PUSH 0x7
JMP 0x0012c564
caseD_4:
MOV R15D,dword ptr [R14 + 0x10]
XOR R12D,R12D
JMP 0x0012c674
caseD_5:
MOV RDI,qword ptr [R14 + 0x10]
MOV dword ptr [RSP + 0x24],EDX
CALL 0x00120a0b
MOV R15,RAX
MOV R12,RDX
JMP 0x0012c670
caseD_7:
XOR R15D,R15D
PUSH 0x3
LAB_0012c564:
POP R12
JMP 0x0012c674
LAB_0012c56b:
XOR R15D,R15D
PUSH 0x3
POP R12
LAB_0012c572:
AND dword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x3
CMP qword ptr [R14 + 0x18],0x0
JZ 0x0012c5d6
MOV RCX,qword ptr [R14]
LEA RDI,[RSP + 0x50]
PUSH 0x40
POP RSI
LEA RDX,[0x1869d2]
XOR EAX,EAX
CALL 0x0010e2e0
XOR EAX,EAX
CMP byte ptr [R14 + 0x9],0x2
MOV RSI,qword ptr [R14 + 0x18]
SETZ AL
LEA R8D,[RAX + RAX*0x1 + 0x9]
MOVSX R9D,word ptr [R14 + 0xa]
MOV RDI,R13
LEA RDX,[RSP + 0x50]
PUSH 0x1
POP RCX
CALL 0x0011b2dd
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV EDX,dword ptr [RSP + 0x24]
LAB_0012c5d6:
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],EDX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
MOV R8,R15
MOV R9,R12
CALL 0x00120a89
JMP 0x0012c691
LAB_0012c602:
MOV EAX,EDX
LAB_0012c604:
MOV dword ptr [RSP],EAX
LAB_0012c607:
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
PUSH 0x2
POP R8
MOV R9,R14
CALL 0x001393f2
JMP 0x0012c691
LAB_0012c624:
MOV RSI,qword ptr [R13 + 0x1a0]
MOV RDX,qword ptr [R13 + 0x1a8]
JMP 0x0012c640
LAB_0012c634:
MOV RCX,qword ptr [R13 + 0x40]
MOV RSI,qword ptr [RCX + 0x20]
MOV RDX,qword ptr [RCX + 0x28]
LAB_0012c640:
MOV RDI,R13
LAB_0012c643:
MOV ECX,EAX
CALL 0x0011b043
MOV R15,RAX
MOV R12,RDX
MOV RDI,R13
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x0011a995
CMP EBP,0xd3
JZ 0x0012c6a4
CMP EBP,0xdc
JNZ 0x0012c670
XOR EDX,EDX
JMP 0x0012c674
LAB_0012c670:
MOV EDX,dword ptr [RSP + 0x24]
LAB_0012c674:
MOV dword ptr [RSP],EDX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,EBP
MOV R8,R15
MOV R9,R12
CALL 0x00120872
LAB_0012c691:
MOV RDI,R13
MOV ESI,EBP
CALL 0x0011a995
ADD R14,0x20
JMP 0x0012c42b
LAB_0012c6a4:
PUSH 0x1
POP RDX
JMP 0x0012c674
LAB_0012c6a9:
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012c6bb:
CALL 0x0010e090
|
void JS_SetPropertyFunctionList
(long param_1,int8 param_2,int8 param_3,int8 *param_4,uint param_5)
{
int iVar1;
int iVar2;
int4 uVar3;
int1 uVar4;
int4 extraout_EDX;
int8 uVar5;
ulong uVar6;
int8 uVar7;
bool bVar8;
int1 auVar9 [16];
int1 uVar10;
int4 local_88;
int4 uStack_80;
char local_78 [72];
uVar6 = (ulong)param_5;
if ((int)param_5 < 1) {
uVar6 = 0;
}
do {
bVar8 = uVar6 == 0;
uVar6 = uVar6 - 1;
if (bVar8) {
return;
}
iVar2 = find_atom(param_1,*param_4);
if (9 < *(byte *)((long)param_4 + 9)) {
LAB_0012c6bb:
/* WARNING: Subroutine does not return */
abort();
}
uVar4 = *(int1 *)(param_4 + 1);
switch(*(byte *)((long)param_4 + 9)) {
case 0:
uVar10 = 1;
if ((iVar2 != 0xd3) && (uVar10 = uVar4, iVar2 == 0xdc)) {
uVar10 = 0;
}
goto LAB_0012c607;
default:
if (param_4[2] == 0) {
auVar9 = ZEXT816(3) << 0x40;
}
else {
snprintf(local_78,0x40,"get %s",*param_4);
auVar9 = JS_NewCFunction2(param_1,param_4[2],local_78,0,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\b',
(int)*(short *)((long)param_4 + 10));
}
local_88 = 0;
uStack_80 = 3;
if (param_4[3] != 0) {
snprintf(local_78,0x40,"set %s",*param_4);
local_88 = JS_NewCFunction2(param_1,param_4[3],local_78,1,
(*(char *)((long)param_4 + 9) == '\x02') * '\x02' + '\t',
(int)*(short *)((long)param_4 + 10));
uStack_80 = extraout_EDX;
}
JS_DefinePropertyGetSet
(param_1,param_2,param_3,iVar2,auVar9._0_8_,auVar9._8_8_,local_88,uStack_80,uVar4);
goto LAB_0012c691;
case 3:
case 8:
uVar10 = uVar4;
LAB_0012c607:
JS_DefineAutoInitProperty(param_1,param_2,param_3,iVar2,2,param_4,uVar10);
goto LAB_0012c691;
case 4:
auVar9 = ZEXT416(*(uint *)(param_4 + 2));
break;
case 5:
auVar9 = js_int64(param_4[2]);
break;
case 6:
auVar9._8_8_ = 7;
auVar9._0_8_ = param_4[2];
break;
case 7:
auVar9 = ZEXT816(3) << 0x40;
break;
case 9:
uVar3 = find_atom(param_1,param_4[2]);
iVar1 = *(int *)(param_4 + 3);
if (iVar1 == 1) {
uVar5 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x28);
uVar7 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x20);
}
else if (iVar1 == 0) {
uVar5 = *(int8 *)(param_1 + 0x1a8);
uVar7 = *(int8 *)(param_1 + 0x1a0);
}
else {
uVar5 = param_3;
uVar7 = param_2;
if (iVar1 != -1) goto LAB_0012c6bb;
}
auVar9 = JS_GetProperty(param_1,uVar7,uVar5,uVar3);
JS_FreeAtom(param_1,uVar3);
if (iVar2 == 0xd3) {
uVar4 = 1;
}
else if (iVar2 == 0xdc) {
uVar4 = 0;
}
}
JS_DefinePropertyValue(param_1,param_2,param_3,iVar2,auVar9._0_8_,auVar9._8_8_,uVar4);
LAB_0012c691:
JS_FreeAtom(param_1,iVar2);
param_4 = param_4 + 4;
} while( true );
}
|
|
9,525 |
LefDefParser::lefwStartVia(char const*, char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwStartVia(const char *viaName,
const char *isDefault)
{ // optional
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState == LEFW_VIA_START ||
lefwState == LEFW_VIA)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_INIT && lefwState < LEFW_END &&
(!lefwIsNonDefaultRule)) // via defined in nondefaultrule
return LEFW_BAD_ORDER; // not of the ENDs
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) "VIA %s ", viaName);
if (isDefault && strcmp(isDefault, "DEFAULT") == 0)
encPrint(lefwFile, (char*) "DEFAULT");
encPrint(lefwFile, (char*) "\n");
} else {
fprintf(lefwFile, "VIA %s ", viaName);
if (isDefault && strcmp(isDefault, "DEFAULT") == 0)
fprintf(lefwFile, "DEFAULT");
fprintf(lefwFile, "\n");
}
lefwLines++;
lefwSynArray[LEFW_VIA_START] = 1;
lefwState = LEFW_VIA_START;
lefwDidLayer = 0; // hasn't set the layer yet
lefwViaHasVal = 0;
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwStartVia(char const*, char const*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rdx
leaq 0x16c07(%rip), %r15 # 0x24e00
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe29a
leaq 0x16e48(%rip), %rcx # 0x25054
movl $0x2, %eax
cmpl $0x0, (%rcx)
je 0xe29f
leaq 0x16e2f(%rip), %r14 # 0x25050
movl (%r14), %ecx
cmpl $0xf, %ecx
je 0xe29f
cmpl $0x48, %ecx
je 0xe29f
movq %rsi, %rbx
cmpl $0x1, %ecx
je 0xe247
cmpl $0x4e, %ecx
jg 0xe247
leaq 0x16e7a(%rip), %rcx # 0x250bc
cmpl $0x0, (%rcx)
je 0xe29f
cmpb $0x1, 0x16e9e(%rip) # 0x250ec
jne 0xe2a5
leaq 0xd179(%rip), %rsi # 0x1b3d0
xorl %eax, %eax
callq 0x18c35
testq %rbx, %rbx
je 0xe287
leaq 0xd0cd(%rip), %rsi # 0x1b337
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
jne 0xe287
movq (%r15), %rdi
leaq 0xd0b7(%rip), %rsi # 0x1b337
xorl %eax, %eax
callq 0x18c35
movq (%r15), %rdi
leaq 0xd6e0(%rip), %rsi # 0x1b971
xorl %eax, %eax
callq 0x18c35
jmp 0xe2f1
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd124(%rip), %rsi # 0x1b3d0
xorl %eax, %eax
callq 0x10f0
testq %rbx, %rbx
je 0xe2e4
leaq 0xd078(%rip), %rsi # 0x1b337
movq %rbx, %rdi
callq 0x10e0
testl %eax, %eax
jne 0xe2e4
movq (%r15), %rcx
leaq 0xd062(%rip), %rdi # 0x1b337
movl $0x7, %esi
movl $0x1, %edx
callq 0x1110
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10b0
leaq 0x16d54(%rip), %rax # 0x2504c
incl (%rax)
leaq 0x16b0f(%rip), %rax # 0x24e10
movl $0x1, 0x3c(%rax)
movl $0xf, (%r14)
leaq 0x16d42(%rip), %rax # 0x25058
movl $0x0, (%rax)
movb $0x0, 0x16de1(%rip) # 0x25104
xorl %eax, %eax
jmp 0xe29f
|
_ZN12LefDefParser12lefwStartViaEPKcS1_:
push r15
push r14
push rbx
mov rdx, rdi
lea r15, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [r15]
test rdi, rdi
jz loc_E29A
lea rcx, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rcx], 0
jz loc_E29F
lea r14, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [r14]
cmp ecx, 0Fh
jz short loc_E29F
cmp ecx, 48h ; 'H'
jz short loc_E29F
mov rbx, rsi
cmp ecx, 1
jz short loc_E247
cmp ecx, 4Eh ; 'N'
jg short loc_E247
lea rcx, _ZN12LefDefParser20lefwIsNonDefaultRuleE; LefDefParser::lefwIsNonDefaultRule
cmp dword ptr [rcx], 0
jz short loc_E29F
loc_E247:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_E2A5
lea rsi, aViaS+3; "VIA %s "
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
test rbx, rbx
jz short loc_E287
lea rsi, aDefault+1; "DEFAULT"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_E287
mov rdi, [r15]
lea rsi, aDefault+1; "DEFAULT"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
loc_E287:
mov rdi, [r15]
lea rsi, aEnd+7; "\n"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_E2F1
loc_E29A:
mov eax, 1
loc_E29F:
pop rbx
pop r14
pop r15
retn
loc_E2A5:
lea rsi, aViaS+3; "VIA %s "
xor eax, eax
call _fprintf
test rbx, rbx
jz short loc_E2E4
lea rsi, aDefault+1; "DEFAULT"
mov rdi, rbx
call _strcmp
test eax, eax
jnz short loc_E2E4
mov rcx, [r15]
lea rdi, aDefault+1; "DEFAULT"
mov esi, 7
mov edx, 1
call _fwrite
loc_E2E4:
mov rsi, [r15]
mov edi, 0Ah
call _fputc
loc_E2F1:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
lea rax, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
mov dword ptr [rax+3Ch], 1
mov dword ptr [r14], 0Fh
lea rax, _ZN12LefDefParser12lefwDidLayerE; LefDefParser::lefwDidLayer
mov dword ptr [rax], 0
mov cs:_ZN12LefDefParserL13lefwViaHasValE, 0; LefDefParser::lefwViaHasVal
xor eax, eax
jmp loc_E29F
|
long long LefDefParser::lefwStartVia(
LefDefParser *this,
const char *a2,
const char *a3,
long long a4,
int a5,
int a6)
{
long long result; // rax
_DWORD *v7; // rcx
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit )
{
LODWORD(v7) = LefDefParser::lefwState;
if ( LefDefParser::lefwState != 15 && LefDefParser::lefwState != 72 )
{
if ( LefDefParser::lefwState == 1
|| (int)LefDefParser::lefwState > 78
|| (v7 = &LefDefParser::lefwIsNonDefaultRule, LefDefParser::lefwIsNonDefaultRule) )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
{
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"VIA %s ", (_DWORD)this, (_DWORD)v7, a5, a6);
if ( a2 )
{
if ( !(unsigned int)strcmp(a2, "DEFAULT") )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"DEFAULT", v8, v9, v10, v11);
}
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n", v8, v9, v10, v11);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "VIA %s ", (const char *)this);
if ( a2 && !(unsigned int)strcmp(a2, "DEFAULT") )
fwrite("DEFAULT", 7LL, 1LL, *(_QWORD *)&LefDefParser::lefwFile);
fputc(10LL, *(_QWORD *)&LefDefParser::lefwFile);
}
++LefDefParser::lefwLines;
LefDefParser::lefwSynArray[15] = 1;
LefDefParser::lefwState = 15;
LefDefParser::lefwDidLayer = 0;
LefDefParser::lefwViaHasVal = 0;
return 0LL;
}
}
}
return result;
}
|
lefwStartVia:
PUSH R15
PUSH R14
PUSH RBX
MOV RDX,RDI
LEA R15,[0x124e00]
MOV RDI,qword ptr [R15]
TEST RDI,RDI
JZ 0x0010e29a
LEA RCX,[0x125054]
MOV EAX,0x2
CMP dword ptr [RCX],0x0
JZ 0x0010e29f
LEA R14,[0x125050]
MOV ECX,dword ptr [R14]
CMP ECX,0xf
JZ 0x0010e29f
CMP ECX,0x48
JZ 0x0010e29f
MOV RBX,RSI
CMP ECX,0x1
JZ 0x0010e247
CMP ECX,0x4e
JG 0x0010e247
LEA RCX,[0x1250bc]
CMP dword ptr [RCX],0x0
JZ 0x0010e29f
LAB_0010e247:
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010e2a5
LEA RSI,[0x11b3d0]
XOR EAX,EAX
CALL 0x00118c35
TEST RBX,RBX
JZ 0x0010e287
LEA RSI,[0x11b337]
MOV RDI,RBX
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x0010e287
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b337]
XOR EAX,EAX
CALL 0x00118c35
LAB_0010e287:
MOV RDI,qword ptr [R15]
LEA RSI,[0x11b971]
XOR EAX,EAX
CALL 0x00118c35
JMP 0x0010e2f1
LAB_0010e29a:
MOV EAX,0x1
LAB_0010e29f:
POP RBX
POP R14
POP R15
RET
LAB_0010e2a5:
LEA RSI,[0x11b3d0]
XOR EAX,EAX
CALL 0x001010f0
TEST RBX,RBX
JZ 0x0010e2e4
LEA RSI,[0x11b337]
MOV RDI,RBX
CALL 0x001010e0
TEST EAX,EAX
JNZ 0x0010e2e4
MOV RCX,qword ptr [R15]
LEA RDI,[0x11b337]
MOV ESI,0x7
MOV EDX,0x1
CALL 0x00101110
LAB_0010e2e4:
MOV RSI,qword ptr [R15]
MOV EDI,0xa
CALL 0x001010b0
LAB_0010e2f1:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LEA RAX,[0x124e10]
MOV dword ptr [RAX + 0x3c],0x1
MOV dword ptr [R14],0xf
LEA RAX,[0x125058]
MOV dword ptr [RAX],0x0
MOV byte ptr [0x00125104],0x0
XOR EAX,EAX
JMP 0x0010e29f
|
/* LefDefParser::lefwStartVia(char const*, char const*) */
int8 LefDefParser::lefwStartVia(char *param_1,char *param_2)
{
int iVar1;
int8 uVar2;
if (lefwFile == (_IO_FILE *)0x0) {
uVar2 = 1;
}
else {
uVar2 = 2;
if (lefwDidInit != 0) {
if (((lefwState != 0xf) && (lefwState != 0x48)) &&
((lefwState == 1 || ((0x4e < lefwState || (lefwIsNonDefaultRule != 0)))))) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,"VIA %s ");
if (param_2 != (char *)0x0) {
iVar1 = strcmp(param_2,"DEFAULT");
if (iVar1 == 0) {
encPrint(lefwFile,"DEFAULT");
}
}
encPrint(lefwFile,"\n");
}
else {
fprintf(lefwFile,"VIA %s ",param_1);
if (param_2 != (char *)0x0) {
iVar1 = strcmp(param_2,"DEFAULT");
if (iVar1 == 0) {
fwrite("DEFAULT",7,1,lefwFile);
}
}
fputc(10,lefwFile);
}
lefwLines = lefwLines + 1;
lefwSynArray._60_4_ = 1;
lefwState = 0xf;
lefwDidLayer = 0;
lefwViaHasVal = 0;
uVar2 = 0;
}
}
}
return uVar2;
}
|
|
9,526 |
my_wc_mb_big5
|
eloqsql/strings/ctype-big5.c
|
static int
my_wc_mb_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((int) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_big5_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
}
|
O3
|
c
|
my_wc_mb_big5:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x669f5
cmpl $0x7f, %esi
jg 0x668b8
movb %sil, (%rdx)
movl $0x1, %eax
jmp 0x669f5
leal -0xa2(%rsi), %edi
cmpl $0x55, %edi
ja 0x668ce
movl %edi, %esi
leaq 0x41e84(%rip), %rdi # 0xa8750
jmp 0x66930
leal -0x2c7(%rsi), %edi
cmpl $0x18a, %edi # imm = 0x18A
ja 0x668e7
movl %edi, %esi
leaq 0x41f1b(%rip), %rdi # 0xa8800
jmp 0x66930
leal -0x2013(%rsi), %edi
cmpl $0x2ac, %edi # imm = 0x2AC
ja 0x66900
movl %edi, %esi
leaq 0x42222(%rip), %rdi # 0xa8b20
jmp 0x66930
leal -0x2460(%rsi), %edi
cmpl $0x1e2, %edi # imm = 0x1E2
ja 0x66919
movl %edi, %esi
leaq 0x42769(%rip), %rdi # 0xa9080
jmp 0x66930
leal -0x3000(%rsi), %edi
cmpl $0x129, %edi # imm = 0x129
ja 0x6695d
movl %edi, %esi
leaq 0x42b20(%rip), %rdi # 0xa9450
leaq (%rdi,%rsi,2), %rsi
movzwl (%rsi), %edi
testl %edi, %edi
je 0x669f3
leaq 0x2(%rdx), %rsi
cmpq %rcx, %rsi
ja 0x669f5
rolw $0x8, %di
movw %di, (%rdx)
movl $0x2, %eax
jmp 0x669f5
movl $0xa1c0, %edi # imm = 0xA1C0
cmpl $0x32a3, %esi # imm = 0x32A3
je 0x6693f
leal -0x338e(%rsi), %edi
cmpl $0x47, %edi
ja 0x66980
movl %edi, %esi
leaq 0x42d32(%rip), %rdi # 0xa96b0
jmp 0x66930
leal -0x4e00(%rsi), %edi
cmpl $0x4683, %edi # imm = 0x4683
ja 0x66999
movl %edi, %esi
leaq 0x42da9(%rip), %rdi # 0xa9740
jmp 0x66930
leal -0x9577(%rsi), %edi
cmpl $0xa2d, %edi # imm = 0xA2D
ja 0x669b5
movl %edi, %esi
leaq 0x4baa0(%rip), %rdi # 0xb2450
jmp 0x66930
movl %esi, %edi
andl $0x7ffffffe, %edi # imm = 0x7FFFFFFE
cmpl $0xfa0c, %edi # imm = 0xFA0C
jne 0x669d7
addl $0xffff05f4, %esi # imm = 0xFFFF05F4
leaq 0x4d27a(%rip), %rdi # 0xb3c4c
jmp 0x66930
addl $0xffff01d0, %esi # imm = 0xFFFF01D0
cmpl $0x1cd, %esi # imm = 0x1CD
ja 0x669f3
movl %esi, %esi
leaq 0x4cec2(%rip), %rdi # 0xb38b0
jmp 0x66930
xorl %eax, %eax
popq %rbp
retq
|
my_wc_mb_big5:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_669F5
cmp esi, 7Fh
jg short loc_668B8
mov [rdx], sil
mov eax, 1
jmp loc_669F5
loc_668B8:
lea edi, [rsi-0A2h]
cmp edi, 55h ; 'U'
ja short loc_668CE
mov esi, edi
lea rdi, tab_uni_big50
jmp short loc_66930
loc_668CE:
lea edi, [rsi-2C7h]
cmp edi, 18Ah
ja short loc_668E7
mov esi, edi
lea rdi, tab_uni_big51
jmp short loc_66930
loc_668E7:
lea edi, [rsi-2013h]
cmp edi, 2ACh
ja short loc_66900
mov esi, edi
lea rdi, tab_uni_big52
jmp short loc_66930
loc_66900:
lea edi, [rsi-2460h]
cmp edi, 1E2h
ja short loc_66919
mov esi, edi
lea rdi, tab_uni_big53
jmp short loc_66930
loc_66919:
lea edi, [rsi-3000h]
cmp edi, 129h
ja short loc_6695D
mov esi, edi
lea rdi, tab_uni_big54
loc_66930:
lea rsi, [rdi+rsi*2]
movzx edi, word ptr [rsi]
test edi, edi
jz loc_669F3
loc_6693F:
lea rsi, [rdx+2]
cmp rsi, rcx
ja loc_669F5
rol di, 8
mov [rdx], di
mov eax, 2
jmp loc_669F5
loc_6695D:
mov edi, 0A1C0h
cmp esi, 32A3h
jz short loc_6693F
lea edi, [rsi-338Eh]
cmp edi, 47h ; 'G'
ja short loc_66980
mov esi, edi
lea rdi, tab_uni_big56
jmp short loc_66930
loc_66980:
lea edi, [rsi-4E00h]
cmp edi, 4683h
ja short loc_66999
mov esi, edi
lea rdi, tab_uni_big57
jmp short loc_66930
loc_66999:
lea edi, [rsi-9577h]
cmp edi, 0A2Dh
ja short loc_669B5
mov esi, edi
lea rdi, tab_uni_big58
jmp loc_66930
loc_669B5:
mov edi, esi
and edi, 7FFFFFFEh
cmp edi, 0FA0Ch
jnz short loc_669D7
add esi, 0FFFF05F4h
lea rdi, tab_uni_big59
jmp loc_66930
loc_669D7:
add esi, 0FFFF01D0h
cmp esi, 1CDh
ja short loc_669F3
mov esi, esi
lea rdi, tab_uni_big510
jmp loc_66930
loc_669F3:
xor eax, eax
loc_669F5:
pop rbp
retn
|
long long my_wc_mb_big5(long long a1, int a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rsi
_WORD *v6; // rdi
__int16 v7; // di
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 <= 127 )
{
*a3 = a2;
return 1LL;
}
if ( (unsigned int)(a2 - 162) > 0x55 )
{
if ( (unsigned int)(a2 - 711) > 0x18A )
{
if ( (unsigned int)(a2 - 8211) > 0x2AC )
{
if ( (unsigned int)(a2 - 9312) > 0x1E2 )
{
if ( (unsigned int)(a2 - 12288) > 0x129 )
{
v7 = -24128;
if ( a2 == 12963 )
{
LABEL_15:
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v7, 8);
return 2LL;
}
return result;
}
if ( (unsigned int)(a2 - 13198) > 0x47 )
{
if ( (unsigned int)(a2 - 19968) > 0x4683 )
{
if ( (unsigned int)(a2 - 38263) > 0xA2D )
{
if ( (a2 & 0x7FFFFFFE) == 0xFA0C )
{
v5 = (unsigned int)(a2 - 64012);
v6 = &tab_uni_big59;
}
else
{
LODWORD(v5) = a2 - 65072;
if ( (unsigned int)v5 > 0x1CD )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_big510;
}
}
else
{
v5 = (unsigned int)(a2 - 38263);
v6 = &tab_uni_big58;
}
}
else
{
v5 = (unsigned int)(a2 - 19968);
v6 = &tab_uni_big57;
}
}
else
{
v5 = (unsigned int)(a2 - 13198);
v6 = &tab_uni_big56;
}
}
else
{
v5 = (unsigned int)(a2 - 12288);
v6 = &tab_uni_big54;
}
}
else
{
v5 = (unsigned int)(a2 - 9312);
v6 = &tab_uni_big53;
}
}
else
{
v5 = (unsigned int)(a2 - 8211);
v6 = &tab_uni_big52;
}
}
else
{
v5 = (unsigned int)(a2 - 711);
v6 = &tab_uni_big51;
}
}
else
{
v5 = (unsigned int)(a2 - 162);
v6 = &tab_uni_big50;
}
v7 = v6[v5];
if ( v7 )
goto LABEL_15;
return 0LL;
}
return result;
}
|
my_wc_mb_big5:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001669f5
CMP ESI,0x7f
JG 0x001668b8
MOV byte ptr [RDX],SIL
MOV EAX,0x1
JMP 0x001669f5
LAB_001668b8:
LEA EDI,[RSI + -0xa2]
CMP EDI,0x55
JA 0x001668ce
MOV ESI,EDI
LEA RDI,[0x1a8750]
JMP 0x00166930
LAB_001668ce:
LEA EDI,[RSI + -0x2c7]
CMP EDI,0x18a
JA 0x001668e7
MOV ESI,EDI
LEA RDI,[0x1a8800]
JMP 0x00166930
LAB_001668e7:
LEA EDI,[RSI + -0x2013]
CMP EDI,0x2ac
JA 0x00166900
MOV ESI,EDI
LEA RDI,[0x1a8b20]
JMP 0x00166930
LAB_00166900:
LEA EDI,[RSI + -0x2460]
CMP EDI,0x1e2
JA 0x00166919
MOV ESI,EDI
LEA RDI,[0x1a9080]
JMP 0x00166930
LAB_00166919:
LEA EDI,[RSI + -0x3000]
CMP EDI,0x129
JA 0x0016695d
MOV ESI,EDI
LEA RDI,[0x1a9450]
LAB_00166930:
LEA RSI,[RDI + RSI*0x2]
MOVZX EDI,word ptr [RSI]
TEST EDI,EDI
JZ 0x001669f3
LAB_0016693f:
LEA RSI,[RDX + 0x2]
CMP RSI,RCX
JA 0x001669f5
ROL DI,0x8
MOV word ptr [RDX],DI
MOV EAX,0x2
JMP 0x001669f5
LAB_0016695d:
MOV EDI,0xa1c0
CMP ESI,0x32a3
JZ 0x0016693f
LEA EDI,[RSI + -0x338e]
CMP EDI,0x47
JA 0x00166980
MOV ESI,EDI
LEA RDI,[0x1a96b0]
JMP 0x00166930
LAB_00166980:
LEA EDI,[RSI + -0x4e00]
CMP EDI,0x4683
JA 0x00166999
MOV ESI,EDI
LEA RDI,[0x1a9740]
JMP 0x00166930
LAB_00166999:
LEA EDI,[RSI + -0x9577]
CMP EDI,0xa2d
JA 0x001669b5
MOV ESI,EDI
LEA RDI,[0x1b2450]
JMP 0x00166930
LAB_001669b5:
MOV EDI,ESI
AND EDI,0x7ffffffe
CMP EDI,0xfa0c
JNZ 0x001669d7
ADD ESI,0xffff05f4
LEA RDI,[0x1b3c4c]
JMP 0x00166930
LAB_001669d7:
ADD ESI,0xffff01d0
CMP ESI,0x1cd
JA 0x001669f3
MOV ESI,ESI
LEA RDI,[0x1b38b0]
JMP 0x00166930
LAB_001669f3:
XOR EAX,EAX
LAB_001669f5:
POP RBP
RET
|
int8 my_wc_mb_big5(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
ulong uVar2;
ushort uVar3;
int1 *puVar4;
uVar1 = 0xffffff9b;
if (param_4 <= param_3) {
return 0xffffff9b;
}
if ((int)param_2 < 0x80) {
*(char *)param_3 = (char)param_2;
return 1;
}
if (param_2 - 0xa2 < 0x56) {
uVar2 = (ulong)(param_2 - 0xa2);
puVar4 = tab_uni_big50;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar2 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_big51;
}
else if (param_2 - 0x2013 < 0x2ad) {
uVar2 = (ulong)(param_2 - 0x2013);
puVar4 = tab_uni_big52;
}
else if (param_2 - 0x2460 < 0x1e3) {
uVar2 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_big53;
}
else if (param_2 - 0x3000 < 0x12a) {
uVar2 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_big54;
}
else {
uVar3 = 0xa1c0;
if (param_2 == 0x32a3) goto LAB_0016693f;
if (param_2 - 0x338e < 0x48) {
uVar2 = (ulong)(param_2 - 0x338e);
puVar4 = tab_uni_big56;
}
else if (param_2 - 0x4e00 < 0x4684) {
uVar2 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_big57;
}
else if (param_2 - 0x9577 < 0xa2e) {
uVar2 = (ulong)(param_2 - 0x9577);
puVar4 = tab_uni_big58;
}
else if ((param_2 & 0x7ffffffe) == 0xfa0c) {
uVar2 = (ulong)(param_2 - 0xfa0c);
puVar4 = (int1 *)&tab_uni_big59;
}
else {
if (0x1cd < param_2 - 0xfe30) {
return 0;
}
uVar2 = (ulong)(param_2 - 0xfe30);
puVar4 = tab_uni_big510;
}
}
uVar3 = *(ushort *)((long)puVar4 + uVar2 * 2);
if (uVar3 == 0) {
return 0;
}
LAB_0016693f:
if (param_3 + 1 <= param_4) {
*param_3 = uVar3 << 8 | uVar3 >> 8;
uVar1 = 2;
}
return uVar1;
}
|
|
9,527 |
my_caseup_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_caseup_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_toupper_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_caseup_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x46585
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0x46585
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0x46567
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x46567
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0x46585
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0x46521
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_caseup_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_46585
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_46521:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_46585
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_46567
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_46567
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4]
mov [rbp+var_40], rsi
loc_46567:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_46585
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_46521
loc_46585:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_caseup_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
|
my_caseup_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x00146585
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_00146521:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x00146585
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x00146567
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x00146567
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_00146567:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x00146585
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x00146521
LAB_00146585:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
|
|
9,528 |
js_object_list_resize_hash
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_object_list_resize_hash(JSContext *ctx, JSObjectList *s,
uint32_t new_hash_size)
{
JSObjectListEntry *e;
uint32_t i, h, *new_hash_table;
new_hash_table = js_malloc(ctx, sizeof(new_hash_table[0]) * new_hash_size);
if (!new_hash_table)
return -1;
js_free(ctx, s->hash_table);
s->hash_table = new_hash_table;
s->hash_size = new_hash_size;
for(i = 0; i < s->hash_size; i++) {
s->hash_table[i] = -1;
}
for(i = 0; i < s->object_count; i++) {
e = &s->object_tab[i];
h = js_object_list_get_hash(e->obj, s->hash_size);
e->hash_next = s->hash_table[h];
s->hash_table[h] = i;
}
return 0;
}
|
O0
|
c
|
js_object_list_resize_hash:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x27fa0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x801ce
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x802b9
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x280a0
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x80231
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x80202
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x802b1
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x80160
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x80239
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_object_list_resize_hash:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov rdi, [rsp+38h+var_10]
mov eax, [rsp+38h+var_1C]
mov esi, eax
shl rsi, 2
call js_malloc
mov [rsp+38h+var_38], rax
cmp [rsp+38h+var_38], 0
jnz short loc_801CE
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp loc_802B9
loc_801CE:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+10h]
call js_free
mov rcx, [rsp+38h+var_38]
mov rax, [rsp+38h+var_18]
mov [rax+10h], rcx
mov ecx, [rsp+38h+var_1C]
mov rax, [rsp+38h+var_18]
mov [rax+18h], ecx
mov [rsp+38h+var_2C], 0
loc_80202:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+18h]
jnb short loc_80231
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_2C]
mov dword ptr [rax+rcx*4], 0FFFFFFFFh
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_80202
loc_80231:
mov [rsp+38h+var_2C], 0
loc_80239:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+8]
jnb short loc_802B1
mov rax, [rsp+38h+var_18]
mov rax, [rax]
mov ecx, [rsp+38h+var_2C]
shl rcx, 4
add rax, rcx
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
mov rdi, [rax]
mov rax, [rsp+38h+var_18]
mov esi, [rax+18h]
call js_object_list_get_hash
mov [rsp+38h+var_30], eax
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_30]
mov ecx, [rax+rcx*4]
mov rax, [rsp+38h+var_28]
mov [rax+8], ecx
mov edx, [rsp+38h+var_2C]
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_30]
mov [rax+rcx*4], edx
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_80239
loc_802B1:
mov [rsp+38h+var_4], 0
loc_802B9:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long js_object_list_resize_hash(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+0h] [rbp-38h]
unsigned int hash; // [rsp+8h] [rbp-30h]
unsigned int i; // [rsp+Ch] [rbp-2Ch]
unsigned int j; // [rsp+Ch] [rbp-2Ch]
long long v8; // [rsp+10h] [rbp-28h]
v4 = js_malloc(a1, 4LL * a3);
if ( v4 )
{
js_free(a1, *(_QWORD *)(a2 + 16));
*(_QWORD *)(a2 + 16) = v4;
*(_DWORD *)(a2 + 24) = a3;
for ( i = 0; i < *(_DWORD *)(a2 + 24); ++i )
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * i) = -1;
for ( j = 0; j < *(_DWORD *)(a2 + 8); ++j )
{
v8 = 16LL * j + *(_QWORD *)a2;
hash = js_object_list_get_hash(*(_QWORD *)v8, *(_DWORD *)(a2 + 24));
*(_DWORD *)(v8 + 8) = *(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * hash);
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * hash) = j;
}
return 0;
}
else
{
return (unsigned int)-1;
}
}
|
js_object_list_resize_hash:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV RDI,qword ptr [RSP + 0x28]
MOV EAX,dword ptr [RSP + 0x1c]
MOV ESI,EAX
SHL RSI,0x2
CALL 0x00127fa0
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x001801ce
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001802b9
LAB_001801ce:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x001280a0
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV ECX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x18],ECX
MOV dword ptr [RSP + 0xc],0x0
LAB_00180202:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x18]
JNC 0x00180231
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX + RCX*0x4],0xffffffff
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00180202
LAB_00180231:
MOV dword ptr [RSP + 0xc],0x0
LAB_00180239:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x8]
JNC 0x001802b1
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RSP + 0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RAX + 0x18]
CALL 0x00180160
MOV dword ptr [RSP + 0x8],EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX + 0x8],ECX
MOV EDX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0x8]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00180239
LAB_001802b1:
MOV dword ptr [RSP + 0x34],0x0
LAB_001802b9:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 js_object_list_resize_hash(int8 param_1,long *param_2,uint param_3)
{
uint uVar1;
long lVar2;
int8 *puVar3;
uint local_2c;
int4 local_4;
lVar2 = js_malloc(param_1,(ulong)param_3 << 2);
if (lVar2 == 0) {
local_4 = 0xffffffff;
}
else {
js_free(param_1,param_2[2]);
param_2[2] = lVar2;
*(uint *)(param_2 + 3) = param_3;
for (local_2c = 0; local_2c < *(uint *)(param_2 + 3); local_2c = local_2c + 1) {
*(int4 *)(param_2[2] + (ulong)local_2c * 4) = 0xffffffff;
}
for (local_2c = 0; local_2c < *(uint *)(param_2 + 1); local_2c = local_2c + 1) {
puVar3 = (int8 *)(*param_2 + (ulong)local_2c * 0x10);
uVar1 = js_object_list_get_hash(*puVar3,(int)param_2[3]);
*(int4 *)(puVar3 + 1) = *(int4 *)(param_2[2] + (ulong)uVar1 * 4);
*(uint *)(param_2[2] + (ulong)uVar1 * 4) = local_2c;
}
local_4 = 0;
}
return local_4;
}
|
|
9,529 |
ImageResizeNN
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
void ImageResizeNN(Image *image,int newWidth,int newHeight)
{
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
Color *pixels = LoadImageColors(*image);
Color *output = (Color *)RL_MALLOC(newWidth*newHeight*sizeof(Color));
// EDIT: added +1 to account for an early rounding problem
int xRatio = (int)((image->width << 16)/newWidth) + 1;
int yRatio = (int)((image->height << 16)/newHeight) + 1;
int x2, y2;
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
x2 = ((x*xRatio) >> 16);
y2 = ((y*yRatio) >> 16);
output[(y*newWidth) + x] = pixels[(y2*image->width) + x2] ;
}
}
int format = image->format;
RL_FREE(image->data);
image->data = output;
image->width = newWidth;
image->height = newHeight;
image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
UnloadImageColors(pixels);
}
|
O0
|
c
|
ImageResizeNN:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x100d30
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x100d30
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x100d35
jmp 0x100e6b
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc0c0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0xa6e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shll $0x10, %eax
cltd
idivl -0xc(%rbp)
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll $0x10, %eax
cltd
idivl -0x10(%rbp)
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x100e16
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x100e09
movl -0x38(%rbp), %eax
imull -0x24(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
imull -0x28(%rbp), %eax
sarl $0x10, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x38(%rbp), %ecx
movslq %ecx, %rcx
movq -0x18(%rbp), %rdx
movl -0x30(%rbp), %esi
movq -0x8(%rbp), %rdi
imull 0x8(%rdi), %esi
addl -0x2c(%rbp), %esi
movslq %esi, %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x100db0
jmp 0x100e0b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x100da1
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa640
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0x14(%rax)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0xfe440
movq -0x18(%rbp), %rdi
callq 0x101840
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ImageResizeNN:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_100D30
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 0
jz short loc_100D30
mov rax, [rbp+var_8]
cmp dword ptr [rax+0Ch], 0
jnz short loc_100D35
loc_100D30:
jmp loc_100E6B
loc_100D35:
mov rax, [rbp+var_8]
mov rcx, [rax]
mov [rsp+60h+var_60], rcx
mov rcx, [rax+8]
mov [rsp+60h+var_58], rcx
mov rax, [rax+10h]
mov [rsp+60h+var_50], rax
call LoadImageColors
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
imul eax, [rbp+var_10]
movsxd rdi, eax
shl rdi, 2
call _malloc
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov eax, [rax+8]
shl eax, 10h
cdq
idiv [rbp+var_C]
add eax, 1
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
shl eax, 10h
cdq
idiv [rbp+var_10]
add eax, 1
mov [rbp+var_28], eax
mov [rbp+var_34], 0
loc_100DA1:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_10]
jge short loc_100E16
mov [rbp+var_38], 0
loc_100DB0:
mov eax, [rbp+var_38]
cmp eax, [rbp+var_C]
jge short loc_100E09
mov eax, [rbp+var_38]
imul eax, [rbp+var_24]
sar eax, 10h
mov [rbp+var_2C], eax
mov eax, [rbp+var_34]
imul eax, [rbp+var_28]
sar eax, 10h
mov [rbp+var_30], eax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_34]
imul ecx, [rbp+var_C]
add ecx, [rbp+var_38]
movsxd rcx, ecx
mov rdx, [rbp+var_18]
mov esi, [rbp+var_30]
mov rdi, [rbp+var_8]
imul esi, [rdi+8]
add esi, [rbp+var_2C]
movsxd rsi, esi
mov edx, [rdx+rsi*4]
mov [rax+rcx*4], edx
mov eax, [rbp+var_38]
add eax, 1
mov [rbp+var_38], eax
jmp short loc_100DB0
loc_100E09:
jmp short $+2
loc_100E0B:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
jmp short loc_100DA1
loc_100E16:
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_8]
mov rdi, [rax]
call _free
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+8], ecx
mov ecx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+0Ch], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+14h], 7
mov rdi, [rbp+var_8]
mov esi, [rbp+var_3C]
call ImageFormat
mov rdi, [rbp+var_18]
call UnloadImageColors
loc_100E6B:
add rsp, 60h
pop rbp
retn
|
long long ImageResizeNN(long long *a1, int a2, int a3, long long a4, int a5, int a6)
{
long long result; // rax
int v7; // edx
int v8; // r8d
int v9; // r9d
int v10; // [rsp+24h] [rbp-3Ch]
int j; // [rsp+28h] [rbp-38h]
int i; // [rsp+2Ch] [rbp-34h]
int v13; // [rsp+38h] [rbp-28h]
int v14; // [rsp+3Ch] [rbp-24h]
long long v15; // [rsp+40h] [rbp-20h]
long long ImageColors; // [rsp+48h] [rbp-18h]
result = (long long)a1;
if ( *a1 )
{
result = (long long)a1;
if ( *((_DWORD *)a1 + 2) )
{
result = (long long)a1;
if ( *((_DWORD *)a1 + 3) )
{
ImageColors = LoadImageColors((_DWORD)a1, a2, a3, a1[1], a5, a6, *a1, a1[1], a1[2]);
v15 = malloc(4LL * a3 * a2);
v14 = (*((_DWORD *)a1 + 2) << 16) / a2 + 1;
v13 = (*((_DWORD *)a1 + 3) << 16) / a3 + 1;
for ( i = 0; i < a3; ++i )
{
for ( j = 0; j < a2; ++j )
*(_DWORD *)(v15 + 4LL * (j + a2 * i)) = *(_DWORD *)(ImageColors
+ 4LL
* (((v14 * j) >> 16)
+ *((_DWORD *)a1 + 2) * ((v13 * i) >> 16)));
}
v10 = *((_DWORD *)a1 + 5);
free(*a1);
*a1 = v15;
*((_DWORD *)a1 + 2) = a2;
*((_DWORD *)a1 + 3) = a3;
*((_DWORD *)a1 + 5) = 7;
ImageFormat((long long)a1, v10, v7, a3, v8, v9);
return UnloadImageColors(ImageColors);
}
}
}
return result;
}
| |||
9,530 |
ImageResizeNN
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
void ImageResizeNN(Image *image,int newWidth,int newHeight)
{
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
Color *pixels = LoadImageColors(*image);
Color *output = (Color *)RL_MALLOC(newWidth*newHeight*sizeof(Color));
// EDIT: added +1 to account for an early rounding problem
int xRatio = (int)((image->width << 16)/newWidth) + 1;
int yRatio = (int)((image->height << 16)/newHeight) + 1;
int x2, y2;
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
x2 = ((x*xRatio) >> 16);
y2 = ((y*yRatio) >> 16);
output[(y*newWidth) + x] = pixels[(y2*image->width) + x2] ;
}
}
int format = image->format;
RL_FREE(image->data);
image->data = output;
image->width = newWidth;
image->height = newHeight;
image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format); // Reformat 32bit RGBA image to original format
UnloadImageColors(pixels);
}
|
O3
|
c
|
ImageResizeNN:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, (%rdi)
je 0x95ce0
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x95ce0
cmpl $0x0, 0xc(%rbx)
je 0x95ce0
movl %edx, %ebp
movl %esi, %r14d
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x92846
movq %rax, %r15
movl %ebp, %eax
imull %r14d, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0xa6f0
movq %rax, 0x20(%rsp)
movl %ebp, 0x1c(%rsp)
testl %ebp, %ebp
jle 0x95c99
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %eax
shll $0x10, %eax
cltd
movl 0x1c(%rsp), %edi
idivl %edi
movl %eax, %ecx
incl %ecx
movl %esi, %eax
shll $0x10, %eax
cltd
idivl %r14d
incl %eax
movl %r14d, %edx
movl %edi, %edi
leaq (,%rdx,4), %r8
xorl %r9d, %r9d
movq 0x20(%rsp), %r10
testl %r14d, %r14d
jle 0x95c8e
movl %ecx, %r11d
imull %r9d, %r11d
sarl $0x10, %r11d
imull %esi, %r11d
xorl %r13d, %r13d
xorl %r12d, %r12d
movl %r13d, %ebp
sarl $0x10, %ebp
addl %r11d, %ebp
movslq %ebp, %rbp
movl (%r15,%rbp,4), %ebp
movl %ebp, (%r10,%r12,4)
incq %r12
addl %eax, %r13d
cmpq %r12, %rdx
jne 0x95c6f
incq %r9
addq %r8, %r10
cmpq %rdi, %r9
jne 0x95c55
movl 0x14(%rbx), %r13d
movq (%rbx), %rdi
callq 0xa650
movq 0x20(%rsp), %rax
movq %rax, (%rbx)
movl %r14d, 0x8(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rbx)
movl $0x7, 0x14(%rbx)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x94249
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa650
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ImageResizeNN:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
cmp qword ptr [rdi], 0
jz loc_95CE0
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz loc_95CE0
cmp dword ptr [rbx+0Ch], 0
jz loc_95CE0
mov ebp, edx
mov r14d, esi
mov rax, [rbx+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+58h+var_58], xmm0
call LoadImageColors
mov r15, rax
mov eax, ebp
imul eax, r14d
movsxd rdi, eax
shl rdi, 2
call _malloc
mov [rsp+58h+var_38], rax
mov [rsp+58h+var_3C], ebp
test ebp, ebp
jle short loc_95C99
mov esi, [rbx+8]
mov eax, [rbx+0Ch]
shl eax, 10h
cdq
mov edi, [rsp+58h+var_3C]
idiv edi
mov ecx, eax
inc ecx
mov eax, esi
shl eax, 10h
cdq
idiv r14d
inc eax
mov edx, r14d
mov edi, edi
lea r8, ds:0[rdx*4]
xor r9d, r9d
mov r10, [rsp+58h+var_38]
loc_95C55:
test r14d, r14d
jle short loc_95C8E
mov r11d, ecx
imul r11d, r9d
sar r11d, 10h
imul r11d, esi
xor r13d, r13d
xor r12d, r12d
loc_95C6F:
mov ebp, r13d
sar ebp, 10h
add ebp, r11d
movsxd rbp, ebp
mov ebp, [r15+rbp*4]
mov [r10+r12*4], ebp
inc r12
add r13d, eax
cmp rdx, r12
jnz short loc_95C6F
loc_95C8E:
inc r9
add r10, r8
cmp r9, rdi
jnz short loc_95C55
loc_95C99:
mov r13d, [rbx+14h]
mov rdi, [rbx]
call _free
mov rax, [rsp+58h+var_38]
mov [rbx], rax
mov [rbx+8], r14d
mov eax, [rsp+58h+var_3C]
mov [rbx+0Ch], eax
mov dword ptr [rbx+14h], 7
mov rdi, rbx
mov esi, r13d
call ImageFormat
mov rdi, r15
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
loc_95CE0:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void ImageResizeNN(__m128i *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
int v6; // ebp
int v7; // r14d
__m128i v8; // xmm0
long long ImageColors; // r15
__int32 v10; // esi
int v11; // ecx
long long v12; // r9
long long v13; // r10
int v14; // r13d
long long v15; // r12
int v16; // r13d
long long v17; // rdx
long long v18; // rcx
int v19; // r8d
int v20; // r9d
long long v21; // [rsp+20h] [rbp-38h]
if ( a1->m128i_i64[0] && a1->m128i_i32[2] && a1->m128i_i32[3] )
{
v6 = a3;
v7 = a2;
v8 = *a1;
ImageColors = LoadImageColors(
*a1,
(long long)a1,
a2,
a3,
a4,
a5,
a6,
a1->m128i_i64[0],
a1->m128i_i64[1],
a1[1].m128i_i64[0]);
v21 = malloc(4LL * (int)a2 * v6);
if ( v6 > 0 )
{
v10 = a1->m128i_i32[2];
v11 = (a1->m128i_i32[3] << 16) / v6 + 1;
v12 = 0LL;
v13 = v21;
do
{
if ( v7 > 0 )
{
v14 = 0;
v15 = 0LL;
do
{
*(_DWORD *)(v13 + 4 * v15++) = *(_DWORD *)(ImageColors + 4LL
* (v10 * (((int)v12 * v11) >> 16) + (v14 >> 16)));
v14 += (v10 << 16) / v7 + 1;
}
while ( v7 != v15 );
}
++v12;
v13 += 4LL * (unsigned int)v7;
}
while ( v12 != v6 );
}
v16 = a1[1].m128i_i32[1];
free(a1->m128i_i64[0]);
a1->m128i_i64[0] = v21;
a1->m128i_i32[2] = v7;
a1->m128i_i32[3] = v6;
a1[1].m128i_i32[1] = 7;
ImageFormat(a1->m128i_i64, v16, *(float *)v8.m128i_i32, v17, v18, v19, v20);
free(ImageColors);
}
}
|
ImageResizeNN:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
CMP qword ptr [RDI],0x0
JZ 0x00195ce0
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00195ce0
CMP dword ptr [RBX + 0xc],0x0
JZ 0x00195ce0
MOV EBP,EDX
MOV R14D,ESI
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00192846
MOV R15,RAX
MOV EAX,EBP
IMUL EAX,R14D
MOVSXD RDI,EAX
SHL RDI,0x2
CALL 0x0010a6f0
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x1c],EBP
TEST EBP,EBP
JLE 0x00195c99
MOV ESI,dword ptr [RBX + 0x8]
MOV EAX,dword ptr [RBX + 0xc]
SHL EAX,0x10
CDQ
MOV EDI,dword ptr [RSP + 0x1c]
IDIV EDI
MOV ECX,EAX
INC ECX
MOV EAX,ESI
SHL EAX,0x10
CDQ
IDIV R14D
INC EAX
MOV EDX,R14D
MOV EDI,EDI
LEA R8,[RDX*0x4]
XOR R9D,R9D
MOV R10,qword ptr [RSP + 0x20]
LAB_00195c55:
TEST R14D,R14D
JLE 0x00195c8e
MOV R11D,ECX
IMUL R11D,R9D
SAR R11D,0x10
IMUL R11D,ESI
XOR R13D,R13D
XOR R12D,R12D
LAB_00195c6f:
MOV EBP,R13D
SAR EBP,0x10
ADD EBP,R11D
MOVSXD RBP,EBP
MOV EBP,dword ptr [R15 + RBP*0x4]
MOV dword ptr [R10 + R12*0x4],EBP
INC R12
ADD R13D,EAX
CMP RDX,R12
JNZ 0x00195c6f
LAB_00195c8e:
INC R9
ADD R10,R8
CMP R9,RDI
JNZ 0x00195c55
LAB_00195c99:
MOV R13D,dword ptr [RBX + 0x14]
MOV RDI,qword ptr [RBX]
CALL 0x0010a650
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],R14D
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RBX + 0xc],EAX
MOV dword ptr [RBX + 0x14],0x7
MOV RDI,RBX
MOV ESI,R13D
CALL 0x00194249
MOV RDI,R15
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010a650
LAB_00195ce0:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void ImageResizeNN(long *param_1,uint param_2,uint param_3)
{
int iVar1;
int4 uVar2;
long lVar3;
void *__ptr;
void *pvVar4;
ulong uVar5;
void *pvVar6;
ulong uVar7;
int iVar8;
if (((*param_1 != 0) && ((int)param_1[1] != 0)) && (*(int *)((long)param_1 + 0xc) != 0)) {
__ptr = (void *)LoadImageColors();
pvVar4 = malloc((long)(int)(param_3 * param_2) << 2);
if (0 < (int)param_3) {
lVar3 = param_1[1];
iVar1 = *(int *)((long)param_1 + 0xc);
uVar5 = 0;
pvVar6 = pvVar4;
do {
if (0 < (int)param_2) {
iVar8 = 0;
uVar7 = 0;
do {
*(int4 *)((long)pvVar6 + uVar7 * 4) =
*(int4 *)
((long)__ptr +
(long)((iVar8 >> 0x10) +
(((iVar1 << 0x10) / (int)param_3 + 1) * (int)uVar5 >> 0x10) * (int)lVar3) *
4);
uVar7 = uVar7 + 1;
iVar8 = iVar8 + ((int)lVar3 << 0x10) / (int)param_2 + 1;
} while (param_2 != uVar7);
}
uVar5 = uVar5 + 1;
pvVar6 = (void *)((long)pvVar6 + (ulong)param_2 * 4);
} while (uVar5 != param_3);
}
uVar2 = *(int4 *)((long)param_1 + 0x14);
free((void *)*param_1);
*param_1 = (long)pvVar4;
*(uint *)(param_1 + 1) = param_2;
*(uint *)((long)param_1 + 0xc) = param_3;
*(int4 *)((long)param_1 + 0x14) = 7;
ImageFormat(param_1,uVar2);
free(__ptr);
return;
}
return;
}
|
|
9,531 |
common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool)
|
monkey531[P]llama/common/common.cpp
|
std::string common_detokenize(const struct llama_vocab * vocab, const std::vector<llama_token> & tokens, bool special) {
std::string text;
text.resize(std::max(text.capacity(), tokens.size()));
int32_t n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
if (n_chars < 0) {
text.resize(-n_chars);
n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
GGML_ASSERT(n_chars <= (int32_t)text.size()); // whitespace trimming is performed after per-token detokenization
}
text.resize(n_chars);
// NOTE: the original tokenizer decodes bytes after collecting the pieces.
return text;
}
|
O2
|
cpp
|
common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x2, %rax
cmpq $0x10, %rax
pushq $0xf
popq %rsi
cmovaeq %rax, %rsi
callq 0x27130
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movzbl %bpl, %ebp
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x260e0
testl %eax, %eax
jns 0x72a7c
negl %eax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27130
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x260e0
cmpl 0x8(%rbx), %eax
jg 0x72a95
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x27130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d6b1(%rip), %rdi # 0xd014d
leaq 0x53ea0(%rip), %rdx # 0xc6943
leaq 0x5dd1e(%rip), %rcx # 0xd07c8
movl $0x6e2, %esi # imm = 0x6E2
xorl %eax, %eax
callq 0x27520
jmp 0x72ab8
movq %rax, %r14
movq %rbx, %rdi
callq 0x27998
movq %r14, %rdi
callq 0x27660
|
_Z17common_detokenizeB5cxx11PK11llama_vocabRKSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rdx+8]
sub rax, [rdx]
sar rax, 2
cmp rax, 10h
push 0Fh
pop rsi
cmovnb rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
movzx ebp, bpl
mov [rsp+28h+var_28], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
test eax, eax
jns short loc_72A7C
neg eax
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
mov [rsp+28h+var_28], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
cmp eax, [rbx+8]
jg short loc_72A95
loc_72A7C:
movsxd rsi, eax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm; std::string::resize(ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_72A95:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsInt32TTe; "n_chars <= (int32_t)text.size()"
mov esi, 6E2h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_72AB8:
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
_QWORD * common_detokenize[abi:cxx11](_QWORD *a1, long long a2, _QWORD *a3, unsigned __int8 a4)
{
long long v4; // rax
long long v8; // rsi
int v9; // eax
long long v10; // rdx
long long v12; // r14
long long v13; // [rsp+0h] [rbp-28h]
long long v14; // [rsp+0h] [rbp-28h]
HIDWORD(v13) = HIDWORD(v4);
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v8 = 15LL;
if ( (unsigned long long)((long long)(a3[1] - *a3) >> 2) >= 0x10 )
v8 = (long long)(a3[1] - *a3) >> 2;
std::string::resize(a1, v8, a3);
LODWORD(v13) = a4;
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v13);
if ( v9 < 0 )
{
std::string::resize(a1, (unsigned int)-v9, v10);
LODWORD(v14) = a4;
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v14);
if ( v9 > *((_DWORD *)a1 + 2) )
{
v12 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1762LL,
"GGML_ASSERT(%s) failed",
"n_chars <= (int32_t)text.size()");
std::string::~string(a1);
_Unwind_Resume(v12);
}
}
std::string::resize(a1, v9, v10);
return a1;
}
|
common_detokenize[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RDX + 0x8]
SUB RAX,qword ptr [RDX]
SAR RAX,0x2
CMP RAX,0x10
PUSH 0xf
POP RSI
CMOVNC RSI,RAX
LAB_00172a17:
CALL 0x00127130
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
LAB_00172a31:
MOVZX EBP,BPL
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x001260e0
TEST EAX,EAX
JNS 0x00172a7c
NEG EAX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00127130
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x001260e0
CMP EAX,dword ptr [RBX + 0x8]
JG 0x00172a95
LAB_00172a7c:
MOVSXD RSI,EAX
MOV RDI,RBX
CALL 0x00127130
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00172a95:
LEA RDI,[0x1d014d]
LEA RDX,[0x1c6943]
LEA RCX,[0x1d07c8]
MOV ESI,0x6e2
XOR EAX,EAX
CALL 0x00127520
|
/* common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int> > const&,
bool) */
llama_vocab * common_detokenize_abi_cxx11_(llama_vocab *param_1,vector *param_2,bool param_3)
{
int iVar1;
int8 in_RAX;
int4 uVar2;
int4 in_ECX;
int7 in_register_00000011;
long *plVar3;
ulong uVar4;
uVar2 = (int4)((ulong)in_RAX >> 0x20);
plVar3 = (long *)CONCAT71(in_register_00000011,param_3);
*(llama_vocab **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (llama_vocab)0x0;
/* try { // try from 00172a17 to 00172a1b has its CatchHandler @ 00172ab6 */
std::__cxx11::string::resize((ulong)param_1);
/* try { // try from 00172a31 to 00172ab5 has its CatchHandler @ 00172ab8 */
uVar4 = CONCAT44(uVar2,in_ECX) & 0xffffffff000000ff;
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,uVar4);
uVar2 = (int4)(uVar4 >> 0x20);
if (iVar1 < 0) {
std::__cxx11::string::resize((ulong)param_1);
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,
*(int8 *)param_1,*(int4 *)(param_1 + 8),0,
CONCAT44(uVar2,in_ECX) & 0xffffffff000000ff);
if (*(int *)(param_1 + 8) < iVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x6e2
,"GGML_ASSERT(%s) failed","n_chars <= (int32_t)text.size()");
}
}
std::__cxx11::string::resize((ulong)param_1);
return param_1;
}
|
|
9,532 |
stack_add_head
|
qoraal-tictactoe/build_O0/_deps/qoraal-src/include/qoraal/common/lists.h
|
static INLINE void
stack_add_head (stack_t* ll, plists_t obj, unsigned int offsetof_next)
{
LISTS_ASSERT(obj, ("stack_add_head")) ;
if (ll->head != NULL_LLO) {
*LISTS_NEXT_REF(obj, offsetof_next) = ll->head ;
} else {
*LISTS_NEXT_REF(obj, offsetof_next) = NULL_LLO ;
}
ll->head = obj ;
}
|
O0
|
c
|
stack_add_head:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24128
leaq 0x10178(%rip), %rdi # 0x34299
movb $0x0, %al
callq 0x1bb90
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24148
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x24159
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
stack_add_head_3:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
cmp [rbp+var_10], 0
jnz short loc_24128
lea rdi, aStackAddHead; "stack_add_head"
mov al, 0
call debug_assert
loc_24128:
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_24148
mov rax, [rbp+var_8]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov edx, [rbp+var_14]
add rax, rdx
mov [rax], rcx
jmp short loc_24159
loc_24148:
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
add rax, rcx
mov qword ptr [rax], 0
loc_24159:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
add rsp, 20h
pop rbp
retn
|
_QWORD * stack_add_head_3(
_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)
{
_QWORD *result; // rax
char v15; // [rsp+0h] [rbp-20h]
unsigned int v16; // [rsp+Ch] [rbp-14h]
v16 = a3;
if ( !a2 )
debug_assert((long long)aStackAddHead, 0LL, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v15);
if ( *a1 )
*(_QWORD *)(v16 + a2) = *a1;
else
*(_QWORD *)(v16 + a2) = 0LL;
result = a1;
*a1 = a2;
return result;
}
|
stack_add_head:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00124128
LEA RDI,[0x134299]
MOV AL,0x0
CALL 0x0011bb90
LAB_00124128:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x00124148
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
ADD RAX,RDX
MOV qword ptr [RAX],RCX
JMP 0x00124159
LAB_00124148:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
ADD RAX,RCX
MOV qword ptr [RAX],0x0
LAB_00124159:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
ADD RSP,0x20
POP RBP
RET
|
void stack_add_head(long *param_1,long param_2,uint param_3)
{
if (param_2 == 0) {
debug_assert(s_stack_add_head_00134299);
}
if (*param_1 == 0) {
*(int8 *)(param_2 + (ulong)param_3) = 0;
}
else {
*(long *)(param_2 + (ulong)param_3) = *param_1;
}
*param_1 = param_2;
return;
}
|
|
9,533 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array()
|
hkr04[P]cpp-mcp/common/json.hpp
|
bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x1, 0x2f(%rsp)
addq $0x8, %rdi
callq 0x3bb70
cmpq $0x0, (%rax)
je 0x3b002
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x3b6b0
movq 0x10(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x3bb70
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq (%rax), %rcx
movl $0x3, %edx
callq 0x3b650
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x3afc5
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3bb70
movq (%rax), %rdi
callq 0xb1e0
jmp 0x3b000
movq 0x10(%rsp), %rsi
addq $0xa8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x8f20
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3bb70
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x22280
leaq 0x18(%rsp), %rdi
callq 0x87f0
jmp 0x3b002
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3c810
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x3b630
testb $0x1, 0x2f(%rsp)
jne 0x3b06d
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3bec0
testb $0x1, %al
jne 0x3b06d
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3bb70
movq (%rax), %rdi
callq 0x8d00
testb $0x1, %al
jne 0x3b053
jmp 0x3b06d
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3bb70
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xa190
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rdi, [rsp+38h+var_8]
mov [rsp+38h+var_28], rdi
mov [rsp+38h+var_9], 1
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_3B002
mov rdi, [rsp+38h+var_28]
mov rax, rdi
add rax, 80h
mov [rsp+38h+var_38], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, [rsp+38h+var_28]
sub eax, 1
mov [rsp+38h+var_2C], eax
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
mov rdi, [rsp+38h+var_38]
mov esi, [rsp+38h+var_2C]
mov rcx, [rax]
mov edx, 3
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)
and al, 1
mov [rsp+38h+var_9], al
test [rsp+38h+var_9], 1
jz short loc_3AFC5
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; 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>::set_parents(void)
jmp short loc_3B000
loc_3AFC5:
mov rsi, [rsp+38h+var_28]
add rsi, 0A8h
lea rdi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
lea rsi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
lea rdi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_3B000:
jmp short $+2
loc_3B002:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::pop_back(void)
mov rdi, [rsp+38h+var_28]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
test [rsp+38h+var_9], 1
jnz short loc_3B06D
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::empty(void)
test al, 1
jnz short loc_3B06D
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; 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>::is_array(void)
test al, 1
jnz short loc_3B053
jmp short loc_3B06D
loc_3B053:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<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> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
loc_3B06D:
mov al, 1
and al, 1
add rsp, 38h
retn
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array(
long long a1)
{
_QWORD *v1; // rax
long long *v2; // rax
_BYTE **v3; // rax
long long v4; // rax
unsigned int v6; // [rsp+Ch] [rbp-2Ch]
_BYTE v7[23]; // [rsp+18h] [rbp-20h] BYREF
char v8; // [rsp+2Fh] [rbp-9h]
long long v9; // [rsp+30h] [rbp-8h]
v9 = a1;
v8 = 1;
if ( *(_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8) )
{
v6 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::size(a1 + 8)
- 1;
v1 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
v8 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
v6,
3LL,
*v1) & 1;
if ( v8 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::set_parents();
}
else
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v7,
a1 + 168);
v2 = (long long *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*v2,
(long long)v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v7);
}
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::pop_back(a1 + 8);
std::vector<bool>::pop_back(a1 + 32);
if ( (v8 & 1) == 0
&& (std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::empty(a1 + 8) & 1) == 0 )
{
v3 = (_BYTE **)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
if ( nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v3) )
{
v4 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(*(_QWORD *)v4 + 8LL));
}
}
return 1;
}
|
end_array:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
MOV byte ptr [RSP + 0x2f],0x1
ADD RDI,0x8
CALL 0x0013bb70
CMP qword ptr [RAX],0x0
JZ 0x0013b002
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP],RAX
ADD RDI,0x8
CALL 0x0013b6b0
MOV RDI,qword ptr [RSP + 0x10]
SUB EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
ADD RDI,0x8
CALL 0x0013bb70
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RAX]
MOV EDX,0x3
CALL 0x0013b650
AND AL,0x1
MOV byte ptr [RSP + 0x2f],AL
TEST byte ptr [RSP + 0x2f],0x1
JZ 0x0013afc5
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013bb70
MOV RDI,qword ptr [RAX]
CALL 0x0010b1e0
JMP 0x0013b000
LAB_0013afc5:
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0xa8
LEA RDI,[RSP + 0x18]
CALL 0x00108f20
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013bb70
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0x18]
CALL 0x00122280
LEA RDI,[RSP + 0x18]
CALL 0x001087f0
LAB_0013b000:
JMP 0x0013b002
LAB_0013b002:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013c810
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x0013b630
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x0013b06d
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013bec0
TEST AL,0x1
JNZ 0x0013b06d
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013bb70
MOV RDI,qword ptr [RAX]
CALL 0x00108d00
TEST AL,0x1
JNZ 0x0013b053
JMP 0x0013b06d
LAB_0013b053:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x0013bb70
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0010a190
LAB_0013b06d:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x38
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_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_array(json_sax_dom_callback_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)
{
int iVar1;
long *plVar2;
int8 *puVar3;
ulong uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_20 [23];
byte local_9;
json_sax_dom_callback_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>>
*local_8;
local_9 = 1;
local_8 = this;
plVar2 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar2 != 0) {
iVar1 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_9 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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 + 0x80),iVar1 + -1,3,*puVar3);
local_9 = local_9 & 1;
if (local_9 == 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>
::basic_json(local_20,(basic_json *)(this + 0xa8));
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((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>
*)*puVar3,local_20);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_20);
}
else {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
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>
::set_parents();
}
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::pop_back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((local_9 & 1) == 0) &&
(uVar4 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8)), (uVar4 & 1) == 0)) {
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar4 = 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>
::is_array((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>
*)*puVar3);
if ((uVar4 & 1) != 0) {
plVar2 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar2 + 8));
}
}
return 1;
}
|
|
9,534 |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array()
|
hkr04[P]cpp-mcp/common/json.hpp
|
bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x151eb
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x3
popq %rdx
callq 0x154b4
testb %al, %al
je 0x15209
addq $-0x8, 0x10(%rbx)
jmp 0x151f3
addq $-0x8, %rsi
movq %rsi, 0x10(%rbx)
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x14b42
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x67c4
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movb (%rax), %cl
movb (%r14), %dl
movb %dl, (%rax)
movb %cl, (%r14)
movq 0x8(%rax), %rcx
movq 0x8(%r14), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%r14)
movq %r14, %rdi
callq 0x69d6
addq $-0x8, 0x10(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x14b42
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x151ff
movq -0x8(%rax), %rax
cmpb $0x2, (%rax)
jne 0x151ff
movq 0x8(%rax), %rdi
callq 0xea56
jmp 0x151ff
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov rsi, [rdi+10h]
mov rcx, [rsi-8]
test rcx, rcx
jz short loc_151EB
lea rdi, [rbx+80h]
sub rsi, [rbx+8]
shr rsi, 3
dec esi
push 3
pop rdx
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)
test al, al
jz short loc_15209
add qword ptr [rbx+10h], 0FFFFFFFFFFFFFFF8h
jmp short loc_151F3
loc_151EB:
add rsi, 0FFFFFFFFFFFFFFF8h
mov [rbx+10h], rsi
loc_151F3:
add rbx, 30h ; '0'
mov rdi, rbx; this
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
loc_151FF:
mov al, 1
add rsp, 18h
pop rbx
pop r14
retn
loc_15209:
lea rsi, [rbx+0A8h]
lea r14, [rsp+28h+var_20]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov cl, [rax]
mov dl, [r14]
mov [rax], dl
mov [r14], cl
mov rcx, [rax+8]
mov rdx, [r14+8]
mov [rax+8], rdx
mov [r14+8], rcx
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add qword ptr [rbx+10h], 0FFFFFFFFFFFFFFF8h
lea rdi, [rbx+30h]; this
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_151FF
mov rax, [rax-8]
cmp byte ptr [rax], 2
jnz short loc_151FF
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
jmp short loc_151FF
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array(
long long a1)
{
long long v1; // rsi
long long v2; // rcx
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
char *v8; // rax
char v9; // cl
long long v10; // rcx
long long v11; // rax
long long v12; // rax
_BYTE v13[8]; // [rsp+8h] [rbp-20h] BYREF
long long v14; // [rsp+10h] [rbp-18h]
v1 = *(_QWORD *)(a1 + 16);
v2 = *(_QWORD *)(v1 - 8);
if ( !v2 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
goto LABEL_5;
}
if ( (unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(unsigned int)((unsigned long long)(v1 - *(_QWORD *)(a1 + 8)) >> 3) - 1,
3LL,
v2) )
{
*(_QWORD *)(a1 + 16) -= 8LL;
LABEL_5:
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 48));
return 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>::basic_json(
(long long)v13,
(unsigned __int8 *)(a1 + 168),
v3,
v4,
v5,
v6);
v8 = *(char **)(*(_QWORD *)(a1 + 16) - 8LL);
v9 = *v8;
*v8 = v13[0];
v13[0] = v9;
v10 = *((_QWORD *)v8 + 1);
*((_QWORD *)v8 + 1) = v14;
v14 = v10;
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(v13);
*(_QWORD *)(a1 + 16) -= 8LL;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 48));
v11 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) != v11 )
{
v12 = *(_QWORD *)(v11 - 8);
if ( *(_BYTE *)v12 == 2 )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(v12 + 8));
}
return 1;
}
|
end_array:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RSI + -0x8]
TEST RCX,RCX
JZ 0x001151eb
LEA RDI,[RBX + 0x80]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
DEC ESI
PUSH 0x3
POP RDX
CALL 0x001154b4
TEST AL,AL
JZ 0x00115209
ADD qword ptr [RBX + 0x10],-0x8
JMP 0x001151f3
LAB_001151eb:
ADD RSI,-0x8
MOV qword ptr [RBX + 0x10],RSI
LAB_001151f3:
ADD RBX,0x30
MOV RDI,RBX
CALL 0x00114b42
LAB_001151ff:
MOV AL,0x1
ADD RSP,0x18
POP RBX
POP R14
RET
LAB_00115209:
LEA RSI,[RBX + 0xa8]
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001067c4
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV CL,byte ptr [RAX]
MOV DL,byte ptr [R14]
MOV byte ptr [RAX],DL
MOV byte ptr [R14],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [R14 + 0x8],RCX
MOV RDI,R14
CALL 0x001069d6
ADD qword ptr [RBX + 0x10],-0x8
LEA RDI,[RBX + 0x30]
CALL 0x00114b42
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001151ff
MOV RAX,qword ptr [RAX + -0x8]
CMP byte ptr [RAX],0x2
JNZ 0x001151ff
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0010ea56
JMP 0x001151ff
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_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_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_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_array(json_sax_dom_callback_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)
{
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>
bVar1;
long lVar2;
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>
*pbVar3;
int8 uVar4;
char *pcVar5;
char cVar6;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_20 [8];
int8 local_18;
lVar2 = *(long *)(this + 0x10);
if (*(long *)(lVar2 + -8) == 0) {
*(long *)(this + 0x10) = lVar2 + -8;
}
else {
cVar6 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(int)((ulong)(lVar2 - *(long *)(this + 8)) >> 3) + -1,3);
if (cVar6 == '\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>
::basic_json(local_20,(basic_json *)(this + 0xa8));
pbVar3 = *(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>
**)(*(long *)(this + 0x10) + -8);
bVar1 = *pbVar3;
*pbVar3 = local_20[0];
uVar4 = *(int8 *)(pbVar3 + 8);
*(int8 *)(pbVar3 + 8) = local_18;
local_20[0] = bVar1;
local_18 = uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_20);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + -8;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x30));
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
return 1;
}
pcVar5 = *(char **)(*(long *)(this + 0x10) + -8);
if (*pcVar5 != '\x02') {
return 1;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar5 + 8));
return 1;
}
*(long *)(this + 0x10) = *(long *)(this + 0x10) + -8;
}
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x30));
return 1;
}
|
|
9,535 |
google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
|
bool CopyingOutputStreamAdaptor::Next(void** data, int* size) {
if (buffer_used_ == buffer_size_) {
if (!WriteBuffer()) return false;
}
AllocateBufferIfNeeded();
*data = buffer_.get() + buffer_used_;
*size = buffer_size_ - buffer_used_;
buffer_used_ = buffer_size_;
return true;
}
|
O0
|
cpp
|
google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x2c(%rcx), %eax
cmpl 0x28(%rcx), %eax
jne 0x1ad70a
movq (%rsp), %rdi
callq 0x1ad5d0
testb $0x1, %al
jne 0x1ad708
movb $0x0, 0x27(%rsp)
jmp 0x1ad74e
jmp 0x1ad70a
movq (%rsp), %rdi
callq 0x1ad760
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x1ae0d0
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x2c(%rax), %rcx
addq %rcx, %rdx
movq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movl 0x28(%rax), %edx
subl 0x2c(%rax), %edx
movq 0x8(%rsp), %rcx
movl %edx, (%rcx)
movl 0x28(%rax), %ecx
movl %ecx, 0x2c(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZN6google8protobuf2io26CopyingOutputStreamAdaptor4NextEPPvPi:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov rcx, [rsp+28h+var_10]
mov [rsp+28h+var_28], rcx
mov eax, [rcx+2Ch]
cmp eax, [rcx+28h]
jnz short loc_1AD70A
mov rdi, [rsp+28h+var_28]; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor11WriteBufferEv; google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(void)
test al, 1
jnz short loc_1AD708
mov [rsp+28h+var_1], 0
jmp short loc_1AD74E
loc_1AD708:
jmp short $+2
loc_1AD70A:
mov rdi, [rsp+28h+var_28]; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor22AllocateBufferIfNeededEv; google::protobuf::io::CopyingOutputStreamAdaptor::AllocateBufferIfNeeded(void)
mov rdi, [rsp+28h+var_28]
add rdi, 20h ; ' '
call _ZNKSt10unique_ptrIA_hSt14default_deleteIS0_EE3getEv; std::unique_ptr<uchar []>::get(void)
mov rdx, rax
mov rax, [rsp+28h+var_28]
movsxd rcx, dword ptr [rax+2Ch]
add rdx, rcx
mov rcx, [rsp+28h+var_18]
mov [rcx], rdx
mov edx, [rax+28h]
sub edx, [rax+2Ch]
mov rcx, [rsp+28h+var_20]
mov [rcx], edx
mov ecx, [rax+28h]
mov [rax+2Ch], ecx
mov [rsp+28h+var_1], 1
loc_1AD74E:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
|
char google::protobuf::io::CopyingOutputStreamAdaptor::Next(
google::protobuf::io::CopyingOutputStreamAdaptor *this,
void **a2,
int *a3)
{
if ( *((_DWORD *)this + 11) == *((_DWORD *)this + 10)
&& (google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(this) & 1) == 0 )
{
return 0;
}
google::protobuf::io::CopyingOutputStreamAdaptor::AllocateBufferIfNeeded(this);
*a2 = (void *)(*((int *)this + 11) + std::unique_ptr<unsigned char []>::get((char *)this + 32));
*a3 = *((_DWORD *)this + 10) - *((_DWORD *)this + 11);
*((_DWORD *)this + 11) = *((_DWORD *)this + 10);
return 1;
}
|
InternalSwap:
SUB RSP,0x48
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RCX
ADD RCX,0x8
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x8
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001de020
MOV RAX,qword ptr [RSP]
ADD RAX,0x10
MOV qword ptr [RSP + 0x40],RAX
MOV dword ptr [RSP + 0x3c],0x0
MOV RDI,qword ptr [RSP + 0x40]
MOVSXD RAX,dword ptr [RSP + 0x3c]
SHL RAX,0x2
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x10
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x2c],0x0
MOV RSI,qword ptr [RSP + 0x30]
MOVSXD RAX,dword ptr [RSP + 0x2c]
SHL RAX,0x2
ADD RSI,RAX
CALL 0x001d5790
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x10
ADD RSI,0x8
CALL 0x001d5880
ADD RSP,0x48
RET
|
/* google::protobuf::DescriptorProto_ExtensionRange::InternalSwap(google::protobuf::DescriptorProto_ExtensionRange*)
*/
void __thiscall
google::protobuf::DescriptorProto_ExtensionRange::InternalSwap
(DescriptorProto_ExtensionRange *this,DescriptorProto_ExtensionRange *param_1)
{
std::swap<long>((long *)(this + 8),(long *)(param_1 + 8));
std::swap<unsigned_int>((uint *)(this + 0x10),(uint *)(param_1 + 0x10));
std::enable_if<((16)>=(16ul))&&((16)<((1u)<<(31))),void>::type_google::protobuf::internal::
memswap<16>((char *)(this + 0x18),(char *)(param_1 + 0x18));
return;
}
|
|
9,536 |
google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
|
bool CopyingOutputStreamAdaptor::Next(void** data, int* size) {
if (buffer_used_ == buffer_size_) {
if (!WriteBuffer()) return false;
}
AllocateBufferIfNeeded();
*data = buffer_.get() + buffer_used_;
*size = buffer_size_ - buffer_used_;
buffer_used_ = buffer_size_;
return true;
}
|
O3
|
cpp
|
google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
cmpl %ebp, 0x2c(%rdi)
jne 0x9d777
movq %rbx, %rdi
callq 0x9d6cc
testb %al, %al
je 0x9d7af
movl 0x28(%rbx), %ebp
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0x9d796
testl %ebp, %ebp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
movslq %eax, %rdi
callq 0xf030
movq %rax, 0x20(%rbx)
movslq 0x2c(%rbx), %rcx
addq %rcx, %rax
movq %rax, (%r15)
subl %ecx, %ebp
movl %ebp, (%r14)
movl 0x28(%rbx), %eax
movl %eax, 0x2c(%rbx)
movb $0x1, %al
jmp 0x9d7b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6google8protobuf2io26CopyingOutputStreamAdaptor4NextEPPvPi:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov ebp, [rdi+28h]
cmp [rdi+2Ch], ebp
jnz short loc_9D777
mov rdi, rbx; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor11WriteBufferEv; google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(void)
test al, al
jz short loc_9D7AF
mov ebp, [rbx+28h]
loc_9D777:
mov rax, [rbx+20h]
test rax, rax
jnz short loc_9D796
test ebp, ebp
mov eax, 0FFFFFFFFh
cmovns eax, ebp
movsxd rdi, eax; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+20h], rax
loc_9D796:
movsxd rcx, dword ptr [rbx+2Ch]
add rax, rcx
mov [r15], rax
sub ebp, ecx
mov [r14], ebp
mov eax, [rbx+28h]
mov [rbx+2Ch], eax
mov al, 1
jmp short loc_9D7B1
loc_9D7AF:
xor eax, eax
loc_9D7B1:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
char google::protobuf::io::CopyingOutputStreamAdaptor::Next(
google::protobuf::io::CopyingOutputStreamAdaptor *this,
void **a2,
int *a3)
{
int v4; // ebp
long long v5; // rax
int v6; // eax
long long v7; // rcx
v4 = *((_DWORD *)this + 10);
if ( *((_DWORD *)this + 11) == v4 )
{
if ( !(unsigned __int8)google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(this) )
return 0;
v4 = *((_DWORD *)this + 10);
}
v5 = *((_QWORD *)this + 4);
if ( !v5 )
{
v6 = -1;
if ( v4 >= 0 )
v6 = v4;
v5 = operator new[](v6);
*((_QWORD *)this + 4) = v5;
}
v7 = *((int *)this + 11);
*a2 = (void *)(v7 + v5);
*a3 = v4 - v7;
*((_DWORD *)this + 11) = *((_DWORD *)this + 10);
return 1;
}
|
Next:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV EBP,dword ptr [RDI + 0x28]
CMP dword ptr [RDI + 0x2c],EBP
JNZ 0x0019d777
MOV RDI,RBX
CALL 0x0019d6cc
TEST AL,AL
JZ 0x0019d7af
MOV EBP,dword ptr [RBX + 0x28]
LAB_0019d777:
MOV RAX,qword ptr [RBX + 0x20]
TEST RAX,RAX
JNZ 0x0019d796
TEST EBP,EBP
MOV EAX,0xffffffff
CMOVNS EAX,EBP
MOVSXD RDI,EAX
CALL 0x0010f030
MOV qword ptr [RBX + 0x20],RAX
LAB_0019d796:
MOVSXD RCX,dword ptr [RBX + 0x2c]
ADD RAX,RCX
MOV qword ptr [R15],RAX
SUB EBP,ECX
MOV dword ptr [R14],EBP
MOV EAX,dword ptr [RBX + 0x28]
MOV dword ptr [RBX + 0x2c],EAX
MOV AL,0x1
JMP 0x0019d7b1
LAB_0019d7af:
XOR EAX,EAX
LAB_0019d7b1:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*) */
int8 __thiscall
google::protobuf::io::CopyingOutputStreamAdaptor::Next
(CopyingOutputStreamAdaptor *this,void **param_1,int *param_2)
{
char cVar1;
int iVar2;
void *pvVar3;
int iVar4;
iVar4 = *(int *)(this + 0x28);
if (*(int *)(this + 0x2c) == iVar4) {
cVar1 = WriteBuffer(this);
if (cVar1 == '\0') {
return 0;
}
iVar4 = *(int *)(this + 0x28);
}
pvVar3 = *(void **)(this + 0x20);
if (pvVar3 == (void *)0x0) {
iVar2 = -1;
if (-1 < iVar4) {
iVar2 = iVar4;
}
pvVar3 = operator_new__((long)iVar2);
*(void **)(this + 0x20) = pvVar3;
}
iVar2 = *(int *)(this + 0x2c);
*param_1 = (void *)((long)pvVar3 + (long)iVar2);
*param_2 = iVar4 - iVar2;
*(int4 *)(this + 0x2c) = *(int4 *)(this + 0x28);
return CONCAT71((uint7)(uint3)((uint)*(int4 *)(this + 0x28) >> 8),1);
}
|
|
9,537 |
minja::ElifTemplateToken::~ElifTemplateToken()
|
monkey531[P]llama/common/./minja.hpp
|
ElifTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::Elif, location, pre, post), condition(std::move(c)) {}
|
O3
|
cpp
|
minja::ElifTemplateToken::~ElifTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x955e9(%rip), %rax # 0xeeb88
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x595b0
callq 0x2f80e
leaq 0x94c11(%rip), %rax # 0xee1c8
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x595c8
callq 0x2f80e
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x186a0
|
_ZN5minja17ElifTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, off_EEB88
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_595B0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_595B0:
lea rax, off_EE1C8
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_595C8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_595C8:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::ElifTemplateToken::~ElifTemplateToken(minja::ElifTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = off_EEB88;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = off_EE1C8;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~ElifTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1eeb88]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x001595b0
CALL 0x0012f80e
LAB_001595b0:
LEA RAX,[0x1ee1c8]
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001595c8
CALL 0x0012f80e
LAB_001595c8:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x001186a0
|
/* minja::ElifTemplateToken::~ElifTemplateToken() */
void __thiscall minja::ElifTemplateToken::~ElifTemplateToken(ElifTemplateToken *this)
{
*(int ***)this = &PTR__ElifTemplateToken_001eeb88;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_001ee1c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
9,538 |
mysql_cset_escape_quotes
|
eloqsql/libmariadb/libmariadb/ma_charset.c
|
size_t mysql_cset_escape_quotes(const MARIADB_CHARSET_INFO *cset, char *newstr,
const char * escapestr, size_t escapestr_len )
{
const char *newstr_s = newstr;
const char *newstr_e = newstr + 2 * escapestr_len;
const char *end = escapestr + escapestr_len;
my_bool escape_overflow = FALSE;
for (;escapestr < end; escapestr++) {
unsigned int len = 0;
/* check unicode characters */
if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
/* check possible overflow */
if ((newstr + len) > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy mb char without escaping it */
while (len--) {
*newstr++ = *escapestr++;
}
escapestr--;
continue;
}
if (*escapestr == '\'') {
if (newstr + 2 > newstr_e) {
escape_overflow = TRUE;
break;
}
*newstr++ = '\'';
*newstr++ = '\'';
} else {
if (newstr + 1 > newstr_e) {
escape_overflow = TRUE;
break;
}
*newstr++ = *escapestr;
}
}
*newstr = '\0';
if (escape_overflow) {
return((size_t)~0);
}
return((size_t)(newstr - newstr_s));
}
|
O3
|
c
|
mysql_cset_escape_quotes:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
testq %rcx, %rcx
jle 0x17e66
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movq -0x30(%rbp), %rbx
leaq (%rbx,%rcx,2), %r13
addq %rdx, %r14
cmpl $0x2, 0x34(%r15)
jb 0x17e37
movq %r12, %rdi
movq %r14, %rsi
callq *0x40(%r15)
testl %eax, %eax
je 0x17e37
movl %eax, %ecx
movl %eax, %eax
addq %rbx, %rax
cmpq %r13, %rax
ja 0x17e6f
decq %r12
movq %r12, %rdx
leaq 0x1(%rdx), %r12
leaq 0x1(%rbx), %rax
movb 0x1(%rdx), %dl
movb %dl, (%rbx)
movq %r12, %rdx
movq %rax, %rbx
decl %ecx
jne 0x17e1e
jmp 0x17e5b
movb (%r12), %cl
cmpb $0x27, %cl
jne 0x17e50
leaq 0x2(%rbx), %rax
cmpq %r13, %rax
ja 0x17e6f
movw $0x2727, (%rbx) # imm = 0x2727
jmp 0x17e5b
leaq 0x1(%rbx), %rax
cmpq %r13, %rax
ja 0x17e6f
movb %cl, (%rbx)
incq %r12
movq %rax, %rbx
cmpq %r14, %r12
jb 0x17df7
movb $0x0, (%rax)
subq -0x30(%rbp), %rax
jmp 0x17e79
movb $0x0, (%rbx)
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mysql_cset_escape_quotes:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], rsi
mov rax, rsi
test rcx, rcx
jle loc_17E66
mov r14, rcx
mov r12, rdx
mov r15, rdi
mov rbx, [rbp+var_30]
lea r13, [rbx+rcx*2]
add r14, rdx
loc_17DF7:
cmp dword ptr [r15+34h], 2
jb short loc_17E37
mov rdi, r12
mov rsi, r14
call qword ptr [r15+40h]
test eax, eax
jz short loc_17E37
mov ecx, eax
mov eax, eax
add rax, rbx
cmp rax, r13
ja short loc_17E6F
dec r12
mov rdx, r12
loc_17E1E:
lea r12, [rdx+1]
lea rax, [rbx+1]
mov dl, [rdx+1]
mov [rbx], dl
mov rdx, r12
mov rbx, rax
dec ecx
jnz short loc_17E1E
jmp short loc_17E5B
loc_17E37:
mov cl, [r12]
cmp cl, 27h ; '''
jnz short loc_17E50
lea rax, [rbx+2]
cmp rax, r13
ja short loc_17E6F
mov word ptr [rbx], 2727h
jmp short loc_17E5B
loc_17E50:
lea rax, [rbx+1]
cmp rax, r13
ja short loc_17E6F
mov [rbx], cl
loc_17E5B:
inc r12
mov rbx, rax
cmp r12, r14
jb short loc_17DF7
loc_17E66:
mov byte ptr [rax], 0
sub rax, [rbp+var_30]
jmp short loc_17E79
loc_17E6F:
mov byte ptr [rbx], 0
mov rax, 0FFFFFFFFFFFFFFFFh
loc_17E79:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mysql_cset_escape_quotes(long long a1, _BYTE *a2, _BYTE *a3, long long a4)
{
_BYTE *v4; // rax
_BYTE *v5; // r12
_WORD *v6; // rbx
unsigned long long v7; // r13
unsigned long long v8; // r14
unsigned int v9; // eax
unsigned int v10; // ecx
_BYTE *v11; // rdx
v4 = a2;
if ( a4 <= 0 )
{
LABEL_15:
*v4 = 0;
return v4 - a2;
}
v5 = a3;
v6 = a2;
v7 = (unsigned long long)&a2[2 * a4];
v8 = (unsigned long long)&a3[a4];
while ( 1 )
{
if ( *(_DWORD *)(a1 + 52) >= 2u )
{
v9 = (*(long long ( **)(_BYTE *, unsigned long long))(a1 + 64))(v5, v8);
if ( v9 )
{
v10 = v9;
if ( (unsigned long long)v6 + v9 > v7 )
goto LABEL_16;
v11 = v5 - 1;
do
{
v5 = v11 + 1;
v4 = (char *)v6 + 1;
*(_BYTE *)v6 = *++v11;
v6 = (_WORD *)((char *)v6 + 1);
--v10;
}
while ( v10 );
goto LABEL_14;
}
}
if ( *v5 != 39 )
break;
v4 = v6 + 1;
if ( (unsigned long long)(v6 + 1) > v7 )
goto LABEL_16;
*v6 = 10023;
LABEL_14:
++v5;
v6 = v4;
if ( (unsigned long long)v5 >= v8 )
goto LABEL_15;
}
v4 = (char *)v6 + 1;
if ( (unsigned long long)v6 + 1 <= v7 )
{
*(_BYTE *)v6 = *v5;
goto LABEL_14;
}
LABEL_16:
*(_BYTE *)v6 = 0;
return -1LL;
}
|
mysql_cset_escape_quotes:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
TEST RCX,RCX
JLE 0x00117e66
MOV R14,RCX
MOV R12,RDX
MOV R15,RDI
MOV RBX,qword ptr [RBP + -0x30]
LEA R13,[RBX + RCX*0x2]
ADD R14,RDX
LAB_00117df7:
CMP dword ptr [R15 + 0x34],0x2
JC 0x00117e37
MOV RDI,R12
MOV RSI,R14
CALL qword ptr [R15 + 0x40]
TEST EAX,EAX
JZ 0x00117e37
MOV ECX,EAX
MOV EAX,EAX
ADD RAX,RBX
CMP RAX,R13
JA 0x00117e6f
DEC R12
MOV RDX,R12
LAB_00117e1e:
LEA R12,[RDX + 0x1]
LEA RAX,[RBX + 0x1]
MOV DL,byte ptr [RDX + 0x1]
MOV byte ptr [RBX],DL
MOV RDX,R12
MOV RBX,RAX
DEC ECX
JNZ 0x00117e1e
JMP 0x00117e5b
LAB_00117e37:
MOV CL,byte ptr [R12]
CMP CL,0x27
JNZ 0x00117e50
LEA RAX,[RBX + 0x2]
CMP RAX,R13
JA 0x00117e6f
MOV word ptr [RBX],0x2727
JMP 0x00117e5b
LAB_00117e50:
LEA RAX,[RBX + 0x1]
CMP RAX,R13
JA 0x00117e6f
MOV byte ptr [RBX],CL
LAB_00117e5b:
INC R12
MOV RBX,RAX
CMP R12,R14
JC 0x00117df7
LAB_00117e66:
MOV byte ptr [RAX],0x0
SUB RAX,qword ptr [RBP + -0x30]
JMP 0x00117e79
LAB_00117e6f:
MOV byte ptr [RBX],0x0
MOV RAX,-0x1
LAB_00117e79:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long mysql_cset_escape_quotes(long param_1,char *param_2,char *param_3,long param_4)
{
char *pcVar1;
uint uVar2;
char *pcVar3;
char *pcVar4;
char *pcVar5;
char *pcVar6;
pcVar3 = param_2;
if (0 < param_4) {
pcVar1 = param_2 + param_4 * 2;
pcVar6 = param_3 + param_4;
pcVar5 = param_2;
do {
if ((*(uint *)(param_1 + 0x34) < 2) ||
(uVar2 = (**(code **)(param_1 + 0x40))(param_3,pcVar6), uVar2 == 0)) {
if (*param_3 == '\'') {
pcVar3 = pcVar5 + 2;
if (pcVar1 < pcVar3) {
LAB_00117e6f:
*pcVar5 = '\0';
return -1;
}
pcVar5[0] = '\'';
pcVar5[1] = '\'';
}
else {
pcVar3 = pcVar5 + 1;
if (pcVar1 < pcVar3) goto LAB_00117e6f;
*pcVar5 = *param_3;
}
}
else {
if (pcVar1 < pcVar5 + uVar2) goto LAB_00117e6f;
pcVar4 = param_3 + -1;
do {
param_3 = pcVar4 + 1;
pcVar3 = pcVar5 + 1;
*pcVar5 = pcVar4[1];
uVar2 = uVar2 - 1;
pcVar4 = param_3;
pcVar5 = pcVar3;
} while (uVar2 != 0);
}
param_3 = param_3 + 1;
pcVar5 = pcVar3;
} while (param_3 < pcVar6);
}
*pcVar3 = '\0';
return (long)pcVar3 - (long)param_2;
}
|
|
9,539 |
bf_pow_generic
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
const bf_t *y = opaque;
bf_t T_s, *T = &T_s;
limb_t prec1;
bf_init(s, T);
/* XXX: proof for the added precision */
prec1 = prec + 32;
bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
if (bf_is_nan(T))
bf_set_nan(r);
else
bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
bf_delete(T);
return BF_ST_INEXACT;
}
|
O0
|
c
|
bf_pow_generic:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe4cb0
movq 0x50(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq (%rsp), %rdx
movl $0x7e6, %ecx # imm = 0x7E6
callq 0xed680
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq (%rsp), %rcx
movl $0x7e6, %r8d # imm = 0x7E6
callq 0xe73c0
movq 0x8(%rsp), %rdi
callq 0xe7f90
cmpl $0x0, %eax
je 0xeecc6
movq 0x60(%rsp), %rdi
callq 0xe4ee0
jmp 0xeecdd
movq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xed360
movq 0x8(%rsp), %rdi
callq 0xe8110
movl $0x10, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
bf_pow_generic:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_20], rcx
mov rax, [rsp+68h+var_8]
mov rax, [rax]
mov [rsp+68h+var_28], rax
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_30], rax
lea rax, [rsp+68h+var_58]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_60]
call bf_init
mov rax, [rsp+68h+var_18]
add rax, 20h ; ' '
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_60]
mov rsi, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_68]
mov ecx, 7E6h
call bf_log
mov rdi, [rsp+68h+var_60]
mov rsi, [rsp+68h+var_60]
mov rdx, [rsp+68h+var_30]
mov rcx, [rsp+68h+var_68]
mov r8d, 7E6h
call bf_mul
mov rdi, [rsp+68h+var_60]
call bf_is_nan
cmp eax, 0
jz short loc_EECC6
mov rdi, [rsp+68h+var_8]
call bf_set_nan
jmp short loc_EECDD
loc_EECC6:
mov rdi, [rsp+68h+var_8]
mov rsi, [rsp+68h+var_60]
mov rdx, [rsp+68h+var_68]
xor eax, eax
mov ecx, eax
call bf_exp_internal
loc_EECDD:
mov rdi, [rsp+68h+var_60]
call bf_delete_0
mov eax, 10h
add rsp, 68h
retn
|
long long bf_pow_generic(long long *a1, long long a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rcx
long long v6; // r8
long long v7; // r9
long long v9; // [rsp+0h] [rbp-68h]
long long v10[5]; // [rsp+10h] [rbp-58h] BYREF
long long v11; // [rsp+38h] [rbp-30h]
long long v12; // [rsp+40h] [rbp-28h]
long long v13; // [rsp+48h] [rbp-20h]
long long v14; // [rsp+50h] [rbp-18h]
long long v15; // [rsp+58h] [rbp-10h]
long long *v16; // [rsp+60h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = *a1;
v11 = a4;
bf_init(v12, (long long)v10);
v9 = v14 + 32;
bf_log(v10, v15, v14 + 32, 0x7E6u);
bf_mul(v10, (long long)v10, v11, v9, 0x7E6u);
if ( bf_is_nan((long long)v10) )
bf_set_nan((long long)v16);
else
bf_exp_internal(v16, v10, v9, 0LL);
bf_delete_0(v10, (long long)v10, v4, v5, v6, v7);
return 16LL;
}
|
bf_pow_generic:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x48],RCX
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x38],RAX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001e4cb0
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x20
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP]
MOV ECX,0x7e6
CALL 0x001ed680
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP]
MOV R8D,0x7e6
CALL 0x001e73c0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001e7f90
CMP EAX,0x0
JZ 0x001eecc6
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x001e4ee0
JMP 0x001eecdd
LAB_001eecc6:
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001ed360
LAB_001eecdd:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001e8110
MOV EAX,0x10
ADD RSP,0x68
RET
|
int8 bf_pow_generic(int8 *param_1,int8 param_2,long param_3,int8 param_4)
{
int iVar1;
long lVar2;
int1 local_58 [40];
int8 local_30;
int8 local_28;
int8 local_20;
long local_18;
int8 local_10;
int8 *local_8;
local_28 = *param_1;
local_30 = param_4;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
bf_init(local_28,local_58);
lVar2 = local_18 + 0x20;
bf_log(local_58,local_10,lVar2,0x7e6);
bf_mul(local_58,local_58,local_30,lVar2,0x7e6);
iVar1 = bf_is_nan(local_58);
if (iVar1 == 0) {
bf_exp_internal(local_8,local_58,lVar2,0);
}
else {
bf_set_nan(local_8);
}
bf_delete(local_58);
return 0x10;
}
|
|
9,540 |
bf_pow_generic
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
const bf_t *y = opaque;
bf_t T_s, *T = &T_s;
limb_t prec1;
bf_init(s, T);
/* XXX: proof for the added precision */
prec1 = prec + 32;
bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
if (bf_is_nan(T))
bf_set_nan(r);
else
bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
bf_delete(T);
return BF_ST_INEXACT;
}
|
O1
|
c
|
bf_pow_generic:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
movq (%rdi), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl $0x0, 0x8(%r12)
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
addq $0x20, %r14
movq %r12, %rdi
movq %r14, %rdx
movl $0x7e6, %ecx # imm = 0x7E6
callq 0x8a4d2
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl $0x7e6, %r8d # imm = 0x7E6
callq 0x85afd
cmpq %r13, 0x10(%r12)
jne 0x8b8c5
cmpq $0x0, 0x18(%rbx)
je 0x8b8b8
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r13, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x8b8d5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8a1b7
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x8b8f1
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x8b8f1
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movl $0x10, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
bf_pow_generic:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 30h
mov r15, rcx
mov r14, rdx
mov rbx, rdi
mov r13, 7FFFFFFFFFFFFFFFh
mov rax, [rdi]
lea r12, [rsp+58h+var_50]
mov [r12], rax
mov dword ptr [r12+8], 0
lea rax, [r13+1]
mov [r12+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r12+18h], xmm0
add r14, 20h ; ' '
mov rdi, r12
mov rdx, r14
mov ecx, 7E6h
call bf_log
mov rdi, r12
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8d, 7E6h
call bf_mul
cmp [r12+10h], r13
jnz short loc_8B8C5
cmp qword ptr [rbx+18h], 0
jz short loc_8B8B8
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8B8B8:
mov [rbx+10h], r13
mov dword ptr [rbx+8], 0
jmp short loc_8B8D5
loc_8B8C5:
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
mov rdx, r14
call bf_exp_internal
loc_8B8D5:
mov rax, [rsp+58h+var_50]
test rax, rax
jz short loc_8B8F1
mov rsi, [rsp+58h+var_30]
test rsi, rsi
jz short loc_8B8F1
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_8B8F1:
mov eax, 10h
add rsp, 30h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long bf_pow_generic(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long v5; // r14
__int128 v7; // [rsp+8h] [rbp-50h] BYREF
unsigned long long v8; // [rsp+18h] [rbp-40h]
__int128 v9; // [rsp+20h] [rbp-38h]
*(_QWORD *)&v7 = *a1;
DWORD2(v7) = 0;
v8 = 0x8000000000000000LL;
v9 = 0LL;
v5 = a3 + 32;
bf_log(&v7, a2, a3 + 32, 0x7E6u);
bf_mul(&v7, (long long)&v7, a4, v5, 0x7E6u);
if ( v8 == 0x7FFFFFFFFFFFFFFFLL )
{
if ( a1[3] )
{
a1[4] = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
}
else
{
bf_exp_internal((long long)a1, (long long)&v7, v5);
}
if ( (_QWORD)v7 && *((_QWORD *)&v9 + 1) )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v7 + 8))(*(_QWORD *)v7, *((_QWORD *)&v9 + 1), 0LL);
return 16LL;
}
|
bf_pow_generic:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R15,RCX
MOV R14,RDX
MOV RBX,RDI
MOV R13,0x7fffffffffffffff
MOV RAX,qword ptr [RDI]
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RAX
MOV dword ptr [R12 + 0x8],0x0
LEA RAX,[R13 + 0x1]
MOV qword ptr [R12 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12 + 0x18],XMM0
ADD R14,0x20
MOV RDI,R12
MOV RDX,R14
MOV ECX,0x7e6
CALL 0x0018a4d2
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8D,0x7e6
CALL 0x00185afd
CMP qword ptr [R12 + 0x10],R13
JNZ 0x0018b8c5
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018b8b8
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018b8b8:
MOV qword ptr [RBX + 0x10],R13
MOV dword ptr [RBX + 0x8],0x0
JMP 0x0018b8d5
LAB_0018b8c5:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x0018a1b7
LAB_0018b8d5:
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x0018b8f1
MOV RSI,qword ptr [RSP + 0x28]
TEST RSI,RSI
JZ 0x0018b8f1
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_0018b8f1:
MOV EAX,0x10
ADD RSP,0x30
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 bf_pow_generic(long *param_1,int8 param_2,long param_3,int8 param_4)
{
long lVar1;
int8 *local_50;
int4 local_48;
long local_40;
int8 local_38;
long lStack_30;
local_50 = (int8 *)*param_1;
local_48 = 0;
local_40 = -0x8000000000000000;
local_38 = 0;
lStack_30 = 0;
param_3 = param_3 + 0x20;
bf_log(&local_50,param_2,param_3,0x7e6);
bf_mul(&local_50,&local_50,param_4,param_3,0x7e6);
if (local_40 == 0x7fffffffffffffff) {
if (param_1[3] != 0) {
lVar1 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar1;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
}
else {
bf_exp_internal(param_1,&local_50,param_3);
}
if ((local_50 != (int8 *)0x0) && (lStack_30 != 0)) {
(*(code *)local_50[1])(*local_50,lStack_30,0);
}
return 0x10;
}
|
|
9,541 |
maria_page_crc_set_index
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_set_index(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= _ma_get_page_used(share, page);
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_index");
DBUG_PRINT("info", ("Page %lu crc: %lu",
(ulong) page_no, (ulong) crc));
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + share->block_size - CRC_SIZE, crc);
DBUG_RETURN(0);
}
|
O0
|
c
|
maria_page_crc_set_index:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x36680
movl %eax, -0x28(%rbp)
jmp 0x367bd
jmp 0x367bf
jmp 0x367c1
jmp 0x367c3
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x367e7
jmp 0x367e9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
maria_page_crc_set_index:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_10]
mov rdx, [rbp+var_20]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov edi, eax
mov rsi, [rbp+var_10]
mov edx, [rbp+var_24]
call maria_page_crc
mov [rbp+var_28], eax
jmp short $+2
loc_367BD:
jmp short $+2
loc_367BF:
jmp short $+2
loc_367C1:
jmp short $+2
loc_367C3:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov ecx, [rcx+7BCh]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rax
mov ecx, [rbp+var_28]
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_367E7:
jmp short $+2
loc_367E9:
xor eax, eax
add rsp, 30h
pop rbp
retn
|
long long maria_page_crc_set_index(long long *a1)
{
long long v2; // [rsp+10h] [rbp-20h]
long long v3; // [rsp+20h] [rbp-10h]
v3 = *a1;
v2 = a1[2];
*(_DWORD *)(*(unsigned int *)(v2 + 1980) + v3 - 4) = maria_page_crc(
a1[1],
*a1,
_byteswap_ushort(*(_WORD *)(*a1
+ *(unsigned int *)(v2 + 1860)
- 2)));
return 0LL;
}
|
maria_page_crc_set_index:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
CALL 0x00136680
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001367bd
LAB_001367bd:
JMP 0x001367bf
LAB_001367bf:
JMP 0x001367c1
LAB_001367c1:
JMP 0x001367c3
LAB_001367c3:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0x7bc]
ADD RAX,RCX
ADD RAX,-0x4
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
JMP 0x001367e7
LAB_001367e7:
JMP 0x001367e9
LAB_001367e9:
XOR EAX,EAX
ADD RSP,0x30
POP RBP
RET
|
int8 maria_page_crc_set_index(long *param_1)
{
long lVar1;
long lVar2;
int4 uVar3;
lVar1 = *param_1;
lVar2 = param_1[2];
uVar3 = maria_page_crc(param_1[1] & 0xffffffff,lVar1,
CONCAT11(*(int1 *)(lVar1 + -2 + (ulong)*(uint *)(lVar2 + 0x744)),
*(int1 *)(lVar1 + -1 + (ulong)*(uint *)(lVar2 + 0x744))));
*(int4 *)(lVar1 + (ulong)*(uint *)(lVar2 + 0x7bc) + -4) = uVar3;
return 0;
}
|
|
9,542 |
mi_read_mempack_record
|
eloqsql/storage/myisam/mi_packrec.c
|
static int _mi_read_mempack_record(MI_INFO *info, my_off_t filepos, uchar *buf)
{
MI_BLOCK_INFO block_info;
MYISAM_SHARE *share=info->s;
uchar *pos;
DBUG_ENTER("mi_read_mempack_record");
if (filepos == HA_OFFSET_ERROR)
DBUG_RETURN(-1); /* _search() didn't find record */
if (!(pos= (uchar*) _mi_mempack_get_block_info(info, &info->bit_buff,
&block_info, &info->rec_buff,
(uchar*) share->file_map+
filepos)))
DBUG_RETURN(-1);
/* No need to end-zero pos here for valgrind as data is memory mapped */
DBUG_RETURN(_mi_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
}
|
O0
|
c
|
mi_read_mempack_record:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $-0x1, -0x78(%rbp)
jne 0xc3894
jmp 0xc388b
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3903
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x50, %rsi
movq -0x70(%rbp), %rcx
addq $0x120, %rcx # imm = 0x120
movq -0x88(%rbp), %rax
movq 0x270(%rax), %r8
addq -0x78(%rbp), %r8
leaq -0x60(%rbp), %rdx
callq 0xc5840
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
jne 0xc38de
jmp 0xc38d5
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3903
jmp 0xc38e0
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x50, %rsi
movq -0x80(%rbp), %rdx
movq -0x90(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0xc2fd0
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc392d
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x29230
nopw %cs:(%rax,%rax)
|
_mi_read_mempack_record:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rbp+var_88], rax
cmp [rbp+var_78], 0FFFFFFFFFFFFFFFFh
jnz short loc_C3894
jmp short $+2
loc_C388B:
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_C3903
loc_C3894:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 50h ; 'P'
mov rcx, [rbp+var_70]
add rcx, 120h
mov rax, [rbp+var_88]
mov r8, [rax+270h]
add r8, [rbp+var_78]
lea rdx, [rbp+var_60]
call _mi_mempack_get_block_info
mov [rbp+var_90], rax
cmp rax, 0
jnz short loc_C38DE
jmp short $+2
loc_C38D5:
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_C3903
loc_C38DE:
jmp short $+2
loc_C38E0:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 50h ; 'P'
mov rdx, [rbp+var_80]
mov rcx, [rbp+var_90]
mov r8, [rbp+var_48]
call _mi_pack_rec_unpack
mov [rbp+var_64], eax
loc_C3903:
mov eax, [rbp+var_64]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C392D
mov eax, [rbp+var_94]
add rsp, 0A0h
pop rbp
retn
loc_C392D:
call ___stack_chk_fail
|
long long mi_read_mempack_record(long long *a1, long long a2, long long a3)
{
long long block_info; // [rsp+10h] [rbp-90h]
_BYTE v7[24]; // [rsp+40h] [rbp-60h] BYREF
long long v8; // [rsp+58h] [rbp-48h]
unsigned long long v9; // [rsp+98h] [rbp-8h]
v9 = __readfsqword(0x28u);
if ( a2 == -1 )
{
return (unsigned int)-1;
}
else
{
block_info = mi_mempack_get_block_info(a1, a1 + 10, v7, a1 + 36, a2 + *(_QWORD *)(*a1 + 624));
if ( block_info )
return (unsigned int)mi_pack_rec_unpack(a1, (long long)(a1 + 10), a3, block_info, v8);
else
return (unsigned int)-1;
}
}
|
_mi_read_mempack_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
CMP qword ptr [RBP + -0x78],-0x1
JNZ 0x001c3894
JMP 0x001c388b
LAB_001c388b:
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x001c3903
LAB_001c3894:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x50
MOV RCX,qword ptr [RBP + -0x70]
ADD RCX,0x120
MOV RAX,qword ptr [RBP + -0x88]
MOV R8,qword ptr [RAX + 0x270]
ADD R8,qword ptr [RBP + -0x78]
LEA RDX,[RBP + -0x60]
CALL 0x001c5840
MOV qword ptr [RBP + -0x90],RAX
CMP RAX,0x0
JNZ 0x001c38de
JMP 0x001c38d5
LAB_001c38d5:
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x001c3903
LAB_001c38de:
JMP 0x001c38e0
LAB_001c38e0:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x50
MOV RDX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x90]
MOV R8,qword ptr [RBP + -0x48]
CALL 0x001c2fd0
MOV dword ptr [RBP + -0x64],EAX
LAB_001c3903:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c392d
MOV EAX,dword ptr [RBP + -0x94]
ADD RSP,0xa0
POP RBP
RET
LAB_001c392d:
CALL 0x00129230
|
int4 _mi_read_mempack_record(long *param_1,long param_2,int8 param_3)
{
long lVar1;
long in_FS_OFFSET;
int4 local_6c;
int1 local_68 [24];
int8 local_50;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == -1) {
local_6c = 0xffffffff;
}
else {
lVar1 = _mi_mempack_get_block_info
(param_1,param_1 + 10,local_68,param_1 + 0x24,
*(long *)(*param_1 + 0x270) + param_2);
if (lVar1 == 0) {
local_6c = 0xffffffff;
}
else {
local_6c = _mi_pack_rec_unpack(param_1,param_1 + 10,param_3,lVar1,local_50);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_6c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
9,543 |
ma_pvio_write
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
ssize_t ma_pvio_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t r= 0;
if (!pvio)
return -1;
if (IS_PVIO_ASYNC_ACTIVE(pvio))
{
r=
#if defined(HAVE_TLS) && !defined(HAVE_SCHANNEL)
(pvio->ctls) ? ma_tls_write_async(pvio, buffer, length) :
#endif
ma_pvio_write_async(pvio, buffer, length);
goto end;
}
else
{
if (IS_PVIO_ASYNC(pvio))
{
/*
If switching from non-blocking to blocking API usage, set the socket
back to blocking mode.
*/
my_bool old_mode;
ma_pvio_blocking(pvio, TRUE, &old_mode);
}
}
/* secure connection */
#ifdef HAVE_TLS
if (pvio->ctls)
{
r= ma_pvio_tls_write(pvio->ctls, buffer, length);
goto end;
}
#endif
if (pvio->methods->write)
r= pvio->methods->write(pvio, buffer, length);
end:
if (pvio_callback)
{
void (*callback)(int mode, MYSQL *mysql, const uchar *buffer, size_t length);
LIST *p= pvio_callback;
while (p)
{
callback= p->data;
callback(1, pvio->mysql, buffer, r);
p= p->next;
}
}
if (r > 0)
pvio->bytes_sent+= r;
return r;
}
|
O3
|
c
|
ma_pvio_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x615ed
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x6161b
movq 0x480(%rax), %rax
testq %rax, %rax
je 0x6161b
movq 0x28(%rax), %r13
testq %r13, %r13
je 0x615f9
cmpb $0x0, 0x14(%r13)
je 0x615f9
cmpq $0x0, 0x38(%rbx)
je 0x61694
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6c65b
jmp 0x61649
movq $-0x1, %r12
jmp 0x6167d
cmpq $0x0, 0x28(%rax)
je 0x6161b
movq 0x48(%rbx), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x6161b
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq *%rax
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x61631
movq %r14, %rsi
movq %r15, %rdx
callq 0x61ab8
jmp 0x61649
movq 0x48(%rbx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x6168f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *%rax
movq %rax, %r12
leaq 0x385675(%rip), %rax # 0x3e6cc8
movq (%rax), %r15
testq %r15, %r15
je 0x61674
movq 0x40(%rbx), %rsi
movl $0x1, %edi
movq %r14, %rdx
movq %r12, %rcx
callq *0x10(%r15)
movq 0x8(%r15), %r15
jmp 0x61656
testq %r12, %r12
jle 0x6167d
addq %r12, 0x68(%rbx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x6164c
movl 0x2c(%rbx), %eax
movl %eax, -0x30(%rbp)
leaq 0x38(%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x48(%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%rax)
movq %rax, %r12
testq %rax, %rax
jns 0x6164c
callq 0x3ab70
movl (%rax), %eax
cmpl $0xb, %eax
je 0x616cb
cmpl $0x4, %eax
jne 0x6164c
movl $0x2, (%r13)
movl -0x30(%rbp), %eax
testl %eax, %eax
js 0x616e6
movl $0xa, (%r13)
movl %eax, 0x10(%r13)
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x616fa
movq 0x28(%r13), %rsi
movl $0x1, %edi
callq *%rax
movq -0x38(%rbp), %rdi
callq 0x71a29
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x61714
movq 0x28(%r13), %rsi
xorl %edi, %edi
callq *%rax
movq $-0x1, %r12
testb $0x8, 0x4(%r13)
je 0x616a2
jmp 0x6164c
|
ma_pvio_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
test rdi, rdi
jz short loc_615ED
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi+40h]
test rax, rax
jz short loc_6161B
mov rax, [rax+480h]
test rax, rax
jz short loc_6161B
mov r13, [rax+28h]
test r13, r13
jz short loc_615F9
cmp byte ptr [r13+14h], 0
jz short loc_615F9
cmp qword ptr [rbx+38h], 0
jz loc_61694
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call ma_tls_write_async
jmp short loc_61649
loc_615ED:
mov r12, 0FFFFFFFFFFFFFFFFh
jmp loc_6167D
loc_615F9:
cmp qword ptr [rax+28h], 0
jz short loc_6161B
mov rax, [rbx+48h]
mov rax, [rax+38h]
test rax, rax
jz short loc_6161B
lea rdx, [rbp+var_29]
mov rdi, rbx
mov esi, 1
call rax
loc_6161B:
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_61631
mov rsi, r14
mov rdx, r15
call ma_pvio_tls_write
jmp short loc_61649
loc_61631:
mov rax, [rbx+48h]
mov rax, [rax+20h]
test rax, rax
jz short loc_6168F
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call rax
loc_61649:
mov r12, rax
loc_6164C:
lea rax, pvio_callback
mov r15, [rax]
loc_61656:
test r15, r15
jz short loc_61674
mov rsi, [rbx+40h]
mov edi, 1
mov rdx, r14
mov rcx, r12
call qword ptr [r15+10h]
mov r15, [r15+8]
jmp short loc_61656
loc_61674:
test r12, r12
jle short loc_6167D
add [rbx+68h], r12
loc_6167D:
mov rax, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6168F:
xor r12d, r12d
jmp short loc_6164C
loc_61694:
mov eax, [rbx+2Ch]
mov [rbp+var_30], eax
lea rax, [r13+38h]
mov [rbp+var_38], rax
loc_616A2:
mov rax, [rbx+48h]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call qword ptr [rax+28h]
mov r12, rax
test rax, rax
jns short loc_6164C
call ___errno_location
mov eax, [rax]
cmp eax, 0Bh
jz short loc_616CB
cmp eax, 4
jnz short loc_6164C
loc_616CB:
mov dword ptr [r13+0], 2
mov eax, [rbp+var_30]
test eax, eax
js short loc_616E6
mov dword ptr [r13+0], 0Ah
mov [r13+10h], eax
loc_616E6:
mov rax, [r13+20h]
test rax, rax
jz short loc_616FA
mov rsi, [r13+28h]
mov edi, 1
call rax
loc_616FA:
mov rdi, [rbp+var_38]
call my_context_yield
mov rax, [r13+20h]
test rax, rax
jz short loc_61714
mov rsi, [r13+28h]
xor edi, edi
call rax
loc_61714:
mov r12, 0FFFFFFFFFFFFFFFFh
test byte ptr [r13+4], 8
jz short loc_616A2
jmp loc_6164C
|
long long ma_pvio_write(long long a1, long long a2, long long a3)
{
long long v5; // rax
long long v6; // rax
long long v7; // r13
long long v8; // rax
long long v9; // r12
void ( *v10)(long long, long long, _BYTE *); // rax
long long v11; // rdi
long long ( *v12)(long long, long long, long long); // rax
long long i; // r15
int v15; // eax
void ( *v16)(long long, _QWORD); // rax
void ( *v17)(_QWORD, _QWORD); // rax
int v18; // [rsp+10h] [rbp-30h]
_BYTE v19[41]; // [rsp+17h] [rbp-29h] BYREF
if ( !a1 )
return -1LL;
v5 = *(_QWORD *)(a1 + 64);
if ( v5 )
{
v6 = *(_QWORD *)(v5 + 1152);
if ( v6 )
{
v7 = *(_QWORD *)(v6 + 40);
if ( v7 && *(_BYTE *)(v7 + 20) )
{
if ( !*(_QWORD *)(a1 + 56) )
{
v18 = *(_DWORD *)(a1 + 44);
do
{
v9 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 72) + 40LL))(a1, a2, a3);
if ( v9 >= 0 )
break;
v15 = *(_DWORD *)__errno_location();
if ( v15 != 11 && v15 != 4 )
break;
*(_DWORD *)v7 = 2;
if ( v18 >= 0 )
{
*(_DWORD *)v7 = 10;
*(_DWORD *)(v7 + 16) = v18;
}
v16 = *(void ( **)(long long, _QWORD))(v7 + 32);
if ( v16 )
v16(1LL, *(_QWORD *)(v7 + 40));
my_context_yield(v7 + 56);
v17 = *(void ( **)(_QWORD, _QWORD))(v7 + 32);
if ( v17 )
v17(0LL, *(_QWORD *)(v7 + 40));
v9 = -1LL;
}
while ( (*(_BYTE *)(v7 + 4) & 8) == 0 );
goto LABEL_17;
}
v8 = ma_tls_write_async(a1, a2, a3);
goto LABEL_16;
}
if ( *(_QWORD *)(v6 + 40) )
{
v10 = *(void ( **)(long long, long long, _BYTE *))(*(_QWORD *)(a1 + 72) + 56LL);
if ( v10 )
v10(a1, 1LL, v19);
}
}
}
v11 = *(_QWORD *)(a1 + 56);
if ( v11 )
{
v8 = ma_pvio_tls_write(v11, a2, a3);
}
else
{
v12 = *(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 72) + 32LL);
if ( !v12 )
{
v9 = 0LL;
goto LABEL_17;
}
v8 = v12(a1, a2, a3);
}
LABEL_16:
v9 = v8;
LABEL_17:
for ( i = pvio_callback; i; i = *(_QWORD *)(i + 8) )
(*(void ( **)(long long, _QWORD, long long, long long))(i + 16))(1LL, *(_QWORD *)(a1 + 64), a2, v9);
if ( v9 > 0 )
*(_QWORD *)(a1 + 104) += v9;
return v9;
}
|
ma_pvio_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
TEST RDI,RDI
JZ 0x001615ed
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x40]
TEST RAX,RAX
JZ 0x0016161b
MOV RAX,qword ptr [RAX + 0x480]
TEST RAX,RAX
JZ 0x0016161b
MOV R13,qword ptr [RAX + 0x28]
TEST R13,R13
JZ 0x001615f9
CMP byte ptr [R13 + 0x14],0x0
JZ 0x001615f9
CMP qword ptr [RBX + 0x38],0x0
JZ 0x00161694
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0016c65b
JMP 0x00161649
LAB_001615ed:
MOV R12,-0x1
JMP 0x0016167d
LAB_001615f9:
CMP qword ptr [RAX + 0x28],0x0
JZ 0x0016161b
MOV RAX,qword ptr [RBX + 0x48]
MOV RAX,qword ptr [RAX + 0x38]
TEST RAX,RAX
JZ 0x0016161b
LEA RDX,[RBP + -0x29]
MOV RDI,RBX
MOV ESI,0x1
CALL RAX
LAB_0016161b:
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JZ 0x00161631
MOV RSI,R14
MOV RDX,R15
CALL 0x00161ab8
JMP 0x00161649
LAB_00161631:
MOV RAX,qword ptr [RBX + 0x48]
MOV RAX,qword ptr [RAX + 0x20]
TEST RAX,RAX
JZ 0x0016168f
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL RAX
LAB_00161649:
MOV R12,RAX
LAB_0016164c:
LEA RAX,[0x4e6cc8]
MOV R15,qword ptr [RAX]
LAB_00161656:
TEST R15,R15
JZ 0x00161674
MOV RSI,qword ptr [RBX + 0x40]
MOV EDI,0x1
MOV RDX,R14
MOV RCX,R12
CALL qword ptr [R15 + 0x10]
MOV R15,qword ptr [R15 + 0x8]
JMP 0x00161656
LAB_00161674:
TEST R12,R12
JLE 0x0016167d
ADD qword ptr [RBX + 0x68],R12
LAB_0016167d:
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016168f:
XOR R12D,R12D
JMP 0x0016164c
LAB_00161694:
MOV EAX,dword ptr [RBX + 0x2c]
MOV dword ptr [RBP + -0x30],EAX
LEA RAX,[R13 + 0x38]
MOV qword ptr [RBP + -0x38],RAX
LAB_001616a2:
MOV RAX,qword ptr [RBX + 0x48]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL qword ptr [RAX + 0x28]
MOV R12,RAX
TEST RAX,RAX
JNS 0x0016164c
CALL 0x0013ab70
MOV EAX,dword ptr [RAX]
CMP EAX,0xb
JZ 0x001616cb
CMP EAX,0x4
JNZ 0x0016164c
LAB_001616cb:
MOV dword ptr [R13],0x2
MOV EAX,dword ptr [RBP + -0x30]
TEST EAX,EAX
JS 0x001616e6
MOV dword ptr [R13],0xa
MOV dword ptr [R13 + 0x10],EAX
LAB_001616e6:
MOV RAX,qword ptr [R13 + 0x20]
TEST RAX,RAX
JZ 0x001616fa
MOV RSI,qword ptr [R13 + 0x28]
MOV EDI,0x1
CALL RAX
LAB_001616fa:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00171a29
MOV RAX,qword ptr [R13 + 0x20]
TEST RAX,RAX
JZ 0x00161714
MOV RSI,qword ptr [R13 + 0x28]
XOR EDI,EDI
CALL RAX
LAB_00161714:
MOV R12,-0x1
TEST byte ptr [R13 + 0x4],0x8
JZ 0x001616a2
JMP 0x0016164c
|
long ma_pvio_write(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
code *pcVar3;
long lVar4;
int *piVar5;
long lVar6;
int1 local_31;
if (param_1 == 0) {
return -1;
}
if ((*(long *)(param_1 + 0x40) != 0) &&
(lVar6 = *(long *)(*(long *)(param_1 + 0x40) + 0x480), lVar6 != 0)) {
puVar2 = *(int4 **)(lVar6 + 0x28);
if ((puVar2 != (int4 *)0x0) && (*(char *)(puVar2 + 5) != '\0')) {
if (*(long *)(param_1 + 0x38) == 0) {
iVar1 = *(int *)(param_1 + 0x2c);
do {
lVar4 = (**(code **)(*(long *)(param_1 + 0x48) + 0x28))(param_1,param_2,param_3);
lVar6 = pvio_callback;
if (-1 < lVar4) break;
piVar5 = __errno_location();
if ((*piVar5 != 0xb) && (lVar6 = pvio_callback, *piVar5 != 4)) break;
*puVar2 = 2;
if (-1 < iVar1) {
*puVar2 = 10;
puVar2[4] = iVar1;
}
if (*(code **)(puVar2 + 8) != (code *)0x0) {
(**(code **)(puVar2 + 8))(1,*(int8 *)(puVar2 + 10));
}
my_context_yield(puVar2 + 0xe);
if (*(code **)(puVar2 + 8) != (code *)0x0) {
(**(code **)(puVar2 + 8))(0,*(int8 *)(puVar2 + 10));
}
lVar4 = -1;
lVar6 = pvio_callback;
} while ((*(byte *)(puVar2 + 1) & 8) == 0);
}
else {
lVar4 = ma_tls_write_async(param_1,param_2,param_3);
lVar6 = pvio_callback;
}
goto LAB_00161656;
}
if ((*(long *)(lVar6 + 0x28) != 0) &&
(pcVar3 = *(code **)(*(long *)(param_1 + 0x48) + 0x38), pcVar3 != (code *)0x0)) {
(*pcVar3)(param_1,1,&local_31);
}
}
if (*(long *)(param_1 + 0x38) == 0) {
pcVar3 = *(code **)(*(long *)(param_1 + 0x48) + 0x20);
if (pcVar3 == (code *)0x0) {
lVar4 = 0;
lVar6 = pvio_callback;
}
else {
lVar4 = (*pcVar3)(param_1,param_2,param_3);
lVar6 = pvio_callback;
}
}
else {
lVar4 = ma_pvio_tls_write(*(long *)(param_1 + 0x38),param_2,param_3);
lVar6 = pvio_callback;
}
LAB_00161656:
for (; lVar6 != 0; lVar6 = *(long *)(lVar6 + 8)) {
(**(code **)(lVar6 + 0x10))(1,*(int8 *)(param_1 + 0x40),param_2,lVar4);
}
if (0 < lVar4) {
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + lVar4;
}
return lVar4;
}
|
|
9,544 |
SchemaConverter::_not_strings(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
monkey531[P]llama/common/json-schema-to-grammar.cpp
|
std::string _not_strings(const std::vector<std::string> & strings) {
struct TrieNode {
std::map<char, TrieNode> children;
bool is_end_of_string;
TrieNode() : is_end_of_string(false) {}
void insert(const std::string & string) {
auto node = this;
for (char c : string) {
node = &node->children[c];
}
node->is_end_of_string = true;
}
};
TrieNode trie;
for (const auto & s : strings) {
trie.insert(s);
}
std::string char_rule = _add_primitive("char", PRIMITIVE_RULES.at("char"));
std::ostringstream out;
out << "[\"] ( ";
std::function<void(const TrieNode &)> visit = [&](const TrieNode & node) {
std::ostringstream rejects;
auto first = true;
for (const auto & kv : node.children) {
rejects << kv.first;
if (first) {
first = false;
} else {
out << " | ";
}
out << "[" << kv.first << "]";
if (!kv.second.children.empty()) {
out << " (";
visit(kv.second);
out << ")";
} else if (kv.second.is_end_of_string) {
out << " " << char_rule << "+";
}
}
if (!node.children.empty()) {
if (!first) {
out << " | ";
}
out << "[^\"" << rejects.str() << "] " << char_rule << "*";
}
};
visit(trie);
out << " )";
if (!trie.is_end_of_string) {
out << "?";
}
out << " [\"] space";
return out.str();
}
|
O3
|
cpp
|
SchemaConverter::_not_strings(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rdx), %r14
movq 0x8(%rdx), %r13
cmpq %r13, %r14
je 0xc95eb
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc9d62
addq $0x20, %r14
cmpq %r13, %r14
jne 0xc95d7
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x72616863, %eax # imm = 0x72616863
movl %eax, (%r13)
movl $0x4, %ecx
movq %rcx, -0x8(%r13)
xorl %edx, %edx
movb %dl, 0x4(%r13)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movl %eax, (%rbp)
movq %rcx, -0x8(%rbp)
movb %dl, 0x4(%rbp)
leaq 0x65dc7(%rip), %rdi # 0x12f3f0
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xcdaa4
testq %rax, %rax
je 0xc97d9
addq $0x28, %rax
leaq 0x28(%rsp), %r15
leaq 0x80(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0xc82e0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc9675
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1ba20
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0xc9692
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1ba20
leaq 0x80(%rsp), %rdi
callq 0x1bd60
leaq 0x2d556(%rip), %rsi # 0xf6bfc
leaq 0x80(%rsp), %r12
movl $0x6, %edx
movq %r12, %rdi
callq 0x1bb70
movq $0x0, 0x10(%rsp)
movl $0x18, %edi
callq 0x1b9f0
movq %r12, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
leaq 0x967(%rip), %rcx # 0xca04c
movq %rcx, 0x20(%rsp)
leaq 0x963(%rip), %rcx # 0xca054
movq %rcx, 0x18(%rsp)
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0xca07c
leaq 0x2d208(%rip), %rsi # 0xf6912
leaq 0x80(%rsp), %rdi
movl $0x2, %edx
callq 0x1bb70
cmpb $0x0, 0x78(%rsp)
jne 0xc973c
leaq 0x2d316(%rip), %rsi # 0xf6a40
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x1bb70
leaq 0x2d4c0(%rip), %rsi # 0xf6c03
leaq 0x80(%rsp), %rdi
movl $0xa, %edx
callq 0x1bb70
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bfd0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xc977e
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x647eb(%rip), %rsi # 0x12df70
leaq 0x80(%rsp), %rdi
callq 0x1b560
leaq 0xf0(%rsp), %rdi
callq 0x1b2f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc97ba
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1ba20
leaq 0x48(%rsp), %rdi
callq 0xca37e
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d3cd(%rip), %rdi # 0xf6bad
callq 0x1beb0
jmp 0xc9881
jmp 0xc97ec
movq %rax, %rbx
jmp 0xc9843
movq %rax, %rbx
jmp 0xc9864
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc9810
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1ba20
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0xc988c
movq 0x90(%rsp), %rsi
jmp 0xc9877
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xc9843
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x64726(%rip), %rsi # 0x12df70
leaq 0x80(%rsp), %rdi
callq 0x1b560
leaq 0xf0(%rsp), %rdi
callq 0x1b2f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc988c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1ba20
jmp 0xc988c
movq %rax, %rdi
callq 0x2290d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xca37e
movq %rbx, %rdi
callq 0x1c1e0
|
_ZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1F8h
mov r12, rsi
mov rbx, rdi
lea rax, [rsp+228h+var_1D8]
mov dword ptr [rax], 0
xor ecx, ecx
mov [rax+8], rcx
mov [rax+10h], rax
mov [rax+18h], rax
mov [rax+20h], rcx
mov byte ptr [rax+28h], 0
mov r14, [rdx]
mov r13, [rdx+8]
cmp r14, r13
jz short loc_C95EB
lea r15, [rsp+228h+var_1E0]
loc_C95D7:
mov rdi, r15
mov rsi, r14
call _ZZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEEN8TrieNode6insertERKS6_; SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(std::string const&)
add r14, 20h ; ' '
cmp r14, r13
jnz short loc_C95D7
loc_C95EB:
lea r13, [rsp+228h+var_198]
mov [r13-10h], r13
mov eax, 72616863h
mov [r13+0], eax
mov ecx, 4
mov [r13-8], rcx
xor edx, edx
mov [r13+4], dl
lea rbp, [rsp+228h+var_210]
mov [rbp-10h], rbp
mov [rbp+0], eax
mov [rbp-8], rcx
mov [rbp+4], dl
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
lea r14, [rsp+228h+var_220]
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
test rax, rax
jz loc_C97D9
add rax, 28h ; '('
lea r15, [rsp+228h+var_200]
lea rdx, [rsp+228h+var_1A8]; int
mov rdi, r15; int
mov rsi, r12; int
mov rcx, rax; int
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
mov rdi, [rsp+228h+var_220]; void *
cmp rdi, rbp
jz short loc_C9675
mov rsi, [rsp+228h+var_210]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C9675:
mov rdi, [rsp+228h+var_1A8]; void *
cmp rdi, r13
jz short loc_C9692
mov rsi, [rsp+228h+var_198]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C9692:
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, asc_F6BFC; "[\"] ( "
lea r12, [rsp+228h+var_1A8]
mov edx, 6
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 [rsp+228h+var_218], 0
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], r14
mov [rax+10h], r15
mov [rsp+228h+var_220], rax
lea rcx, _ZNSt17_Function_handlerIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEZNS0_12_not_stringsESB_EUlSE_E_E9_M_invokeERKSt9_Any_dataSE_; std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_invoke(std::_Any_data const&,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)
mov [rsp+228h+var_208], rcx
lea rcx, _ZNSt17_Function_handlerIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEZNS0_12_not_stringsESB_EUlSE_E_E10_M_managerERSt9_Any_dataRKSI_St18_Manager_operation; std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+228h+var_210], rcx
lea rsi, [rsp+228h+var_1E0]
mov rdi, rax
call _ZZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEENKUlRKZNS_12_not_stringsESA_E8TrieNodeE_clESD_; SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}::operator()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)
lea rsi, a09401910201912+50h; " )"
lea rdi, [rsp+228h+var_1A8]
mov edx, 2
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cmp [rsp+228h+var_1B0], 0
jnz short loc_C973C
lea rsi, asc_F6A3D+3; "?"
lea rdi, [rsp+228h+var_1A8]
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_C973C:
lea rsi, aSpace_6; " [\"] space"
lea rdi, [rsp+228h+var_1A8]
mov edx, 0Ah
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, [rsp+228h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rax, [rsp+228h+var_210]
test rax, rax
jz short loc_C977E
lea rdi, [rsp+228h+var_220]
mov rsi, rdi
mov edx, 3
call rax
loc_C977E:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+228h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
lea rax, [rsp+228h+var_1F0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C97BA
mov rsi, [rsp+228h+var_1F0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C97BA:
lea rdi, [rsp+228h+var_1E0]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rax, rbx
add rsp, 1F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C97D9:
lea rdi, aMapBaseAt; "_Map_base::at"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
jmp loc_C9881
jmp short $+2
loc_C97EC:
mov rbx, rax
jmp short loc_C9843
mov rbx, rax
jmp short loc_C9864
mov rbx, rax
mov rdi, [rsp+228h+var_220]; void *
cmp rdi, rbp
jz short loc_C9810
mov rsi, [rsp+228h+var_210]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C9810:
mov rdi, [rsp+228h+var_1A8]
cmp rdi, r13
jz short loc_C988C
mov rsi, [rsp+228h+var_198]
jmp short loc_C9877
mov rbx, rax
mov rax, [rsp+228h+var_210]
test rax, rax
jz short loc_C9843
lea rdi, [rsp+228h+var_220]
mov rsi, rdi
mov edx, 3
call rax
loc_C9843:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+228h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_C9864:
lea rax, [rsp+228h+var_1F0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C988C
mov rsi, [rsp+228h+var_1F0]
loc_C9877:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C988C
loc_C9881:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_C988C:
lea rdi, [rsp+228h+var_1E0]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
|
long long SchemaConverter::_not_strings(long long a1, long long a2, long long *a3)
{
long long v3; // r14
long long v4; // r13
long long v5; // rax
void ***v6; // rax
void *v8; // [rsp+8h] [rbp-220h] BYREF
long long v9; // [rsp+10h] [rbp-218h]
_QWORD v10[2]; // [rsp+18h] [rbp-210h] BYREF
int v11[4]; // [rsp+28h] [rbp-200h] BYREF
long long v12; // [rsp+38h] [rbp-1F0h] BYREF
_BYTE v13[8]; // [rsp+48h] [rbp-1E0h] BYREF
int v14; // [rsp+50h] [rbp-1D8h] BYREF
long long v15; // [rsp+58h] [rbp-1D0h]
int *v16; // [rsp+60h] [rbp-1C8h]
int *v17; // [rsp+68h] [rbp-1C0h]
long long v18; // [rsp+70h] [rbp-1B8h]
char v19; // [rsp+78h] [rbp-1B0h]
void *v20; // [rsp+80h] [rbp-1A8h] BYREF
long long v21; // [rsp+88h] [rbp-1A0h] BYREF
char v22[96]; // [rsp+90h] [rbp-198h] BYREF
_BYTE v23[312]; // [rsp+F0h] [rbp-138h] BYREF
v14 = 0;
v15 = 0LL;
v16 = &v14;
v17 = &v14;
v18 = 0LL;
v19 = 0;
v3 = *a3;
v4 = a3[1];
if ( *a3 != v4 )
{
do
{
SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(v13, v3);
v3 += 32LL;
}
while ( v3 != v4 );
}
v20 = v22;
strcpy(v22, "char");
v21 = 4LL;
v8 = v10;
strcpy((char *)v10, "char");
v9 = 4LL;
v5 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
PRIMITIVE_RULES[abi:cxx11],
&v8);
if ( !v5 )
std::__throw_out_of_range("_Map_base::at");
SchemaConverter::_add_primitive((long long)v11, a2, (long long *)&v20, (_QWORD *)(v5 + 40));
if ( v8 != v10 )
operator delete(v8, v10[0] + 1LL);
if ( v20 != v22 )
operator delete(v20, *(_QWORD *)v22 + 1LL);
std::ostringstream::basic_ostringstream(&v20);
std::__ostream_insert<char,std::char_traits<char>>(&v20, "[\"] ( ", 6LL);
v9 = 0LL;
v6 = (void ***)operator new(0x18uLL);
*v6 = &v20;
v6[1] = &v8;
v6[2] = (void **)v11;
v8 = v6;
v10[1] = std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_invoke;
v10[0] = std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_manager;
SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}::operator()(
v6,
v13);
std::__ostream_insert<char,std::char_traits<char>>(&v20, " )", 2LL);
if ( !v19 )
std::__ostream_insert<char,std::char_traits<char>>(&v20, "?", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(&v20, " [\"] space", 10LL);
std::stringbuf::str(a1, &v21);
if ( v10[0] )
((void ( *)(void **, void **, long long))v10[0])(&v8, &v8, 3LL);
std::ostringstream::~ostringstream(&v20, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v23);
if ( *(long long **)v11 != &v12 )
operator delete(*(void **)v11, v12 + 1);
std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree(v13);
return a1;
}
|
_not_strings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f8
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0x50]
MOV dword ptr [RAX],0x0
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
MOV qword ptr [RAX + 0x20],RCX
MOV byte ptr [RAX + 0x28],0x0
MOV R14,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
CMP R14,R13
JZ 0x001c95eb
LEA R15,[RSP + 0x48]
LAB_001c95d7:
MOV RDI,R15
MOV RSI,R14
CALL 0x001c9d62
ADD R14,0x20
CMP R14,R13
JNZ 0x001c95d7
LAB_001c95eb:
LEA R13,[RSP + 0x90]
MOV qword ptr [R13 + -0x10],R13
MOV EAX,0x72616863
MOV dword ptr [R13],EAX
MOV ECX,0x4
MOV qword ptr [R13 + -0x8],RCX
XOR EDX,EDX
MOV byte ptr [R13 + 0x4],DL
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
MOV dword ptr [RBP],EAX
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RBP + 0x4],DL
LAB_001c9622:
LEA RDI,[0x22f3f0]
LEA R14,[RSP + 0x8]
MOV RSI,R14
CALL 0x001cdaa4
TEST RAX,RAX
JZ 0x001c97d9
ADD RAX,0x28
LEA R15,[RSP + 0x28]
LEA RDX,[RSP + 0x80]
MOV RDI,R15
MOV RSI,R12
MOV RCX,RAX
CALL 0x001c82e0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001c9675
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011ba20
LAB_001c9675:
MOV RDI,qword ptr [RSP + 0x80]
CMP RDI,R13
JZ 0x001c9692
MOV RSI,qword ptr [RSP + 0x90]
INC RSI
CALL 0x0011ba20
LAB_001c9692:
LEA RDI,[RSP + 0x80]
CALL 0x0011bd60
LAB_001c969f:
LEA RSI,[0x1f6bfc]
LEA R12,[RSP + 0x80]
MOV EDX,0x6
MOV RDI,R12
CALL 0x0011bb70
MOV qword ptr [RSP + 0x10],0x0
LAB_001c96c4:
MOV EDI,0x18
CALL 0x0011b9f0
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R14
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RSP + 0x8],RAX
LEA RCX,[0x1ca04c]
MOV qword ptr [RSP + 0x20],RCX
LEA RCX,[0x1ca054]
MOV qword ptr [RSP + 0x18],RCX
LAB_001c96f6:
LEA RSI,[RSP + 0x48]
MOV RDI,RAX
CALL 0x001ca07c
LEA RSI,[0x1f6912]
LEA RDI,[RSP + 0x80]
MOV EDX,0x2
CALL 0x0011bb70
CMP byte ptr [RSP + 0x78],0x0
JNZ 0x001c973c
LEA RSI,[0x1f6a40]
LEA RDI,[RSP + 0x80]
MOV EDX,0x1
CALL 0x0011bb70
LAB_001c973c:
LEA RSI,[0x1f6c03]
LEA RDI,[RSP + 0x80]
MOV EDX,0xa
CALL 0x0011bb70
LEA RSI,[RSP + 0x88]
MOV RDI,RBX
CALL 0x0011bfd0
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x001c977e
LAB_001c976f:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c977e:
MOV RSI,qword ptr [0x0022df70]
LEA RDI,[RSP + 0x80]
CALL 0x0011b560
LEA RDI,[RSP + 0xf0]
CALL 0x0011b2f0
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001c97ba
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011ba20
LAB_001c97ba:
LEA RDI,[RSP + 0x48]
CALL 0x001ca37e
MOV RAX,RBX
ADD RSP,0x1f8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c97d9:
LEA RDI,[0x1f6bad]
CALL 0x0011beb0
LAB_001c97e5:
JMP 0x001c9881
LAB_001c9881:
MOV RDI,RAX
CALL 0x0012290d
|
/* SchemaConverter::_not_strings(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&) */
vector * SchemaConverter::_not_strings(vector *param_1)
{
long lVar1;
int8 uVar2;
long *in_RDX;
BuiltinRule *in_RSI;
long lVar3;
_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*local_220;
int8 local_218;
code *local_210;
code *local_208;
long *local_200 [2];
long local_1f0 [2];
TrieNode local_1e0 [8];
int4 local_1d8 [2];
int8 local_1d0;
int4 *local_1c8;
int4 *local_1c0;
int8 local_1b8;
char local_1b0;
int4 *local_1a8;
int8 local_1a0;
int4 local_198;
uint uStack_194;
ios_base local_138 [264];
local_1c8 = local_1d8;
local_1d8[0] = 0;
local_1d0 = 0;
local_1b8 = 0;
local_1b0 = '\0';
lVar3 = *in_RDX;
lVar1 = in_RDX[1];
local_1c0 = local_1c8;
if (lVar3 != lVar1) {
do {
/* try { // try from 001c95d7 to 001c95e1 has its CatchHandler @ 001c9889 */
_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::
TrieNode::insert(std::__cxx11::string_const__(local_1e0,lVar3);
lVar3 = lVar3 + 0x20;
} while (lVar3 != lVar1);
}
local_198 = 0x72616863;
local_1a0 = 4;
uStack_194 = uStack_194 & 0xffffff00;
local_218 = 4;
local_210 = (code *)CONCAT35(local_210._5_3_,0x72616863);
/* try { // try from 001c9622 to 001c965d has its CatchHandler @ 001c97f6 */
local_220 = (_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)&local_210;
local_1a8 = &local_198;
lVar3 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)PRIMITIVE_RULES_abi_cxx11_,(string *)&local_220);
if (lVar3 != 0) {
_add_primitive((string *)local_200,in_RSI);
if (local_220 !=
(_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)&local_210) {
operator_delete(local_220,(ulong)(local_210 + 1));
}
if (local_1a8 != &local_198) {
operator_delete(local_1a8,CONCAT44(uStack_194,local_198) + 1);
}
/* try { // try from 001c9692 to 001c969e has its CatchHandler @ 001c97f1 */
std::__cxx11::ostringstream::ostringstream((ostringstream *)&local_1a8);
/* try { // try from 001c969f to 001c96ba has its CatchHandler @ 001c97ec */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8,"[\"] ( ",6);
local_218 = 0;
/* try { // try from 001c96c4 to 001c96cd has its CatchHandler @ 001c97ea */
local_220 = (_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)operator_new(0x18);
*(ostream **)local_220 = (ostream *)&local_1a8;
*(string **)(local_220 + 8) = (string *)&local_220;
*(string **)(local_220 + 0x10) = (string *)local_200;
local_208 = std::
_Function_handler<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&),SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}>
::_M_invoke;
local_210 = std::
_Function_handler<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&),SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}>
::_M_manager;
/* try { // try from 001c96f6 to 001c9764 has its CatchHandler @ 001c9827 */
_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::
{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}
::operator()(local_220,local_1e0);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8," )",2);
if (local_1b0 == '\0') {
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8,"?",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8," [\"] space",10);
std::__cxx11::stringbuf::str();
if (local_210 != (code *)0x0) {
/* try { // try from 001c976f to 001c977d has its CatchHandler @ 001c97e5 */
(*local_210)(&local_220,&local_220,3);
}
std::__cxx11::ostringstream::~ostringstream((ostringstream *)&local_1a8);
std::ios_base::~ios_base(local_138);
if (local_200[0] != local_1f0) {
operator_delete(local_200[0],local_1f0[0] + 1);
}
std::
_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
::~_Rb_tree((_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
*)local_1e0);
return param_1;
}
/* try { // try from 001c97d9 to 001c97e4 has its CatchHandler @ 001c97f6 */
uVar2 = std::__throw_out_of_range("_Map_base::at");
/* catch(type#1 @ 00000000) { ... } // from try @ 001c976f with catch @ 001c97e5
*/
/* catch(type#1 @ 00000000) { ... } // from try @ 001c9834 with catch @ 001c9881
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar2);
}
|
|
9,545 |
mujoco::plugin::elasticity::(anonymous namespace)::ComputeBasis(double*, double const*, int const*, int const*, int const*, double)
|
aimrt_mujoco_sim/_deps/mujoco-src/plugin/elasticity/membrane.cc
|
void ComputeBasis(mjtNum basis[9], const mjtNum* x, const int v[kNumVerts],
const int faceL[2], const int faceR[2], mjtNum area) {
mjtNum basisL[3], basisR[3];
mjtNum edgesL[3], edgesR[3];
mjtNum normal[3];
mju_sub3(edgesL, x+3*v[faceL[0]], x+3*v[faceL[1]]);
mju_sub3(edgesR, x+3*v[faceR[1]], x+3*v[faceR[0]]);
mju_cross(normal, edgesR, edgesL);
mju_normalize3(normal);
mju_cross(basisL, normal, edgesL);
mju_cross(basisR, edgesR, normal);
// we use as basis the symmetrized tensor products of the edge normals of the
// other two edges; this is shown in Weischedel "A discrete geometric view on
// shear-deformable shell models" in the remark at the end of section 4.1;
// equivalent to linear finite elements but in a coordinate-free formulation.
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
basis[3*i+j] = ( basisL[i]*basisR[j] +
basisR[i]*basisL[j] ) / (8*area*area);
}
}
}
|
O0
|
cpp
|
mujoco::plugin::elasticity::(anonymous namespace)::ComputeBasis(double*, double const*, int const*, int const*, int const*, double):
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
vmovsd %xmm0, 0xa8(%rsp)
leaq 0x50(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movslq (%rcx), %rcx
imull $0x3, (%rax,%rcx,4), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq 0xc8(%rsp), %rdx
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rcx
movslq 0x4(%rcx), %rcx
imull $0x3, (%rax,%rcx,4), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x5960
leaq 0x30(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0xb0(%rsp), %rcx
movslq 0x4(%rcx), %rcx
imull $0x3, (%rax,%rcx,4), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq 0xc8(%rsp), %rdx
movq 0xc0(%rsp), %rax
movq 0xb0(%rsp), %rcx
movslq (%rcx), %rcx
imull $0x3, (%rax,%rcx,4), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x5960
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x5970
leaq 0x10(%rsp), %rdi
callq 0x5980
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x5970
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5970
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x101a0
movl $0x0, 0x8(%rsp)
cmpl $0x3, 0x8(%rsp)
jge 0x1018e
movslq 0xc(%rsp), %rax
vmovsd 0x90(%rsp,%rax,8), %xmm0
movslq 0x8(%rsp), %rax
vmovsd 0x70(%rsp,%rax,8), %xmm2
movslq 0xc(%rsp), %rax
vmovsd 0x70(%rsp,%rax,8), %xmm1
movslq 0x8(%rsp), %rax
vmulsd 0x90(%rsp,%rax,8), %xmm1, %xmm1
vmulsd %xmm2, %xmm0, %xmm0
vaddsd %xmm1, %xmm0, %xmm0
vmovsd 0x79d9(%rip), %xmm1 # 0x17b28
vmulsd 0xa8(%rsp), %xmm1, %xmm1
vmulsd 0xa8(%rsp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
movq 0xd0(%rsp), %rax
imull $0x3, 0xc(%rsp), %ecx
addl 0x8(%rsp), %ecx
movslq %ecx, %rcx
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10102
jmp 0x10190
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x100ef
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
|
_ZN6mujoco6plugin10elasticity12_GLOBAL__N_112ComputeBasisEPdPKdPKiS7_S7_d:
sub rsp, 0D8h
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
mov [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_20], rcx
mov [rsp+0D8h+var_28], r8
vmovsd [rsp+0D8h+var_30], xmm0
lea rdi, [rsp+0D8h+var_88]
mov rsi, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rcx, [rsp+0D8h+var_20]
movsxd rcx, dword ptr [rcx]
imul eax, [rax+rcx*4], 3
cdqe
shl rax, 3
add rsi, rax
mov rdx, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rcx, [rsp+0D8h+var_20]
movsxd rcx, dword ptr [rcx+4]
imul eax, [rax+rcx*4], 3
cdqe
shl rax, 3
add rdx, rax
call _mju_sub3
lea rdi, [rsp+0D8h+var_A8]
mov rsi, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rcx, [rsp+0D8h+var_28]
movsxd rcx, dword ptr [rcx+4]
imul eax, [rax+rcx*4], 3
cdqe
shl rax, 3
add rsi, rax
mov rdx, [rsp+0D8h+var_10]
mov rax, [rsp+0D8h+var_18]
mov rcx, [rsp+0D8h+var_28]
movsxd rcx, dword ptr [rcx]
imul eax, [rax+rcx*4], 3
cdqe
shl rax, 3
add rdx, rax
call _mju_sub3
lea rdi, [rsp+0D8h+var_C8]
lea rsi, [rsp+0D8h+var_A8]
lea rdx, [rsp+0D8h+var_88]
call _mju_cross
lea rdi, [rsp+0D8h+var_C8]
call _mju_normalize3
lea rdi, [rsp+0D8h+var_48]
lea rsi, [rsp+0D8h+var_C8]
lea rdx, [rsp+0D8h+var_88]
call _mju_cross
lea rdi, [rsp+0D8h+var_68]
lea rsi, [rsp+0D8h+var_A8]
lea rdx, [rsp+0D8h+var_C8]
call _mju_cross
mov [rsp+0D8h+var_CC], 0
loc_100EF:
cmp [rsp+0D8h+var_CC], 3
jge loc_101A0
mov [rsp+0D8h+var_D0], 0
loc_10102:
cmp [rsp+0D8h+var_D0], 3
jge loc_1018E
movsxd rax, [rsp+0D8h+var_CC]
vmovsd xmm0, [rsp+rax*8+0D8h+var_48]
movsxd rax, [rsp+0D8h+var_D0]
vmovsd xmm2, [rsp+rax*8+0D8h+var_68]
movsxd rax, [rsp+0D8h+var_CC]
vmovsd xmm1, [rsp+rax*8+0D8h+var_68]
movsxd rax, [rsp+0D8h+var_D0]
vmulsd xmm1, xmm1, [rsp+rax*8+0D8h+var_48]
vmulsd xmm0, xmm0, xmm2
vaddsd xmm0, xmm0, xmm1
vmovsd xmm1, cs:qword_17B28
vmulsd xmm1, xmm1, [rsp+0D8h+var_30]
vmulsd xmm1, xmm1, [rsp+0D8h+var_30]
vdivsd xmm0, xmm0, xmm1
mov rax, [rsp+0D8h+var_8]
imul ecx, [rsp+0D8h+var_CC], 3
add ecx, [rsp+0D8h+var_D0]
movsxd rcx, ecx
vmovsd qword ptr [rax+rcx*8], xmm0
mov eax, [rsp+0D8h+var_D0]
add eax, 1
mov [rsp+0D8h+var_D0], eax
jmp loc_10102
loc_1018E:
jmp short $+2
loc_10190:
mov eax, [rsp+0D8h+var_CC]
add eax, 1
mov [rsp+0D8h+var_CC], eax
jmp loc_100EF
loc_101A0:
add rsp, 0D8h
retn
|
long long mujoco::plugin::elasticity::`anonymous namespace'::ComputeBasis(
mujoco::plugin::elasticity::_anonymous_namespace_ *this,
double *a2,
const double *a3,
const int *a4,
const int *a5,
const int *a6,
__m128 _XMM0)
{
long long result; // rax
int j; // [rsp+8h] [rbp-D0h]
int i; // [rsp+Ch] [rbp-CCh]
_BYTE v25[32]; // [rsp+10h] [rbp-C8h] BYREF
_BYTE v26[32]; // [rsp+30h] [rbp-A8h] BYREF
_BYTE v27[32]; // [rsp+50h] [rbp-88h] BYREF
_QWORD v28[4]; // [rsp+70h] [rbp-68h] BYREF
_QWORD v29[4]; // [rsp+90h] [rbp-48h] BYREF
const int *v30; // [rsp+B0h] [rbp-28h]
const int *v31; // [rsp+B8h] [rbp-20h]
const double *v32; // [rsp+C0h] [rbp-18h]
double *v33; // [rsp+C8h] [rbp-10h]
mujoco::plugin::elasticity::_anonymous_namespace_ *v34; // [rsp+D0h] [rbp-8h]
v34 = this;
v33 = a2;
v32 = a3;
v31 = a4;
v30 = a5;
__asm { vmovsd [rsp+0D8h+var_30], xmm0 }
mju_sub3(v27, &a2[3 * *((_DWORD *)a3 + *a4)], &a2[3 * *((_DWORD *)a3 + a4[1])]);
mju_sub3(v26, &v33[3 * *((_DWORD *)v32 + v30[1])], &v33[3 * *((_DWORD *)v32 + *v30)]);
mju_cross(v25, v26, v27);
mju_normalize3(v25);
mju_cross(v29, v25, v27);
result = mju_cross(v28, v26, v25);
for ( i = 0; i < 3; ++i )
{
for ( j = 0; j < 3; ++j )
{
_RAX = i;
__asm { vmovsd xmm0, [rsp+rax*8+0D8h+var_48] }
_RAX = j;
__asm { vmovsd xmm2, [rsp+rax*8+0D8h+var_68] }
_RAX = i;
__asm
{
vmovsd xmm1, [rsp+rax*8+0D8h+var_68]
vmulsd xmm1, xmm1, [rsp+rax*8+0D8h+var_48]
vmulsd xmm0, xmm0, xmm2
vaddsd xmm0, xmm0, xmm1
vmovsd xmm1, cs:qword_17B28
vmulsd xmm1, xmm1, [rsp+0D8h+var_30]
vmulsd xmm1, xmm1, [rsp+0D8h+var_30]
vdivsd xmm0, xmm0, xmm1
}
_RAX = v34;
_RCX = j + 3 * i;
__asm { vmovsd qword ptr [rax+rcx*8], xmm0 }
}
result = (unsigned int)(i + 1);
}
return result;
}
|
ComputeBasis:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xd0],RDI
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xb8],RCX
MOV qword ptr [RSP + 0xb0],R8
VMOVSD qword ptr [RSP + 0xa8],XMM0
LEA RDI,[RSP + 0x50]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xb8]
MOVSXD RCX,dword ptr [RCX]
IMUL EAX,dword ptr [RAX + RCX*0x4],0x3
CDQE
SHL RAX,0x3
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xb8]
MOVSXD RCX,dword ptr [RCX + 0x4]
IMUL EAX,dword ptr [RAX + RCX*0x4],0x3
CDQE
SHL RAX,0x3
ADD RDX,RAX
CALL 0x00105960
LEA RDI,[RSP + 0x30]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RCX + 0x4]
IMUL EAX,dword ptr [RAX + RCX*0x4],0x3
CDQE
SHL RAX,0x3
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0xc8]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RCX]
IMUL EAX,dword ptr [RAX + RCX*0x4],0x3
CDQE
SHL RAX,0x3
ADD RDX,RAX
CALL 0x00105960
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x50]
CALL 0x00105970
LEA RDI,[RSP + 0x10]
CALL 0x00105980
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x50]
CALL 0x00105970
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
CALL 0x00105970
MOV dword ptr [RSP + 0xc],0x0
LAB_001100ef:
CMP dword ptr [RSP + 0xc],0x3
JGE 0x001101a0
MOV dword ptr [RSP + 0x8],0x0
LAB_00110102:
CMP dword ptr [RSP + 0x8],0x3
JGE 0x0011018e
MOVSXD RAX,dword ptr [RSP + 0xc]
VMOVSD XMM0,qword ptr [RSP + RAX*0x8 + 0x90]
MOVSXD RAX,dword ptr [RSP + 0x8]
VMOVSD XMM2,qword ptr [RSP + RAX*0x8 + 0x70]
MOVSXD RAX,dword ptr [RSP + 0xc]
VMOVSD XMM1,qword ptr [RSP + RAX*0x8 + 0x70]
MOVSXD RAX,dword ptr [RSP + 0x8]
VMULSD XMM1,XMM1,qword ptr [RSP + RAX*0x8 + 0x90]
VMULSD XMM0,XMM0,XMM2
VADDSD XMM0,XMM0,XMM1
VMOVSD XMM1,qword ptr [0x00117b28]
VMULSD XMM1,XMM1,qword ptr [RSP + 0xa8]
VMULSD XMM1,XMM1,qword ptr [RSP + 0xa8]
VDIVSD XMM0,XMM0,XMM1
MOV RAX,qword ptr [RSP + 0xd0]
IMUL ECX,dword ptr [RSP + 0xc],0x3
ADD ECX,dword ptr [RSP + 0x8]
MOVSXD RCX,ECX
VMOVSD qword ptr [RAX + RCX*0x8],XMM0
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8],EAX
JMP 0x00110102
LAB_0011018e:
JMP 0x00110190
LAB_00110190:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001100ef
LAB_001101a0:
ADD RSP,0xd8
RET
|
/* mujoco::plugin::elasticity::(anonymous namespace)::ComputeBasis(double*, double const*, int
const*, int const*, int const*, double) */
void mujoco::plugin::elasticity::(anonymous_namespace)::ComputeBasis
(double *param_1,double *param_2,int *param_3,int *param_4,int *param_5,
double param_6)
{
int local_d0;
int local_cc;
int1 local_c8 [32];
int1 local_a8 [32];
int1 local_88 [32];
double local_68 [4];
double local_48 [4];
int *local_28;
int *local_20;
int *local_18;
double *local_10;
double *local_8;
local_48[3] = param_6;
local_28 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
mju_sub3(local_88,param_2 + param_3[*param_4] * 3,param_2 + param_3[param_4[1]] * 3);
mju_sub3(local_a8,local_10 + local_18[local_28[1]] * 3,local_10 + local_18[*local_28] * 3);
mju_cross(local_c8,local_a8,local_88);
mju_normalize3(local_c8);
mju_cross(local_48,local_c8,local_88);
mju_cross(local_68,local_a8,local_c8);
for (local_cc = 0; local_cc < 3; local_cc = local_cc + 1) {
for (local_d0 = 0; local_d0 < 3; local_d0 = local_d0 + 1) {
local_8[local_cc * 3 + local_d0] =
(local_48[local_cc] * local_68[local_d0] + local_68[local_cc] * local_48[local_d0]) /
(DAT_00117b28 * local_48[3] * local_48[3]);
}
}
return;
}
|
|
9,546 |
my_strnncoll_win1250ch
|
eloqsql/strings/ctype-win1250ch.c
|
static int my_strnncoll_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
int v1, v2;
const uchar *p1, * p2;
int pass1 = 0, pass2 = 0;
int diff;
if (s2_is_prefix && len1 > len2)
len1=len2;
p1 = s1; p2 = s2;
do
{
NEXT_CMP_VALUE(s1, p1, pass1, v1, (int)len1);
NEXT_CMP_VALUE(s2, p2, pass2, v2, (int)len2);
if ((diff = v1 - v2))
return diff;
} while (v1);
return 0;
}
|
O3
|
c
|
my_strnncoll_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %r8, %rdx
movq %r8, %rax
cmovbq %rdx, %rax
testb %r9b, %r9b
cmoveq %rdx, %rax
movq %rax, -0x70(%rbp)
movslq %eax, %rdx
movq %r8, -0x78(%rbp)
movslq %r8d, %r9
movl $0x1, %eax
movl $0x1, %edi
subq %rsi, %rdi
movq %rdi, -0x60(%rbp)
subq %rcx, %rax
movq %rax, -0x68(%rbp)
xorl %r13d, %r13d
leaq 0x288cea(%rip), %r14 # 0x312920
movq %rsi, %r15
movq %rcx, %r12
xorl %ebx, %ebx
movq %rcx, -0x48(%rbp)
movq %rsi, -0x58(%rbp)
movq %r15, %rax
subq %rsi, %rax
cmpq %rdx, %rax
jge 0x89c5e
testl %r13d, %r13d
je 0x89c8c
movl $0x9, %r8d
jmp 0x89c87
testl %r13d, %r13d
sete %r8b
cmpl $0x0, -0x70(%rbp)
setg %dil
xorl %eax, %eax
testb %r8b, %dil
je 0x89d52
movl $0x1, %r13d
movl $0x9, %r8d
movq %rsi, %r15
movq %r14, %rax
jmp 0x89c9c
xorl %r13d, %r13d
movl $0x8, %r8d
leaq 0x288b84(%rip), %rax # 0x312820
movzbl (%r15), %edi
movb (%rax,%rdi), %al
cmpb $-0x1, %al
jne 0x89d4c
movq %r8, -0x50(%rbp)
movq %r12, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r15, %r11
subq %rsi, %r11
movq -0x60(%rbp), %rax
leaq (%rax,%r15), %rcx
xorl %edi, %edi
movq %r15, %r12
movq %rdi, %r8
shlq $0x4, %r8
leaq 0x2a56f5(%rip), %rax # 0x32f3d0
movq (%r8,%rax), %r13
movb (%r13), %r10b
testb %r10b, %r10b
je 0x89d13
cmpq %rdx, %r11
jge 0x89d13
incq %r13
movq %rcx, %rbx
cmpb (%r15), %r10b
jne 0x89d18
incq %r15
movb (%r13), %r10b
testb %r10b, %r10b
je 0x89d13
leaq 0x1(%rbx), %rax
incq %r13
cmpq %rdx, %rbx
movq %rax, %rbx
jl 0x89cf3
testb %r10b, %r10b
je 0x89d28
incq %rdi
cmpq $0x50, %rdi
movq %r12, %r15
jne 0x89ccd
movb $-0x1, %al
jmp 0x89d3d
leaq 0x2a56a1(%rip), %rax # 0x32f3d0
addq %rax, %r8
movq -0x50(%rbp), %rax
movb (%r8,%rax), %al
decq %r15
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r12
movzbl %al, %eax
incq %r15
movq %r12, %rdi
subq %rcx, %rdi
cmpq %r9, %rdi
jge 0x89d69
testl %ebx, %ebx
je 0x89d96
movl $0x9, %r10d
jmp 0x89d91
testl %ebx, %ebx
sete %dil
cmpl $0x0, -0x78(%rbp)
setg %r8b
xorl %r10d, %r10d
testb %dil, %r8b
je 0x89e90
movl $0x1, %ebx
movl $0x9, %r10d
movq %rcx, %r12
movq %r14, %r8
jmp 0x89da5
xorl %ebx, %ebx
movl $0x8, %r10d
leaq 0x288a7b(%rip), %r8 # 0x312820
movzbl (%r12), %edi
movb (%r8,%rdi), %dil
cmpb $-0x1, %dil
jne 0x89e89
movq %r10, -0x50(%rbp)
movq %r15, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r12, %r14
subq %rcx, %r14
movq -0x68(%rbp), %rcx
movq %r12, %r11
leaq (%rcx,%r12), %rsi
xorl %r8d, %r8d
movq %r8, %r15
shlq $0x4, %r15
leaq 0x2a55e7(%rip), %rcx # 0x32f3d0
movq (%r15,%rcx), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x89e24
cmpq %r9, %r14
jge 0x89e24
incq %rbx
movq %rsi, %rdi
movq %r11, %r10
cmpb (%r10), %r13b
jne 0x89e2c
incq %r10
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x89e27
leaq 0x1(%rdi), %r12
incq %rbx
cmpq %r9, %rdi
movq %r12, %rdi
jl 0x89e03
jmp 0x89e27
movq %r11, %r10
testb %r13b, %r13b
je 0x89e57
incq %r8
cmpq $0x50, %r8
jne 0x89ddb
movb $-0x1, %dil
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x288ad9(%rip), %r14 # 0x312920
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movq %r11, %r12
jmp 0x89e89
leaq 0x2a5572(%rip), %rcx # 0x32f3d0
addq %rcx, %r15
movq -0x50(%rbp), %rcx
movb (%r15,%rcx), %dil
decq %r10
movq %r10, %r12
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x288aa2(%rip), %r14 # 0x312920
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movzbl %dil, %r10d
incq %r12
testl %eax, %eax
je 0x89e9d
cmpl %r10d, %eax
je 0x89c46
subl %r10d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnncoll_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
cmp rdx, r8
mov rax, r8
cmovb rax, rdx
test r9b, r9b
cmovz rax, rdx
mov [rbp+var_70], rax
movsxd rdx, eax
mov [rbp+var_78], r8
movsxd r9, r8d
mov eax, 1
mov edi, 1
sub rdi, rsi
mov [rbp+var_60], rdi
sub rax, rcx
mov [rbp+var_68], rax
xor r13d, r13d
lea r14, _sort_order_win1250ch2
mov r15, rsi
mov r12, rcx
xor ebx, ebx
mov [rbp+var_48], rcx
mov [rbp+var_58], rsi
loc_89C46:
mov rax, r15
sub rax, rsi
cmp rax, rdx
jge short loc_89C5E
test r13d, r13d
jz short loc_89C8C
mov r8d, 9
jmp short loc_89C87
loc_89C5E:
test r13d, r13d
setz r8b
cmp dword ptr [rbp+var_70], 0
setnle dil
xor eax, eax
test dil, r8b
jz loc_89D52
mov r13d, 1
mov r8d, 9
mov r15, rsi
loc_89C87:
mov rax, r14
jmp short loc_89C9C
loc_89C8C:
xor r13d, r13d
mov r8d, 8
lea rax, _sort_order_win1250ch1
loc_89C9C:
movzx edi, byte ptr [r15]
mov al, [rax+rdi]
cmp al, 0FFh
jnz loc_89D4C
mov [rbp+var_50], r8
mov [rbp+var_38], r12
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r11, r15
sub r11, rsi
mov rax, [rbp+var_60]
lea rcx, [rax+r15]
xor edi, edi
mov r12, r15
loc_89CCD:
mov r8, rdi
shl r8, 4
lea rax, doubles_0
mov r13, [r8+rax]
mov r10b, [r13+0]
test r10b, r10b
jz short loc_89D13
cmp r11, rdx
jge short loc_89D13
inc r13
mov rbx, rcx
loc_89CF3:
cmp r10b, [r15]
jnz short loc_89D18
inc r15
mov r10b, [r13+0]
test r10b, r10b
jz short loc_89D13
lea rax, [rbx+1]
inc r13
cmp rbx, rdx
mov rbx, rax
jl short loc_89CF3
loc_89D13:
test r10b, r10b
jz short loc_89D28
loc_89D18:
inc rdi
cmp rdi, 50h ; 'P'
mov r15, r12
jnz short loc_89CCD
mov al, 0FFh
jmp short loc_89D3D
loc_89D28:
lea rax, doubles_0
add r8, rax
mov rax, [rbp+var_50]
mov al, [r8+rax]
dec r15
loc_89D3D:
mov rcx, [rbp+var_48]
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_38]
loc_89D4C:
movzx eax, al
inc r15
loc_89D52:
mov rdi, r12
sub rdi, rcx
cmp rdi, r9
jge short loc_89D69
test ebx, ebx
jz short loc_89D96
mov r10d, 9
jmp short loc_89D91
loc_89D69:
test ebx, ebx
setz dil
cmp dword ptr [rbp+var_78], 0
setnle r8b
xor r10d, r10d
test r8b, dil
jz loc_89E90
mov ebx, 1
mov r10d, 9
mov r12, rcx
loc_89D91:
mov r8, r14
jmp short loc_89DA5
loc_89D96:
xor ebx, ebx
mov r10d, 8
lea r8, _sort_order_win1250ch1
loc_89DA5:
movzx edi, byte ptr [r12]
mov dil, [r8+rdi]
cmp dil, 0FFh
jnz loc_89E89
mov [rbp+var_50], r10
mov [rbp+var_38], r15
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r14, r12
sub r14, rcx
mov rcx, [rbp+var_68]
mov r11, r12
lea rsi, [rcx+r12]
xor r8d, r8d
loc_89DDB:
mov r15, r8
shl r15, 4
lea rcx, doubles_0
mov rbx, [r15+rcx]
mov r13b, [rbx]
test r13b, r13b
jz short loc_89E24
cmp r14, r9
jge short loc_89E24
inc rbx
mov rdi, rsi
mov r10, r11
loc_89E03:
cmp r13b, [r10]
jnz short loc_89E2C
inc r10
mov r13b, [rbx]
test r13b, r13b
jz short loc_89E27
lea r12, [rdi+1]
inc rbx
cmp rdi, r9
mov rdi, r12
jl short loc_89E03
jmp short loc_89E27
loc_89E24:
mov r10, r11
loc_89E27:
test r13b, r13b
jz short loc_89E57
loc_89E2C:
inc r8
cmp r8, 50h ; 'P'
jnz short loc_89DDB
mov dil, 0FFh
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
mov r12, r11
jmp short loc_89E89
loc_89E57:
lea rcx, doubles_0
add r15, rcx
mov rcx, [rbp+var_50]
mov dil, [r15+rcx]
dec r10
mov r12, r10
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
loc_89E89:
movzx r10d, dil
inc r12
loc_89E90:
test eax, eax
jz short loc_89E9D
cmp eax, r10d
jz loc_89C46
loc_89E9D:
sub eax, r10d
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnncoll_win1250ch(
long long a1,
_BYTE *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
int v6; // eax
long long v7; // rdx
long long v8; // r9
long long v9; // r13
_BYTE *v10; // r15
unsigned __int8 *v11; // r12
int v12; // ebx
long long v13; // r8
_BYTE *v14; // rax
_BYTE *v15; // r11
_BYTE *v16; // rcx
long long v17; // rdi
_BYTE *v18; // r12
char *v19; // r13
char v20; // r10
char *v21; // r13
_BYTE *v22; // rbx
bool v23; // cc
long long v24; // r10
int v25; // r10d
_BYTE *v26; // r8
unsigned __int8 v27; // di
long long v28; // r8
char *v29; // rbx
char v30; // r13
char *v31; // rbx
unsigned __int8 *v32; // rdi
_BYTE *v33; // r10
int v35; // [rsp+0h] [rbp-78h]
int v36; // [rsp+8h] [rbp-70h]
long long v37; // [rsp+10h] [rbp-68h]
long long v38; // [rsp+18h] [rbp-60h]
_BYTE *v39; // [rsp+20h] [rbp-58h]
long long v40; // [rsp+28h] [rbp-50h]
unsigned __int8 *v41; // [rsp+30h] [rbp-48h]
long long v42; // [rsp+38h] [rbp-40h]
long long v43; // [rsp+38h] [rbp-40h]
unsigned __int8 *v44; // [rsp+40h] [rbp-38h]
int v45; // [rsp+4Ch] [rbp-2Ch]
int v46; // [rsp+4Ch] [rbp-2Ch]
v6 = a5;
if ( a3 < a5 )
v6 = a3;
if ( !a6 )
v6 = a3;
v36 = v6;
v7 = v6;
v35 = a5;
v8 = (int)a5;
v38 = 1LL - (_QWORD)a2;
v37 = 1LL - (_QWORD)a4;
v9 = 0LL;
v10 = a2;
v11 = a4;
v12 = 0;
v41 = a4;
v39 = a2;
do
{
if ( v10 - a2 >= v7 )
{
LODWORD(v14) = 0;
if ( (_DWORD)v9 != 0 || v36 <= 0 )
goto LABEL_27;
v9 = 1LL;
v13 = 9LL;
v10 = a2;
}
else
{
if ( !(_DWORD)v9 )
{
v9 = 0LL;
v13 = 8LL;
v14 = &sort_order_win1250ch1;
goto LABEL_13;
}
v13 = 9LL;
}
v14 = &sort_order_win1250ch2;
LABEL_13:
LOBYTE(v14) = v14[(unsigned __int8)*v10];
if ( (_BYTE)v14 != 0xFF )
goto LABEL_26;
v44 = v11;
v45 = v12;
v42 = v9;
v15 = (_BYTE *)(v10 - a2);
v16 = &v10[v38];
v17 = 0LL;
v18 = v10;
while ( 1 )
{
v19 = (char *)*(&doubles_0 + 2 * v17);
v20 = *v19;
if ( *v19 && (long long)v15 < v7 )
{
v21 = v19 + 1;
v22 = v16;
while ( v20 == *v10 )
{
++v10;
v20 = *v21;
if ( *v21 )
{
++v21;
v23 = (long long)v22++ < v7;
if ( v23 )
continue;
}
goto LABEL_21;
}
goto LABEL_22;
}
LABEL_21:
if ( !v20 )
break;
LABEL_22:
++v17;
v10 = v18;
if ( v17 == 80 )
{
LOBYTE(v14) = -1;
goto LABEL_25;
}
}
LOBYTE(v14) = *((_BYTE *)&doubles_0 + 16 * v17 + v13);
--v10;
LABEL_25:
a4 = v41;
v9 = v42;
v12 = v45;
v11 = v44;
LABEL_26:
LODWORD(v14) = (unsigned __int8)v14;
++v10;
LABEL_27:
if ( v11 - a4 >= v8 )
{
v25 = 0;
if ( v12 != 0 || v35 <= 0 )
continue;
v12 = 1;
v24 = 9LL;
v11 = a4;
LABEL_32:
v26 = &sort_order_win1250ch2;
}
else
{
if ( v12 )
{
v24 = 9LL;
goto LABEL_32;
}
v12 = 0;
v24 = 8LL;
v26 = &sort_order_win1250ch1;
}
v27 = v26[*v11];
if ( v27 != 0xFF )
goto LABEL_48;
v40 = v24;
v46 = v12;
v43 = v9;
v28 = 0LL;
while ( 2 )
{
v29 = (char *)*(&doubles_0 + 2 * v28);
v30 = *v29;
if ( *v29 && v11 - a4 < v8 )
{
v31 = v29 + 1;
v32 = &v11[v37];
v33 = v11;
while ( v30 == *v33 )
{
++v33;
v30 = *v31;
if ( *v31 )
{
++v31;
v23 = (long long)v32++ < v8;
if ( v23 )
continue;
}
goto LABEL_44;
}
goto LABEL_45;
}
v33 = v11;
LABEL_44:
if ( v30 )
{
LABEL_45:
if ( ++v28 == 80 )
{
v27 = -1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
goto LABEL_48;
}
continue;
}
break;
}
v27 = *((_BYTE *)&doubles_0 + 16 * v28 + v40);
v11 = v33 - 1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
LABEL_48:
v25 = v27;
++v11;
}
while ( (_DWORD)v14 && (_DWORD)v14 == v25 );
return (unsigned int)((_DWORD)v14 - v25);
}
|
my_strnncoll_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
CMP RDX,R8
MOV RAX,R8
CMOVC RAX,RDX
TEST R9B,R9B
CMOVZ RAX,RDX
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RDX,EAX
MOV qword ptr [RBP + -0x78],R8
MOVSXD R9,R8D
MOV EAX,0x1
MOV EDI,0x1
SUB RDI,RSI
MOV qword ptr [RBP + -0x60],RDI
SUB RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
XOR R13D,R13D
LEA R14,[0x412920]
MOV R15,RSI
MOV R12,RCX
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x58],RSI
LAB_00189c46:
MOV RAX,R15
SUB RAX,RSI
CMP RAX,RDX
JGE 0x00189c5e
TEST R13D,R13D
JZ 0x00189c8c
MOV R8D,0x9
JMP 0x00189c87
LAB_00189c5e:
TEST R13D,R13D
SETZ R8B
CMP dword ptr [RBP + -0x70],0x0
SETG DIL
XOR EAX,EAX
TEST DIL,R8B
JZ 0x00189d52
MOV R13D,0x1
MOV R8D,0x9
MOV R15,RSI
LAB_00189c87:
MOV RAX,R14
JMP 0x00189c9c
LAB_00189c8c:
XOR R13D,R13D
MOV R8D,0x8
LEA RAX,[0x412820]
LAB_00189c9c:
MOVZX EDI,byte ptr [R15]
MOV AL,byte ptr [RAX + RDI*0x1]
CMP AL,0xff
JNZ 0x00189d4c
MOV qword ptr [RBP + -0x50],R8
MOV qword ptr [RBP + -0x38],R12
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R11,R15
SUB R11,RSI
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RAX + R15*0x1]
XOR EDI,EDI
MOV R12,R15
LAB_00189ccd:
MOV R8,RDI
SHL R8,0x4
LEA RAX,[0x42f3d0]
MOV R13,qword ptr [R8 + RAX*0x1]
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x00189d13
CMP R11,RDX
JGE 0x00189d13
INC R13
MOV RBX,RCX
LAB_00189cf3:
CMP R10B,byte ptr [R15]
JNZ 0x00189d18
INC R15
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x00189d13
LEA RAX,[RBX + 0x1]
INC R13
CMP RBX,RDX
MOV RBX,RAX
JL 0x00189cf3
LAB_00189d13:
TEST R10B,R10B
JZ 0x00189d28
LAB_00189d18:
INC RDI
CMP RDI,0x50
MOV R15,R12
JNZ 0x00189ccd
MOV AL,0xff
JMP 0x00189d3d
LAB_00189d28:
LEA RAX,[0x42f3d0]
ADD R8,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [R8 + RAX*0x1]
DEC R15
LAB_00189d3d:
MOV RCX,qword ptr [RBP + -0x48]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x38]
LAB_00189d4c:
MOVZX EAX,AL
INC R15
LAB_00189d52:
MOV RDI,R12
SUB RDI,RCX
CMP RDI,R9
JGE 0x00189d69
TEST EBX,EBX
JZ 0x00189d96
MOV R10D,0x9
JMP 0x00189d91
LAB_00189d69:
TEST EBX,EBX
SETZ DIL
CMP dword ptr [RBP + -0x78],0x0
SETG R8B
XOR R10D,R10D
TEST R8B,DIL
JZ 0x00189e90
MOV EBX,0x1
MOV R10D,0x9
MOV R12,RCX
LAB_00189d91:
MOV R8,R14
JMP 0x00189da5
LAB_00189d96:
XOR EBX,EBX
MOV R10D,0x8
LEA R8,[0x412820]
LAB_00189da5:
MOVZX EDI,byte ptr [R12]
MOV DIL,byte ptr [R8 + RDI*0x1]
CMP DIL,0xff
JNZ 0x00189e89
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x38],R15
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R14,R12
SUB R14,RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV R11,R12
LEA RSI,[RCX + R12*0x1]
XOR R8D,R8D
LAB_00189ddb:
MOV R15,R8
SHL R15,0x4
LEA RCX,[0x42f3d0]
MOV RBX,qword ptr [R15 + RCX*0x1]
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x00189e24
CMP R14,R9
JGE 0x00189e24
INC RBX
MOV RDI,RSI
MOV R10,R11
LAB_00189e03:
CMP R13B,byte ptr [R10]
JNZ 0x00189e2c
INC R10
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x00189e27
LEA R12,[RDI + 0x1]
INC RBX
CMP RDI,R9
MOV RDI,R12
JL 0x00189e03
JMP 0x00189e27
LAB_00189e24:
MOV R10,R11
LAB_00189e27:
TEST R13B,R13B
JZ 0x00189e57
LAB_00189e2c:
INC R8
CMP R8,0x50
JNZ 0x00189ddb
MOV DIL,0xff
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x412920]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
MOV R12,R11
JMP 0x00189e89
LAB_00189e57:
LEA RCX,[0x42f3d0]
ADD R15,RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV DIL,byte ptr [R15 + RCX*0x1]
DEC R10
MOV R12,R10
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x412920]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
LAB_00189e89:
MOVZX R10D,DIL
INC R12
LAB_00189e90:
TEST EAX,EAX
JZ 0x00189e9d
CMP EAX,R10D
JZ 0x00189c46
LAB_00189e9d:
SUB EAX,R10D
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_strnncoll_win1250ch
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
bool bVar1;
bool bVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
byte bVar6;
int iVar7;
ulong uVar9;
int1 *puVar10;
long lVar11;
int iVar12;
uint uVar13;
long lVar14;
byte *pbVar15;
byte *pbVar16;
byte *pbVar17;
byte *pbVar18;
uint uVar8;
uVar9 = param_5;
if (param_3 < param_5) {
uVar9 = param_3;
}
if (param_6 == '\0') {
uVar9 = param_3;
}
iVar7 = (int)uVar9;
iVar12 = (int)param_5;
bVar2 = false;
bVar1 = false;
pbVar15 = param_4;
pbVar18 = param_2;
do {
if ((long)pbVar18 - (long)param_2 < (long)iVar7) {
if (bVar2) {
LAB_00189c87:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar2 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar18];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar18;
pbVar5 = pbVar18 + (1 - (long)param_2);
pbVar4 = pbVar18 + -(long)param_2;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar7) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_00189d18;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar18 = pbVar17 + -1;
goto LAB_00189d4c;
}
LAB_00189d18:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00189d4c:
uVar8 = (uint)bVar6;
pbVar18 = pbVar18 + 1;
}
else {
uVar8 = 0;
if (0 < iVar7 && !bVar2) {
bVar2 = true;
pbVar18 = param_2;
goto LAB_00189c87;
}
}
if ((long)pbVar15 - (long)param_4 < (long)iVar12) {
if (bVar1) {
LAB_00189d91:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar1 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar15];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar15;
pbVar5 = pbVar15 + (1 - (long)param_4);
pbVar4 = pbVar15 + -(long)param_4;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar12) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_00189e2c;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar15 = pbVar17 + -1;
goto LAB_00189e89;
}
LAB_00189e2c:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00189e89:
uVar13 = (uint)bVar6;
pbVar15 = pbVar15 + 1;
}
else {
uVar13 = 0;
if (0 < iVar12 && !bVar1) {
bVar1 = true;
pbVar15 = param_4;
goto LAB_00189d91;
}
}
if ((uVar8 == 0) || (uVar8 != uVar13)) {
return uVar8 - uVar13;
}
} while( true );
}
|
|
9,547 |
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
|
llama.cpp/common/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x79780
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x79780
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x796ef
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpb $0x2, %r14b
jne 0x79599
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
movq %rsp, %rdi
callq 0x797c4
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x795d4
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7857e
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x7957f
jmp 0x795d4
movq 0x28(%rax), %rsi
movq %rsp, %rdi
callq 0x797c4
movq (%rbx), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0x795d4
movq %rsp, %r12
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x7857e
movq %r15, %rdi
callq 0x21050
movq %rax, %r15
cmpq %r13, %rax
jne 0x795b8
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x796e7
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x733b4
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x733b4
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x733b4
movq %r13, %rdi
callq 0x78f02
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x7968e
cmpl $0x2, %eax
jne 0x796c6
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x79684
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x7857e
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x79664
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x79918
jmp 0x796c6
movq 0x28(%rsp), %rdi
movq 0x18(%rdi), %r13
leaq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x796c1
leaq 0x40(%r13), %rsi
movq %r12, %rdi
callq 0x7857e
movq %r13, %rdi
callq 0x21050
movq %rax, %r13
cmpq %rbp, %rax
jne 0x796a0
movq 0x28(%rsp), %rdi
callq 0x7995e
movq %r15, %rdi
xorl %esi, %esi
callq 0x733b4
movq %r15, %rdi
callq 0x78f02
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x795eb
movq %rsp, %rdi
callq 0x798c6
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x79780
leaq 0x99b53(%rip), %rcx # 0x113258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x7998c
movq (%rbx), %rdi
movl $0x30, %esi
jmp 0x7977b
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x79740
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x20180
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x7977b
movq (%rbx), %rdi
callq 0x798c6
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x7977b
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x79776
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x20180
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x20180
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x79793
jmp 0x79793
movq %rax, %rbx
jmp 0x797b4
jmp 0x7979a
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x733b4
movq %r14, %rdi
callq 0x78f02
movq %rsp, %rdi
callq 0x798c6
movq %rbx, %rdi
callq 0x20b00
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_7970C; jumptable 000000000007970C default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_7970C; jumptable 000000000007970C default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_796EF
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
cmp r14b, 2
jnz short loc_79599
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_795D4
inc r13
mov r12, rsp
loc_7957F:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<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::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> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_7957F
jmp short loc_795D4
loc_79599:
mov rsi, [rax+28h]
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov r13, [rbx]
mov r15, [r13+18h]
add r13, 8
cmp r15, r13
jz short loc_795D4
mov r12, rsp
loc_795B8:
lea rsi, [r15+40h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<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::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> &&)
mov rdi, r15
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r15, rax
cmp rax, r13
jnz short loc_795B8
loc_795D4:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_796E7
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_795EB:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_7968E
cmp eax, 2
jnz short loc_796C6
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_79684
inc rbp
loc_79664:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<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::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> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_79664
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_79684:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(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>*)
jmp short loc_796C6
loc_7968E:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi+18h]
lea rbp, [rdi+8]
cmp r13, rbp
jz short loc_796C1
loc_796A0:
lea rsi, [r13+40h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<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::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> &&)
mov rdi, r13
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r13, rax
cmp rax, rbp
jnz short loc_796A0
mov rdi, qword ptr [rsp+68h+var_48+8]
loc_796C1:
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE5clearEv; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,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>>>>::clear(void)
loc_796C6:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_795EB
loc_796E7:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_796EF:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja def_7970C; jumptable 000000000007970C default case, cases 4-7
lea rcx, jpt_7970C
movsxd rax, ds:(jpt_7970C - 113258h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7970E:
mov rdi, [rbx]; jumptable 000000000007970C case 1
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,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>>>>::~_Rb_tree()
mov rdi, [rbx]
mov esi, 30h ; '0'
jmp short loc_7977B
loc_79720:
mov rdi, [rbx]; jumptable 000000000007970C case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_79740
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]
loc_79740:
mov esi, 20h ; ' '
jmp short loc_7977B
loc_79747:
mov rdi, [rbx]; jumptable 000000000007970C case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_7977B
loc_79759:
mov rdi, [rbx]; jumptable 000000000007970C case 8
mov rax, [rdi]
test rax, rax
jz short loc_79776
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_79776:
mov esi, 28h ; '('; unsigned __int64
loc_7977B:
call __ZdlPvm; operator delete(void *,ulong)
def_7970C:
add rsp, 38h; jumptable 000000000007970C default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_79793
jmp short $+2
loc_79793:
mov rbx, rax
jmp short loc_797B4
jmp short $+2
loc_7979A:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_797B4:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void 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>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // r15
long long v6; // r13
long long v7; // r13
bool v8; // cf
long long v9; // r15
long long i; // r13
long long j; // r13
char *v12; // r13
long long v13; // rsi
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
unsigned long long v22; // rsi
_QWORD *v23; // rcx
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
if ( (_BYTE)a2 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
(v2[1] - *v2) >> 4);
v5 = **a1;
v6 = ((*a1)[1] - v5) >> 4;
if ( v6 > 0 )
{
v7 = v6 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v5);
v5 += 16LL;
v8 = v7-- == 1;
}
while ( !v8 && v7 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v2[5]);
v9 = (*a1)[3];
for ( i = (long long)(*a1 + 1); v9 != i; v9 = std::_Rb_tree_increment(v9) )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v9 + 64);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
v12 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v12;
v13 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v12);
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>::data::~data(v12);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 24LL);
v20 = *((_QWORD *)&v27[0] + 1) + 8LL;
if ( v19 != *((_QWORD *)&v27[0] + 1) + 8LL )
{
do
{
v13 = v19 + 64;
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v19 + 64);
v19 = std::_Rb_tree_increment(v19);
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
}
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,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>>>>::clear(
v18,
v13);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
v15);
}
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
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>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,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>>>>::~_Rb_tree(*a1);
v21 = (void **)*a1;
v22 = 48LL;
goto LABEL_34;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = (void **)*a1;
v22 = 24LL;
goto LABEL_34;
case 3:
v21 = (void **)*a1;
v23 = *a1 + 2;
if ( (_QWORD *)**a1 != v23 )
{
operator delete((void *)**a1, *v23 + 1LL);
v21 = (void **)*a1;
}
v22 = 32LL;
goto LABEL_34;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v22 = 40LL;
LABEL_34:
operator delete(v21, v22);
break;
default:
return;
}
}
}
}
|
destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x00179780
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x00179780
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x001796ef
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
CMP R14B,0x2
JNZ 0x00179599
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
LAB_0017955b:
MOV RDI,RSP
CALL 0x001797c4
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x001795d4
INC R13
MOV R12,RSP
LAB_0017957f:
MOV RDI,R12
MOV RSI,R15
CALL 0x0017857e
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x0017957f
JMP 0x001795d4
LAB_00179599:
MOV RSI,qword ptr [RAX + 0x28]
LAB_0017959d:
MOV RDI,RSP
CALL 0x001797c4
MOV R13,qword ptr [RBX]
MOV R15,qword ptr [R13 + 0x18]
ADD R13,0x8
CMP R15,R13
JZ 0x001795d4
MOV R12,RSP
LAB_001795b8:
LEA RSI,[R15 + 0x40]
LAB_001795bc:
MOV RDI,R12
CALL 0x0017857e
MOV RDI,R15
CALL 0x00121050
MOV R15,RAX
CMP RAX,R13
JNZ 0x001795b8
LAB_001795d4:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x001796e7
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_001795eb:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001733b4
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001733b4
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001733b4
MOV RDI,R13
CALL 0x00178f02
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0017968e
CMP EAX,0x2
JNZ 0x001796c6
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x00179684
INC RBP
LAB_00179664:
MOV RDI,R12
MOV RSI,R13
CALL 0x0017857e
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x00179664
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_00179684:
MOV RSI,R13
CALL 0x00179918
JMP 0x001796c6
LAB_0017968e:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI + 0x18]
LEA RBP,[RDI + 0x8]
CMP R13,RBP
JZ 0x001796c1
LAB_001796a0:
LEA RSI,[R13 + 0x40]
LAB_001796a4:
MOV RDI,R12
CALL 0x0017857e
LAB_001796ac:
MOV RDI,R13
CALL 0x00121050
MOV R13,RAX
CMP RAX,RBP
JNZ 0x001796a0
MOV RDI,qword ptr [RSP + 0x28]
LAB_001796c1:
CALL 0x0017995e
LAB_001796c6:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001733b4
MOV RDI,R15
CALL 0x00178f02
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x001795eb
LAB_001796e7:
MOV RDI,RSP
CALL 0x001798c6
LAB_001796ef:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x00179780
LEA RCX,[0x213258]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0017998c
MOV RDI,qword ptr [RBX]
MOV ESI,0x30
JMP 0x0017977b
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x00179740
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00120180
MOV RDI,qword ptr [RBX]
LAB_00179740:
MOV ESI,0x20
JMP 0x0017977b
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x001798c6
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x0017977b
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00179776
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00120180
MOV RDI,qword ptr [RBX]
LAB_00179776:
MOV ESI,0x28
LAB_0017977b:
CALL 0x00120180
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
void *pvVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
byte bVar5;
bool bVar6;
int8 *puVar7;
long lVar8;
ulong uVar9;
data *pdVar10;
basic_json *pbVar11;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*p_Stack_40;
plVar1 = *(long **)this;
if ((param_2 != 1 || plVar1 != (long *)0x0) &&
(bVar5 = (byte)param_2, bVar5 != 8 && (bVar5 & 0xfe) != 2 || plVar1 != (long *)0x0)) {
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
if (bVar5 == 2) {
/* try { // try from 0017955b to 00179562 has its CatchHandler @ 0017978f */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[1] - *plVar1 >> 4);
pbVar11 = (basic_json *)**(long **)this;
lVar8 = (*(long **)this)[1] - (long)pbVar11 >> 4;
if (0 < lVar8) {
uVar9 = lVar8 + 1;
do {
/* try { // try from 0017957f to 00179589 has its CatchHandler @ 00179793 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar11);
pbVar11 = pbVar11 + 0x10;
uVar9 = uVar9 - 1;
} while (1 < uVar9);
}
}
else {
/* try { // try from 0017959d to 001795a4 has its CatchHandler @ 0017978f */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[5]);
lVar8 = *(long *)this;
for (p_Var3 = *(_Rb_tree_node_base **)(lVar8 + 0x18);
p_Var3 != (_Rb_tree_node_base *)(lVar8 + 8);
p_Var3 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var3)) {
/* try { // try from 001795bc to 001795c3 has its CatchHandler @ 00179791 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var3 + 0x40));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
p_Stack_40 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar6 = SUB81((data *)&local_48,0);
assert_invariant(bVar6);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
p_Var3 = (_Rb_tree_node_base *)(p_Stack_40 + 8);
for (p_Var4 = *(_Rb_tree_node_base **)(p_Stack_40 + 0x18); p_Var4 != p_Var3;
p_Var4 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var4)) {
/* try { // try from 001796a4 to 001796ab has its CatchHandler @ 0017979a */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var4 + 0x40));
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear(p_Stack_40);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar11 = *(basic_json **)p_Stack_40;
lVar8 = *(long *)(p_Stack_40 + 8) - (long)pbVar11 >> 4;
if (0 < lVar8) {
lVar8 = lVar8 + 1;
do {
/* try { // try from 00179664 to 0017966e has its CatchHandler @ 00179798 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar11);
pbVar11 = pbVar11 + 0x10;
lVar8 = lVar8 + -1;
} while (1 < lVar8);
pbVar11 = *(basic_json **)p_Stack_40;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)p_Stack_40,pbVar11);
}
assert_invariant(bVar6);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~_Rb_tree(*(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
puVar7 = *(int8 **)this;
uVar9 = 0x30;
break;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
puVar7 = *(int8 **)this;
uVar9 = 0x18;
break;
case 3:
puVar7 = *(int8 **)this;
if ((long *)*puVar7 != puVar7 + 2) {
operator_delete((long *)*puVar7,puVar7[2] + 1);
puVar7 = *(int8 **)this;
}
uVar9 = 0x20;
break;
default:
goto switchD_0017970c_caseD_4;
case 8:
puVar7 = *(int8 **)this;
pvVar2 = (void *)*puVar7;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar7[2] - (long)pvVar2);
puVar7 = *(int8 **)this;
}
uVar9 = 0x28;
}
operator_delete(puVar7,uVar9);
}
switchD_0017970c_caseD_4:
return;
}
|
|
9,548 |
ma_calc_length_for_store_length
|
eloqsql/storage/maria/ma_blockrec.c
|
uint ma_calc_length_for_store_length(ulong nr)
{
if (nr < 251)
return 1;
if (nr < 65536)
{
if (nr <= 255)
return 2;
return 3;
}
if (nr < 16777216)
return 4;
return 5;
}
|
O0
|
c
|
ma_calc_length_for_store_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0xfb, -0x10(%rbp)
jae 0x7a93b
movl $0x1, -0x4(%rbp)
jmp 0x7a97b
cmpq $0x10000, -0x10(%rbp) # imm = 0x10000
jae 0x7a961
cmpq $0xff, -0x10(%rbp)
ja 0x7a958
movl $0x2, -0x4(%rbp)
jmp 0x7a97b
movl $0x3, -0x4(%rbp)
jmp 0x7a97b
cmpq $0x1000000, -0x10(%rbp) # imm = 0x1000000
jae 0x7a974
movl $0x4, -0x4(%rbp)
jmp 0x7a97b
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
|
ma_calc_length_for_store_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0FBh
jnb short loc_7A93B
mov [rbp+var_4], 1
jmp short loc_7A97B
loc_7A93B:
cmp [rbp+var_10], 10000h
jnb short loc_7A961
cmp [rbp+var_10], 0FFh
ja short loc_7A958
mov [rbp+var_4], 2
jmp short loc_7A97B
loc_7A958:
mov [rbp+var_4], 3
jmp short loc_7A97B
loc_7A961:
cmp [rbp+var_10], 1000000h
jnb short loc_7A974
mov [rbp+var_4], 4
jmp short loc_7A97B
loc_7A974:
mov [rbp+var_4], 5
loc_7A97B:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long ma_calc_length_for_store_length(unsigned long long a1)
{
if ( a1 >= 0xFB )
{
if ( a1 >= 0x10000 )
{
if ( a1 >= 0x1000000 )
return 5;
else
return 4;
}
else if ( a1 > 0xFF )
{
return 3;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
ma_calc_length_for_store_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0xfb
JNC 0x0017a93b
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017a97b
LAB_0017a93b:
CMP qword ptr [RBP + -0x10],0x10000
JNC 0x0017a961
CMP qword ptr [RBP + -0x10],0xff
JA 0x0017a958
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0017a97b
LAB_0017a958:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0017a97b
LAB_0017a961:
CMP qword ptr [RBP + -0x10],0x1000000
JNC 0x0017a974
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0017a97b
LAB_0017a974:
MOV dword ptr [RBP + -0x4],0x5
LAB_0017a97b:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 ma_calc_length_for_store_length(ulong param_1)
{
int4 local_c;
if (param_1 < 0xfb) {
local_c = 1;
}
else if (param_1 < 0x10000) {
if (param_1 < 0x100) {
local_c = 2;
}
else {
local_c = 3;
}
}
else if (param_1 < 0x1000000) {
local_c = 4;
}
else {
local_c = 5;
}
return local_c;
}
|
|
9,549 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/./minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O2
|
cpp
|
minja::Parser::parseIfExpression():
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x39e4e
cmpq $0x0, (%r15)
je 0x3a164
movb 0xa8f06(%rip), %al # 0xe2f80
testb %al, %al
je 0x3a194
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0xa8ed0(%rip), %rdx # 0xe2f60
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x2f3f2
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x20d78
testq %r15, %r15
je 0x3a117
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x2f20e
movq %rsp, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x524c4
leaq 0x28(%rsp), %rdi
callq 0x2eeb2
movq (%r14), %rax
testq %rax, %rax
jne 0x3a11b
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x6474a(%rip), %rsi # 0x9e841
movq %rax, %rdi
callq 0x20280
movq 0xa7ee2(%rip), %rsi # 0xe1fe8
movq 0xa7e63(%rip), %rdx # 0xe1f70
movq %r14, %rdi
callq 0x20b30
jmp 0x3a194
movq (%rsp), %rax
leaq 0x18(%rsp), %r14
movaps -0x8(%r14), %xmm0
andq $0x0, (%r14)
andq $0x0, -0x8(%r14)
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, 0x18(%rbx)
andq $0x0, -0x8(%rdi)
callq 0x2eeb2
movq %r14, %rdi
callq 0x2eeb2
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x646a6(%rip), %rsi # 0x9e81c
movq %rax, %rdi
callq 0x20280
movq 0xa7e63(%rip), %rsi # 0xe1fe8
movq 0xa7de4(%rip), %rdx # 0xe1f70
movq %r14, %rdi
callq 0x20b30
leaq 0xa8de5(%rip), %rdi # 0xe2f80
callq 0x20bf0
testl %eax, %eax
je 0x3a082
leaq 0xa8db1(%rip), %rdi # 0xe2f60
leaq 0x64684(%rip), %rsi # 0x9e83a
pushq $0x10
popq %rdx
callq 0x2ef2e
leaq -0xb231(%rip), %rdi # 0x2ef94
leaq 0xa8d94(%rip), %rsi # 0xe2f60
leaq 0xa84f5(%rip), %rdx # 0xe26c8
callq 0x205f0
leaq 0xa8da1(%rip), %rdi # 0xe2f80
callq 0x20480
jmp 0x3a082
movq %rax, %rbx
leaq 0xa8d8d(%rip), %rdi # 0xe2f80
callq 0x20470
jmp 0x3a22a
jmp 0x3a21d
movq %rax, %rbx
movq %r14, %rdi
callq 0x20520
jmp 0x3a220
movq %rax, %rbx
jmp 0x3a22a
movq %rax, %rbx
movq %r14, %rdi
callq 0x20520
jmp 0x3a22a
jmp 0x3a21d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2eeb2
leaq 0x18(%rsp), %rdi
callq 0x2eeb2
movq %rbx, %rdi
callq 0x20b90
|
_ZN5minja6Parser17parseIfExpressionEv:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+58h+var_48]
mov rdi, r15; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
cmp qword ptr [r15], 0
jz loc_3A164
mov al, cs:_ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
test al, al
jz loc_3A194
loc_3A082:
xorps xmm0, xmm0
movaps [rsp+58h+var_58], xmm0
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+58h+var_38]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+58h+var_38]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_3A117
lea rdi, [rsp+58h+var_38]; this
push 1
pop rdx
mov rsi, r14; bool
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov r14, rsp
lea rsi, [rsp+58h+var_38]
mov rdi, r14
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSEOS4_; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>&&)
lea rdi, [rsp+58h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, [r14]
test rax, rax
jnz short loc_3A11B
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_3A194
loc_3A117:
mov rax, qword ptr [rsp+58h+var_58]
loc_3A11B:
lea r14, [rsp+58h+var_40]
movaps xmm0, xmmword ptr [r14-8]
and qword ptr [r14], 0
and qword ptr [r14-8], 0
movups xmmword ptr [rbx], xmm0
mov [rbx+10h], rax
lea rdi, [rsp+58h+var_58+8]
mov rax, [rdi]
and qword ptr [rdi], 0
mov [rbx+18h], rax
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_3A164:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_3A194:
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_3A082
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_3A082
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_3A22A
jmp short loc_3A21D
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3A220
mov rbx, rax
jmp short loc_3A22A
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3A22A
jmp short $+2
loc_3A21D:
mov rbx, rax
loc_3A220:
lea rdi, [rsp+arg_0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_3A22A:
lea rdi, [rsp+arg_10]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
long long v3; // rax
std::runtime_error *v4; // r14
__int128 v5; // xmm0
long long v6; // rax
std::runtime_error *exception; // r14
__int128 v9; // [rsp+0h] [rbp-58h] BYREF
__int128 v10; // [rsp+10h] [rbp-48h] BYREF
long long v11; // [rsp+20h] [rbp-38h] BYREF
_QWORD v12[6]; // [rsp+28h] [rbp-30h] BYREF
minja::Parser::parseLogicalOr((minja::Parser *)&v10, a2);
if ( !(_QWORD)v10 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
v9 = 0LL;
minja::Parser::consumeToken(&v11, (long long)a2, (int)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11], 1u);
v2 = v12[0];
std::string::~string(&v11);
if ( v2 )
{
minja::Parser::parseExpression((minja::Parser *)&v11, a2, 1);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=(&v9, &v11);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
v3 = v9;
if ( !(_QWORD)v9 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected 'else' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v3 = v9;
}
v5 = v10;
v10 = 0uLL;
*(_OWORD *)this = v5;
*((_QWORD *)this + 2) = v3;
v6 = *((_QWORD *)&v9 + 1);
*((_QWORD *)&v9 + 1) = 0LL;
*((_QWORD *)this + 3) = v6;
*(_QWORD *)&v9 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v9 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v10 + 1);
return this;
}
|
parseIfExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV RDI,R15
CALL 0x00139e4e
CMP qword ptr [R15],0x0
JZ 0x0013a164
MOV AL,byte ptr [0x001e2f80]
TEST AL,AL
JZ 0x0013a194
LAB_0013a082:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_0013a089:
LEA RDX,[0x1e2f60]
LEA RDI,[RSP + 0x20]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x0012f3f2
LEA RDI,[RSP + 0x20]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x00120d78
TEST R15,R15
JZ 0x0013a117
LAB_0013a0b3:
LEA RDI,[RSP + 0x20]
PUSH 0x1
POP RDX
MOV RSI,R14
CALL 0x0012f20e
LAB_0013a0c3:
MOV R14,RSP
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x001524c4
LEA RDI,[RSP + 0x28]
CALL 0x0012eeb2
MOV RAX,qword ptr [R14]
TEST RAX,RAX
JNZ 0x0013a11b
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0013a0f0:
LEA RSI,[0x19e841]
MOV RDI,RAX
CALL 0x00120280
LAB_0013a0ff:
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R14
CALL 0x00120b30
LAB_0013a117:
MOV RAX,qword ptr [RSP]
LAB_0013a11b:
LEA R14,[RSP + 0x18]
MOVAPS XMM0,xmmword ptr [R14 + -0x8]
AND qword ptr [R14],0x0
AND qword ptr [R14 + -0x8],0x0
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],RAX
LEA RDI,[RSP + 0x8]
MOV RAX,qword ptr [RDI]
AND qword ptr [RDI],0x0
MOV qword ptr [RBX + 0x18],RAX
AND qword ptr [RDI + -0x8],0x0
CALL 0x0012eeb2
MOV RDI,R14
CALL 0x0012eeb2
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_0013a164:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0013a16f:
LEA RSI,[0x19e81c]
MOV RDI,RAX
CALL 0x00120280
LAB_0013a17e:
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R14
CALL 0x00120b30
LAB_0013a194:
LEA RDI,[0x1e2f80]
CALL 0x00120bf0
TEST EAX,EAX
JZ 0x0013a082
LAB_0013a1a8:
LEA RDI,[0x1e2f60]
LEA RSI,[0x19e83a]
PUSH 0x10
POP RDX
CALL 0x0012ef2e
LAB_0013a1be:
LEA RDI,[0x12ef94]
LEA RSI,[0x1e2f60]
LEA RDX,[0x1e26c8]
CALL 0x001205f0
LEA RDI,[0x1e2f80]
CALL 0x00120480
JMP 0x0013a082
|
/* minja::Parser::parseIfExpression() */
void minja::Parser::parseIfExpression(void)
{
long lVar1;
long lVar2;
long lVar3;
int iVar4;
runtime_error *prVar5;
long *in_RDI;
long local_58;
long lStack_50;
long local_48;
long lStack_40;
string local_38 [8];
long local_30 [3];
parseLogicalOr();
if (local_48 == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013a16f to 0013a17d has its CatchHandler @ 0013a20e */
std::runtime_error::runtime_error(prVar5,"Expected condition expression");
/* try { // try from 0013a17e to 0013a193 has its CatchHandler @ 0013a209 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
if ((parseIfExpression()::else_tok_abi_cxx11_ == '\0') &&
(iVar4 = __cxa_guard_acquire(&parseIfExpression()::else_tok_abi_cxx11_), iVar4 != 0)) {
/* try { // try from 0013a1a8 to 0013a1bd has its CatchHandler @ 0013a1e9 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIfExpression()::else_tok_abi_cxx11_,"else\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIfExpression()::else_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIfExpression()::else_tok_abi_cxx11_);
}
local_58 = 0;
lStack_50 = 0;
/* try { // try from 0013a089 to 0013a09f has its CatchHandler @ 0013a21d */
consumeToken(local_38);
std::__cxx11::string::~string(local_38);
if (local_30[0] != 0) {
/* try { // try from 0013a0b3 to 0013a0c2 has its CatchHandler @ 0013a21b */
parseExpression(SUB81(local_38,0));
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *)&local_58,
(__shared_ptr *)local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_30);
if (local_58 == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013a0f0 to 0013a0fe has its CatchHandler @ 0013a1fc */
std::runtime_error::runtime_error(prVar5,"Expected \'else\' expression");
/* try { // try from 0013a0ff to 0013a114 has its CatchHandler @ 0013a1fa */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
}
lVar3 = lStack_40;
lVar2 = local_48;
lVar1 = lStack_50;
lStack_40 = 0;
local_48 = 0;
*in_RDI = lVar2;
in_RDI[1] = lVar3;
in_RDI[2] = local_58;
lStack_50 = 0;
in_RDI[3] = lVar1;
local_58 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_40);
return;
}
|
|
9,550 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/./minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O3
|
cpp
|
minja::Parser::parseIfExpression():
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3c238
cmpq $0x0, (%r15)
je 0x3c5a5
movb 0xb4a66(%rip), %al # 0xf0f50
testb %al, %al
je 0x3c5d7
leaq 0xb4a37(%rip), %rdx # 0xf0f30
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x2fd6a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x3c52a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x186a0
testq %r15, %r15
je 0x3c584
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2fb5e
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %r14
testq %rax, %rax
jne 0x3c589
movl $0x10, %edi
callq 0x18360
movq %rax, %r15
leaq 0x7ef67(%rip), %rsi # 0xbb4cb
movq %rax, %rdi
callq 0x18270
movq 0xb3a7d(%rip), %rsi # 0xefff0
movq 0xb3a06(%rip), %rdx # 0xeff80
movq %r15, %rdi
callq 0x18b30
jmp 0x3c5d7
xorl %eax, %eax
xorl %r14d, %r14d
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %r14
leaq 0x7eeed(%rip), %rsi # 0xbb4a6
movq %rax, %rdi
callq 0x18270
movq 0xb3a28(%rip), %rsi # 0xefff0
movq 0xb39b1(%rip), %rdx # 0xeff80
movq %r14, %rdi
callq 0x18b30
leaq 0xb4972(%rip), %rdi # 0xf0f50
callq 0x18be0
testl %eax, %eax
je 0x3c4f2
leaq 0xb493e(%rip), %rdi # 0xf0f30
leaq 0x7eecb(%rip), %rsi # 0xbb4c4
movl $0x10, %edx
callq 0x2f87e
leaq -0xcd24(%rip), %rdi # 0x2f8e6
leaq 0xb491f(%rip), %rsi # 0xf0f30
leaq 0xb4080(%rip), %rdx # 0xf0698
callq 0x185d0
leaq 0xb492c(%rip), %rdi # 0xf0f50
callq 0x18450
jmp 0x3c4f2
movq %rax, %rbx
leaq 0xb4918(%rip), %rdi # 0xf0f50
callq 0x18440
jmp 0x3c672
movq %rax, %rbx
jmp 0x3c64f
movq %rax, %rbx
movq %r15, %rdi
callq 0x18500
testq %r14, %r14
je 0x3c672
movq %r14, %rdi
callq 0x2f80e
jmp 0x3c672
jmp 0x3c66f
movq %rax, %rbx
movq %r14, %rdi
callq 0x18500
jmp 0x3c672
jmp 0x3c66f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c681
callq 0x2f80e
movq %rbx, %rdi
callq 0x18b90
nop
|
_ZN5minja6Parser17parseIfExpressionEv:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov rdi, r15; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
cmp qword ptr [r15], 0
jz loc_3C5A5
mov al, cs:_ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
test al, al
jz loc_3C5D7
loc_3C4F2:
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+48h+var_38]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_3C52A
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C52A:
test r15, r15
jz short loc_3C584
lea rdi, [rsp+48h+var_38]; this
mov rsi, r14; bool
mov edx, 1
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov rax, [rsp+48h+var_38]
mov r14, [rsp+48h+var_30]
test rax, rax
jnz short loc_3C589
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_3C5D7
loc_3C584:
xor eax, eax
xor r14d, r14d
loc_3C589:
movaps xmm0, [rsp+48h+var_48]
movups xmmword ptr [rbx], xmm0
mov [rbx+10h], rax
mov [rbx+18h], r14
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_3C5A5:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_3C5D7:
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_3C4F2
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_3C4F2
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_3C672
mov rbx, rax
jmp short loc_3C64F
mov rbx, rax
mov rdi, r15; void *
call ___cxa_free_exception
loc_3C64F:
test r14, r14
jz short loc_3C672
mov rdi, r14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_3C672
jmp short loc_3C66F
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3C672
jmp short $+2
loc_3C66F:
mov rbx, rax
loc_3C672:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_3C681
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3C681:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, long long *a2)
{
long long v2; // r15
long long *v3; // rax
long long v4; // r14
std::runtime_error *v5; // r15
std::runtime_error *exception; // r14
__int128 v8; // [rsp+0h] [rbp-48h] BYREF
long long *v9; // [rsp+10h] [rbp-38h] BYREF
long long v10; // [rsp+18h] [rbp-30h]
long long v11; // [rsp+20h] [rbp-28h] BYREF
minja::Parser::parseLogicalOr((volatile signed __int32 **)&v8, a2);
if ( !(_QWORD)v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)&v9,
(long long)a2,
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
1u);
v2 = v10;
if ( v9 != &v11 )
operator delete(v9, v11 + 1);
if ( v2 )
{
minja::Parser::parseExpression((minja::Parser *)&v9, a2, 1);
v3 = v9;
v4 = v10;
if ( !v9 )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected 'else' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v3 = 0LL;
v4 = 0LL;
}
*(_OWORD *)this = v8;
*((_QWORD *)this + 2) = v3;
*((_QWORD *)this + 3) = v4;
return this;
}
|
parseIfExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x0013c238
CMP qword ptr [R15],0x0
JZ 0x0013c5a5
MOV AL,byte ptr [0x001f0f50]
TEST AL,AL
JZ 0x0013c5d7
LAB_0013c4f2:
LEA RDX,[0x1f0f30]
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV ECX,0x1
CALL 0x0012fd6a
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x0013c52a
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001186a0
LAB_0013c52a:
TEST R15,R15
JZ 0x0013c584
LAB_0013c52f:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV EDX,0x1
CALL 0x0012fb5e
LAB_0013c541:
MOV RAX,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x18]
TEST RAX,RAX
JNZ 0x0013c589
MOV EDI,0x10
CALL 0x00118360
MOV R15,RAX
LAB_0013c55d:
LEA RSI,[0x1bb4cb]
MOV RDI,RAX
CALL 0x00118270
LAB_0013c56c:
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R15
CALL 0x00118b30
LAB_0013c584:
XOR EAX,EAX
XOR R14D,R14D
LAB_0013c589:
MOVAPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RBX + 0x18],R14
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_0013c5a5:
MOV EDI,0x10
CALL 0x00118360
MOV R14,RAX
LAB_0013c5b2:
LEA RSI,[0x1bb4a6]
MOV RDI,RAX
CALL 0x00118270
LAB_0013c5c1:
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R14
CALL 0x00118b30
LAB_0013c5d7:
LEA RDI,[0x1f0f50]
CALL 0x00118be0
TEST EAX,EAX
JZ 0x0013c4f2
LAB_0013c5eb:
LEA RDI,[0x1f0f30]
LEA RSI,[0x1bb4c4]
MOV EDX,0x10
CALL 0x0012f87e
LAB_0013c603:
LEA RDI,[0x12f8e6]
LEA RSI,[0x1f0f30]
LEA RDX,[0x1f0698]
CALL 0x001185d0
LEA RDI,[0x1f0f50]
CALL 0x00118450
JMP 0x0013c4f2
|
/* minja::Parser::parseIfExpression() */
void minja::Parser::parseIfExpression(void)
{
long lVar1;
int iVar2;
runtime_error *prVar3;
long *in_RDI;
long local_48;
long lStack_40;
long *local_38;
long local_30;
long local_28 [2];
parseLogicalOr();
if (local_48 == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c5b2 to 0013c5c0 has its CatchHandler @ 0013c660 */
std::runtime_error::runtime_error(prVar3,"Expected condition expression");
/* try { // try from 0013c5c1 to 0013c5d6 has its CatchHandler @ 0013c65e */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (parseIfExpression()::else_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseIfExpression()::else_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 0013c5eb to 0013c602 has its CatchHandler @ 0013c62e */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIfExpression()::else_tok_abi_cxx11_,"else\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIfExpression()::else_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIfExpression()::else_tok_abi_cxx11_);
}
}
/* try { // try from 0013c4f2 to 0013c50a has its CatchHandler @ 0013c66f */
consumeToken(&local_38);
lVar1 = local_30;
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
if (lVar1 == 0) {
local_38 = (long *)0x0;
local_30 = 0;
}
else {
/* try { // try from 0013c52f to 0013c540 has its CatchHandler @ 0013c66d */
parseExpression(SUB81(&local_38,0));
if (local_38 == (long *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c55d to 0013c56b has its CatchHandler @ 0013c644 */
std::runtime_error::runtime_error(prVar3,"Expected \'else\' expression");
/* try { // try from 0013c56c to 0013c581 has its CatchHandler @ 0013c63f */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
}
*in_RDI = local_48;
in_RDI[1] = lStack_40;
in_RDI[2] = (long)local_38;
in_RDI[3] = local_30;
return;
}
|
|
9,551 |
my_coll_rules_realloc
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_rules_realloc(MY_COLL_RULES *rules, size_t n)
{
if (rules->nrules < rules->mrules ||
(rules->rule= rules->loader->realloc(rules->rule,
sizeof(MY_COLL_RULE) *
(rules->mrules= n + 128))))
return 0;
return -1;
}
|
O0
|
c
|
my_coll_rules_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x604f3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
movq -0x10(%rbp), %rdx
movq %rcx, 0x18(%rdx)
imulq $0xa0, %rcx, %rsi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
je 0x604fc
movl $0x0, -0x4(%rbp)
jmp 0x60503
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_coll_rules_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jb short loc_604F3
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rax, [rax+90h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+20h]
mov rcx, [rbp+var_18]
add rcx, 80h
mov rdx, [rbp+var_10]
mov [rdx+18h], rcx
imul rsi, rcx, 0A0h
call rax
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jz short loc_604FC
loc_604F3:
mov [rbp+var_4], 0
jmp short loc_60503
loc_604FC:
mov [rbp+var_4], 0FFFFFFFFh
loc_60503:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_coll_rules_realloc(_QWORD *a1, long long a2)
{
long long ( *v2)(long long, long long); // rax
long long v3; // rdi
long long v4; // rax
if ( a1[2] < a1[3] )
return 0;
v2 = *(long long ( **)(long long, long long))(a1[5] + 144LL);
v3 = a1[4];
a1[3] = a2 + 128;
v4 = v2(v3, 160 * (a2 + 128));
if ( (a1[4] = v4) != 0LL )
return 0;
else
return (unsigned int)-1;
}
|
my_coll_rules_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JC 0x001604f3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x80
MOV RDX,qword ptr [RBP + -0x10]
MOV qword ptr [RDX + 0x18],RCX
IMUL RSI,RCX,0xa0
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JZ 0x001604fc
LAB_001604f3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00160503
LAB_001604fc:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_00160503:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_rules_realloc(long param_1,long param_2)
{
code *pcVar1;
long lVar2;
if (*(ulong *)(param_1 + 0x18) <= *(ulong *)(param_1 + 0x10)) {
pcVar1 = *(code **)(*(long *)(param_1 + 0x28) + 0x90);
*(long *)(param_1 + 0x18) = param_2 + 0x80;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x20),(param_2 + 0x80) * 0xa0);
*(long *)(param_1 + 0x20) = lVar2;
if (lVar2 == 0) {
return 0xffffffff;
}
}
return 0;
}
|
|
9,552 |
json_as_bytes
|
corpus-core[P]colibri-stateless/src/util/json.c
|
bytes_t json_as_bytes(json_t val, buffer_t* buffer) {
if (val.type == JSON_TYPE_NUMBER) {
buffer->data.len = 8;
buffer_grow(buffer, 8);
uint64_to_be(buffer->data.data, json_as_uint64(val));
return buffer->data;
}
if (val.type != JSON_TYPE_STRING) return NULL_BYTES;
buffer_grow(buffer, val.len / 2);
buffer->data.len = val.len;
int len = hex_to_bytes(val.start + 1, val.len - 2, buffer->data);
if (len == -1) return NULL_BYTES;
buffer->data.len = (uint32_t) len;
return buffer->data;
}
|
O1
|
c
|
json_as_bytes:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movl 0x10(%r15), %eax
cmpl $0x1, %eax
je 0x5bf90
cmpl $0x2, %eax
jne 0x5bfcf
movl $0x8, (%rbx)
movl $0x8, %esi
movq %rbx, %rdi
callq 0x56fb5
leaq 0x8(%rbx), %r12
movq 0x8(%rbx), %r14
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x5be64
movq %r14, %rdi
movq %rax, %rsi
callq 0x56fa7
movl (%rbx), %eax
jmp 0x5bfc9
movq 0x8(%r15), %r14
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x56fb5
movl %r14d, (%rbx)
movq (%r15), %rdi
incq %rdi
leal -0x2(%r14), %esi
movq 0x8(%rbx), %rcx
movl %r14d, %edx
callq 0x571d6
cmpl $-0x1, %eax
je 0x5bfcf
movl %eax, (%rbx)
addq $0x8, %rbx
movq %rbx, %r12
movq (%r12), %rdx
jmp 0x5bfd3
xorl %eax, %eax
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
json_as_bytes:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r15, [rsp+38h+arg_0]
mov eax, [r15+10h]
cmp eax, 1
jz short loc_5BF90
cmp eax, 2
jnz short loc_5BFCF
mov dword ptr [rbx], 8
mov esi, 8
mov rdi, rbx
call buffer_grow
lea r12, [rbx+8]
mov r14, [rbx+8]
mov rax, [r15+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+38h+var_38], xmm0
call json_as_uint64
mov rdi, r14
mov rsi, rax
call uint64_to_be
mov eax, [rbx]
jmp short loc_5BFC9
loc_5BF90:
mov r14, [r15+8]
mov rsi, r14
shr rsi, 1
mov rdi, rbx
call buffer_grow
mov [rbx], r14d
mov rdi, [r15]
inc rdi
lea esi, [r14-2]
mov rcx, [rbx+8]
mov edx, r14d
call hex_to_bytes
cmp eax, 0FFFFFFFFh
jz short loc_5BFCF
mov [rbx], eax
add rbx, 8
mov r12, rbx
loc_5BFC9:
mov rdx, [r12]
jmp short loc_5BFD3
loc_5BFCF:
xor eax, eax
xor edx, edx
loc_5BFD3:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long json_as_bytes(
char **a1,
_DWORD a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
unsigned long long a8,
long long a9)
{
char *v9; // r14
int v10; // edx
int v11; // ecx
long long v12; // r8
long long v13; // r9
unsigned long long v14; // rax
long long result; // rax
if ( (_DWORD)a9 != 1 )
{
if ( (_DWORD)a9 == 2 )
{
*(_DWORD *)a1 = 8;
buffer_grow((long long)a1, 8uLL);
v9 = a1[1];
v14 = json_as_uint64((_DWORD)a1, 8, v10, v11, v12, v13, a7, a8, a9);
uint64_to_be(v9, v14);
return *(unsigned int *)a1;
}
return 0LL;
}
buffer_grow((long long)a1, a8 >> 1);
*(_DWORD *)a1 = a8;
result = hex_to_bytes((_BYTE *)(a7 + 1), (char *)(unsigned int)(a8 - 2), a8, a1[1]);
if ( (_DWORD)result == -1 )
return 0LL;
*(_DWORD *)a1 = result;
return result;
}
|
json_as_bytes:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R15,[RSP + 0x40]
MOV EAX,dword ptr [R15 + 0x10]
CMP EAX,0x1
JZ 0x0015bf90
CMP EAX,0x2
JNZ 0x0015bfcf
MOV dword ptr [RBX],0x8
MOV ESI,0x8
MOV RDI,RBX
CALL 0x00156fb5
LEA R12,[RBX + 0x8]
MOV R14,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0015be64
MOV RDI,R14
MOV RSI,RAX
CALL 0x00156fa7
MOV EAX,dword ptr [RBX]
JMP 0x0015bfc9
LAB_0015bf90:
MOV R14,qword ptr [R15 + 0x8]
MOV RSI,R14
SHR RSI,0x1
MOV RDI,RBX
CALL 0x00156fb5
MOV dword ptr [RBX],R14D
MOV RDI,qword ptr [R15]
INC RDI
LEA ESI,[R14 + -0x2]
MOV RCX,qword ptr [RBX + 0x8]
MOV EDX,R14D
CALL 0x001571d6
CMP EAX,-0x1
JZ 0x0015bfcf
MOV dword ptr [RBX],EAX
ADD RBX,0x8
MOV R12,RBX
LAB_0015bfc9:
MOV RDX,qword ptr [R12]
JMP 0x0015bfd3
LAB_0015bfcf:
XOR EAX,EAX
XOR EDX,EDX
LAB_0015bfd3:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] json_as_bytes(uint *param_1)
{
int8 uVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [16];
long in_stack_00000008;
uint uStack0000000000000010;
int in_stack_00000018;
if (in_stack_00000018 == 1) {
buffer_grow(param_1,_uStack0000000000000010 >> 1);
*param_1 = uStack0000000000000010;
uVar2 = hex_to_bytes(in_stack_00000008 + 1,uStack0000000000000010 - 2,uStack0000000000000010,
*(int8 *)(param_1 + 2));
if ((uint)uVar2 == 0xffffffff) goto LAB_0015bfcf;
*param_1 = (uint)uVar2;
}
else {
if (in_stack_00000018 != 2) {
LAB_0015bfcf:
uVar2 = 0;
uVar3 = 0;
goto LAB_0015bfd3;
}
*param_1 = 8;
buffer_grow(param_1,8);
uVar3 = *(int8 *)(param_1 + 2);
uVar1 = json_as_uint64();
uint64_to_be(uVar3,uVar1);
uVar2 = (ulong)*param_1;
}
uVar3 = *(int8 *)(param_1 + 2);
LAB_0015bfd3:
auVar4._8_8_ = uVar3;
auVar4._0_8_ = uVar2;
return auVar4;
}
|
|
9,553 |
json_as_bytes
|
corpus-core[P]colibri-stateless/src/util/json.c
|
bytes_t json_as_bytes(json_t val, buffer_t* buffer) {
if (val.type == JSON_TYPE_NUMBER) {
buffer->data.len = 8;
buffer_grow(buffer, 8);
uint64_to_be(buffer->data.data, json_as_uint64(val));
return buffer->data;
}
if (val.type != JSON_TYPE_STRING) return NULL_BYTES;
buffer_grow(buffer, val.len / 2);
buffer->data.len = val.len;
int len = hex_to_bytes(val.start + 1, val.len - 2, buffer->data);
if (len == -1) return NULL_BYTES;
buffer->data.len = (uint32_t) len;
return buffer->data;
}
|
O2
|
c
|
json_as_bytes:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movl 0x10(%r15), %eax
cmpl $0x1, %eax
je 0x4f903
cmpl $0x2, %eax
jne 0x4f942
movl $0x8, (%rbx)
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x4b01d
leaq 0x8(%rbx), %r12
movq 0x8(%rbx), %r14
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4f7df
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b00f
movl (%rbx), %eax
jmp 0x4f93c
movq 0x8(%r15), %r14
movq %r14, %rsi
shrq %rsi
movq %rbx, %rdi
callq 0x4b01d
movl %r14d, (%rbx)
movq (%r15), %rdi
incq %rdi
leal -0x2(%r14), %esi
movq 0x8(%rbx), %rcx
movl %r14d, %edx
callq 0x4b22a
cmpl $-0x1, %eax
je 0x4f942
movl %eax, (%rbx)
addq $0x8, %rbx
movq %rbx, %r12
movq (%r12), %rdx
jmp 0x4f946
xorl %eax, %eax
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
json_as_bytes:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea r15, [rsp+38h+arg_0]
mov eax, [r15+10h]
cmp eax, 1
jz short loc_4F903
cmp eax, 2
jnz short loc_4F942
mov dword ptr [rbx], 8
push 8
pop rsi
mov rdi, rbx
call buffer_grow
lea r12, [rbx+8]
mov r14, [rbx+8]
mov rax, [r15+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+38h+var_38], xmm0
call json_as_uint64
mov rdi, r14
mov rsi, rax
call uint64_to_be
mov eax, [rbx]
jmp short loc_4F93C
loc_4F903:
mov r14, [r15+8]
mov rsi, r14
shr rsi, 1
mov rdi, rbx
call buffer_grow
mov [rbx], r14d
mov rdi, [r15]
inc rdi
lea esi, [r14-2]
mov rcx, [rbx+8]
mov edx, r14d
call hex_to_bytes
cmp eax, 0FFFFFFFFh
jz short loc_4F942
mov [rbx], eax
add rbx, 8
mov r12, rbx
loc_4F93C:
mov rdx, [r12]
jmp short loc_4F946
loc_4F942:
xor eax, eax
xor edx, edx
loc_4F946:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long json_as_bytes(
_QWORD *a1,
_DWORD a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
unsigned long long a8,
long long a9)
{
_QWORD *v9; // r14
long long v10; // rdx
int v11; // ecx
long long v12; // r8
long long v13; // r9
unsigned long long v14; // rax
long long result; // rax
if ( (_DWORD)a9 != 1 )
{
if ( (_DWORD)a9 == 2 )
{
*(_DWORD *)a1 = 8;
buffer_grow((long long)a1, 8uLL);
v9 = (_QWORD *)a1[1];
v14 = json_as_uint64((_DWORD)a1, 8, v10, v11, v12, v13, a7, a8, a9);
uint64_to_be(v9, v14);
return *(unsigned int *)a1;
}
return 0LL;
}
buffer_grow((long long)a1, a8 >> 1);
*(_DWORD *)a1 = a8;
result = hex_to_bytes((_BYTE *)(a7 + 1), (int)a8 - 2, a8, (_BYTE *)a1[1]);
if ( (_DWORD)result == -1 )
return 0LL;
*(_DWORD *)a1 = result;
return result;
}
|
json_as_bytes:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R15,[RSP + 0x40]
MOV EAX,dword ptr [R15 + 0x10]
CMP EAX,0x1
JZ 0x0014f903
CMP EAX,0x2
JNZ 0x0014f942
MOV dword ptr [RBX],0x8
PUSH 0x8
POP RSI
MOV RDI,RBX
CALL 0x0014b01d
LEA R12,[RBX + 0x8]
MOV R14,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x0014f7df
MOV RDI,R14
MOV RSI,RAX
CALL 0x0014b00f
MOV EAX,dword ptr [RBX]
JMP 0x0014f93c
LAB_0014f903:
MOV R14,qword ptr [R15 + 0x8]
MOV RSI,R14
SHR RSI,0x1
MOV RDI,RBX
CALL 0x0014b01d
MOV dword ptr [RBX],R14D
MOV RDI,qword ptr [R15]
INC RDI
LEA ESI,[R14 + -0x2]
MOV RCX,qword ptr [RBX + 0x8]
MOV EDX,R14D
CALL 0x0014b22a
CMP EAX,-0x1
JZ 0x0014f942
MOV dword ptr [RBX],EAX
ADD RBX,0x8
MOV R12,RBX
LAB_0014f93c:
MOV RDX,qword ptr [R12]
JMP 0x0014f946
LAB_0014f942:
XOR EAX,EAX
XOR EDX,EDX
LAB_0014f946:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] json_as_bytes(uint *param_1)
{
int8 uVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [16];
long in_stack_00000008;
uint uStack0000000000000010;
int in_stack_00000018;
if (in_stack_00000018 == 1) {
buffer_grow(param_1,_uStack0000000000000010 >> 1);
*param_1 = uStack0000000000000010;
uVar2 = hex_to_bytes(in_stack_00000008 + 1,uStack0000000000000010 - 2,uStack0000000000000010,
*(int8 *)(param_1 + 2));
if ((uint)uVar2 == 0xffffffff) goto LAB_0014f942;
*param_1 = (uint)uVar2;
}
else {
if (in_stack_00000018 != 2) {
LAB_0014f942:
uVar2 = 0;
uVar3 = 0;
goto LAB_0014f946;
}
*param_1 = 8;
buffer_grow(param_1,8);
uVar3 = *(int8 *)(param_1 + 2);
uVar1 = json_as_uint64();
uint64_to_be(uVar3,uVar1);
uVar2 = (ulong)*param_1;
}
uVar3 = *(int8 *)(param_1 + 2);
LAB_0014f946:
auVar4._8_8_ = uVar3;
auVar4._0_8_ = uVar2;
return auVar4;
}
|
|
9,554 |
tailoring_append_abbreviation
|
eloqsql/strings/ctype.c
|
static int
tailoring_append_abbreviation(MY_XML_PARSER *st,
const char *fmt, size_t len, const char *attr)
{
size_t clen;
const char *attrend= attr + len;
my_wc_t wc;
for ( ; (clen= scan_one_character(attr, attrend, &wc)) > 0; attr+= clen)
{
DBUG_ASSERT(attr < attrend);
if (tailoring_append(st, fmt, clen, attr) != MY_XML_OK)
return MY_XML_ERROR;
}
return MY_XML_OK;
}
|
O0
|
c
|
tailoring_append_abbreviation:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xbdca0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0xbdc86
jmp 0xbdc51
jmp 0xbdc53
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd740
cmpl $0x0, %eax
je 0xbdc76
movl $0x1, -0x4(%rbp)
jmp 0xbdc8d
jmp 0xbdc78
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xbdc34
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
tailoring_append_abbreviation:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
add rax, [rbp+var_20]
mov [rbp+var_38], rax
loc_BDC34:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_38]
lea rdx, [rbp+var_40]
call scan_one_character
mov [rbp+var_30], rax
cmp rax, 0
jbe short loc_BDC86
jmp short $+2
loc_BDC51:
jmp short $+2
loc_BDC53:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
call tailoring_append
cmp eax, 0
jz short loc_BDC76
mov [rbp+var_4], 1
jmp short loc_BDC8D
loc_BDC76:
jmp short $+2
loc_BDC78:
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
jmp short loc_BDC34
loc_BDC86:
mov [rbp+var_4], 0
loc_BDC8D:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long tailoring_append_abbreviation(long long a1, const char *a2, long long a3, long long a4)
{
_BYTE v5[8]; // [rsp+0h] [rbp-40h] BYREF
long long v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+10h] [rbp-30h]
long long v8; // [rsp+18h] [rbp-28h]
long long v9; // [rsp+20h] [rbp-20h]
const char *v10; // [rsp+28h] [rbp-18h]
long long v11; // [rsp+30h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = a3 + a4;
while ( 1 )
{
v7 = scan_one_character(v8, v6, v5);
if ( !v7 )
break;
if ( (unsigned int)tailoring_append(v11, v10, v7, v8) )
return 1;
v8 += v7;
}
return 0;
}
|
tailoring_append_abbreviation:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
LAB_001bdc34:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
LEA RDX,[RBP + -0x40]
CALL 0x001bdca0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JBE 0x001bdc86
JMP 0x001bdc51
LAB_001bdc51:
JMP 0x001bdc53
LAB_001bdc53:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x001bd740
CMP EAX,0x0
JZ 0x001bdc76
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001bdc8d
LAB_001bdc76:
JMP 0x001bdc78
LAB_001bdc78:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001bdc34
LAB_001bdc86:
MOV dword ptr [RBP + -0x4],0x0
LAB_001bdc8d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
tailoring_append_abbreviation(int8 param_1,int8 param_2,long param_3,long param_4)
{
int iVar1;
int1 local_48 [8];
long local_40;
long local_38;
long local_30;
long local_28;
int8 local_20;
int8 local_18;
local_40 = param_4 + param_3;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
while( true ) {
local_38 = scan_one_character(local_30,local_40,local_48);
if (local_38 == 0) {
return 0;
}
iVar1 = tailoring_append(local_18,local_20,local_38,local_30);
if (iVar1 != 0) break;
local_30 = local_38 + local_30;
}
return 1;
}
|
|
9,555 |
add_global_var
|
bluesky950520[P]quickjs/quickjs.c
|
static JSGlobalVar *add_global_var(JSContext *ctx, JSFunctionDef *s,
JSAtom name)
{
JSGlobalVar *hf;
if (js_resize_array(ctx, (void **)&s->global_vars,
sizeof(s->global_vars[0]),
&s->global_var_size, s->global_var_count + 1))
return NULL;
hf = &s->global_vars[s->global_var_count++];
hf->cpool_idx = -1;
hf->force_init = FALSE;
hf->is_lexical = FALSE;
hf->is_const = FALSE;
hf->scope_level = s->scope_level;
hf->var_name = JS_DupAtom(ctx, name);
return hf;
}
|
O1
|
c
|
add_global_var:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x124(%rsi), %r8d
cmpl %r8d, 0x128(%rsi)
jle 0x65231
movq 0x130(%r15), %rcx
movslq 0x124(%r15), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x124(%r15)
shlq $0x4, %rdx
movl $0xffffffff, (%rcx,%rdx) # imm = 0xFFFFFFFF
andb $-0x8, 0x4(%rcx,%rdx)
leaq (%rcx,%rdx), %rax
movl 0xe8(%r15), %esi
movl %esi, 0x8(%rcx,%rdx)
cmpl $0xe0, %ebx
jl 0x65228
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x130(%r15), %rsi
leaq 0x128(%r15), %rcx
incl %r8d
movq %r14, %rdi
movl $0x10, %edx
callq 0x434ef
testl %eax, %eax
je 0x651d9
xorl %eax, %eax
jmp 0x6522b
|
add_global_var:
push r15
push r14
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov r8d, [rsi+124h]
cmp [rsi+128h], r8d
jle short loc_65231
loc_651D9:
mov rcx, [r15+130h]
movsxd rdx, dword ptr [r15+124h]
lea eax, [rdx+1]
mov [r15+124h], eax
shl rdx, 4
mov dword ptr [rcx+rdx], 0FFFFFFFFh
and byte ptr [rcx+rdx+4], 0F8h
lea rax, [rcx+rdx]
mov esi, [r15+0E8h]
mov [rcx+rdx+8], esi
cmp ebx, 0E0h
jl short loc_65228
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_65228:
mov [rax+0Ch], ebx
loc_6522B:
pop rbx
pop r14
pop r15
retn
loc_65231:
lea rsi, [r15+130h]
lea rcx, [r15+128h]
inc r8d
mov rdi, r14
mov edx, 10h
call js_realloc_array
test eax, eax
jz short loc_651D9
xor eax, eax
jmp short loc_6522B
|
long long add_global_var(long long a1, long long a2, int a3)
{
int v4; // r8d
long long v5; // rcx
long long v6; // rdx
long long result; // rax
_DWORD *v8; // rcx
v4 = *(_DWORD *)(a2 + 292);
if ( *(_DWORD *)(a2 + 296) <= v4
&& (unsigned int)js_realloc_array(a1, (long long *)(a2 + 304), 0x10u, (_DWORD *)(a2 + 296), v4 + 1) )
{
return 0LL;
}
v5 = *(_QWORD *)(a2 + 304);
v6 = *(int *)(a2 + 292);
*(_DWORD *)(a2 + 292) = v6 + 1;
v6 *= 16LL;
*(_DWORD *)(v5 + v6) = -1;
*(_BYTE *)(v5 + v6 + 4) &= 0xF8u;
result = v5 + v6;
*(_DWORD *)(v5 + v6 + 8) = *(_DWORD *)(a2 + 232);
if ( a3 >= 224 )
{
v8 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v8;
}
*(_DWORD *)(result + 12) = a3;
return result;
}
|
add_global_var:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV R8D,dword ptr [RSI + 0x124]
CMP dword ptr [RSI + 0x128],R8D
JLE 0x00165231
LAB_001651d9:
MOV RCX,qword ptr [R15 + 0x130]
MOVSXD RDX,dword ptr [R15 + 0x124]
LEA EAX,[RDX + 0x1]
MOV dword ptr [R15 + 0x124],EAX
SHL RDX,0x4
MOV dword ptr [RCX + RDX*0x1],0xffffffff
AND byte ptr [RCX + RDX*0x1 + 0x4],0xf8
LEA RAX,[RCX + RDX*0x1]
MOV ESI,dword ptr [R15 + 0xe8]
MOV dword ptr [RCX + RDX*0x1 + 0x8],ESI
CMP EBX,0xe0
JL 0x00165228
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00165228:
MOV dword ptr [RAX + 0xc],EBX
LAB_0016522b:
POP RBX
POP R14
POP R15
RET
LAB_00165231:
LEA RSI,[R15 + 0x130]
LEA RCX,[R15 + 0x128]
INC R8D
MOV RDI,R14
MOV EDX,0x10
CALL 0x001434ef
TEST EAX,EAX
JZ 0x001651d9
XOR EAX,EAX
JMP 0x0016522b
|
long add_global_var(long param_1,long param_2,uint param_3)
{
byte *pbVar1;
long lVar2;
int *piVar3;
int iVar4;
long lVar5;
if ((*(int *)(param_2 + 0x128) <= *(int *)(param_2 + 0x124)) &&
(iVar4 = js_realloc_array(param_1,param_2 + 0x130,0x10,param_2 + 0x128,
*(int *)(param_2 + 0x124) + 1), iVar4 != 0)) {
return 0;
}
lVar2 = *(long *)(param_2 + 0x130);
iVar4 = *(int *)(param_2 + 0x124);
*(int *)(param_2 + 0x124) = iVar4 + 1;
lVar5 = (long)iVar4 * 0x10;
*(int4 *)(lVar2 + lVar5) = 0xffffffff;
pbVar1 = (byte *)(lVar2 + 4 + lVar5);
*pbVar1 = *pbVar1 & 0xf8;
*(int4 *)(lVar2 + 8 + lVar5) = *(int4 *)(param_2 + 0xe8);
if (0xdf < (int)param_3) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar2 + lVar5 + 0xc) = param_3;
return lVar2 + lVar5;
}
|
|
9,556 |
add_global_var
|
bluesky950520[P]quickjs/quickjs.c
|
static JSGlobalVar *add_global_var(JSContext *ctx, JSFunctionDef *s,
JSAtom name)
{
JSGlobalVar *hf;
if (js_resize_array(ctx, (void **)&s->global_vars,
sizeof(s->global_vars[0]),
&s->global_var_size, s->global_var_count + 1))
return NULL;
hf = &s->global_vars[s->global_var_count++];
hf->cpool_idx = -1;
hf->force_init = FALSE;
hf->is_lexical = FALSE;
hf->is_const = FALSE;
hf->scope_level = s->scope_level;
hf->var_name = JS_DupAtom(ctx, name);
return hf;
}
|
O2
|
c
|
add_global_var:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
addq $0x130, %rsi # imm = 0x130
leaq 0x128(%r15), %rcx
movl 0x124(%r15), %r8d
incl %r8d
pushq $0x10
popq %rdx
callq 0x3b0ef
testl %eax, %eax
je 0x56427
xorl %eax, %eax
jmp 0x56476
movq 0x130(%r15), %rcx
movslq 0x124(%r15), %rdx
leal 0x1(%rdx), %eax
movl %eax, 0x124(%r15)
shlq $0x4, %rdx
orl $-0x1, (%rcx,%rdx)
andb $-0x8, 0x4(%rcx,%rdx)
leaq (%rcx,%rdx), %rax
movl 0xe8(%r15), %esi
movl %esi, 0x8(%rcx,%rdx)
cmpl $0xe0, %ebx
jl 0x56473
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %r15
retq
|
add_global_var:
push r15
push r14
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
add rsi, 130h
lea rcx, [r15+128h]
mov r8d, [r15+124h]
inc r8d
push 10h
pop rdx
call js_resize_array
test eax, eax
jz short loc_56427
xor eax, eax
jmp short loc_56476
loc_56427:
mov rcx, [r15+130h]
movsxd rdx, dword ptr [r15+124h]
lea eax, [rdx+1]
mov [r15+124h], eax
shl rdx, 4
or dword ptr [rcx+rdx], 0FFFFFFFFh
and byte ptr [rcx+rdx+4], 0F8h
lea rax, [rcx+rdx]
mov esi, [r15+0E8h]
mov [rcx+rdx+8], esi
cmp ebx, 0E0h
jl short loc_56473
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_56473:
mov [rax+0Ch], ebx
loc_56476:
pop rbx
pop r14
pop r15
retn
|
long long add_global_var(long long a1, long long a2, int a3)
{
long long result; // rax
long long v5; // rcx
long long v6; // rdx
_DWORD *v7; // rcx
if ( (unsigned int)js_resize_array(a1, a2 + 304, 16LL, (_DWORD *)(a2 + 296), *(_DWORD *)(a2 + 292) + 1) )
return 0LL;
v5 = *(_QWORD *)(a2 + 304);
v6 = *(int *)(a2 + 292);
*(_DWORD *)(a2 + 292) = v6 + 1;
v6 *= 16LL;
*(_DWORD *)(v5 + v6) = -1;
*(_BYTE *)(v5 + v6 + 4) &= 0xF8u;
result = v5 + v6;
*(_DWORD *)(v5 + v6 + 8) = *(_DWORD *)(a2 + 232);
if ( a3 >= 224 )
{
v7 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v7;
}
*(_DWORD *)(result + 12) = a3;
return result;
}
|
add_global_var:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
ADD RSI,0x130
LEA RCX,[R15 + 0x128]
MOV R8D,dword ptr [R15 + 0x124]
INC R8D
PUSH 0x10
POP RDX
CALL 0x0013b0ef
TEST EAX,EAX
JZ 0x00156427
XOR EAX,EAX
JMP 0x00156476
LAB_00156427:
MOV RCX,qword ptr [R15 + 0x130]
MOVSXD RDX,dword ptr [R15 + 0x124]
LEA EAX,[RDX + 0x1]
MOV dword ptr [R15 + 0x124],EAX
SHL RDX,0x4
OR dword ptr [RCX + RDX*0x1],0xffffffff
AND byte ptr [RCX + RDX*0x1 + 0x4],0xf8
LEA RAX,[RCX + RDX*0x1]
MOV ESI,dword ptr [R15 + 0xe8]
MOV dword ptr [RCX + RDX*0x1 + 0x8],ESI
CMP EBX,0xe0
JL 0x00156473
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_00156473:
MOV dword ptr [RAX + 0xc],EBX
LAB_00156476:
POP RBX
POP R14
POP R15
RET
|
long add_global_var(long param_1,long param_2,uint param_3)
{
byte *pbVar1;
long lVar2;
int *piVar3;
int iVar4;
long lVar5;
long lVar6;
iVar4 = js_resize_array(param_1,param_2 + 0x130,0x10,param_2 + 0x128,*(int *)(param_2 + 0x124) + 1
);
if (iVar4 == 0) {
lVar2 = *(long *)(param_2 + 0x130);
iVar4 = *(int *)(param_2 + 0x124);
*(int *)(param_2 + 0x124) = iVar4 + 1;
lVar6 = (long)iVar4 * 0x10;
*(int4 *)(lVar2 + lVar6) = 0xffffffff;
pbVar1 = (byte *)(lVar2 + 4 + lVar6);
*pbVar1 = *pbVar1 & 0xf8;
lVar5 = lVar2 + lVar6;
*(int4 *)(lVar2 + 8 + lVar6) = *(int4 *)(param_2 + 0xe8);
if (0xdf < (int)param_3) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + 0xc) = param_3;
}
else {
lVar5 = 0;
}
return lVar5;
}
|
|
9,557 |
maria_page_filler_set_normal
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_filler_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
#ifdef DBUG_ASSERT_EXISTS
pgcache_page_no_t page_no= args->pageno;
#endif
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_page_filler_set_normal");
DBUG_ASSERT(page_no != 0); /* Catches some simple bugs */
int4store_aligned(page + share->block_size - CRC_SIZE,
MARIA_NO_CRC_NORMAL_PAGE);
DBUG_RETURN(0);
}
|
O0
|
c
|
maria_page_filler_set_normal:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5ebb1
jmp 0x5ebb3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0x5ebd8
jmp 0x5ebda
xorl %eax, %eax
popq %rbp
retq
nop
|
maria_page_filler_set_normal:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_18], rax
jmp short $+2
loc_5EBB1:
jmp short $+2
loc_5EBB3:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_18]
mov ecx, [rcx+7BCh]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov dword ptr [rax], 0FFFFFFFFh
jmp short $+2
loc_5EBD8:
jmp short $+2
loc_5EBDA:
xor eax, eax
pop rbp
retn
|
long long maria_page_filler_set_normal(_QWORD *a1)
{
*(_DWORD *)(*(unsigned int *)(a1[2] + 1980LL) + *a1 - 4LL) = -1;
return 0LL;
}
|
maria_page_filler_set_normal:
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
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0015ebb1
LAB_0015ebb1:
JMP 0x0015ebb3
LAB_0015ebb3:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x7bc]
ADD RAX,RCX
ADD RAX,-0x4
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0xffffffff
JMP 0x0015ebd8
LAB_0015ebd8:
JMP 0x0015ebda
LAB_0015ebda:
XOR EAX,EAX
POP RBP
RET
|
int8 maria_page_filler_set_normal(long *param_1)
{
*(int4 *)(*param_1 + (ulong)*(uint *)(param_1[2] + 0x7bc) + -4) = 0xffffffff;
return 0;
}
|
|
9,558 |
maria_page_filler_set_normal
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_filler_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
#ifdef DBUG_ASSERT_EXISTS
pgcache_page_no_t page_no= args->pageno;
#endif
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
DBUG_ENTER("maria_page_filler_set_normal");
DBUG_ASSERT(page_no != 0); /* Catches some simple bugs */
int4store_aligned(page + share->block_size - CRC_SIZE,
MARIA_NO_CRC_NORMAL_PAGE);
DBUG_RETURN(0);
}
|
O3
|
c
|
maria_page_filler_set_normal:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movl 0x7bc(%rcx), %ecx
movl $0xffffffff, -0x4(%rax,%rcx) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbp
retq
|
maria_page_filler_set_normal:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rcx, [rdi+10h]
mov ecx, [rcx+7BCh]
mov dword ptr [rax+rcx-4], 0FFFFFFFFh
xor eax, eax
pop rbp
retn
|
long long maria_page_filler_set_normal(_QWORD *a1)
{
*(_DWORD *)(*a1 + *(unsigned int *)(a1[2] + 1980LL) - 4LL) = -1;
return 0LL;
}
|
maria_page_filler_set_normal:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x10]
MOV ECX,dword ptr [RCX + 0x7bc]
MOV dword ptr [RAX + RCX*0x1 + -0x4],0xffffffff
XOR EAX,EAX
POP RBP
RET
|
int8 maria_page_filler_set_normal(long *param_1)
{
*(int4 *)(*param_1 + -4 + (ulong)*(uint *)(param_1[2] + 0x7bc)) = 0xffffffff;
return 0;
}
|
|
9,559 |
pvio_socket_close
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
my_bool pvio_socket_close(MARIADB_PVIO *pvio)
{
struct st_pvio_socket *csock= NULL;
int r= 0;
if (!pvio)
return 1;
if (pvio->data)
{
csock= (struct st_pvio_socket *)pvio->data;
if (csock && csock->socket != INVALID_SOCKET)
{
r= closesocket(csock->socket);
csock->socket= INVALID_SOCKET;
}
free((gptr)pvio->data);
pvio->data= NULL;
}
return r;
}
|
O3
|
c
|
pvio_socket_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2f533
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x2f538
movl (%r15), %edi
cmpl $-0x1, %edi
je 0x2f53d
callq 0x13850
movl %eax, %r14d
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq (%rbx), %r15
jmp 0x2f540
movb $0x1, %r14b
jmp 0x2f54f
xorl %r14d, %r14d
jmp 0x2f54f
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x13570
movq $0x0, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
pvio_socket_close:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
test rdi, rdi
jz short loc_2F533
mov rbx, rdi
mov r15, [rdi]
test r15, r15
jz short loc_2F538
mov edi, [r15]
cmp edi, 0FFFFFFFFh
jz short loc_2F53D
call _close
mov r14d, eax
mov dword ptr [r15], 0FFFFFFFFh
mov r15, [rbx]
jmp short loc_2F540
loc_2F533:
mov r14b, 1
jmp short loc_2F54F
loc_2F538:
xor r14d, r14d
jmp short loc_2F54F
loc_2F53D:
xor r14d, r14d
loc_2F540:
mov rdi, r15
call _free
mov qword ptr [rbx], 0
loc_2F54F:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long pvio_socket_close(_DWORD **a1)
{
unsigned int v1; // r14d
_DWORD *v3; // r15
long long v4; // rdi
if ( a1 )
{
v3 = *a1;
if ( *a1 )
{
v4 = (unsigned int)*v3;
if ( (_DWORD)v4 == -1 )
{
v1 = 0;
}
else
{
v1 = close(v4);
*v3 = -1;
v3 = *a1;
}
free(v3);
*a1 = 0LL;
}
else
{
return 0;
}
}
else
{
LOBYTE(v1) = 1;
}
return v1;
}
|
pvio_socket_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x0012f533
MOV RBX,RDI
MOV R15,qword ptr [RDI]
TEST R15,R15
JZ 0x0012f538
MOV EDI,dword ptr [R15]
CMP EDI,-0x1
JZ 0x0012f53d
CALL 0x00113850
MOV R14D,EAX
MOV dword ptr [R15],0xffffffff
MOV R15,qword ptr [RBX]
JMP 0x0012f540
LAB_0012f533:
MOV R14B,0x1
JMP 0x0012f54f
LAB_0012f538:
XOR R14D,R14D
JMP 0x0012f54f
LAB_0012f53d:
XOR R14D,R14D
LAB_0012f540:
MOV RDI,R15
CALL 0x00113570
MOV qword ptr [RBX],0x0
LAB_0012f54f:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong pvio_socket_close(int8 *param_1)
{
uint uVar1;
int8 unaff_R14;
ulong uVar2;
int *__ptr;
if (param_1 == (int8 *)0x0) {
uVar2 = CONCAT71((int7)((ulong)unaff_R14 >> 8),1);
}
else {
__ptr = (int *)*param_1;
if (__ptr == (int *)0x0) {
uVar2 = 0;
}
else {
if (*__ptr == -1) {
uVar2 = 0;
}
else {
uVar1 = close(*__ptr);
uVar2 = (ulong)uVar1;
*__ptr = -1;
__ptr = (int *)*param_1;
}
free(__ptr);
*param_1 = 0;
}
}
return uVar2 & 0xffffffff;
}
|
|
9,560 |
TABLE_STATISTICS_CB::Statistics_state::start_load(THD*)
|
eloqsql/sql/table.cc
|
bool TABLE_STATISTICS_CB::Statistics_state::start_load(THD *thd)
{
for (;;)
{
int32 expected= EMPTY;
if (my_atomic_cas32_weak_explicit(&state, &expected, LOADING,
MY_MEMORY_ORDER_RELAXED,
MY_MEMORY_ORDER_RELAXED))
return true;
if (expected == READY)
return false;
#ifdef COROUTINE_ENABLED
if (thd != nullptr && thd->coro_status_ == THD::CoroStatus::Ongoing)
{
// The resume functor re-enqueues the SQL command, so that it will be
// picked up by a thread in the MySQL thread pool to re-enter the waiting
// loop. The yield functor yields busy waiting, so that the current
// thread gets a chance to execute the next SQL command in the queue.
thd->long_resume_func_();
std::atomic_thread_fence(std::memory_order_seq_cst);
thd->yield_func_();
}
else
{
(void) LF_BACKOFF();
}
#else
(void) LF_BACKOFF();
#endif
}
}
|
O0
|
cpp
|
TABLE_STATISTICS_CB::Statistics_state::start_load(THD*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %edx
lock
cmpxchgl %edx, (%rcx)
movl %eax, %ecx
sete %al
movb %al, -0x35(%rbp)
movl %ecx, -0x34(%rbp)
testb $0x1, %al
jne 0xafca19
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0xafca30
movb $0x1, -0x5(%rbp)
jmp 0xafcab0
cmpl $0x2, -0x1c(%rbp)
jne 0xafca3c
movb $0x0, -0x5(%rbp)
jmp 0xafcab0
cmpq $0x0, -0x18(%rbp)
je 0xafcaa6
movq -0x18(%rbp), %rax
cmpl $0x1, 0x6940(%rax)
jne 0xafcaa6
movq -0x18(%rbp), %rdi
addq $0x6920, %rdi # imm = 0x6920
callq 0x853540
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x4, %eax
ja 0xafca94
movq -0x40(%rbp), %rax
leaq 0x9b579a(%rip), %rcx # 0x14b221c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xafca94
jmp 0xafca94
jmp 0xafca94
mfence
movq -0x18(%rbp), %rdi
addq $0x68e0, %rdi # imm = 0x68E0
callq 0x853540
jmp 0xafcaab
callq 0xafcac0
jmp 0xafc9e8
movb -0x5(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN19TABLE_STATISTICS_CB16Statistics_state10start_loadEP3THD:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
loc_AFC9E8:
mov rcx, [rbp+var_30]
mov [rbp+var_1C], 0
mov [rbp+var_20], 1
mov eax, [rbp+var_1C]
mov edx, [rbp+var_20]
lock cmpxchg [rcx], edx
mov ecx, eax
setz al
mov [rbp+var_35], al
mov [rbp+var_34], ecx
test al, 1
jnz short loc_AFCA19
mov eax, [rbp+var_34]
mov [rbp+var_1C], eax
loc_AFCA19:
mov al, [rbp+var_35]
and al, 1
mov [rbp+var_21], al
test [rbp+var_21], 1
jz short loc_AFCA30
mov [rbp+var_5], 1
jmp loc_AFCAB0
loc_AFCA30:
cmp [rbp+var_1C], 2
jnz short loc_AFCA3C
mov [rbp+var_5], 0
jmp short loc_AFCAB0
loc_AFCA3C:
cmp [rbp+var_18], 0
jz short loc_AFCAA6
mov rax, [rbp+var_18]
cmp dword ptr [rax+6940h], 1
jnz short loc_AFCAA6
mov rdi, [rbp+var_18]
add rdi, 6920h
call _ZNKSt8functionIFvvEEclEv; std::function<void ()(void)>::operator()(void)
mov [rbp+var_4], 5
mov eax, [rbp+var_4]
dec eax; switch 5 cases
mov ecx, eax
mov [rbp+var_40], rcx
sub eax, 4
ja short def_AFCA89; jumptable 0000000000AFCA89 default case
mov rax, [rbp+var_40]
lea rcx, jpt_AFCA89
movsxd rax, ds:(jpt_AFCA89 - 14B221Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_AFCA8B:
jmp short def_AFCA89; jumptable 0000000000AFCA89 cases 1,2
loc_AFCA8D:
jmp short def_AFCA89; jumptable 0000000000AFCA89 case 3
loc_AFCA8F:
jmp short def_AFCA89; jumptable 0000000000AFCA89 case 4
loc_AFCA91:
mfence; jumptable 0000000000AFCA89 case 5
def_AFCA89:
mov rdi, [rbp+var_18]; jumptable 0000000000AFCA89 default case
add rdi, 68E0h
call _ZNKSt8functionIFvvEEclEv; std::function<void ()(void)>::operator()(void)
jmp short loc_AFCAAB
loc_AFCAA6:
call _ZL10LF_BACKOFFv_0; LF_BACKOFF(void)
loc_AFCAAB:
jmp loc_AFC9E8
loc_AFCAB0:
mov al, [rbp+var_5]
and al, 1
add rsp, 40h
pop rbp
retn
|
char TABLE_STATISTICS_CB::Statistics_state::start_load(
TABLE_STATISTICS_CB::Statistics_state *this,
long long (**a2)(void))
{
signed __int32 v2; // eax
while ( 1 )
{
v2 = _InterlockedCompareExchange((volatile signed __int32 *)this, 1, 0);
if ( !v2 )
return 1;
if ( v2 == 2 )
break;
if ( a2 && *((_DWORD *)a2 + 6736) == 1 )
{
std::function<void ()(void)>::operator()(a2 + 3364);
_mm_mfence();
std::function<void ()(void)>::operator()(a2 + 3356);
}
else
{
LF_BACKOFF();
}
}
return 0;
}
|
set_up_partition_func_pointers:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x009ce280
TEST AL,0x1
JNZ 0x00afc9ee
JMP 0x00afcbd8
LAB_00afc9ee:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb05fe0]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x1
JNZ 0x00afcaab
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JZ 0x00afca2c
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06080]
MOV qword ptr [RAX + 0x70],RCX
JMP 0x00afca3b
LAB_00afca2c:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb061b0]
MOV qword ptr [RAX + 0x70],RCX
LAB_00afca3b:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x237],0x1
JZ 0x00afca77
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afca66
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06310]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afca75
LAB_00afca66:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06360]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afca75:
JMP 0x00afcaa6
LAB_00afca77:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afca95
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063b0]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afcaa4
LAB_00afca95:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063f0]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcaa4:
JMP 0x00afcaa6
LAB_00afcaa6:
JMP 0x00afcbd3
LAB_00afcaab:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x4
JNZ 0x00afcb37
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06430]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x237],0x1
JZ 0x00afcb03
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afcaf2
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06310]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afcb01
LAB_00afcaf2:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06360]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcb01:
JMP 0x00afcb32
LAB_00afcb03:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afcb21
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063b0]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afcb30
LAB_00afcb21:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063f0]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcb30:
JMP 0x00afcb32
LAB_00afcb32:
JMP 0x00afcbd1
LAB_00afcb37:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JZ 0x00afcb55
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06580]
MOV qword ptr [RAX + 0x70],RCX
JMP 0x00afcb64
LAB_00afcb55:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb066a0]
MOV qword ptr [RAX + 0x70],RCX
LAB_00afcb64:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x237],0x1
JZ 0x00afcba0
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afcb8f
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06310]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afcb9e
LAB_00afcb8f:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06360]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcb9e:
JMP 0x00afcbcf
LAB_00afcba0:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afcbbe
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063b0]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x00afcbcd
LAB_00afcbbe:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb063f0]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcbcd:
JMP 0x00afcbcf
LAB_00afcbcf:
JMP 0x00afcbd1
LAB_00afcbd1:
JMP 0x00afcbd3
LAB_00afcbd3:
JMP 0x00afccff
LAB_00afcbd8:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x70],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x78],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x1
JNZ 0x00afcc2f
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JZ 0x00afcc1b
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06080]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00afcc2a
LAB_00afcc1b:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb061b0]
MOV qword ptr [RAX + 0x68],RCX
LAB_00afcc2a:
JMP 0x00afccfd
LAB_00afcc2f:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x3
JNZ 0x00afcc6e
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JZ 0x00afcc5a
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06580]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00afcc69
LAB_00afcc5a:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb066a0]
MOV qword ptr [RAX + 0x68],RCX
LAB_00afcc69:
JMP 0x00afccfb
LAB_00afcc6e:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x4
JNZ 0x00afcc8c
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06430]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00afccf9
LAB_00afcc8c:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x236],0x1
JZ 0x00afccc8
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afccb7
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06840]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00afccc6
LAB_00afccb7:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06890]
MOV qword ptr [RAX + 0x68],RCX
LAB_00afccc6:
JMP 0x00afccf7
LAB_00afccc8:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x238],0x1
JZ 0x00afcce6
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb068f0]
MOV qword ptr [RAX + 0x68],RCX
JMP 0x00afccf5
LAB_00afcce6:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06930]
MOV qword ptr [RAX + 0x68],RCX
LAB_00afccf5:
JMP 0x00afccf7
LAB_00afccf7:
JMP 0x00afccf9
LAB_00afccf9:
JMP 0x00afccfb
LAB_00afccfb:
JMP 0x00afccfd
LAB_00afccfd:
JMP 0x00afccff
LAB_00afccff:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0xa8],0x0
JZ 0x00afcd88
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x009ce280
TEST AL,0x1
JNZ 0x00afcd1c
JMP 0x00afcd51
LAB_00afcd1c:
JMP 0x00afcd1e
LAB_00afcd1e:
JMP 0x00afcd20
LAB_00afcd20:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JNZ 0x00afcd4f
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x70]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x80],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06970]
MOV qword ptr [RAX + 0x70],RCX
LAB_00afcd4f:
JMP 0x00afcd86
LAB_00afcd51:
JMP 0x00afcd53
LAB_00afcd53:
JMP 0x00afcd55
LAB_00afcd55:
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0x23c],0x1
JNZ 0x00afcd84
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x80],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06970]
MOV qword ptr [RAX + 0x70],RCX
LAB_00afcd84:
JMP 0x00afcd86
LAB_00afcd86:
JMP 0x00afcd88
LAB_00afcd88:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0xb0],0x0
JZ 0x00afcdbc
JMP 0x00afcd98
LAB_00afcd98:
JMP 0x00afcd9a
LAB_00afcd9a:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb069f0]
MOV qword ptr [RAX + 0x78],RCX
LAB_00afcdbc:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x1
JNZ 0x00afcddd
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06a70]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x00afce35
LAB_00afcddd:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x3
JNZ 0x00afcdfe
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb06dc0]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x00afce33
LAB_00afcdfe:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x1f8],0x4
JNZ 0x00afce1f
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb072b0]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x00afce31
LAB_00afce1f:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xb074d0]
MOV qword ptr [RAX + 0x90],RCX
LAB_00afce31:
JMP 0x00afce33
LAB_00afce33:
JMP 0x00afce35
LAB_00afce35:
JMP 0x00afce37
LAB_00afce37:
JMP 0x00afce39
LAB_00afce39:
ADD RSP,0x10
POP RBP
RET
|
/* set_up_partition_func_pointers(partition_info*) */
void set_up_partition_func_pointers(partition_info *param_1)
{
ulong uVar1;
uVar1 = partition_info::is_sub_partitioned(param_1);
if ((uVar1 & 1) == 0) {
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
if (*(int *)(param_1 + 0x1f8) == 1) {
if (((byte)param_1[0x23c] & 1) == 0) {
*(code **)(param_1 + 0x68) = get_partition_id_range;
}
else {
*(code **)(param_1 + 0x68) = get_partition_id_range_col;
}
}
else if (*(int *)(param_1 + 0x1f8) == 3) {
if (((byte)param_1[0x23c] & 1) == 0) {
*(code **)(param_1 + 0x68) = get_partition_id_list;
}
else {
*(code **)(param_1 + 0x68) = get_partition_id_list_col;
}
}
else if (*(int *)(param_1 + 0x1f8) == 4) {
*(code **)(param_1 + 0x68) = vers_get_partition_id;
}
else if (((byte)param_1[0x236] & 1) == 0) {
if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x68) = get_partition_id_hash_nosub;
}
else {
*(code **)(param_1 + 0x68) = get_partition_id_linear_hash_nosub;
}
}
else if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x68) = get_partition_id_key_nosub;
}
else {
*(code **)(param_1 + 0x68) = get_partition_id_linear_key_nosub;
}
}
else {
*(code **)(param_1 + 0x68) = get_partition_id_with_sub;
if (*(int *)(param_1 + 0x1f8) == 1) {
if (((byte)param_1[0x23c] & 1) == 0) {
*(code **)(param_1 + 0x70) = get_partition_id_range;
}
else {
*(code **)(param_1 + 0x70) = get_partition_id_range_col;
}
if (((byte)param_1[0x237] & 1) == 0) {
if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_hash_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_hash_sub;
}
}
else if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_key_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_key_sub;
}
}
else if (*(int *)(param_1 + 0x1f8) == 4) {
*(code **)(param_1 + 0x70) = vers_get_partition_id;
if (((byte)param_1[0x237] & 1) == 0) {
if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_hash_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_hash_sub;
}
}
else if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_key_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_key_sub;
}
}
else {
if (((byte)param_1[0x23c] & 1) == 0) {
*(code **)(param_1 + 0x70) = get_partition_id_list;
}
else {
*(code **)(param_1 + 0x70) = get_partition_id_list_col;
}
if (((byte)param_1[0x237] & 1) == 0) {
if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_hash_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_hash_sub;
}
}
else if (((byte)param_1[0x238] & 1) == 0) {
*(code **)(param_1 + 0x78) = get_partition_id_key_sub;
}
else {
*(code **)(param_1 + 0x78) = get_partition_id_linear_key_sub;
}
}
}
if (*(long *)(param_1 + 0xa8) != 0) {
uVar1 = partition_info::is_sub_partitioned(param_1);
if ((uVar1 & 1) == 0) {
if (((byte)param_1[0x23c] & 1) == 0) {
*(int8 *)(param_1 + 0x80) = *(int8 *)(param_1 + 0x68);
*(code **)(param_1 + 0x70) = get_part_id_charset_func_part;
}
}
else if (((byte)param_1[0x23c] & 1) == 0) {
*(int8 *)(param_1 + 0x80) = *(int8 *)(param_1 + 0x70);
*(code **)(param_1 + 0x70) = get_part_id_charset_func_part;
}
}
if (*(long *)(param_1 + 0xb0) != 0) {
*(int8 *)(param_1 + 0x88) = *(int8 *)(param_1 + 0x78);
*(code **)(param_1 + 0x78) = get_part_id_charset_func_subpart;
}
if (*(int *)(param_1 + 0x1f8) == 1) {
*(code **)(param_1 + 0x90) = check_range_constants;
}
else if (*(int *)(param_1 + 0x1f8) == 3) {
*(code **)(param_1 + 0x90) = check_list_constants;
}
else if (*(int *)(param_1 + 0x1f8) == 4) {
*(code **)(param_1 + 0x90) = check_vers_constants;
}
else {
*(code **)(param_1 + 0x90) = check_no_constants;
}
return;
}
|
|
9,561 |
vio_getnameinfo
|
eloqsql/vio/viosocket.c
|
int vio_getnameinfo(const struct sockaddr *sa,
char *hostname, size_t hostname_size,
char *port, size_t port_size,
int flags)
{
int sa_length= 0;
switch (sa->sa_family) {
case AF_INET:
sa_length= sizeof (struct sockaddr_in);
#ifdef HAVE_SOCKADDR_IN_SIN_LEN
((struct sockaddr_in *) sa)->sin_len= sa_length;
#endif /* HAVE_SOCKADDR_IN_SIN_LEN */
break;
#ifdef HAVE_IPV6
case AF_INET6:
sa_length= sizeof (struct sockaddr_in6);
# ifdef HAVE_SOCKADDR_IN6_SIN6_LEN
((struct sockaddr_in6 *) sa)->sin6_len= sa_length;
# endif /* HAVE_SOCKADDR_IN6_SIN6_LEN */
break;
#endif /* HAVE_IPV6 */
}
return getnameinfo(sa, sa_length,
hostname, (uint)hostname_size,
port, (uint)port_size,
flags);
}
|
O0
|
c
|
vio_getnameinfo:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0xdf76f2
jmp 0xdf76e8
movl -0x34(%rbp), %eax
subl $0xa, %eax
je 0xdf76fb
jmp 0xdf7702
movl $0x10, -0x30(%rbp)
jmp 0xdf7702
movl $0x1c, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movl %eax, %r9d
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
callq 0x759fd0
addq $0x40, %rsp
popq %rbp
retq
nop
|
vio_getnameinfo:
push rbp
mov rbp, rsp
sub rsp, 40h
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_2C], r9d
mov [rbp+var_30], 0
mov rax, [rbp+var_8]
movzx eax, word ptr [rax]
mov [rbp+var_34], eax
sub eax, 2
jz short loc_DF76F2
jmp short $+2
loc_DF76E8:
mov eax, [rbp+var_34]
sub eax, 0Ah
jz short loc_DF76FB
jmp short loc_DF7702
loc_DF76F2:
mov [rbp+var_30], 10h
jmp short loc_DF7702
loc_DF76FB:
mov [rbp+var_30], 1Ch
loc_DF7702:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_18]
mov ecx, eax
mov r8, [rbp+var_20]
mov rax, [rbp+var_28]
mov r9d, eax
mov eax, [rbp+var_2C]
mov [rsp+40h+var_40], eax
call _getnameinfo
add rsp, 40h
pop rbp
retn
|
long long vio_getnameinfo(
unsigned __int16 *a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
int a6)
{
int v7; // [rsp+Ch] [rbp-34h]
unsigned int v8; // [rsp+10h] [rbp-30h]
v8 = 0;
v7 = *a1;
if ( v7 == 2 )
{
v8 = 16;
}
else if ( v7 == 10 )
{
v8 = 28;
}
return getnameinfo(a1, v8, a2, a3, a4, a5, a6);
}
|
scan_table:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
CMP dword ptr [RAX + 0x1b0],0x0
JZ 0x00df76f5
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00956940
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00df770f
LAB_00df76f5:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,0x1
CALL 0x009af200
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x00df7727
LAB_00df770f:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00a6a820
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00df77eb
LAB_00df7727:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00dfd3b0
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RAX + 0xa38]
MOV RAX,qword ptr [RDI]
MOV ESI,0x3
CALL qword ptr [RAX + 0x2a0]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2a6],0x0
LAB_00df7760:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x50]
CALL 0x00d1eb90
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00df77a1
CMP dword ptr [RBP + -0x14],0x89
JNZ 0x00df7790
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00df77cf
LAB_00df7790:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00a6a820
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00df77cf
LAB_00df77a1:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x00df77c3
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xf0]
CMP RAX,0x0
JZ 0x00df77cd
LAB_00df77c3:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x40],0x0
JMP 0x00df77cf
LAB_00df77cd:
JMP 0x00df7760
LAB_00df77cf:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0095d770
CMP dword ptr [RBP + -0x14],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
LAB_00df77eb:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
/* subselect_uniquesubquery_engine::scan_table() */
bool __thiscall subselect_uniquesubquery_engine::scan_table(subselect_uniquesubquery_engine *this)
{
TABLE *pTVar1;
long *plVar2;
int iVar3;
long lVar4;
bool bVar5;
int local_1c;
pTVar1 = (TABLE *)**(int8 **)(this + 0x30);
if (((*(int *)(*(long *)(pTVar1 + 8) + 0x1b0) == 0) ||
(local_1c = handler::ha_index_end(*(handler **)(pTVar1 + 8)), local_1c == 0)) &&
(local_1c = handler::ha_rnd_init(SUB81(*(int8 *)(pTVar1 + 8),0)), local_1c == 0)) {
plVar2 = *(long **)(pTVar1 + 8);
lVar4 = subselect_engine::get_thd((subselect_engine *)this);
(**(code **)(*plVar2 + 0x2a0))(plVar2,3,*(int8 *)(lVar4 + 0xa38));
pTVar1[0x2a6] = (TABLE)0x0;
do {
iVar3 = handler::ha_rnd_next(*(handler **)(pTVar1 + 8),*(uchar **)(pTVar1 + 0x50));
if (iVar3 != 0) {
if (iVar3 == 0x89) {
local_1c = 0;
}
else {
local_1c = report_error(pTVar1,iVar3);
}
goto LAB_00df77cf;
}
} while ((*(long *)(this + 0x38) != 0) &&
(lVar4 = (**(code **)(**(long **)(this + 0x38) + 0xf0))(), lVar4 == 0));
this[0x40] = (subselect_uniquesubquery_engine)0x0;
local_1c = 0;
LAB_00df77cf:
handler::ha_rnd_end(*(handler **)(pTVar1 + 8));
bVar5 = local_1c != 0;
}
else {
report_error(pTVar1,local_1c);
bVar5 = true;
}
return bVar5;
}
|
|
9,562 |
FileExists
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
bool FileExists(const char *fileName)
{
bool result = false;
#if defined(_WIN32)
if (_access(fileName, 0) != -1) result = true;
#else
if (access(fileName, F_OK) != -1) result = true;
#endif
// NOTE: Alternatively, stat() can be used instead of access()
//#include <sys/stat.h>
//struct stat statbuf;
//if (stat(filename, &statbuf) == 0) result = true;
return result;
}
|
O0
|
c
|
FileExists:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xa980
cmpl $-0x1, %eax
je 0xd1094
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
|
FileExists:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rdi, [rbp+var_8]
xor esi, esi
call _access
cmp eax, 0FFFFFFFFh
jz short loc_D1094
mov [rbp+var_9], 1
loc_D1094:
mov al, [rbp+var_9]
and al, 1
add rsp, 10h
pop rbp
retn
|
bool FileExists(long long a1)
{
return (unsigned int)access(a1, 0LL) != -1;
}
|
FileExists:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x0010a980
CMP EAX,-0x1
JZ 0x001d1094
MOV byte ptr [RBP + -0x9],0x1
LAB_001d1094:
MOV AL,byte ptr [RBP + -0x9]
AND AL,0x1
ADD RSP,0x10
POP RBP
RET
|
bool FileExists(char *param_1)
{
int iVar1;
iVar1 = access(param_1,0);
return iVar1 != -1;
}
|
|
9,563 |
FileExists
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
bool FileExists(const char *fileName)
{
bool result = false;
#if defined(_WIN32)
if (_access(fileName, 0) != -1) result = true;
#else
if (access(fileName, F_OK) != -1) result = true;
#endif
// NOTE: Alternatively, stat() can be used instead of access()
//#include <sys/stat.h>
//struct stat statbuf;
//if (stat(filename, &statbuf) == 0) result = true;
return result;
}
|
O1
|
c
|
FileExists:
pushq %rax
xorl %esi, %esi
callq 0x9960
cmpl $-0x1, %eax
setne %al
popq %rcx
retq
|
FileExists:
push rax
xor esi, esi
call _access
cmp eax, 0FFFFFFFFh
setnz al
pop rcx
retn
|
bool FileExists(long long a1)
{
return (unsigned int)access(a1, 0LL) != -1;
}
|
FileExists:
PUSH RAX
XOR ESI,ESI
CALL 0x00109960
CMP EAX,-0x1
SETNZ AL
POP RCX
RET
|
bool FileExists(char *param_1)
{
int iVar1;
iVar1 = access(param_1,0);
return iVar1 != -1;
}
|
|
9,564 |
FileExists
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c
|
bool FileExists(const char *fileName)
{
bool result = false;
#if defined(_WIN32)
if (_access(fileName, 0) != -1) result = true;
#else
if (access(fileName, F_OK) != -1) result = true;
#endif
// NOTE: Alternatively, stat() can be used instead of access()
//#include <sys/stat.h>
//struct stat statbuf;
//if (stat(filename, &statbuf) == 0) result = true;
return result;
}
|
O2
|
c
|
FileExists:
pushq %rax
xorl %esi, %esi
callq 0x9950
cmpl $-0x1, %eax
setne %al
popq %rcx
retq
|
FileExists:
push rax
xor esi, esi
call _access
cmp eax, 0FFFFFFFFh
setnz al
pop rcx
retn
|
bool FileExists(long long a1)
{
return (unsigned int)access(a1, 0LL) != -1;
}
|
FileExists:
PUSH RAX
XOR ESI,ESI
CALL 0x00109950
CMP EAX,-0x1
SETNZ AL
POP RCX
RET
|
bool FileExists(char *param_1)
{
int iVar1;
iVar1 = access(param_1,0);
return iVar1 != -1;
}
|
|
9,565 |
spdlog::details::backtracer::~backtracer()
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/backtracer.h
|
class SPDLOG_API backtracer {
mutable std::mutex mutex_;
std::atomic<bool> enabled_{false};
circular_q<log_msg_buffer> messages_;
public:
backtracer() = default;
backtracer(const backtracer &other);
backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
backtracer &operator=(backtracer other);
void enable(size_t size);
void disable();
bool enabled() const;
void push_back(const log_msg &msg);
bool empty() const;
// pop all items in the q and apply the given fun on each of them.
void foreach_pop(std::function<void(const details::log_msg &)> fun);
}
|
O0
|
c
|
spdlog::details::backtracer::~backtracer():
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x410b0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
|
_ZN6spdlog7details10backtracerD2Ev:
push rax
mov [rsp+8+var_8], rdi
mov rdi, [rsp+8+var_8]
add rdi, 30h ; '0'
call _ZN6spdlog7details10circular_qINS0_14log_msg_bufferEED2Ev; spdlog::details::circular_q<spdlog::details::log_msg_buffer>::~circular_q()
pop rax
retn
|
void spdlog::details::backtracer::~backtracer(spdlog::details::backtracer *this)
{
spdlog::details::circular_q<spdlog::details::log_msg_buffer>::~circular_q((long long)this + 48);
}
|
~backtracer:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
ADD RDI,0x30
CALL 0x001410b0
POP RAX
RET
|
/* spdlog::details::backtracer::~backtracer() */
backtracer * __thiscall spdlog::details::backtracer::~backtracer(backtracer *this)
{
circular_q<spdlog::details::log_msg_buffer>::~circular_q
((circular_q<spdlog::details::log_msg_buffer> *)(this + 0x30));
return this;
}
|
|
9,566 |
inline_mysql_file_open
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline File
inline_mysql_file_open(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_OPEN, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_open(filename, flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_open(filename, flags, myFlags);
return file;
}
|
O0
|
c
|
inline_mysql_file_open:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x23af88(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x88(%rbp), %rdi
movl $0x2, %edx
leaq -0x40(%rbp), %r8
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 0x90562
leaq 0x23af3a(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xfa960
movl %eax, -0x34(%rbp)
leaq 0x23af09(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9057b
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xfa960
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
inline_mysql_file_open_1:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_88]
mov edx, 2
lea r8, [rbp+var_40]
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 short loc_90562
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_40]
mov esi, [rbp+var_34]
call rax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_9057B
loc_90562:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_9057B:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long inline_mysql_file_open_1(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h] BYREF
unsigned int v9; // [rsp+5Ch] [rbp-34h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+7Ch] [rbp-14h]
long long v14; // [rsp+80h] [rbp-10h]
unsigned int v15; // [rsp+88h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v7, a1, 2LL, a4, &v8);
if ( v8 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v8, v14, v13);
v9 = my_open(v12, v11, v10);
((void ( *)(long long, _QWORD))PSI_server[64])(v8, v9);
}
else
{
return (unsigned int)my_open(v12, v11, v10);
}
return v9;
}
|
inline_mysql_file_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x88]
MOV EDX,0x2
LEA R8,[RBP + -0x40]
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 0x00190562
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001fa960
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x34]
CALL RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019057b
LAB_00190562:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001fa960
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_0019057b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
inline_mysql_file_open
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int4 local_3c;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_48 = (**(code **)(PSI_server + 0x148))(local_90,param_1,2,param_4,&local_48);
if (local_48 == 0) {
local_c = my_open(local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_48,local_18,local_1c);
local_3c = my_open(local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x200))(local_48,local_3c);
local_c = local_3c;
}
return local_c;
}
|
|
9,567 |
cs_leave
|
eloqsql/strings/ctype.c
|
static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
}
|
O0
|
c
|
cs_leave:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6dd80
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6cb76
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x6cb7d
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x6cb7d
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x9, %eax
je 0x6cc57
jmp 0x6cb94
movl -0x38(%rbp), %eax
subl $0x191, %eax # imm = 0x191
je 0x6cd04
jmp 0x6cba4
movl -0x38(%rbp), %eax
subl $0x192, %eax # imm = 0x192
je 0x6cd23
jmp 0x6cbb4
movl -0x38(%rbp), %eax
subl $0x193, %eax # imm = 0x193
je 0x6cd42
jmp 0x6cbc4
movl -0x38(%rbp), %eax
subl $0x194, %eax # imm = 0x194
je 0x6cd61
jmp 0x6cbd4
movl -0x38(%rbp), %eax
subl $0x195, %eax # imm = 0x195
je 0x6cd80
jmp 0x6cbe4
movl -0x38(%rbp), %eax
subl $0x196, %eax # imm = 0x196
je 0x6cd9f
jmp 0x6cbf4
movl -0x38(%rbp), %eax
subl $0x197, %eax # imm = 0x197
je 0x6cdbb
jmp 0x6cc04
movl -0x38(%rbp), %eax
subl $0x198, %eax # imm = 0x198
je 0x6cdd7
jmp 0x6cc14
movl -0x38(%rbp), %eax
subl $0x199, %eax # imm = 0x199
je 0x6cdf3
jmp 0x6cc24
movl -0x38(%rbp), %eax
subl $0x19a, %eax # imm = 0x19A
je 0x6ce0f
jmp 0x6cc34
movl -0x38(%rbp), %eax
subl $0x19b, %eax # imm = 0x19B
je 0x6ccc6
jmp 0x6cc44
movl -0x38(%rbp), %eax
subl $0x19c, %eax # imm = 0x19C
je 0x6cce5
jmp 0x6ce2b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x690(%rax)
je 0x6cc7b
movq -0x20(%rbp), %rax
movq 0x688(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x718(%rax)
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0x6ccb4
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0xa8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x6e0, %rdi # imm = 0x6E0
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0x6ccbb
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6ccbb
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedfc(%rip), %rsi # 0x7bacd
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedf3(%rip), %rsi # 0x7bae3
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xede9(%rip), %rsi # 0x7baf8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xede4(%rip), %rsi # 0x7bb12
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedde(%rip), %rsi # 0x7bb2b
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xeddb(%rip), %rsi # 0x7bb47
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedd7(%rip), %rsi # 0x7bb62
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedd3(%rip), %rsi # 0x7bb7d
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedd1(%rip), %rsi # 0x7bb97
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedc6(%rip), %rsi # 0x7bba8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedba(%rip), %rsi # 0x7bbb8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movq -0x8(%rbp), %rdi
leaq 0xedaf(%rip), %rsi # 0x7bbc9
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6de10
movl %eax, -0x30(%rbp)
jmp 0x6ce32
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
cs_leave:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+140h]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cs_file_sec
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_6CB76
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_34], eax
jmp short loc_6CB7D
loc_6CB76:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_6CB7D:
mov eax, [rbp+var_34]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_38], eax
sub eax, 9
jz loc_6CC57
jmp short $+2
loc_6CB94:
mov eax, [rbp+var_38]
sub eax, 191h
jz loc_6CD04
jmp short $+2
loc_6CBA4:
mov eax, [rbp+var_38]
sub eax, 192h
jz loc_6CD23
jmp short $+2
loc_6CBB4:
mov eax, [rbp+var_38]
sub eax, 193h
jz loc_6CD42
jmp short $+2
loc_6CBC4:
mov eax, [rbp+var_38]
sub eax, 194h
jz loc_6CD61
jmp short $+2
loc_6CBD4:
mov eax, [rbp+var_38]
sub eax, 195h
jz loc_6CD80
jmp short $+2
loc_6CBE4:
mov eax, [rbp+var_38]
sub eax, 196h
jz loc_6CD9F
jmp short $+2
loc_6CBF4:
mov eax, [rbp+var_38]
sub eax, 197h
jz loc_6CDBB
jmp short $+2
loc_6CC04:
mov eax, [rbp+var_38]
sub eax, 198h
jz loc_6CDD7
jmp short $+2
loc_6CC14:
mov eax, [rbp+var_38]
sub eax, 199h
jz loc_6CDF3
jmp short $+2
loc_6CC24:
mov eax, [rbp+var_38]
sub eax, 19Ah
jz loc_6CE0F
jmp short $+2
loc_6CC34:
mov eax, [rbp+var_38]
sub eax, 19Bh
jz loc_6CCC6
jmp short $+2
loc_6CC44:
mov eax, [rbp+var_38]
sub eax, 19Ch
jz loc_6CCE5
jmp loc_6CE2B
loc_6CC57:
mov rax, [rbp+var_20]
cmp qword ptr [rax+690h], 0
jz short loc_6CC7B
mov rax, [rbp+var_20]
mov rcx, [rax+688h]
mov rax, [rbp+var_20]
mov [rax+718h], rcx
loc_6CC7B:
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
cmp qword ptr [rax+0A8h], 0
jz short loc_6CCB4
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_20]
add rdi, 6E0h
call rax
mov [rbp+var_3C], eax
jmp short loc_6CCBB
loc_6CCB4:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_6CCBB:
mov eax, [rbp+var_3C]
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CCC6:
mov rdi, [rbp+var_8]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CCE5:
mov rdi, [rbp+var_8]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD04:
mov rdi, [rbp+var_8]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD23:
mov rdi, [rbp+var_8]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD42:
mov rdi, [rbp+var_8]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD61:
mov rdi, [rbp+var_8]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD80:
mov rdi, [rbp+var_8]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_6CE32
loc_6CD9F:
mov rdi, [rbp+var_8]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_6CE32
loc_6CDBB:
mov rdi, [rbp+var_8]
lea rsi, aFirstTrailing; "[first trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_6CE32
loc_6CDD7:
mov rdi, [rbp+var_8]
lea rsi, aLastTrailing; "[last trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_6CE32
loc_6CDF3:
mov rdi, [rbp+var_8]
lea rsi, aFirstVariable; "[first variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_6CE32
loc_6CE0F:
mov rdi, [rbp+var_8]
lea rsi, aLastVariable; "[last variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_6CE32
loc_6CE2B:
mov [rbp+var_30], 0
loc_6CE32:
mov eax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
|
long long cs_leave(long long a1, long long a2, long long a3)
{
int v5; // [rsp+Ch] [rbp-34h]
int *v7; // [rsp+18h] [rbp-28h]
_QWORD *v8; // [rsp+20h] [rbp-20h]
v8 = *(_QWORD **)(a1 + 320);
v7 = (int *)cs_file_sec(a2, a3);
if ( v7 )
v5 = *v7;
else
v5 = 0;
switch ( v5 )
{
case 9:
if ( v8[210] )
v8[227] = v8[209];
if ( *(_QWORD *)(v8[245] + 168LL) )
return (unsigned int)(*(long long ( **)(_QWORD *))(v8[245] + 168LL))(v8 + 220);
else
return 0;
case 401:
return (unsigned int)tailoring_append(a1, "[first primary ignorable]", 0LL);
case 402:
return (unsigned int)tailoring_append(a1, "[last primary ignorable]", 0LL);
case 403:
return (unsigned int)tailoring_append(a1, "[first secondary ignorable]", 0LL);
case 404:
return (unsigned int)tailoring_append(a1, "[last secondary ignorable]", 0LL);
case 405:
return (unsigned int)tailoring_append(a1, "[first tertiary ignorable]", 0LL);
case 406:
return (unsigned int)tailoring_append(a1, "[last tertiary ignorable]", 0LL);
case 407:
return (unsigned int)tailoring_append(a1, "[first trailing]", 0LL);
case 408:
return (unsigned int)tailoring_append(a1, "[last trailing]", 0LL);
case 409:
return (unsigned int)tailoring_append(a1, "[first variable]", 0LL);
case 410:
return (unsigned int)tailoring_append(a1, "[last variable]", 0LL);
case 411:
return (unsigned int)tailoring_append(a1, "[first non-ignorable]", 0LL);
case 412:
return (unsigned int)tailoring_append(a1, "[last non-ignorable]", 0LL);
default:
return 0;
}
}
|
cs_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0016dd80
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0016cb76
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016cb7d
LAB_0016cb76:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016cb7d
LAB_0016cb7d:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
SUB EAX,0x9
JZ 0x0016cc57
JMP 0x0016cb94
LAB_0016cb94:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x191
JZ 0x0016cd04
JMP 0x0016cba4
LAB_0016cba4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x192
JZ 0x0016cd23
JMP 0x0016cbb4
LAB_0016cbb4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x193
JZ 0x0016cd42
JMP 0x0016cbc4
LAB_0016cbc4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x194
JZ 0x0016cd61
JMP 0x0016cbd4
LAB_0016cbd4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x195
JZ 0x0016cd80
JMP 0x0016cbe4
LAB_0016cbe4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x196
JZ 0x0016cd9f
JMP 0x0016cbf4
LAB_0016cbf4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x197
JZ 0x0016cdbb
JMP 0x0016cc04
LAB_0016cc04:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x198
JZ 0x0016cdd7
JMP 0x0016cc14
LAB_0016cc14:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x199
JZ 0x0016cdf3
JMP 0x0016cc24
LAB_0016cc24:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19a
JZ 0x0016ce0f
JMP 0x0016cc34
LAB_0016cc34:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19b
JZ 0x0016ccc6
JMP 0x0016cc44
LAB_0016cc44:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19c
JZ 0x0016cce5
JMP 0x0016ce2b
LAB_0016cc57:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x690],0x0
JZ 0x0016cc7b
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x688]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x718],RCX
LAB_0016cc7b:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
CMP qword ptr [RAX + 0xa8],0x0
JZ 0x0016ccb4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x6e0
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016ccbb
LAB_0016ccb4:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016ccbb
LAB_0016ccbb:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016ccc6:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bacd]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cce5:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bae3]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd04:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17baf8]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd23:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb12]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd42:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb2b]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd61:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb47]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd80:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb62]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cd9f:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb7d]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cdbb:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bb97]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cdd7:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bba8]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016cdf3:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bbb8]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016ce0f:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x17bbc9]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x0016de10
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016ce32
LAB_0016ce2b:
MOV dword ptr [RBP + -0x30],0x0
LAB_0016ce32:
MOV EAX,dword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int4 cs_leave(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int *piVar2;
int4 local_44;
int local_3c;
int4 local_38;
lVar1 = *(long *)(param_1 + 0x140);
piVar2 = (int *)cs_file_sec(param_2,param_3);
if (piVar2 == (int *)0x0) {
local_3c = 0;
}
else {
local_3c = *piVar2;
}
if (local_3c == 9) {
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
if (*(long *)(*(long *)(lVar1 + 0x7a8) + 0xa8) == 0) {
local_44 = 0;
}
else {
local_44 = (**(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8))(lVar1 + 0x6e0);
}
local_38 = local_44;
}
else if (local_3c == 0x191) {
local_38 = tailoring_append(param_1,"[first primary ignorable]",0);
}
else if (local_3c == 0x192) {
local_38 = tailoring_append(param_1,"[last primary ignorable]",0);
}
else if (local_3c == 0x193) {
local_38 = tailoring_append(param_1,"[first secondary ignorable]",0);
}
else if (local_3c == 0x194) {
local_38 = tailoring_append(param_1,"[last secondary ignorable]",0);
}
else if (local_3c == 0x195) {
local_38 = tailoring_append(param_1,"[first tertiary ignorable]",0);
}
else if (local_3c == 0x196) {
local_38 = tailoring_append(param_1,"[last tertiary ignorable]",0);
}
else if (local_3c == 0x197) {
local_38 = tailoring_append(param_1,"[first trailing]",0);
}
else if (local_3c == 0x198) {
local_38 = tailoring_append(param_1,"[last trailing]",0);
}
else if (local_3c == 0x199) {
local_38 = tailoring_append(param_1,"[first variable]",0);
}
else if (local_3c == 0x19a) {
local_38 = tailoring_append(param_1,"[last variable]",0);
}
else if (local_3c == 0x19b) {
local_38 = tailoring_append(param_1,"[first non-ignorable]",0);
}
else if (local_3c == 0x19c) {
local_38 = tailoring_append(param_1,"[last non-ignorable]",0);
}
else {
local_38 = 0;
}
return local_38;
}
|
|
9,568 |
cs_leave
|
eloqsql/strings/ctype.c
|
static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
}
|
O3
|
c
|
cs_leave:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x140(%rdi), %rbx
leaq 0x299b60(%rip), %r13 # 0x2ee550
leaq 0x7d0e(%rip), %r12 # 0x5c705
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x24130
testl %eax, %eax
jne 0x54a10
cmpb $0x0, (%r12,%r14)
je 0x54a2e
movq 0x18(%r13), %r12
addq $0x10, %r13
testq %r12, %r12
jne 0x549f7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r13), %ecx
leal -0x191(%rcx), %eax
cmpl $0xb, %eax
ja 0x54a59
leaq 0x2842b8(%rip), %rcx # 0x2d8cfc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa0b5(%rip), %rsi # 0x5eb09
jmp 0x54b04
cmpl $0x9, %ecx
jne 0x54a1d
cmpq $0x0, 0x690(%rbx)
je 0x54a76
movq 0x688(%rbx), %rax
movq %rax, 0x718(%rbx)
movq 0x7a8(%rbx), %rax
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x54a1d
addq $0x6e0, %rbx # imm = 0x6E0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0xa04a(%rip), %rsi # 0x5eaf4
jmp 0x54b04
leaq 0xa0c0(%rip), %rsi # 0x5eb73
jmp 0x54b04
leaq 0xa11e(%rip), %rsi # 0x5ebda
jmp 0x54b04
leaq 0xa077(%rip), %rsi # 0x5eb3c
jmp 0x54b04
leaq 0xa08a(%rip), %rsi # 0x5eb58
jmp 0x54b04
leaq 0xa0e2(%rip), %rsi # 0x5ebb9
jmp 0x54b04
leaq 0xa043(%rip), %rsi # 0x5eb23
jmp 0x54b04
leaq 0xa0a5(%rip), %rsi # 0x5eb8e
jmp 0x54b04
leaq 0xa0b6(%rip), %rsi # 0x5eba8
jmp 0x54b04
leaq 0x9fe3(%rip), %rsi # 0x5eade
jmp 0x54b04
leaq 0xa0c5(%rip), %rsi # 0x5ebc9
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x55354
|
cs_leave:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, [rdi+140h]
lea r13, sec
lea r12, aIndexXml+6; "xml"
loc_549F7:
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _strncmp
test eax, eax
jnz short loc_54A10
cmp byte ptr [r12+r14], 0
jz short loc_54A2E
loc_54A10:
mov r12, [r13+18h]
add r13, 10h
test r12, r12
jnz short loc_549F7
loc_54A1D:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_54A2E:
mov ecx, [r13+0]
lea eax, [rcx-191h]; switch 12 cases
cmp eax, 0Bh
ja short def_54A4B; jumptable 0000000000054A4B default case
lea rcx, jpt_54A4B
movsxd rax, ds:(jpt_54A4B - 2D8CFCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_54A4D:
lea rsi, aFirstPrimaryIg; jumptable 0000000000054A4B case 401
jmp loc_54B04
def_54A4B:
cmp ecx, 9; jumptable 0000000000054A4B default case
jnz short loc_54A1D
cmp qword ptr [rbx+690h], 0
jz short loc_54A76
mov rax, [rbx+688h]
mov [rbx+718h], rax
loc_54A76:
mov rax, [rbx+7A8h]
mov rax, [rax+0A8h]
test rax, rax
jz short loc_54A1D
add rbx, 6E0h
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_54AA3:
lea rsi, aLastNonIgnorab; jumptable 0000000000054A4B case 412
jmp short loc_54B04
loc_54AAC:
lea rsi, aFirstTertiaryI; jumptable 0000000000054A4B case 405
jmp short loc_54B04
loc_54AB5:
lea rsi, aLastVariable; jumptable 0000000000054A4B case 410
jmp short loc_54B04
loc_54ABE:
lea rsi, aFirstSecondary; jumptable 0000000000054A4B case 403
jmp short loc_54B04
loc_54AC7:
lea rsi, aLastSecondaryI; jumptable 0000000000054A4B case 404
jmp short loc_54B04
loc_54AD0:
lea rsi, aLastTrailing; jumptable 0000000000054A4B case 408
jmp short loc_54B04
loc_54AD9:
lea rsi, aLastPrimaryIgn; jumptable 0000000000054A4B case 402
jmp short loc_54B04
loc_54AE2:
lea rsi, aLastTertiaryIg; jumptable 0000000000054A4B case 406
jmp short loc_54B04
loc_54AEB:
lea rsi, aFirstTrailing; jumptable 0000000000054A4B case 407
jmp short loc_54B04
loc_54AF4:
lea rsi, aFirstNonIgnora; jumptable 0000000000054A4B case 411
jmp short loc_54B04
loc_54AFD:
lea rsi, aFirstVariable; jumptable 0000000000054A4B case 409
loc_54B04:
mov rdi, rbx
xor edx, edx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp tailoring_append
|
long long cs_leave(long long a1, long long a2, long long a3)
{
_QWORD *v4; // rbx
char *v5; // r13
char *v6; // r12
long long result; // rax
long long ( *v8)(_QWORD *); // rax
v4 = *(_QWORD **)(a1 + 320);
v5 = (char *)&sec;
v6 = "xml";
while ( (unsigned int)strncmp(a2, v6, a3) || v6[a3] )
{
v6 = (char *)*((_QWORD *)v5 + 3);
v5 += 16;
if ( !v6 )
return 0LL;
}
switch ( *(_DWORD *)v5 )
{
case 0x191:
result = tailoring_append(v4, "[first primary ignorable]", 0LL, 0LL);
break;
case 0x192:
result = tailoring_append(v4, "[last primary ignorable]", 0LL, 0LL);
break;
case 0x193:
result = tailoring_append(v4, "[first secondary ignorable]", 0LL, 0LL);
break;
case 0x194:
result = tailoring_append(v4, "[last secondary ignorable]", 0LL, 0LL);
break;
case 0x195:
result = tailoring_append(v4, "[first tertiary ignorable]", 0LL, 0LL);
break;
case 0x196:
result = tailoring_append(v4, "[last tertiary ignorable]", 0LL, 0LL);
break;
case 0x197:
result = tailoring_append(v4, "[first trailing]", 0LL, 0LL);
break;
case 0x198:
result = tailoring_append(v4, "[last trailing]", 0LL, 0LL);
break;
case 0x199:
result = tailoring_append(v4, "[first variable]", 0LL, 0LL);
break;
case 0x19A:
result = tailoring_append(v4, "[last variable]", 0LL, 0LL);
break;
case 0x19B:
result = tailoring_append(v4, "[first non-ignorable]", 0LL, 0LL);
break;
case 0x19C:
result = tailoring_append(v4, "[last non-ignorable]", 0LL, 0LL);
break;
default:
if ( *(_DWORD *)v5 != 9 )
return 0LL;
if ( v4[210] )
v4[227] = v4[209];
v8 = *(long long ( **)(_QWORD *))(v4[245] + 168LL);
if ( !v8 )
return 0LL;
result = v8(v4 + 220);
break;
}
return result;
}
|
cs_leave:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,qword ptr [RDI + 0x140]
LEA R13,[0x3ee550]
LEA R12,[0x15c705]
LAB_001549f7:
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x00124130
TEST EAX,EAX
JNZ 0x00154a10
CMP byte ptr [R12 + R14*0x1],0x0
JZ 0x00154a2e
LAB_00154a10:
MOV R12,qword ptr [R13 + 0x18]
ADD R13,0x10
TEST R12,R12
JNZ 0x001549f7
LAB_00154a1d:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00154a2e:
MOV ECX,dword ptr [R13]
LEA EAX,[RCX + -0x191]
CMP EAX,0xb
JA 0x00154a59
LEA RCX,[0x3d8cfc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_191:
LEA RSI,[0x15eb09]
JMP 0x00154b04
LAB_00154a59:
CMP ECX,0x9
JNZ 0x00154a1d
CMP qword ptr [RBX + 0x690],0x0
JZ 0x00154a76
MOV RAX,qword ptr [RBX + 0x688]
MOV qword ptr [RBX + 0x718],RAX
LAB_00154a76:
MOV RAX,qword ptr [RBX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
TEST RAX,RAX
JZ 0x00154a1d
ADD RBX,0x6e0
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
caseD_19c:
LEA RSI,[0x15eaf4]
JMP 0x00154b04
caseD_195:
LEA RSI,[0x15eb73]
JMP 0x00154b04
caseD_19a:
LEA RSI,[0x15ebda]
JMP 0x00154b04
caseD_193:
LEA RSI,[0x15eb3c]
JMP 0x00154b04
caseD_194:
LEA RSI,[0x15eb58]
JMP 0x00154b04
caseD_198:
LEA RSI,[0x15ebb9]
JMP 0x00154b04
caseD_192:
LEA RSI,[0x15eb23]
JMP 0x00154b04
caseD_196:
LEA RSI,[0x15eb8e]
JMP 0x00154b04
caseD_197:
LEA RSI,[0x15eba8]
JMP 0x00154b04
caseD_19b:
LEA RSI,[0x15eade]
JMP 0x00154b04
caseD_199:
LEA RSI,[0x15ebc9]
LAB_00154b04:
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00155354
|
int8 cs_leave(long param_1,char *param_2,size_t param_3)
{
long lVar1;
code *UNRECOVERED_JUMPTABLE;
int iVar2;
int8 uVar3;
char *pcVar4;
int *piVar5;
lVar1 = *(long *)(param_1 + 0x140);
piVar5 = &sec;
pcVar4 = "xml";
while ((iVar2 = strncmp(param_2,pcVar4,param_3), iVar2 != 0 || (pcVar4[param_3] != '\0'))) {
pcVar4 = *(char **)(piVar5 + 6);
piVar5 = piVar5 + 4;
if (pcVar4 == (char *)0x0) {
return 0;
}
}
switch(*piVar5) {
case 0x191:
pcVar4 = "[first primary ignorable]";
break;
case 0x192:
pcVar4 = "[last primary ignorable]";
break;
case 0x193:
pcVar4 = "[first secondary ignorable]";
break;
case 0x194:
pcVar4 = "[last secondary ignorable]";
break;
case 0x195:
pcVar4 = "[first tertiary ignorable]";
break;
case 0x196:
pcVar4 = "[last tertiary ignorable]";
break;
case 0x197:
pcVar4 = "[first trailing]";
break;
case 0x198:
pcVar4 = "[last trailing]";
break;
case 0x199:
pcVar4 = "[first variable]";
break;
case 0x19a:
pcVar4 = "[last variable]";
break;
case 0x19b:
pcVar4 = "[first non-ignorable]";
break;
case 0x19c:
pcVar4 = "[last non-ignorable]";
break;
default:
if (*piVar5 != 9) {
return 0;
}
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
UNRECOVERED_JUMPTABLE = *(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8);
if (UNRECOVERED_JUMPTABLE == (code *)0x0) {
return 0;
}
/* WARNING: Could not recover jumptable at 0x00154aa1. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(lVar1 + 0x6e0);
return uVar3;
}
uVar3 = tailoring_append(lVar1,pcVar4,0,0);
return uVar3;
}
|
|
9,569 |
ma_insert
|
eloqsql/storage/maria/ma_write.c
|
int _ma_insert(register MARIA_HA *info, MARIA_KEY *key,
MARIA_PAGE *anc_page, uchar *key_pos, uchar *key_buff,
MARIA_PAGE *father_page, uchar *father_key_pos,
my_bool insert_last)
{
uint a_length, nod_flag, org_anc_length;
int t_length;
uchar *endpos, *prev_key, *anc_buff;
MARIA_KEY_PARAM s_temp;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
DBUG_ENTER("_ma_insert");
DBUG_PRINT("enter",("key_pos:%p", key_pos));
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE, key););
/*
Note that anc_page->size can be bigger then block_size in case of
delete key that caused increase of page length
*/
org_anc_length= a_length= anc_page->size;
nod_flag= anc_page->node;
anc_buff= anc_page->buff;
endpos= anc_buff+ a_length;
prev_key= (key_pos == anc_buff + share->keypage_header + nod_flag ?
(uchar*) 0 : key_buff);
t_length= (*keyinfo->pack_key)(key, nod_flag,
(key_pos == endpos ? (uchar*) 0 : key_pos),
prev_key, prev_key, &s_temp);
#ifndef DBUG_OFF
if (prev_key && (keyinfo->flag & (HA_BINARY_PACK_KEY | HA_PACK_KEY)))
{
DBUG_DUMP("prev_key", prev_key, _ma_keylength(keyinfo,prev_key));
}
if (keyinfo->flag & HA_PACK_KEY)
{
DBUG_PRINT("test",("t_length: %d ref_len: %d",
t_length,s_temp.ref_length));
DBUG_PRINT("test",("n_ref_len: %d n_length: %d key_pos: %p",
s_temp.n_ref_length, s_temp.n_length, s_temp.key));
}
#endif
if (t_length > 0)
{
if (t_length >= keyinfo->maxlength*2+MARIA_INDEX_OVERHEAD_SIZE)
{
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(-1);
}
bmove_upp(endpos+t_length, endpos, (uint) (endpos-key_pos));
}
else
{
if (-t_length >= keyinfo->maxlength*2+MARIA_INDEX_OVERHEAD_SIZE)
{
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(-1);
}
bmove(key_pos,key_pos-t_length,(uint) (endpos-key_pos)+t_length);
}
(*keyinfo->store_key)(keyinfo,key_pos,&s_temp);
a_length+=t_length;
if (key->flag & (SEARCH_USER_KEY_HAS_TRANSID | SEARCH_PAGE_KEY_HAS_TRANSID))
_ma_mark_page_with_transid(share, anc_page);
anc_page->size= a_length;
page_store_size(share, anc_page);
/*
Check if the new key fits totally into the the page
(anc_buff is big enough to contain a full page + one key)
*/
if (a_length <= share->max_index_block_size)
{
if (share->max_index_block_size - a_length < 32 &&
(keyinfo->flag & HA_FULLTEXT) && key_pos == endpos &&
share->base.key_reflength <= share->rec_reflength &&
share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
{
/*
Normal word. One-level tree. Page is almost full.
Let's consider converting.
We'll compare 'key' and the first key at anc_buff
*/
const uchar *a= key->data;
const uchar *b= anc_buff + share->keypage_header + nod_flag;
uint alen, blen, ft2len= share->ft2_keyinfo.keylength;
/* the very first key on the page is always unpacked */
DBUG_ASSERT((*b & 128) == 0);
#if HA_FT_MAXLEN >= 127
blen= mi_uint2korr(b); b+=2;
When you enable this code, as part of the MyISAM->Maria merge of
[email protected], 2008-04-09 07:41:40+02:00, [email protected] +9 -0
restore ft2 functionality, fix bugs.
Then this will enable two-level fulltext index, which is not totally
recoverable yet.
So remove this text and inform Guilhem so that he fixes the issue.
#else
blen= *b++;
#endif
get_key_length(alen,a);
DBUG_ASSERT(info->ft1_to_ft2==0);
if (alen == blen &&
ha_compare_text(keyinfo->seg->charset, a, alen,
b, blen, 0) == 0)
{
/* Yup. converting */
info->ft1_to_ft2=(DYNAMIC_ARRAY *)
my_malloc(PSI_INSTRUMENT_ME, sizeof(DYNAMIC_ARRAY), MYF(MY_WME));
my_init_dynamic_array(PSI_INSTRUMENT_ME, info->ft1_to_ft2, ft2len, 300,
50, MYF(0));
/*
Now, adding all keys from the page to dynarray
if the page is a leaf (if not keys will be deleted later)
*/
if (!nod_flag)
{
/*
Let's leave the first key on the page, though, because
we cannot easily dispatch an empty page here
*/
b+=blen+ft2len+2;
for (a=anc_buff+a_length ; b < a ; b+=ft2len+2)
insert_dynamic(info->ft1_to_ft2, b);
/* fixing the page's length - it contains only one key now */
anc_page->size= share->keypage_header + blen + ft2len + 2;
page_store_size(share, anc_page);
}
/* the rest will be done when we're back from recursion */
}
}
else
{
if (share->now_transactional &&
_ma_log_add(anc_page, org_anc_length,
key_pos, s_temp.changed_length, t_length, 1,
KEY_OP_DEBUG_LOG_ADD_1))
DBUG_RETURN(-1);
}
DBUG_RETURN(0); /* There is room on page */
}
/* Page is full */
if (nod_flag)
insert_last=0;
/*
TODO:
Remove 'born_transactional' here.
The only reason for having it here is that the current
_ma_balance_page_ can't handle variable length keys.
*/
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)) &&
father_page && !insert_last && !info->quick_mode &&
!info->s->base.born_transactional)
{
s_temp.key_pos= key_pos;
page_mark_changed(info, father_page);
DBUG_RETURN(_ma_balance_page(info, keyinfo, key, anc_page,
father_page, father_key_pos,
&s_temp));
}
DBUG_RETURN(_ma_split_page(info, key, anc_page,
MY_MIN(org_anc_length,
info->s->max_index_block_size),
key_pos, s_temp.changed_length, t_length,
key_buff, insert_last));
}
|
O3
|
c
|
ma_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, -0x58(%rbp)
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r10
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
movl 0x20(%rdx), %edx
movl 0x28(%rbx), %esi
movq 0x10(%rbx), %rcx
movq %rdx, -0x48(%rbp)
leaq (%rcx,%rdx), %r13
movq %rax, -0x60(%rbp)
movl 0x744(%rax), %eax
movq %rcx, -0x50(%rbp)
addq %rsi, %rcx
addq %rcx, %rax
xorl %edx, %edx
cmpq %r12, %rax
movq %r8, -0x68(%rbp)
movq %r8, %rcx
cmoveq %rdx, %rcx
cmpq %r12, %r13
cmovneq %r12, %rdx
movq 0x8(%r10), %r14
leaq -0xb8(%rbp), %r9
movq %r10, -0x40(%rbp)
movq %r10, %rdi
movq %rsi, -0x38(%rbp)
movq %rcx, %r8
callq *0xf0(%r14)
movl %eax, %r15d
testl %eax, %eax
jle 0x55719
movzwl 0xae(%r14), %eax
leal 0x15(,%rax,2), %eax
cmpl %eax, %r15d
jae 0x5585a
movl %r15d, %edi
addq %r13, %rdi
movl %r13d, %edx
subl %r12d, %edx
movq %r13, %rsi
callq 0xb3768
jmp 0x5574f
movl %r15d, %eax
negl %eax
movzwl 0xae(%r14), %ecx
leal 0x15(,%rcx,2), %ecx
cmpl %eax, %ecx
jbe 0x5585a
movslq %r15d, %rax
movq %r12, %rsi
subq %rax, %rsi
movl %r13d, %edx
subl %r12d, %edx
addl %r15d, %edx
movq %r12, %rdi
callq 0x2a130
leaq -0xb8(%rbp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq *0xf8(%r14)
movq -0x48(%rbp), %rsi
leal (%r15,%rsi), %edx
movq -0x40(%rbp), %r10
testb $0x18, 0x1a(%r10)
movq -0x60(%rbp), %rdi
je 0x55799
movl 0x2c(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x2c(%rbx)
movq 0x10(%rbx), %rcx
movl %edx, %r8d
movl 0x744(%rdi), %edx
addl $-0x3, %edx
movb %al, (%rcx,%rdx)
movl %r8d, %edx
movl %edx, 0x20(%rbx)
movq 0x10(%rbx), %rax
movl 0x744(%rdi), %ecx
movb %dl, -0x1(%rax,%rcx)
movq 0x10(%rbx), %rax
movl 0x744(%rdi), %ecx
movb %dh, -0x2(%rax,%rcx)
movl 0x7c0(%rdi), %eax
subl %edx, %eax
jae 0x55872
xorl %ecx, %ecx
cmpq $0x0, -0x38(%rbp)
movzbl 0x18(%rbp), %eax
cmovnel %ecx, %eax
testb %al, %al
jne 0x5590d
cmpq $0x0, -0x58(%rbp)
je 0x5590d
movzwl 0xa2(%r14), %ecx
andl $0x28, %ecx
jne 0x5590d
movq -0x30(%rbp), %rdi
cmpb $0x0, 0x682(%rdi)
movq (%rdi), %rcx
jne 0x55914
cmpb $0x0, 0x44c(%rcx)
jne 0x55914
movq 0x10(%rbp), %r9
movq %r12, -0xa0(%rbp)
movq 0x2e8(%rdi), %rax
movq -0x58(%rbp), %r8
movl 0x30(%r8), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
leaq -0xb8(%rbp), %rax
movq %rax, (%rsp)
movq %r14, %rsi
movq %r10, %rdx
movq %rbx, %rcx
callq 0x55a64
jmp 0x55945
movq -0x30(%rbp), %rdi
movl $0x7e, %esi
callq 0x39cfc
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x55945
cmpl $0x1f, %eax
ja 0x558d7
cmpq %r12, %r13
jne 0x558d7
movzwl 0xa2(%r14), %eax
andl $0x80, %eax
je 0x558d7
movl 0x3e4(%rdi), %eax
cmpl 0x740(%rdi), %eax
ja 0x558d7
testb $0x5, 0x720(%rdi)
je 0x558d7
movl %edx, -0x48(%rbp)
movq (%r10), %rsi
movl 0x744(%rdi), %eax
addq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rcx,%rax), %ecx
movq %rcx, -0x40(%rbp)
movzbl (%rsi), %edx
cmpl $0xff, %edx
je 0x55957
movl $0x1, %ecx
jmp 0x55967
cmpb $0x0, 0x7e7(%rdi)
je 0x55909
movl -0x78(%rbp), %ecx
movl $0x6, (%rsp)
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %r8d
movl $0x1, %r9d
callq 0x3e312
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x55945
xorl %eax, %eax
jmp 0x55945
movq -0x30(%rbp), %rdi
movq (%rdi), %rcx
movl 0x7c0(%rcx), %ecx
cmpl %ecx, %esi
cmovbl %esi, %ecx
movl -0x78(%rbp), %r9d
movsbl %al, %eax
movl %eax, 0x10(%rsp)
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rsp)
movl %r15d, (%rsp)
movq %r10, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq 0x56725
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x1(%rsi), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
movl $0x3, %ecx
movq -0x30(%rbp), %r13
movq -0x40(%rbp), %r15
cmpl %r15d, %edx
jne 0x55909
movzwl 0x502(%rdi), %edx
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rdx
leaq (%rdx,%rax), %r12
incq %r12
addq %rcx, %rsi
movq 0xc0(%r14), %rax
movq (%rax), %rdi
movl %r15d, %edx
movq %r12, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0xa59e8
testl %eax, %eax
jne 0x55909
movl $0x28, %esi
movl $0x10, %edx
xorl %edi, %edi
callq 0xa6f99
movq %rax, 0x320(%r13)
movq $0x0, (%rsp)
xorl %edi, %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
xorl %ecx, %ecx
movl $0x12c, %r8d # imm = 0x12C
movl $0x32, %r9d
callq 0x9691c
cmpq $0x0, -0x38(%rbp)
jne 0x55909
movq -0x30(%rbp), %rcx
movl %ecx, %eax
addl %r15d, %eax
leaq (%r12,%rax), %r14
addq $0x2, %r14
movl -0x48(%rbp), %eax
movq -0x50(%rbp), %r12
addq %rax, %r12
leaq 0x2(%rcx), %r15
cmpq %r12, %r14
jae 0x55a2f
movq 0x320(%r13), %rdi
movq %r14, %rsi
callq 0x969ba
addq %r15, %r14
jmp 0x55a16
movq -0x40(%rbp), %rax
addl %r15d, %eax
movq -0x60(%rbp), %rdx
addl 0x744(%rdx), %eax
movl %eax, 0x20(%rbx)
movq 0x10(%rbx), %rsi
movl 0x744(%rdx), %ecx
movb %al, -0x1(%rsi,%rcx)
movq 0x10(%rbx), %rsi
movl 0x744(%rdx), %ecx
movb %ah, -0x2(%rsi,%rcx)
jmp 0x55909
|
_ma_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov [rbp+var_58], r9
mov r12, rcx
mov rbx, rdx
mov r10, rsi
mov [rbp+var_30], rdi
mov rax, [rdi]
mov edx, [rdx+20h]
mov esi, [rbx+28h]
mov rcx, [rbx+10h]
mov [rbp+var_48], rdx
lea r13, [rcx+rdx]
mov [rbp+var_60], rax
mov eax, [rax+744h]
mov [rbp+var_50], rcx
add rcx, rsi
add rax, rcx
xor edx, edx
cmp rax, r12
mov [rbp+var_68], r8
mov rcx, r8
cmovz rcx, rdx
cmp r13, r12
cmovnz rdx, r12
mov r14, [r10+8]
lea r9, [rbp+var_B8]
mov [rbp+var_40], r10
mov rdi, r10
mov [rbp+var_38], rsi
mov r8, rcx
call qword ptr [r14+0F0h]
mov r15d, eax
test eax, eax
jle short loc_55719
movzx eax, word ptr [r14+0AEh]
lea eax, ds:15h[rax*2]
cmp r15d, eax
jnb loc_5585A
mov edi, r15d
add rdi, r13
mov edx, r13d
sub edx, r12d
mov rsi, r13
call bmove_upp
jmp short loc_5574F
loc_55719:
mov eax, r15d
neg eax
movzx ecx, word ptr [r14+0AEh]
lea ecx, ds:15h[rcx*2]
cmp ecx, eax
jbe loc_5585A
movsxd rax, r15d
mov rsi, r12
sub rsi, rax
mov edx, r13d
sub edx, r12d
add edx, r15d
mov rdi, r12
call _memmove
loc_5574F:
lea rdx, [rbp+var_B8]
mov rdi, r14
mov rsi, r12
call qword ptr [r14+0F8h]
mov rsi, [rbp+var_48]
lea edx, [r15+rsi]
mov r10, [rbp+var_40]
test byte ptr [r10+1Ah], 18h
mov rdi, [rbp+var_60]
jz short loc_55799
mov eax, [rbx+2Ch]
or eax, 2
mov [rbx+2Ch], eax
mov rcx, [rbx+10h]
mov r8d, edx
mov edx, [rdi+744h]
add edx, 0FFFFFFFDh
mov [rcx+rdx], al
mov edx, r8d
loc_55799:
mov [rbx+20h], edx
mov rax, [rbx+10h]
mov ecx, [rdi+744h]
mov [rax+rcx-1], dl
mov rax, [rbx+10h]
mov ecx, [rdi+744h]
mov [rax+rcx-2], dh
mov eax, [rdi+7C0h]
sub eax, edx
jnb loc_55872
xor ecx, ecx
cmp [rbp+var_38], 0
movzx eax, [rbp+arg_8]
cmovnz eax, ecx
test al, al
jnz loc_5590D
cmp [rbp+var_58], 0
jz loc_5590D
movzx ecx, word ptr [r14+0A2h]
and ecx, 28h
jnz loc_5590D
mov rdi, [rbp+var_30]
cmp byte ptr [rdi+682h], 0
mov rcx, [rdi]
jnz loc_55914
cmp byte ptr [rcx+44Ch], 0
jnz loc_55914
mov r9, [rbp+arg_0]
mov [rbp+var_A0], r12
mov rax, [rdi+2E8h]
mov r8, [rbp+var_58]
mov ecx, [r8+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
lea rax, [rbp+var_B8]
mov [rsp+0D0h+var_D0], rax
mov rsi, r14
mov rdx, r10
mov rcx, rbx
call _ma_balance_page
jmp loc_55945
loc_5585A:
mov rdi, [rbp+var_30]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
mov eax, 0FFFFFFFFh
jmp loc_55945
loc_55872:
cmp eax, 1Fh
ja short loc_558D7
cmp r13, r12
jnz short loc_558D7
movzx eax, word ptr [r14+0A2h]
and eax, 80h
jz short loc_558D7
mov eax, [rdi+3E4h]
cmp eax, [rdi+740h]
ja short loc_558D7
test byte ptr [rdi+720h], 5
jz short loc_558D7
mov dword ptr [rbp+var_48], edx
mov rsi, [r10]
mov eax, [rdi+744h]
add rax, [rbp+var_50]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+rax]
mov [rbp+var_40], rcx
movzx edx, byte ptr [rsi]
cmp edx, 0FFh
jz loc_55957
mov ecx, 1
jmp loc_55967
loc_558D7:
cmp byte ptr [rdi+7E7h], 0
jz short loc_55909
mov ecx, [rbp+var_78]
mov dword ptr [rsp+0D0h+var_D0], 6
mov rdi, rbx
mov rdx, r12
mov r8d, r15d
mov r9d, 1
call _ma_log_add
mov ecx, eax
mov eax, 0FFFFFFFFh
test cl, cl
jnz short loc_55945
loc_55909:
xor eax, eax
jmp short loc_55945
loc_5590D:
mov rdi, [rbp+var_30]
mov rcx, [rdi]
loc_55914:
mov ecx, [rcx+7C0h]
cmp esi, ecx
cmovb ecx, esi
mov r9d, [rbp+var_78]
movsx eax, al
mov [rsp+0D0h+var_C0], eax
mov rax, [rbp+var_68]
mov [rsp+0D0h+var_C8], rax
mov dword ptr [rsp+0D0h+var_D0], r15d
mov rsi, r10
mov rdx, rbx
mov r8, r12
call _ma_split_page
loc_55945:
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_55957:
movzx ecx, word ptr [rsi+1]
rol cx, 8
movzx edx, cx
mov ecx, 3
loc_55967:
mov r13, [rbp+var_30]
mov r15, [rbp+var_40]
cmp edx, r15d
jnz short loc_55909
movzx edx, word ptr [rdi+502h]
mov [rbp+var_30], rdx
mov rdx, [rbp+var_38]
lea r12, [rdx+rax]
inc r12
add rsi, rcx
mov rax, [r14+0C0h]
mov rdi, [rax]
mov edx, r15d
mov rcx, r12
mov r8, r15
xor r9d, r9d
call ha_compare_text
test eax, eax
jnz loc_55909
mov esi, 28h ; '('
mov edx, 10h
xor edi, edi
call my_malloc
mov [r13+320h], rax
mov [rsp+0D0h+var_D0], 0
xor edi, edi
mov rsi, rax
mov rdx, [rbp+var_30]
xor ecx, ecx
mov r8d, 12Ch
mov r9d, 32h ; '2'
call init_dynamic_array2
cmp [rbp+var_38], 0
jnz loc_55909
mov rcx, [rbp+var_30]
mov eax, ecx
add eax, r15d
lea r14, [r12+rax]
add r14, 2
mov eax, dword ptr [rbp+var_48]
mov r12, [rbp+var_50]
add r12, rax
lea r15, [rcx+2]
loc_55A16:
cmp r14, r12
jnb short loc_55A2F
mov rdi, [r13+320h]
mov rsi, r14
call insert_dynamic
add r14, r15
jmp short loc_55A16
loc_55A2F:
mov rax, [rbp+var_40]
add eax, r15d
mov rdx, [rbp+var_60]
add eax, [rdx+744h]
mov [rbx+20h], eax
mov rsi, [rbx+10h]
mov ecx, [rdx+744h]
mov [rsi+rcx-1], al
mov rsi, [rbx+10h]
mov ecx, [rdx+744h]
mov [rsi+rcx-2], ah
jmp loc_55909
|
long long ma_insert(
_DWORD *a1,
unsigned __int8 **a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
char a8)
{
long long v11; // rax
long long v12; // rsi
long long v13; // rcx
long long v14; // r13
long long v15; // rax
long long v16; // rax
long long v17; // rdx
long long v18; // rcx
unsigned __int8 *v19; // r14
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
int v23; // r9d
int v24; // r15d
long long v25; // rsi
unsigned int v26; // edx
unsigned __int8 **v27; // r10
long long v28; // rdi
int v29; // eax
unsigned int v30; // eax
bool v31; // cf
unsigned int v32; // eax
int v34; // edi
long long v35; // rcx
int v36; // r8d
long long result; // rax
unsigned __int8 *v38; // rsi
long long v39; // rax
int v40; // edx
long long v41; // rcx
char v42; // cl
unsigned int v43; // ecx
_DWORD *v44; // r13
int v45; // r15d
long long v46; // r12
long long v47; // rax
unsigned long long v48; // r14
unsigned long long v49; // r12
char *v50; // r15
long long v51; // rdx
int v52; // eax
_BYTE v53[24]; // [rsp+18h] [rbp-B8h] BYREF
long long v54; // [rsp+30h] [rbp-A0h]
unsigned int v55; // [rsp+58h] [rbp-78h]
long long v56; // [rsp+68h] [rbp-68h]
long long v57; // [rsp+70h] [rbp-60h]
long long v58; // [rsp+78h] [rbp-58h]
long long v59; // [rsp+80h] [rbp-50h]
long long v60; // [rsp+88h] [rbp-48h]
unsigned __int8 **v61; // [rsp+90h] [rbp-40h]
long long v62; // [rsp+98h] [rbp-38h]
_DWORD *v63; // [rsp+A0h] [rbp-30h]
v58 = a6;
v63 = a1;
v11 = *(_QWORD *)a1;
v12 = *(unsigned int *)(a3 + 40);
v13 = *(_QWORD *)(a3 + 16);
v60 = *(unsigned int *)(a3 + 32);
v14 = v13 + v60;
v57 = v11;
v15 = *(unsigned int *)(v11 + 1860);
v59 = v13;
v16 = v12 + v13 + v15;
v17 = 0LL;
v56 = a5;
v18 = a5;
if ( v16 == a4 )
v18 = 0LL;
if ( v14 != a4 )
v17 = a4;
v19 = a2[1];
v61 = a2;
v62 = v12;
v24 = (*((long long ( **)(unsigned __int8 **, long long, long long, long long, long long, _BYTE *))v19 + 30))(
a2,
v12,
v17,
v18,
v18,
v53);
if ( v24 > 0 )
{
if ( v24 < 2 * (unsigned int)*((unsigned __int16 *)v19 + 87) + 21 )
{
bmove_upp(v14 + (unsigned int)v24, v14);
goto LABEL_10;
}
LABEL_21:
ma_set_fatal_error(v63, (_BYTE *)&dword_7C + 2, v20, v21, v22, v23);
return 0xFFFFFFFFLL;
}
v21 = 2 * (unsigned int)*((unsigned __int16 *)v19 + 87) + 21;
if ( (unsigned int)v21 <= -v24 )
goto LABEL_21;
memmove(a4, a4 - v24, (unsigned int)(v24 + v14 - a4));
LABEL_10:
(*((void ( **)(unsigned __int8 *, long long, _BYTE *))v19 + 31))(v19, a4, v53);
v25 = v60;
v26 = v24 + v60;
v27 = v61;
v28 = v57;
if ( (*((_BYTE *)v61 + 26) & 0x18) != 0 )
{
v29 = *(_DWORD *)(a3 + 44) | 2;
*(_DWORD *)(a3 + 44) = v29;
*(_BYTE *)(*(_QWORD *)(a3 + 16) + (unsigned int)(*(_DWORD *)(v28 + 1860) - 3)) = v29;
}
*(_DWORD *)(a3 + 32) = v26;
*(_BYTE *)(*(_QWORD *)(a3 + 16) + *(unsigned int *)(v28 + 1860) - 1LL) = v26;
*(_BYTE *)(*(_QWORD *)(a3 + 16) + *(unsigned int *)(v28 + 1860) - 2LL) = BYTE1(v26);
v30 = *(_DWORD *)(v28 + 1984);
v31 = v30 < v26;
v32 = v30 - v26;
if ( !v31 )
{
if ( v32 <= 0x1F
&& v14 == a4
&& (*((_WORD *)v19 + 81) & 0x80) != 0
&& *(_DWORD *)(v28 + 996) <= *(_DWORD *)(v28 + 1856)
&& (*(_BYTE *)(v28 + 1824) & 5) != 0 )
{
LODWORD(v60) = v26;
v38 = *v27;
v39 = v59 + *(unsigned int *)(v28 + 1860);
v61 = (unsigned __int8 **)*(unsigned __int8 *)(v62 + v39);
v40 = *v38;
if ( v40 == 255 )
{
v40 = (unsigned __int16)__ROL2__(*(_WORD *)(v38 + 1), 8);
v41 = 3LL;
}
else
{
v41 = 1LL;
}
v44 = v63;
v45 = (int)v61;
if ( v40 == (_DWORD)v61 )
{
v63 = (_DWORD *)*(unsigned __int16 *)(v28 + 1282);
v46 = v62 + v39 + 1;
if ( !(unsigned int)ha_compare_text(**((_QWORD **)v19 + 24), &v38[v41], (unsigned int)v61, v46, v61, 0LL) )
{
v47 = my_malloc(0LL, 40LL, 16LL);
*((_QWORD *)v44 + 100) = v47;
init_dynamic_array2(0, v47, (_DWORD)v63, 0, 300, 50, 0LL);
if ( !v62 )
{
v48 = v46 + (unsigned int)(v45 + (_DWORD)v63) + 2;
v49 = (unsigned int)v60 + v59;
v50 = (char *)v63 + 2;
while ( v48 < v49 )
{
insert_dynamic(*((_QWORD *)v44 + 100), v48);
v48 += (unsigned long long)v50;
}
v51 = v57;
v52 = *(_DWORD *)(v57 + 1860) + (_DWORD)v50 + (_DWORD)v61;
*(_DWORD *)(a3 + 32) = v52;
*(_BYTE *)(*(_QWORD *)(a3 + 16) + *(unsigned int *)(v51 + 1860) - 1LL) = v52;
*(_BYTE *)(*(_QWORD *)(a3 + 16) + *(unsigned int *)(v51 + 1860) - 2LL) = BYTE1(v52);
}
}
}
}
else if ( *(_BYTE *)(v28 + 2023) )
{
v42 = ma_log_add(a3, v25, a4, v55, v24);
result = 0xFFFFFFFFLL;
if ( v42 )
return result;
}
return 0LL;
}
if ( v62 )
a8 = 0;
if ( a8 || !v58 || (*((_WORD *)v19 + 81) & 0x28) != 0 )
{
v34 = (int)v63;
v35 = *(_QWORD *)v63;
}
else
{
v34 = (int)v63;
v35 = *(_QWORD *)v63;
if ( !*((_BYTE *)v63 + 1666) && !*(_BYTE *)(v35 + 1100) )
{
v54 = a4;
v36 = v58;
*(_BYTE *)(*((_QWORD *)v63 + 93) + 24LL * *(unsigned int *)(v58 + 48) + 16) = 1;
return ma_balance_page(v34, (_DWORD)v19, (_DWORD)v27, a3, v36, a7, (long long)v53);
}
}
v43 = *(_DWORD *)(v35 + 1984);
if ( (unsigned int)v25 < v43 )
v43 = v25;
return ma_split_page(v34, (_DWORD)v27, a3, v43, a4, v55, v24, v56, a8);
}
|
_ma_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0x58],R9
MOV R12,RCX
MOV RBX,RDX
MOV R10,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV RAX,qword ptr [RDI]
MOV EDX,dword ptr [RDX + 0x20]
MOV ESI,dword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RBP + -0x48],RDX
LEA R13,[RCX + RDX*0x1]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RAX + 0x744]
MOV qword ptr [RBP + -0x50],RCX
ADD RCX,RSI
ADD RAX,RCX
XOR EDX,EDX
CMP RAX,R12
MOV qword ptr [RBP + -0x68],R8
MOV RCX,R8
CMOVZ RCX,RDX
CMP R13,R12
CMOVNZ RDX,R12
MOV R14,qword ptr [R10 + 0x8]
LEA R9,[RBP + -0xb8]
MOV qword ptr [RBP + -0x40],R10
MOV RDI,R10
MOV qword ptr [RBP + -0x38],RSI
MOV R8,RCX
CALL qword ptr [R14 + 0xf0]
MOV R15D,EAX
TEST EAX,EAX
JLE 0x00155719
MOVZX EAX,word ptr [R14 + 0xae]
LEA EAX,[0x15 + RAX*0x2]
CMP R15D,EAX
JNC 0x0015585a
MOV EDI,R15D
ADD RDI,R13
MOV EDX,R13D
SUB EDX,R12D
MOV RSI,R13
CALL 0x001b3768
JMP 0x0015574f
LAB_00155719:
MOV EAX,R15D
NEG EAX
MOVZX ECX,word ptr [R14 + 0xae]
LEA ECX,[0x15 + RCX*0x2]
CMP ECX,EAX
JBE 0x0015585a
MOVSXD RAX,R15D
MOV RSI,R12
SUB RSI,RAX
MOV EDX,R13D
SUB EDX,R12D
ADD EDX,R15D
MOV RDI,R12
CALL 0x0012a130
LAB_0015574f:
LEA RDX,[RBP + -0xb8]
MOV RDI,R14
MOV RSI,R12
CALL qword ptr [R14 + 0xf8]
MOV RSI,qword ptr [RBP + -0x48]
LEA EDX,[R15 + RSI*0x1]
MOV R10,qword ptr [RBP + -0x40]
TEST byte ptr [R10 + 0x1a],0x18
MOV RDI,qword ptr [RBP + -0x60]
JZ 0x00155799
MOV EAX,dword ptr [RBX + 0x2c]
OR EAX,0x2
MOV dword ptr [RBX + 0x2c],EAX
MOV RCX,qword ptr [RBX + 0x10]
MOV R8D,EDX
MOV EDX,dword ptr [RDI + 0x744]
ADD EDX,-0x3
MOV byte ptr [RCX + RDX*0x1],AL
MOV EDX,R8D
LAB_00155799:
MOV dword ptr [RBX + 0x20],EDX
MOV RAX,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RDI + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],DL
MOV RAX,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RDI + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x2],DH
MOV EAX,dword ptr [RDI + 0x7c0]
SUB EAX,EDX
JNC 0x00155872
XOR ECX,ECX
CMP qword ptr [RBP + -0x38],0x0
MOVZX EAX,byte ptr [RBP + 0x18]
CMOVNZ EAX,ECX
TEST AL,AL
JNZ 0x0015590d
CMP qword ptr [RBP + -0x58],0x0
JZ 0x0015590d
MOVZX ECX,word ptr [R14 + 0xa2]
AND ECX,0x28
JNZ 0x0015590d
MOV RDI,qword ptr [RBP + -0x30]
CMP byte ptr [RDI + 0x682],0x0
MOV RCX,qword ptr [RDI]
JNZ 0x00155914
CMP byte ptr [RCX + 0x44c],0x0
JNZ 0x00155914
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0xa0],R12
MOV RAX,qword ptr [RDI + 0x2e8]
MOV R8,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [R8 + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
LEA RAX,[RBP + -0xb8]
MOV qword ptr [RSP],RAX
MOV RSI,R14
MOV RDX,R10
MOV RCX,RBX
CALL 0x00155a64
JMP 0x00155945
LAB_0015585a:
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,0x7e
CALL 0x00139cfc
MOV EAX,0xffffffff
JMP 0x00155945
LAB_00155872:
CMP EAX,0x1f
JA 0x001558d7
CMP R13,R12
JNZ 0x001558d7
MOVZX EAX,word ptr [R14 + 0xa2]
AND EAX,0x80
JZ 0x001558d7
MOV EAX,dword ptr [RDI + 0x3e4]
CMP EAX,dword ptr [RDI + 0x740]
JA 0x001558d7
TEST byte ptr [RDI + 0x720],0x5
JZ 0x001558d7
MOV dword ptr [RBP + -0x48],EDX
MOV RSI,qword ptr [R10]
MOV EAX,dword ptr [RDI + 0x744]
ADD RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + RAX*0x1]
MOV qword ptr [RBP + -0x40],RCX
MOVZX EDX,byte ptr [RSI]
CMP EDX,0xff
JZ 0x00155957
MOV ECX,0x1
JMP 0x00155967
LAB_001558d7:
CMP byte ptr [RDI + 0x7e7],0x0
JZ 0x00155909
MOV ECX,dword ptr [RBP + -0x78]
MOV dword ptr [RSP],0x6
MOV RDI,RBX
MOV RDX,R12
MOV R8D,R15D
MOV R9D,0x1
CALL 0x0013e312
MOV ECX,EAX
MOV EAX,0xffffffff
TEST CL,CL
JNZ 0x00155945
LAB_00155909:
XOR EAX,EAX
JMP 0x00155945
LAB_0015590d:
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RDI]
LAB_00155914:
MOV ECX,dword ptr [RCX + 0x7c0]
CMP ESI,ECX
CMOVC ECX,ESI
MOV R9D,dword ptr [RBP + -0x78]
MOVSX EAX,AL
MOV dword ptr [RSP + 0x10],EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP],R15D
MOV RSI,R10
MOV RDX,RBX
MOV R8,R12
CALL 0x00156725
LAB_00155945:
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00155957:
MOVZX ECX,word ptr [RSI + 0x1]
ROL CX,0x8
MOVZX EDX,CX
MOV ECX,0x3
LAB_00155967:
MOV R13,qword ptr [RBP + -0x30]
MOV R15,qword ptr [RBP + -0x40]
CMP EDX,R15D
JNZ 0x00155909
MOVZX EDX,word ptr [RDI + 0x502]
MOV qword ptr [RBP + -0x30],RDX
MOV RDX,qword ptr [RBP + -0x38]
LEA R12,[RDX + RAX*0x1]
INC R12
ADD RSI,RCX
MOV RAX,qword ptr [R14 + 0xc0]
MOV RDI,qword ptr [RAX]
MOV EDX,R15D
MOV RCX,R12
MOV R8,R15
XOR R9D,R9D
CALL 0x001a59e8
TEST EAX,EAX
JNZ 0x00155909
MOV ESI,0x28
MOV EDX,0x10
XOR EDI,EDI
CALL 0x001a6f99
MOV qword ptr [R13 + 0x320],RAX
MOV qword ptr [RSP],0x0
XOR EDI,EDI
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV R8D,0x12c
MOV R9D,0x32
CALL 0x0019691c
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00155909
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,ECX
ADD EAX,R15D
LEA R14,[R12 + RAX*0x1]
ADD R14,0x2
MOV EAX,dword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x50]
ADD R12,RAX
LEA R15,[RCX + 0x2]
LAB_00155a16:
CMP R14,R12
JNC 0x00155a2f
MOV RDI,qword ptr [R13 + 0x320]
MOV RSI,R14
CALL 0x001969ba
ADD R14,R15
JMP 0x00155a16
LAB_00155a2f:
MOV RAX,qword ptr [RBP + -0x40]
ADD EAX,R15D
MOV RDX,qword ptr [RBP + -0x60]
ADD EAX,dword ptr [RDX + 0x744]
MOV dword ptr [RBX + 0x20],EAX
MOV RSI,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RDX + 0x744]
MOV byte ptr [RSI + RCX*0x1 + -0x1],AL
MOV RSI,qword ptr [RBX + 0x10]
MOV ECX,dword ptr [RDX + 0x744]
MOV byte ptr [RSI + RCX*0x1 + -0x2],AH
JMP 0x00155909
|
int8
_ma_insert(long *param_1,int8 *param_2,long param_3,void *param_4,void *param_5,long param_6,
int8 param_7,char param_8)
{
void *pvVar1;
byte bVar2;
byte *pbVar3;
long *plVar4;
char cVar5;
uint uVar6;
uint uVar7;
int iVar8;
int8 uVar9;
long lVar10;
long lVar11;
void *pvVar12;
long lVar13;
ulong uVar14;
uint uVar15;
void *pvVar16;
ulong uVar17;
int8 in_stack_ffffffffffffff28;
int4 uVar18;
int1 local_c0 [24];
void *local_a8;
int4 local_80;
void *local_70;
long local_68;
long local_60;
long local_58;
ulong local_50;
int8 *local_48;
ulong local_40;
long *local_38;
uVar18 = (int4)((ulong)in_stack_ffffffffffffff28 >> 0x20);
local_68 = *param_1;
local_50 = (ulong)*(uint *)(param_3 + 0x20);
local_40 = (ulong)*(uint *)(param_3 + 0x28);
local_58 = *(long *)(param_3 + 0x10);
pvVar1 = (void *)(local_58 + local_50);
pvVar12 = param_5;
if ((void *)((ulong)*(uint *)(local_68 + 0x744) + local_58 + local_40) == param_4) {
pvVar12 = (void *)0x0;
}
pvVar16 = (void *)0x0;
if (pvVar1 != param_4) {
pvVar16 = param_4;
}
lVar11 = param_2[1];
local_70 = param_5;
local_60 = param_6;
local_48 = param_2;
local_38 = param_1;
uVar6 = (**(code **)(lVar11 + 0xf0))(param_2,local_40,pvVar16,pvVar12,pvVar12,local_c0);
if ((int)uVar6 < 1) {
if ((uint)*(ushort *)(lVar11 + 0xae) * 2 + 0x15 <= -uVar6) goto LAB_0015585a;
memmove(param_4,(void *)((long)param_4 - (long)(int)uVar6),
(ulong)(((int)pvVar1 - (int)param_4) + uVar6));
}
else {
if ((uint)*(ushort *)(lVar11 + 0xae) * 2 + 0x15 <= uVar6) {
LAB_0015585a:
_ma_set_fatal_error(local_38,0x7e);
return 0xffffffff;
}
bmove_upp((ulong)uVar6 + (long)pvVar1,pvVar1,(int)pvVar1 - (int)param_4);
}
(**(code **)(lVar11 + 0xf8))(lVar11,param_4,local_c0);
plVar4 = local_38;
uVar15 = uVar6 + (uint)local_50;
if ((*(byte *)((long)local_48 + 0x1a) & 0x18) != 0) {
uVar7 = *(uint *)(param_3 + 0x2c) | 2;
*(uint *)(param_3 + 0x2c) = uVar7;
*(char *)(*(long *)(param_3 + 0x10) + (ulong)(*(int *)(local_68 + 0x744) - 3)) = (char)uVar7;
}
*(uint *)(param_3 + 0x20) = uVar15;
*(char *)(*(long *)(param_3 + 0x10) + -1 + (ulong)*(uint *)(local_68 + 0x744)) = (char)uVar15;
*(char *)(*(long *)(param_3 + 0x10) + -2 + (ulong)*(uint *)(local_68 + 0x744)) =
(char)(uVar15 >> 8);
if (*(uint *)(local_68 + 0x7c0) < uVar15) {
if (local_40 != 0) {
param_8 = '\0';
}
if (((param_8 == '\0') && (local_60 != 0)) && ((*(ushort *)(lVar11 + 0xa2) & 0x28) == 0)) {
lVar10 = *local_38;
if ((*(char *)((long)local_38 + 0x682) == '\0') && (*(char *)(lVar10 + 0x44c) == '\0')) {
*(int1 *)(local_38[0x5d] + 0x10 + (ulong)*(uint *)(local_60 + 0x30) * 0x18) = 1;
local_a8 = param_4;
uVar9 = _ma_balance_page(local_38,lVar11,local_48,param_3,local_60,param_7,local_c0);
return uVar9;
}
}
else {
lVar10 = *local_38;
}
uVar14 = (ulong)*(uint *)(lVar10 + 0x7c0);
if ((uint)local_50 < *(uint *)(lVar10 + 0x7c0)) {
uVar14 = local_50 & 0xffffffff;
}
uVar9 = _ma_split_page(local_38,local_48,param_3,uVar14,param_4,local_80,CONCAT44(uVar18,uVar6),
local_70,(int)param_8);
}
else {
if ((((*(uint *)(local_68 + 0x7c0) - uVar15 < 0x20) && (pvVar1 == param_4)) &&
((*(ushort *)(lVar11 + 0xa2) & 0x80) != 0)) &&
((*(uint *)(local_68 + 0x3e4) <= *(uint *)(local_68 + 0x740) &&
((*(byte *)(local_68 + 0x720) & 5) != 0)))) {
local_50 = CONCAT44(local_50._4_4_,uVar15);
pbVar3 = (byte *)*local_48;
lVar10 = (ulong)*(uint *)(local_68 + 0x744) + local_58;
bVar2 = *(byte *)(local_40 + lVar10);
local_48 = (int8 *)(ulong)bVar2;
uVar6 = (uint)*pbVar3;
if (*pbVar3 == 0xff) {
uVar6 = (uint)(ushort)(*(ushort *)(pbVar3 + 1) << 8 | *(ushort *)(pbVar3 + 1) >> 8);
lVar13 = 3;
}
else {
lVar13 = 1;
}
if (uVar6 == bVar2) {
local_38 = (long *)(ulong)*(ushort *)(local_68 + 0x502);
lVar10 = local_40 + lVar10 + 1;
iVar8 = ha_compare_text(**(int8 **)(lVar11 + 0xc0),pbVar3 + lVar13,local_48,lVar10,
local_48,0);
if (iVar8 == 0) {
lVar11 = my_malloc(0,0x28,0x10);
plVar4[100] = lVar11;
init_dynamic_array2(0,lVar11,local_38,0,300,0x32,0);
if (local_40 == 0) {
uVar14 = local_58 + (local_50 & 0xffffffff);
lVar11 = (long)local_38 + 2;
for (uVar17 = lVar10 + (ulong)((int)local_38 + (uint)bVar2) + 2; uVar17 < uVar14;
uVar17 = uVar17 + lVar11) {
insert_dynamic(plVar4[100],uVar17);
}
iVar8 = (int)local_48 + (int)lVar11 + *(int *)(local_68 + 0x744);
*(int *)(param_3 + 0x20) = iVar8;
*(char *)(*(long *)(param_3 + 0x10) + -1 + (ulong)*(uint *)(local_68 + 0x744)) =
(char)iVar8;
*(char *)(*(long *)(param_3 + 0x10) + -2 + (ulong)*(uint *)(local_68 + 0x744)) =
(char)((uint)iVar8 >> 8);
}
}
}
}
else if ((*(char *)(local_68 + 0x7e7) != '\0') &&
(cVar5 = _ma_log_add(param_3,local_50,param_4,local_80,(ulong)uVar6,1,CONCAT44(uVar18,6)
), cVar5 != '\0')) {
return 0xffffffff;
}
uVar9 = 0;
}
return uVar9;
}
|
|
9,570 |
setup_object_hash_get_key(unsigned char const*, unsigned long*, char)
|
eloqsql/storage/perfschema/pfs_setup_object.cc
|
C_MODE_START
static uchar *setup_object_hash_get_key(const uchar *entry, size_t *length,
my_bool)
{
const PFS_setup_object * const *typed_entry;
const PFS_setup_object *setup_object;
const void *result;
typed_entry= reinterpret_cast<const PFS_setup_object* const *> (entry);
assert(typed_entry != NULL);
setup_object= *typed_entry;
assert(setup_object != NULL);
*length= setup_object->m_key.m_key_length;
result= setup_object->m_key.m_hash_key;
return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
}
|
O0
|
cpp
|
setup_object_hash_get_key(unsigned char const*, unsigned long*, char):
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x188(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax)
|
_ZL25setup_object_hash_get_keyPKhPmc:
push rbp
mov rbp, rsp
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov eax, [rax+188h]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
add rax, 4
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
pop rbp
retn
|
long long setup_object_hash_get_key(const unsigned __int8 *a1, unsigned long long *a2)
{
long long v3; // [rsp+8h] [rbp-28h]
v3 = *(_QWORD *)a1;
*a2 = *(unsigned int *)(*(_QWORD *)a1 + 392LL);
return v3 + 4;
}
|
setup_object_hash_get_key:
PUSH RBP
MOV RBP,RSP
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x188]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x4
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
POP RBP
RET
|
/* setup_object_hash_get_key(unsigned char const*, unsigned long*, char) */
long setup_object_hash_get_key(uchar *param_1,ulong *param_2,char param_3)
{
long lVar1;
lVar1 = *(long *)param_1;
*param_2 = (ulong)*(uint *)(lVar1 + 0x188);
return lVar1 + 4;
}
|
|
9,571 |
kv_cache_type_from_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/arg.cpp
|
static ggml_type kv_cache_type_from_str(const std::string & s) {
for (const auto & type : kv_cache_types) {
if (ggml_type_name(type) == s) {
return type;
}
}
throw std::runtime_error("Unsupported cache type: " + s);
}
|
O3
|
cpp
|
kv_cache_type_from_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x1031fa(%rip), %rbx # 0x162f18
movq 0x1031fb(%rip), %r15 # 0x162f20
cmpq %r15, %rbx
je 0x5fd53
movl (%rbx), %edi
callq 0x21330
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f60
testl %eax, %eax
je 0x5fd46
addq $0x4, %rbx
jmp 0x5fd25
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20640
movq %rax, %rbx
leaq 0xbb6ee(%rip), %rsi # 0x11b455
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x640a1
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20470
xorl %ebp, %ebp
movq 0x102233(%rip), %rsi # 0x161fc0
movq 0x1021ec(%rip), %rdx # 0x161f80
movq %rbx, %rdi
callq 0x20a40
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fdba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0x5fdc4
jmp 0x5fdcc
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ef0
movq %r14, %rdi
callq 0x20ae0
|
_ZL22kv_cache_type_from_strRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rdi
mov rbx, cs:_ZL14kv_cache_types; kv_cache_types
mov r15, cs:qword_162F20
loc_5FD25:
cmp rbx, r15
jz short loc_5FD53
mov edi, [rbx]
call _ggml_type_name
mov rdi, r14
mov rsi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_5FD46
add rbx, 4
jmp short loc_5FD25
loc_5FD46:
mov eax, [rbx]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5FD53:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUnsupportedCac; "Unsupported cache type: "
lea rdi, [rsp+48h+var_40]
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+48h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5FDBA
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5FDBA:
test bpl, bpl
jnz short loc_5FDC4
jmp short loc_5FDCC
mov r14, rax
loc_5FDC4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5FDCC:
mov rdi, r14
call __Unwind_Resume
|
long long kv_cache_type_from_str(long long a1)
{
unsigned int *v1; // rbx
long long v2; // r15
long long v3; // rax
void *exception; // rbx
_BYTE v6[16]; // [rsp+8h] [rbp-40h] BYREF
v1 = (unsigned int *)kv_cache_types;
v2 = qword_162F20;
while ( 1 )
{
if ( v1 == (unsigned int *)v2 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>(v6, "Unsupported cache type: ", a1);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = ggml_type_name(*v1);
if ( !(unsigned int)std::string::compare(a1, v3) )
break;
++v1;
}
return *v1;
}
|
kv_cache_type_from_str:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV RBX,qword ptr [0x00262f18]
MOV R15,qword ptr [0x00262f20]
LAB_0015fd25:
CMP RBX,R15
JZ 0x0015fd53
MOV EDI,dword ptr [RBX]
CALL 0x00121330
MOV RDI,R14
MOV RSI,RAX
CALL 0x00120f60
TEST EAX,EAX
JZ 0x0015fd46
ADD RBX,0x4
JMP 0x0015fd25
LAB_0015fd46:
MOV EAX,dword ptr [RBX]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015fd53:
MOV EDI,0x10
CALL 0x00120640
MOV RBX,RAX
LAB_0015fd60:
LEA RSI,[0x21b455]
LEA RDI,[RSP + 0x8]
MOV RDX,R14
CALL 0x001640a1
MOV BPL,0x1
LAB_0015fd77:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00120470
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,RBX
CALL 0x00120a40
|
/* kv_cache_type_from_str(std::__cxx11::string const&) */
int4 kv_cache_type_from_str(string *param_1)
{
int4 *puVar1;
int iVar2;
runtime_error *this;
int4 *puVar3;
string local_40 [32];
puVar1 = DAT_00262f20;
puVar3 = kv_cache_types;
while( true ) {
if (puVar3 == puVar1) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015fd60 to 0015fd73 has its CatchHandler @ 0015fdc1 */
std::operator+((char *)local_40,(string *)"Unsupported cache type: ");
/* try { // try from 0015fd77 to 0015fd9b has its CatchHandler @ 0015fd9c */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
ggml_type_name(*puVar3);
iVar2 = std::__cxx11::string::compare((char *)param_1);
if (iVar2 == 0) break;
puVar3 = puVar3 + 1;
}
return *puVar3;
}
|
|
9,572 |
blackrock_init
|
xtate/src/generate-modules/blackrock-gen.c
|
bool blackrock_init(const XConf *xconf, uint64_t *count_targets,
uint64_t *count_endpoints, bool *init_ipv4,
bool *init_ipv6) {
blackrock_conf.targets = &xconf->targets;
blackrock_conf.seed = xconf->seed;
/**
* NOTE: Must has at least one ip and one port.
*/
if (xconf->targets.count_ipv4s == 0 && xconf->targets.count_ipv6s.hi == 0 &&
xconf->targets.count_ipv6s.lo == 0) {
LOG(LEVEL_ERROR, "target IP address list empty.\n");
return false;
}
uint64_t count_ports = rangelist_count(&xconf->targets.ports);
if (count_ports == 0) {
targetset_add_port_str((TargetSet *)(&xconf->targets), "o:0", 0);
LOG(LEVEL_WARN, "(BlackRock) no ports were specified or remained, a "
"fake port o:0 was"
" specified automaticlly.\n");
targetset_optimize((TargetSet *)&xconf->targets);
count_ports = 1;
}
/**
* !only support 63-bit scans
*/
if (int128_bitcount(targetset_count(&xconf->targets)) > 63) {
LOG(LEVEL_ERROR, "range is too large for scanning: %u-bits\n",
int128_bitcount(targetset_count(&xconf->targets)));
LOG(LEVEL_HINT, "range = target_count * endpoint_count\n");
LOG(LEVEL_HINT, "max range is within 63-bits\n");
return false;
}
/**
* If the IP address range is very big, then require the
* user apply an exclude range
*/
uint64_t count_ips = rangelist_count(&xconf->targets.ipv4) +
range6list_count(&xconf->targets.ipv6).lo;
if (count_ips > 1000000000ULL &&
rangelist_count(&xconf->exclude.ipv4) == 0) {
LOG(LEVEL_ERROR, "range too big, need confirmation\n");
LOG(LEVEL_HINT,
"to prevent accidents, at least one --exclude must be specified\n");
LOG(LEVEL_HINT,
"use \"--exclude 255.255.255.255\" as a simple confirmation\n");
return false;
}
/**
* Count target info
*/
*count_targets = count_ips;
*count_endpoints = count_ports;
*init_ipv4 = targetset_has_any_ipv4(&xconf->targets);
*init_ipv6 = targetset_has_any_ipv6(&xconf->targets);
blackrock_conf.count_ipv4 = rangelist_count(&xconf->targets.ipv4);
blackrock_conf.count_ipv6 = range6list_count(&xconf->targets.ipv6).lo;
blackrock_conf.range_all = count_ips * count_ports;
blackrock_conf.range_ipv6 =
blackrock_conf.count_ipv6 * rangelist_count(&xconf->targets.ports);
/**
* prepare blackrock algorithm
*/
if (blackrock_conf.no_random)
return true;
if (blackrock_conf.rounds <= 0) {
blackrock_conf.rounds = XCONF_DFT_BLACKROCK_ROUNDS;
}
blackrock1_init(&blackrock_conf.br_table, blackrock_conf.range_all,
xconf->seed, blackrock_conf.rounds);
return true;
}
|
O3
|
c
|
blackrock_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %rbp
movq %rdi, %rbx
leaq 0x188(%rdi), %r15
movq %r15, 0x183437(%rip) # 0x1a2ff0
movq 0x6b8(%rdi), %rax
movq %rax, 0x183499(%rip) # 0x1a3060
cmpq $0x0, 0x200(%rdi)
jne 0x1fbe9
cmpq $0x0, 0x208(%rbx)
jne 0x1fbe9
cmpq $0x0, 0x210(%rbx)
je 0x1fde4
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x1d0(%rbx), %r12
movq %r12, %rdi
callq 0x471c3
movq %rax, %r13
testq %rax, %rax
jne 0x1fc39
leaq 0x415b0(%rip), %rsi # 0x611c1
movq %r15, %rdi
xorl %edx, %edx
callq 0x4925d
leaq 0x415a3(%rip), %rsi # 0x611c5
xorl %edi, %edi
xorl %eax, %eax
callq 0x536da
movq %r15, %rdi
callq 0x48e96
movl $0x1, %r13d
movq %r15, %rdi
callq 0x48027
movq %rax, %rdi
movq %rdx, %rsi
callq 0x44b74
cmpl $0x40, %eax
jb 0x1fca6
movq %r15, %rdi
callq 0x48027
movq %rax, %rdi
movq %rdx, %rsi
callq 0x44b74
leaq 0x415b8(%rip), %rsi # 0x61223
xorl %ebp, %ebp
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl %eax, %edx
xorl %eax, %eax
callq 0x536da
leaq 0x415cb(%rip), %rsi # 0x6124d
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
xorl %eax, %eax
callq 0x536da
leaq 0x415df(%rip), %rsi # 0x61274
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
xorl %eax, %eax
callq 0x536da
jmp 0x1fd9f
movq %rbp, (%rsp)
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %r15, %rdi
callq 0x471c3
movq %rax, %r12
leaq 0x1a8(%rbx), %r14
movq %r14, %rdi
callq 0x480bc
movq %rdx, %rbp
addq %r12, %rbp
cmpq $0x3b9aca01, %rbp # imm = 0x3B9ACA01
jb 0x1fcf2
leaq 0x218(%rbx), %rdi
callq 0x471c3
testq %rax, %rax
je 0x1fdb0
movq 0x18(%rsp), %rax
movq %rbp, (%rax)
movq 0x20(%rsp), %rax
movq %r13, (%rax)
movq %r15, %rdi
callq 0x48fc0
movq (%rsp), %rcx
movb %al, (%rcx)
movq %r15, %rdi
callq 0x48fc8
movq 0x10(%rsp), %rcx
movb %al, (%rcx)
movq %r15, %rdi
callq 0x471c3
movq %rax, 0x183312(%rip) # 0x1a3040
movq %r14, %rdi
callq 0x480bc
movq %rdx, %r14
movq %rdx, 0x183308(%rip) # 0x1a3048
imulq %r13, %rbp
movq %rbp, 0x183305(%rip) # 0x1a3050
movq 0x8(%rsp), %rdi
callq 0x471c3
imulq %r14, %rax
movq %rax, 0x1832f8(%rip) # 0x1a3058
movb $0x1, %bpl
testb $0x1, 0x183302(%rip) # 0x1a306c
jne 0x1fd9f
movl 0x1832f6(%rip), %ecx # 0x1a3068
testl %ecx, %ecx
jne 0x1fd85
movl $0xe, 0x1832e8(%rip) # 0x1a3068
movl $0xe, %ecx
movq 0x1832c4(%rip), %rsi # 0x1a3050
movq 0x6b8(%rbx), %rdx
leaq 0x18325e(%rip), %rdi # 0x1a2ff8
callq 0x1a2e8
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x414da(%rip), %rsi # 0x61291
xorl %ebp, %ebp
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x536da
leaq 0x414e7(%rip), %rsi # 0x612b3
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
xorl %eax, %eax
callq 0x536da
leaq 0x41514(%rip), %rsi # 0x612f3
jmp 0x1fc95
leaq 0x413b7(%rip), %rsi # 0x611a2
xorl %ebp, %ebp
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
jmp 0x1fc9a
|
blackrock_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, r8
mov rbp, rcx
mov rbx, rdi
lea r15, [rdi+188h]
mov cs:blackrock_conf, r15
mov rax, [rdi+6B8h]
mov cs:qword_1A3060, rax
cmp qword ptr [rdi+200h], 0
jnz short loc_1FBE9
cmp qword ptr [rbx+208h], 0
jnz short loc_1FBE9
cmp qword ptr [rbx+210h], 0
jz loc_1FDE4
loc_1FBE9:
mov [rsp+58h+var_40], rsi
mov [rsp+58h+var_38], rdx
lea r12, [rbx+1D0h]
mov rdi, r12
call rangelist_count
mov r13, rax
test rax, rax
jnz short loc_1FC39
lea rsi, aO0; "o:0"
mov rdi, r15
xor edx, edx
call targetset_add_port_str
lea rsi, aBlackrockNoPor; "(BlackRock) no ports were specified or "...
xor edi, edi
xor eax, eax
call LOG
mov rdi, r15
call targetset_optimize
mov r13d, 1
loc_1FC39:
mov rdi, r15
call targetset_count
mov rdi, rax
mov rsi, rdx
call int128_bitcount
cmp eax, 40h ; '@'
jb short loc_1FCA6
mov rdi, r15
call targetset_count
mov rdi, rax
mov rsi, rdx
call int128_bitcount
lea rsi, aRangeIsTooLarg; "range is too large for scanning: %u-bit"...
xor ebp, ebp
mov edi, 0FFFFFFFFh
mov edx, eax
xor eax, eax
call LOG
lea rsi, aRangeTargetCou; "range = target_count * endpoint_count\n"
mov edi, 0FFFFFFFEh
xor eax, eax
call LOG
lea rsi, aMaxRangeIsWith; "max range is within 63-bits\n"
loc_1FC95:
mov edi, 0FFFFFFFEh
loc_1FC9A:
xor eax, eax
call LOG
jmp loc_1FD9F
loc_1FCA6:
mov [rsp+58h+var_58], rbp
mov [rsp+58h+var_50], r12
mov [rsp+58h+var_48], r14
mov rdi, r15
call rangelist_count
mov r12, rax
lea r14, [rbx+1A8h]
mov rdi, r14
call range6list_count
mov rbp, rdx
add rbp, r12
cmp rbp, 3B9ACA01h
jb short loc_1FCF2
lea rdi, [rbx+218h]
call rangelist_count
test rax, rax
jz loc_1FDB0
loc_1FCF2:
mov rax, [rsp+58h+var_40]
mov [rax], rbp
mov rax, [rsp+58h+var_38]
mov [rax], r13
mov rdi, r15
call targetset_has_any_ipv4
mov rcx, [rsp+58h+var_58]
mov [rcx], al
mov rdi, r15
call targetset_has_any_ipv6
mov rcx, [rsp+58h+var_48]
mov [rcx], al
mov rdi, r15
call rangelist_count
mov cs:qword_1A3040, rax
mov rdi, r14
call range6list_count
mov r14, rdx
mov cs:qword_1A3048, rdx
imul rbp, r13
mov cs:qword_1A3050, rbp
mov rdi, [rsp+58h+var_50]
call rangelist_count
imul rax, r14
mov cs:qword_1A3058, rax
mov bpl, 1
test cs:byte_1A306C, 1
jnz short loc_1FD9F
mov ecx, cs:dword_1A3068
test ecx, ecx
jnz short loc_1FD85
mov cs:dword_1A3068, 0Eh
mov ecx, 0Eh
loc_1FD85:
mov rsi, cs:qword_1A3050
mov rdx, [rbx+6B8h]
lea rdi, unk_1A2FF8
call blackrock1_init
loc_1FD9F:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1FDB0:
lea rsi, aRangeTooBigNee; "range too big, need confirmation\n"
xor ebp, ebp
mov edi, 0FFFFFFFFh
xor eax, eax
call LOG
lea rsi, aToPreventAccid; "to prevent accidents, at least one --ex"...
mov edi, 0FFFFFFFEh
xor eax, eax
call LOG
lea rsi, aUseExclude2552; "use \"--exclude 255.255.255.255\" as a "...
jmp loc_1FC95
loc_1FDE4:
lea rsi, aTargetIpAddres; "target IP address list empty.\n"
xor ebp, ebp
mov edi, 0FFFFFFFFh
jmp loc_1FC9A
|
long long blackrock_init(_QWORD *a1, _QWORD *a2, long long *a3, _BYTE *a4, _BYTE *a5, int a6)
{
_QWORD *v8; // r15
long long v9; // r13
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
long long v14; // rax
long long v15; // rdx
long long v16; // rax
long long v17; // rdx
int v18; // eax
long long v19; // rbp
int v20; // ecx
int v21; // r8d
int v22; // r9d
int v23; // edx
int v24; // ecx
int v25; // r8d
int v26; // r9d
const char *v27; // rsi
int v28; // edi
long long v29; // r12
long long v30; // rdx
long long v31; // rbp
int v32; // edx
int v33; // ecx
int v34; // r8d
int v35; // r9d
long long v36; // rdx
int v37; // ecx
int v39; // edx
int v40; // ecx
int v41; // r8d
int v42; // r9d
_BYTE *v43; // [rsp+0h] [rbp-58h]
v8 = a1 + 49;
blackrock_conf = (long long)(a1 + 49);
qword_1A3060 = a1[215];
if ( !a1[64] && !a1[65] && !a1[66] )
{
v27 = "target IP address list empty.\n";
LODWORD(v19) = 0;
v28 = -1;
goto LABEL_9;
}
v9 = rangelist_count(a1 + 58);
if ( !v9 )
{
targetset_add_port_str(v8, "o:0", 0LL);
LOG(
0,
(unsigned int)"(BlackRock) no ports were specified or remained, a fake port o:0 was specified automaticlly.\n",
v10,
v11,
v12,
v13);
targetset_optimize(v8);
v9 = 1LL;
}
v14 = targetset_count(v8);
if ( (unsigned int)int128_bitcount(v14, v15) >= 0x40 )
{
v16 = targetset_count(v8);
v18 = int128_bitcount(v16, v17);
LODWORD(v19) = 0;
LOG(-1, (unsigned int)"range is too large for scanning: %u-bits\n", v18, v20, v21, v22);
LOG(-2, (unsigned int)"range = target_count * endpoint_count\n", v23, v24, v25, v26);
v27 = "max range is within 63-bits\n";
LABEL_8:
v28 = -2;
LABEL_9:
LOG(v28, (_DWORD)v27, (_DWORD)a3, (_DWORD)a4, (_DWORD)a5, a6);
return (unsigned int)v19;
}
v43 = a4;
v29 = rangelist_count(v8);
range6list_count(a1 + 53);
v31 = v29 + v30;
if ( (unsigned long long)(v29 + v30) >= 0x3B9ACA01 && !rangelist_count(a1 + 67) )
{
LODWORD(v19) = 0;
LOG(-1, (unsigned int)"range too big, need confirmation\n", v32, v33, v34, v35);
LOG(-2, (unsigned int)"to prevent accidents, at least one --exclude must be specified\n", v39, v40, v41, v42);
v27 = "use \"--exclude 255.255.255.255\" as a simple confirmation\n";
goto LABEL_8;
}
*a2 = v31;
*a3 = v9;
*v43 = targetset_has_any_ipv4(v8);
*a5 = targetset_has_any_ipv6(v8);
qword_1A3040 = rangelist_count(v8);
range6list_count(a1 + 53);
qword_1A3048 = v36;
v19 = v9 * v31;
qword_1A3050 = v19;
qword_1A3058 = v36 * rangelist_count(a1 + 58);
LOBYTE(v19) = 1;
if ( (byte_1A306C & 1) == 0 )
{
v37 = dword_1A3068;
if ( !dword_1A3068 )
{
dword_1A3068 = 14;
v37 = 14;
}
blackrock1_init((long long)&unk_1A2FF8, qword_1A3050, a1[215], v37);
}
return (unsigned int)v19;
}
|
blackrock_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,R8
MOV RBP,RCX
MOV RBX,RDI
LEA R15,[RDI + 0x188]
MOV qword ptr [0x002a2ff0],R15
MOV RAX,qword ptr [RDI + 0x6b8]
MOV qword ptr [0x002a3060],RAX
CMP qword ptr [RDI + 0x200],0x0
JNZ 0x0011fbe9
CMP qword ptr [RBX + 0x208],0x0
JNZ 0x0011fbe9
CMP qword ptr [RBX + 0x210],0x0
JZ 0x0011fde4
LAB_0011fbe9:
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],RDX
LEA R12,[RBX + 0x1d0]
MOV RDI,R12
CALL 0x001471c3
MOV R13,RAX
TEST RAX,RAX
JNZ 0x0011fc39
LEA RSI,[0x1611c1]
MOV RDI,R15
XOR EDX,EDX
CALL 0x0014925d
LEA RSI,[0x1611c5]
XOR EDI,EDI
XOR EAX,EAX
CALL 0x001536da
MOV RDI,R15
CALL 0x00148e96
MOV R13D,0x1
LAB_0011fc39:
MOV RDI,R15
CALL 0x00148027
MOV RDI,RAX
MOV RSI,RDX
CALL 0x00144b74
CMP EAX,0x40
JC 0x0011fca6
MOV RDI,R15
CALL 0x00148027
MOV RDI,RAX
MOV RSI,RDX
CALL 0x00144b74
LEA RSI,[0x161223]
XOR EBP,EBP
MOV EDI,0xffffffff
MOV EDX,EAX
XOR EAX,EAX
CALL 0x001536da
LEA RSI,[0x16124d]
MOV EDI,0xfffffffe
XOR EAX,EAX
CALL 0x001536da
LEA RSI,[0x161274]
LAB_0011fc95:
MOV EDI,0xfffffffe
LAB_0011fc9a:
XOR EAX,EAX
CALL 0x001536da
JMP 0x0011fd9f
LAB_0011fca6:
MOV qword ptr [RSP],RBP
MOV qword ptr [RSP + 0x8],R12
MOV qword ptr [RSP + 0x10],R14
MOV RDI,R15
CALL 0x001471c3
MOV R12,RAX
LEA R14,[RBX + 0x1a8]
MOV RDI,R14
CALL 0x001480bc
MOV RBP,RDX
ADD RBP,R12
CMP RBP,0x3b9aca01
JC 0x0011fcf2
LEA RDI,[RBX + 0x218]
CALL 0x001471c3
TEST RAX,RAX
JZ 0x0011fdb0
LAB_0011fcf2:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RBP
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],R13
MOV RDI,R15
CALL 0x00148fc0
MOV RCX,qword ptr [RSP]
MOV byte ptr [RCX],AL
MOV RDI,R15
CALL 0x00148fc8
MOV RCX,qword ptr [RSP + 0x10]
MOV byte ptr [RCX],AL
MOV RDI,R15
CALL 0x001471c3
MOV qword ptr [0x002a3040],RAX
MOV RDI,R14
CALL 0x001480bc
MOV R14,RDX
MOV qword ptr [0x002a3048],RDX
IMUL RBP,R13
MOV qword ptr [0x002a3050],RBP
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001471c3
IMUL RAX,R14
MOV qword ptr [0x002a3058],RAX
MOV BPL,0x1
TEST byte ptr [0x002a306c],0x1
JNZ 0x0011fd9f
MOV ECX,dword ptr [0x002a3068]
TEST ECX,ECX
JNZ 0x0011fd85
MOV dword ptr [0x002a3068],0xe
MOV ECX,0xe
LAB_0011fd85:
MOV RSI,qword ptr [0x002a3050]
MOV RDX,qword ptr [RBX + 0x6b8]
LEA RDI,[0x2a2ff8]
CALL 0x0011a2e8
LAB_0011fd9f:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011fdb0:
LEA RSI,[0x161291]
XOR EBP,EBP
MOV EDI,0xffffffff
XOR EAX,EAX
CALL 0x001536da
LEA RSI,[0x1612b3]
MOV EDI,0xfffffffe
XOR EAX,EAX
CALL 0x001536da
LEA RSI,[0x1612f3]
JMP 0x0011fc95
LAB_0011fde4:
LEA RSI,[0x1611a2]
XOR EBP,EBP
MOV EDI,0xffffffff
JMP 0x0011fc9a
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong blackrock_init(long param_1,ulong *param_2,long *param_3,int1 *param_4,
int1 *param_5)
{
long lVar1;
int1 uVar2;
uint uVar3;
int4 uVar4;
long lVar5;
long lVar6;
long extraout_RDX;
long extraout_RDX_00;
ulong uVar7;
char *pcVar8;
int8 uVar9;
int1 auVar10 [16];
lVar1 = param_1 + 0x188;
DAT_002a3060 = *(int8 *)(param_1 + 0x6b8);
blackrock_conf = lVar1;
if (((*(long *)(param_1 + 0x200) == 0) && (*(long *)(param_1 + 0x208) == 0)) &&
(*(long *)(param_1 + 0x210) == 0)) {
pcVar8 = "target IP address list empty.\n";
uVar9 = 0xffffffff;
}
else {
lVar5 = rangelist_count(param_1 + 0x1d0);
if (lVar5 == 0) {
targetset_add_port_str(lVar1,&DAT_001611c1,0);
LOG(0,
"(BlackRock) no ports were specified or remained, a fake port o:0 was specified automaticlly.\n"
);
targetset_optimize(lVar1);
lVar5 = 1;
}
auVar10 = targetset_count(lVar1);
uVar3 = int128_bitcount(auVar10._0_8_,auVar10._8_8_);
if (uVar3 < 0x40) {
lVar6 = rangelist_count(lVar1);
range6list_count(param_1 + 0x1a8);
uVar7 = extraout_RDX + lVar6;
if (1000000000 < uVar7) {
lVar6 = rangelist_count(param_1 + 0x218);
if (lVar6 == 0) {
LOG(0xffffffff,"range too big, need confirmation\n");
LOG(0xfffffffe,"to prevent accidents, at least one --exclude must be specified\n");
pcVar8 = "use \"--exclude 255.255.255.255\" as a simple confirmation\n";
goto LAB_0011fc95;
}
}
*param_2 = uVar7;
*param_3 = lVar5;
uVar2 = targetset_has_any_ipv4(lVar1);
*param_4 = uVar2;
uVar2 = targetset_has_any_ipv6(lVar1);
*param_5 = uVar2;
DAT_002a3040 = rangelist_count(lVar1);
range6list_count(param_1 + 0x1a8);
DAT_002a3048 = extraout_RDX_00;
_DAT_002a3050 = uVar7 * lVar5;
_DAT_002a3058 = rangelist_count(param_1 + 0x1d0);
_DAT_002a3058 = _DAT_002a3058 * extraout_RDX_00;
uVar7 = CONCAT71((int7)(uVar7 * lVar5 >> 8),1);
if ((DAT_002a306c & 1) == 0) {
if (_DAT_002a3068 == 0) {
_DAT_002a3068 = 0xe;
}
blackrock1_init(&DAT_002a2ff8,_DAT_002a3050,*(int8 *)(param_1 + 0x6b8),_DAT_002a3068);
}
goto LAB_0011fd9f;
}
auVar10 = targetset_count(lVar1);
uVar4 = int128_bitcount(auVar10._0_8_,auVar10._8_8_);
LOG(0xffffffff,"range is too large for scanning: %u-bits\n",uVar4);
LOG(0xfffffffe,"range = target_count * endpoint_count\n");
pcVar8 = "max range is within 63-bits\n";
LAB_0011fc95:
uVar9 = 0xfffffffe;
}
uVar7 = 0;
LOG(uVar9,pcVar8);
LAB_0011fd9f:
return uVar7 & 0xffffffff;
}
|
|
9,573 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>)
|
monkey531[P]llama/common/json.hpp
|
void push_back(initializer_list_t init)
{
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
}
else
{
push_back(basic_json(init));
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7e397
movq 0x10(%r14), %rax
testq %rax, %rax
cmoveq %r14, %rax
cmpb $0x3, (%rax)
jne 0x7e397
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa0e1c
movq %r15, %rdi
callq 0xb86ac
movq %rax, %r15
addq $0x18, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xa0e1c
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb82ec
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb81f8
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58484
movq %rbx, %rdi
callq 0x5d972
movq -0x20(%rbx), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x7e37b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8f0
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58484
movq %rbx, %rdi
callq 0x5d972
leaq 0x10(%rsp), %rbx
jmp 0x7e3c2
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x7e88e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb8362
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58484
movq %rbx, %rdi
callq 0x5d972
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x86c5e
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58484
movq %r14, %rdi
callq 0x5d972
jmp 0x7e407
jmp 0x7e404
movq %rax, %rbx
leaq 0x10(%rsp), %r14
jmp 0x7e416
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58484
movq %r14, %rdi
callq 0x5d972
movq %rbx, %rdi
callq 0x1afd0
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backESt16initializer_listINS0_6detail8json_refISD_EEE:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
cmp byte ptr [rdi], 1
setz al
cmp rdx, 2
setz cl
and cl, al
cmp cl, 1
jnz loc_7E397
mov rax, [r14+10h]
test rax, rax
cmovz rax, r14
cmp byte ptr [rax], 3
jnz loc_7E397
lea r15, [rsp+68h+var_58]
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov r15, rax
add r14, 18h
mov rdi, rsp
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
lea r14, [rsp+68h+var_48]
mov rdx, rsp
mov rdi, r14
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
lea rbx, [rsp+68h+var_28]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-20h]; void *
lea rax, [rsp+68h+var_38]
cmp rdi, rax
jz short loc_7E37B
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7E37B:
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rbx, [rsp+68h+var_58]
jmp short loc_7E3C2
loc_7E397:
lea r15, [rsp+68h+var_48]
mov rdi, r15
mov rsi, r14
mov ecx, 1
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
lea rbx, [rsp+68h+var_48]
loc_7E3C2:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_7E407
jmp short $+2
loc_7E404:
mov rbx, rax
loc_7E407:
lea r14, [rsp+arg_8]
jmp short loc_7E416
mov rbx, rax
lea r14, [rsp+arg_18]
loc_7E416:
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
_BYTE *a1,
long long a2,
long long a3)
{
_BYTE *v3; // rax
long long v4; // r15
char *v5; // rbx
char v7[16]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v8[16]; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
char v11[40]; // [rsp+40h] [rbp-28h] BYREF
if ( *a1 != 1 || a3 != 2 )
goto LABEL_8;
v3 = *(_BYTE **)(a2 + 16);
if ( !v3 )
v3 = (_BYTE *)a2;
if ( *v3 == 3 )
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v8,
a2);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(v8);
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v7,
a2 + 24);
ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v9,
v4,
v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v11);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v7);
v5 = v8;
}
else
{
LABEL_8:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v9,
a2,
a3,
1LL,
2LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
v5 = (char *)v9;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v5);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v5);
}
|
push_back:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CMP byte ptr [RDI],0x1
SETZ AL
CMP RDX,0x2
SETZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x0017e397
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
CMOVZ RAX,R14
CMP byte ptr [RAX],0x3
JNZ 0x0017e397
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,R14
CALL 0x001a0e1c
LAB_0017e311:
MOV RDI,R15
CALL 0x001b86ac
MOV R15,RAX
ADD R14,0x18
LAB_0017e320:
MOV RDI,RSP
MOV RSI,R14
CALL 0x001a0e1c
LEA R14,[RSP + 0x20]
MOV RDX,RSP
MOV RDI,R14
MOV RSI,R15
CALL 0x001b82ec
LAB_0017e33e:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001b81f8
LAB_0017e349:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158484
MOV RDI,RBX
CALL 0x0015d972
MOV RDI,qword ptr [RBX + -0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0017e37b
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a8f0
LAB_0017e37b:
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158484
MOV RDI,RBX
CALL 0x0015d972
LEA RBX,[RSP + 0x10]
JMP 0x0017e3c2
LAB_0017e397:
LEA R15,[RSP + 0x20]
MOV RDI,R15
MOV RSI,R14
MOV ECX,0x1
MOV R8D,0x2
CALL 0x0017e88e
LAB_0017e3b2:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001b8362
LAB_0017e3bd:
LEA RBX,[RSP + 0x20]
LAB_0017e3c2:
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158484
MOV RDI,RBX
CALL 0x0015d972
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2,long param_3)
{
char *pcVar1;
string *psVar2;
data *this;
data adStack_68 [16];
basic_json local_58 [16];
long *local_48 [2];
long local_38 [2];
data local_28 [16];
if (param_3 == 2 &&
*param_1 ==
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
pcVar1 = *(char **)(param_2 + 0x10);
if (*(char **)(param_2 + 0x10) == (char *)0x0) {
pcVar1 = param_2;
}
if (*pcVar1 == '\x03') {
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 0017e311 to 0017e318 has its CatchHandler @ 0017e404 */
psVar2 = get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_58);
/* try { // try from 0017e320 to 0017e32a has its CatchHandler @ 0017e402 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
_ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_48,psVar2,adStack_68);
/* try { // try from 0017e33e to 0017e348 has its CatchHandler @ 0017e3de */
push_back(param_1,(pair *)local_48);
assert_invariant(SUB81(local_28,0));
data::~data(local_28);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
assert_invariant(SUB81(adStack_68,0));
data::~data(adStack_68);
this = (data *)local_58;
goto LAB_0017e3c2;
}
}
basic_json((basic_json *)local_48,param_2,param_3,1,2);
/* try { // try from 0017e3b2 to 0017e3bc has its CatchHandler @ 0017e40e */
push_back(param_1,(basic_json *)local_48);
this = (data *)local_48;
LAB_0017e3c2:
assert_invariant(SUB81(this,0));
data::~data(this);
return;
}
|
|
9,574 |
ftxui::CheckboxOption::Simple()
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/component_options.cpp
|
CheckboxOption CheckboxOption::Simple() {
auto option = CheckboxOption();
option.transform = [](const EntryState& s) {
#if defined(FTXUI_MICROSOFT_TERMINAL_FALLBACK)
// Microsoft terminal do not use fonts able to render properly the default
// radiobox glyph.
auto prefix = text(s.state ? "[X] " : "[ ] "); // NOLINT
#else
auto prefix = text(s.state ? "▣ " : "☐ "); // NOLINT
#endif
auto t = text(s.label);
if (s.active) {
t |= bold;
}
if (s.focused) {
t |= inverted;
}
return hbox({prefix, t});
};
return option;
}
|
O0
|
cpp
|
ftxui::CheckboxOption::Simple():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
xorl %esi, %esi
movl $0x78, %edx
callq 0xd2d0
movq -0x18(%rbp), %rdi
callq 0x7ab70
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
leaq -0xa(%rbp), %rsi
callq 0x757f0
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x757e4
movq -0x18(%rbp), %rdi
callq 0x7abf0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
|
_ZN5ftxui14CheckboxOption6SimpleEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov rax, rdi
mov [rbp+var_20], rax
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
xor esi, esi
mov edx, 78h ; 'x'
call _memset
mov rdi, [rbp+var_18]; this
call _ZN5ftxui14CheckboxOptionC2Ev; ftxui::CheckboxOption::CheckboxOption(void)
mov rdi, [rbp+var_18]
add rdi, 38h ; '8'
lea rsi, [rbp+var_A]
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEEaSIZNS1_14CheckboxOption6SimpleEvE3$_0EENSt9enable_ifIXsrNS8_9_CallableIT_NSC_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISE_E4typeEE4typeES8_EE5valueESt5decayISE_EE4type4typeESt15__invoke_resultIRSP_JS6_EEEE5valueERS8_E4typeEOSE_
mov [rbp+var_9], 1
test [rbp+var_9], 1
jnz short loc_757E4
mov rdi, [rbp+var_18]; this
call _ZN5ftxui14CheckboxOptionD2Ev; ftxui::CheckboxOption::~CheckboxOption()
loc_757E4:
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
ftxui::CheckboxOption * ftxui::CheckboxOption::Simple(ftxui::CheckboxOption *this)
{
_BYTE v2[2]; // [rsp+16h] [rbp-Ah] BYREF
ftxui::CheckboxOption *v3; // [rsp+18h] [rbp-8h]
v3 = this;
v2[1] = 0;
memset(this, 0LL, 120LL);
ftxui::CheckboxOption::CheckboxOption(this);
std::function<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&)>::operator=<ftxui::CheckboxOption::Simple(void)::$_0>(
(char *)this + 56,
v2);
return this;
}
|
Simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
XOR ESI,ESI
MOV EDX,0x78
CALL 0x0010d2d0
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0017ab70
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x38
LEA RSI,[RBP + -0xa]
CALL 0x001757f0
MOV byte ptr [RBP + -0x9],0x1
TEST byte ptr [RBP + -0x9],0x1
JNZ 0x001757e4
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0017abf0
LAB_001757e4:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x001757db) */
/* ftxui::CheckboxOption::Simple() */
CheckboxOption * __thiscall ftxui::CheckboxOption::Simple(CheckboxOption *this)
{
__0 local_12;
int1 local_11;
CheckboxOption *local_10;
local_11 = 0;
local_10 = this;
memset(this,0,0x78);
CheckboxOption(this);
std::function<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&)>::operator=
((function<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&)> *)(this + 0x38),
&local_12);
return this;
}
|
|
9,575 |
ggml_easy::ctx::get_weight(char const*, ...)
|
ngxson[P]ggml-easy/ggml-easy.h
|
ggml_tensor * get_weight(const char *fmt, ...) {
std::vector<char> str(128);
va_list va;
va_start(va, fmt);
vsnprintf(str.data(), 128, fmt, va);
va_end(va);
auto it = tensors.find(str.data());
if (it == tensors.end()) {
throw std::runtime_error(string_format("weight tensor not found: %s", str.data()));
}
return it->second;
}
|
O3
|
c
|
ggml_easy::ctx::get_weight(char const*, ...):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50(%rsp), %r12
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x5dd0
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
movl $0x80, %edi
callq 0x32f0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
leaq 0x30(%rsp), %rcx
movq %r12, 0x10(%rcx)
leaq 0x130(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
movl $0x80, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3220
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x67e2
addq $0x8, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x78be
movq %rax, %r14
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x5e73
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3300
testq %r14, %r14
je 0x5e9c
movq 0x28(%r14), %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x3300
movq %r14, %rax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x31a0
movq %rax, %r14
leaq 0x2700(%rip), %rsi # 0x85b0
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4871
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x34a0
xorl %ebp, %ebp
movq 0x6118(%rip), %rsi # 0xbff0
movq 0x60e9(%rip), %rdx # 0xbfc8
movq %r14, %rdi
callq 0x3510
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x5f01
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3300
testb %bpl, %bpl
jne 0x5f0b
jmp 0x5f38
movq %rax, %r15
movq %r14, %rdi
callq 0x3250
jmp 0x5f38
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f38
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0x5f38
movq %rax, %r15
movl $0x80, %esi
movq %rbx, %rdi
callq 0x3300
movq %r15, %rdi
callq 0x3540
nop
|
_ZN9ggml_easy3ctx10get_weightEPKcz:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 100h
mov r15, rsi
mov r14, rdi
lea r12, [rsp+128h+var_D8]
mov [r12+10h], rdx
mov [r12+18h], rcx
mov [r12+20h], r8
mov [r12+28h], r9
test al, al
jz short loc_5DD0
movaps [rsp+128h+var_A8], xmm0
movaps [rsp+128h+var_98], xmm1
movaps [rsp+128h+var_88], xmm2
movaps [rsp+128h+var_78], xmm3
movaps [rsp+128h+var_68], xmm4
movaps [rsp+128h+var_58], xmm5
movaps [rsp+128h+var_48], xmm6
movaps [rsp+128h+var_38], xmm7
loc_5DD0:
mov edi, 80h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+10h], xmm0
movups xmmword ptr [rax+20h], xmm0
movups xmmword ptr [rax+30h], xmm0
movups xmmword ptr [rax+40h], xmm0
movups xmmword ptr [rax+50h], xmm0
movups xmmword ptr [rax+60h], xmm0
movups xmmword ptr [rax+70h], xmm0
lea rcx, [rsp+128h+var_F8]
mov [rcx+10h], r12
lea rax, [rsp+128h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
mov esi, 80h
mov rdi, rbx
mov rdx, r15
call _vsnprintf
lea rdi, [rsp+128h+var_118]
lea rdx, [rsp+128h+var_119]
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
add r14, 8
lea rsi, [rsp+128h+var_118]
mov rdi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_P11ggml_tensorESaISA_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSC_18_Mod_range_hashingENSC_20_Default_ranged_hashENSC_20_Prime_rehash_policyENSC_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,ggml_tensor *>,std::allocator<std::pair<std::string const,ggml_tensor *>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov r14, rax
lea r12, [rsp+128h+var_108]
mov rdi, [r12-10h]; void *
cmp rdi, r12
jz short loc_5E73
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E73:
test r14, r14
jz short loc_5E9C
mov r14, [r14+28h]
mov esi, 80h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, r14
add rsp, 100h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5E9C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aWeightTensorNo; "weight tensor not found: %s"
lea rdi, [rsp+128h+var_118]
mov rdx, rbx
xor eax, eax
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
mov bpl, 1
lea rsi, [rsp+128h+var_118]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov r15, rax
mov rdi, [rsp+128h+var_118]; void *
cmp rdi, r12
jz short loc_5F01
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5F01:
test bpl, bpl
jnz short loc_5F0B
jmp short loc_5F38
mov r15, rax
loc_5F0B:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_5F38
mov r15, rax
lea rax, [rsp+128h+var_108]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5F38
mov rsi, [rsp+128h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5F38
mov r15, rax
loc_5F38:
mov esi, 80h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r15
call __Unwind_Resume
|
long long ggml_easy::ctx::get_weight(
ggml_easy::ctx *this,
const char *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)
{
_OWORD *v15; // rbx
long long v16; // r14
long long v17; // r14
void *exception; // r14
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
char v25; // [rsp+0h] [rbp-128h]
char v26; // [rsp+Fh] [rbp-119h] BYREF
void *v27[2]; // [rsp+10h] [rbp-118h] BYREF
long long v28; // [rsp+20h] [rbp-108h] BYREF
_QWORD v29[4]; // [rsp+30h] [rbp-F8h] BYREF
char v30; // [rsp+50h] [rbp-D8h] BYREF
long long v31; // [rsp+60h] [rbp-C8h]
long long v32; // [rsp+68h] [rbp-C0h]
long long v33; // [rsp+70h] [rbp-B8h]
long long v34; // [rsp+78h] [rbp-B0h]
__m128 v35; // [rsp+80h] [rbp-A8h]
__m128 v36; // [rsp+90h] [rbp-98h]
__m128 v37; // [rsp+A0h] [rbp-88h]
__m128 v38; // [rsp+B0h] [rbp-78h]
__m128 v39; // [rsp+C0h] [rbp-68h]
__m128 v40; // [rsp+D0h] [rbp-58h]
__m128 v41; // [rsp+E0h] [rbp-48h]
__m128 v42; // [rsp+F0h] [rbp-38h]
v35 = a7;
v36 = a8;
v37 = a9;
v38 = a10;
v39 = a11;
v40 = a12;
v41 = a13;
v42 = a14;
v31 = a3;
v32 = a4;
v33 = a5;
v34 = a6;
v15 = (_OWORD *)operator new(0x80uLL);
*v15 = 0LL;
v15[1] = 0LL;
v15[2] = 0LL;
v15[3] = 0LL;
v15[4] = 0LL;
v15[5] = 0LL;
v15[6] = 0LL;
v15[7] = 0LL;
v29[2] = &v30;
v29[1] = &a15;
v29[0] = 0x3000000010LL;
vsnprintf(v15, 128LL, a2, v29);
std::string::basic_string<std::allocator<char>>(v27, v15, &v26);
v16 = std::_Hashtable<std::string,std::pair<std::string const,ggml_tensor *>,std::allocator<std::pair<std::string const,ggml_tensor *>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
(char *)this + 8,
v27);
if ( v27[0] != &v28 )
operator delete(v27[0], v28 + 1);
if ( !v16 )
{
exception = __cxa_allocate_exception(0x10uLL);
ggml_easy::string_format[abi:cxx11](
v27,
(long long)"weight tensor not found: %s",
(long long)v15,
v20,
v21,
v22,
(__m128)0LL,
a8,
a9,
a10,
v23,
v24,
a13,
a14,
v25);
std::runtime_error::runtime_error(exception);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v17 = *(_QWORD *)(v16 + 40);
operator delete(v15, 0x80uLL);
return v17;
}
|
get_weight:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x100
MOV R15,RSI
MOV R14,RDI
LEA R12,[RSP + 0x50]
MOV qword ptr [R12 + 0x10],RDX
MOV qword ptr [R12 + 0x18],RCX
MOV qword ptr [R12 + 0x20],R8
MOV qword ptr [R12 + 0x28],R9
TEST AL,AL
JZ 0x00105dd0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVAPS xmmword ptr [RSP + 0x90],XMM1
MOVAPS xmmword ptr [RSP + 0xa0],XMM2
MOVAPS xmmword ptr [RSP + 0xb0],XMM3
MOVAPS xmmword ptr [RSP + 0xc0],XMM4
MOVAPS xmmword ptr [RSP + 0xd0],XMM5
MOVAPS xmmword ptr [RSP + 0xe0],XMM6
MOVAPS xmmword ptr [RSP + 0xf0],XMM7
LAB_00105dd0:
MOV EDI,0x80
CALL 0x001032f0
MOV RBX,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS xmmword ptr [RAX + 0x50],XMM0
MOVUPS xmmword ptr [RAX + 0x60],XMM0
MOVUPS xmmword ptr [RAX + 0x70],XMM0
LEA RCX,[RSP + 0x30]
MOV qword ptr [RCX + 0x10],R12
LEA RAX,[RSP + 0x130]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
MOV ESI,0x80
MOV RDI,RBX
MOV RDX,R15
CALL 0x00103220
LAB_00105e31:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
MOV RSI,RBX
CALL 0x001067e2
ADD R14,0x8
LAB_00105e47:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x001078be
LAB_00105e54:
MOV R14,RAX
LEA R12,[RSP + 0x20]
MOV RDI,qword ptr [R12 + -0x10]
CMP RDI,R12
JZ 0x00105e73
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00103300
LAB_00105e73:
TEST R14,R14
JZ 0x00105e9c
MOV R14,qword ptr [R14 + 0x28]
MOV ESI,0x80
MOV RDI,RBX
CALL 0x00103300
MOV RAX,R14
ADD RSP,0x100
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00105e9c:
MOV EDI,0x10
CALL 0x001031a0
MOV R14,RAX
LAB_00105ea9:
LEA RSI,[0x1085b0]
LEA RDI,[RSP + 0x10]
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00104871
MOV BPL,0x1
LAB_00105ec2:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x001034a0
XOR EBP,EBP
MOV RSI,qword ptr [0x0010bff0]
MOV RDX,qword ptr [0x0010bfc8]
MOV RDI,R14
CALL 0x00103510
|
/* ggml_easy::ctx::get_weight(char const*, ...) */
int8 ggml_easy::ctx::get_weight(char *param_1,...)
{
int8 uVar1;
char in_AL;
char *__s;
long lVar2;
runtime_error *this;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int4 in_XMM0_Da;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
allocator local_119;
long *local_118 [2];
long local_108 [2];
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int4 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
if (in_AL != '\0') {
local_a8 = in_XMM0_Da;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
__s = (char *)operator_new(0x80);
__s[0] = '\0';
__s[1] = '\0';
__s[2] = '\0';
__s[3] = '\0';
__s[4] = '\0';
__s[5] = '\0';
__s[6] = '\0';
__s[7] = '\0';
__s[8] = '\0';
__s[9] = '\0';
__s[10] = '\0';
__s[0xb] = '\0';
__s[0xc] = '\0';
__s[0xd] = '\0';
__s[0xe] = '\0';
__s[0xf] = '\0';
__s[0x10] = '\0';
__s[0x11] = '\0';
__s[0x12] = '\0';
__s[0x13] = '\0';
__s[0x14] = '\0';
__s[0x15] = '\0';
__s[0x16] = '\0';
__s[0x17] = '\0';
__s[0x18] = '\0';
__s[0x19] = '\0';
__s[0x1a] = '\0';
__s[0x1b] = '\0';
__s[0x1c] = '\0';
__s[0x1d] = '\0';
__s[0x1e] = '\0';
__s[0x1f] = '\0';
__s[0x20] = '\0';
__s[0x21] = '\0';
__s[0x22] = '\0';
__s[0x23] = '\0';
__s[0x24] = '\0';
__s[0x25] = '\0';
__s[0x26] = '\0';
__s[0x27] = '\0';
__s[0x28] = '\0';
__s[0x29] = '\0';
__s[0x2a] = '\0';
__s[0x2b] = '\0';
__s[0x2c] = '\0';
__s[0x2d] = '\0';
__s[0x2e] = '\0';
__s[0x2f] = '\0';
__s[0x30] = '\0';
__s[0x31] = '\0';
__s[0x32] = '\0';
__s[0x33] = '\0';
__s[0x34] = '\0';
__s[0x35] = '\0';
__s[0x36] = '\0';
__s[0x37] = '\0';
__s[0x38] = '\0';
__s[0x39] = '\0';
__s[0x3a] = '\0';
__s[0x3b] = '\0';
__s[0x3c] = '\0';
__s[0x3d] = '\0';
__s[0x3e] = '\0';
__s[0x3f] = '\0';
__s[0x40] = '\0';
__s[0x41] = '\0';
__s[0x42] = '\0';
__s[0x43] = '\0';
__s[0x44] = '\0';
__s[0x45] = '\0';
__s[0x46] = '\0';
__s[0x47] = '\0';
__s[0x48] = '\0';
__s[0x49] = '\0';
__s[0x4a] = '\0';
__s[0x4b] = '\0';
__s[0x4c] = '\0';
__s[0x4d] = '\0';
__s[0x4e] = '\0';
__s[0x4f] = '\0';
__s[0x50] = '\0';
__s[0x51] = '\0';
__s[0x52] = '\0';
__s[0x53] = '\0';
__s[0x54] = '\0';
__s[0x55] = '\0';
__s[0x56] = '\0';
__s[0x57] = '\0';
__s[0x58] = '\0';
__s[0x59] = '\0';
__s[0x5a] = '\0';
__s[0x5b] = '\0';
__s[0x5c] = '\0';
__s[0x5d] = '\0';
__s[0x5e] = '\0';
__s[0x5f] = '\0';
__s[0x60] = '\0';
__s[0x61] = '\0';
__s[0x62] = '\0';
__s[99] = '\0';
__s[100] = '\0';
__s[0x65] = '\0';
__s[0x66] = '\0';
__s[0x67] = '\0';
__s[0x68] = '\0';
__s[0x69] = '\0';
__s[0x6a] = '\0';
__s[0x6b] = '\0';
__s[0x6c] = '\0';
__s[0x6d] = '\0';
__s[0x6e] = '\0';
__s[0x6f] = '\0';
__s[0x70] = '\0';
__s[0x71] = '\0';
__s[0x72] = '\0';
__s[0x73] = '\0';
__s[0x74] = '\0';
__s[0x75] = '\0';
__s[0x76] = '\0';
__s[0x77] = '\0';
__s[0x78] = '\0';
__s[0x79] = '\0';
__s[0x7a] = '\0';
__s[0x7b] = '\0';
__s[0x7c] = '\0';
__s[0x7d] = '\0';
__s[0x7e] = '\0';
__s[0x7f] = '\0';
local_f0 = &stack0x00000008;
local_f8 = 0x3000000010;
local_e8 = local_d8;
vsnprintf(__s,0x80,in_RSI,&local_f8);
/* try { // try from 00105e31 to 00105e42 has its CatchHandler @ 00105f35 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_118,__s,&local_119);
/* try { // try from 00105e47 to 00105e53 has its CatchHandler @ 00105f15 */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,ggml_tensor*>,std::allocator<std::pair<std::__cxx11::string_const,ggml_tensor*>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)(param_1 + 8),(string *)local_118);
if (local_118[0] != local_108) {
operator_delete(local_118[0],local_108[0] + 1);
}
if (lVar2 != 0) {
uVar1 = *(int8 *)(lVar2 + 0x28);
operator_delete(__s,0x80);
return uVar1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00105ea9 to 00105ebe has its CatchHandler @ 00105f08 */
string_format_abi_cxx11_((char *)local_118,"weight tensor not found: %s",__s);
/* try { // try from 00105ec2 to 00105ee6 has its CatchHandler @ 00105ee7 */
std::runtime_error::runtime_error(this,(string *)local_118);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0010bff0,PTR__runtime_error_0010bfc8);
}
|
|
9,576 |
strxnmov
|
eloqsql/strings/strxnmov.c
|
char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
}
|
O3
|
c
|
strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0x5a890
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000018, %rcx # imm = 0x3000000018
movq %rcx, -0x20(%rbp)
testq %rdx, %rdx
je 0x5a909
addq %rax, %rsi
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %r8
movq %r8, %r9
cmpq %rsi, %rax
je 0x5a906
movb (%rdx), %r10b
movb %r10b, (%rax)
testb %r10b, %r10b
jne 0x5a8fe
cmpl $0x28, %edi
ja 0x5a8e6
movq %r9, %r10
movl %edi, %r9d
addq %rcx, %r9
addl $0x8, %edi
movl %edi, -0x20(%rbp)
jmp 0x5a8f1
leaq 0x8(%r9), %r8
movq %r8, -0x18(%rbp)
movq %r8, %r10
movq (%r9), %rdx
movq %r10, %r9
testq %rdx, %rdx
jne 0x5a8c0
jmp 0x5a909
incq %rax
incq %rdx
jmp 0x5a8bd
movq %rsi, %rax
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
|
strxnmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_5A890
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_5A890:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000018h
mov [rbp+var_20], rcx
test rdx, rdx
jz short loc_5A909
add rsi, rax
mov rcx, [rbp+var_10]
mov edi, dword ptr [rbp+var_20]
mov r8, [rbp+var_18]
loc_5A8BD:
mov r9, r8
loc_5A8C0:
cmp rax, rsi
jz short loc_5A906
mov r10b, [rdx]
mov [rax], r10b
test r10b, r10b
jnz short loc_5A8FE
cmp edi, 28h ; '('
ja short loc_5A8E6
mov r10, r9
mov r9d, edi
add r9, rcx
add edi, 8
mov dword ptr [rbp+var_20], edi
jmp short loc_5A8F1
loc_5A8E6:
lea r8, [r9+8]
mov [rbp+var_18], r8
mov r10, r8
loc_5A8F1:
mov rdx, [r9]
mov r9, r10
test rdx, rdx
jnz short loc_5A8C0
jmp short loc_5A909
loc_5A8FE:
inc rax
inc rdx
jmp short loc_5A8BD
loc_5A906:
mov rax, rsi
loc_5A909:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
|
char *strxnmov(char *a1, long long a2, char *a3, ...)
{
char *result; // rax
char *v4; // rsi
char *reg_save_area; // rcx
unsigned int gp_offset; // edi
char *overflow_arg_area; // r8
char *v8; // r9
char v9; // r10
char *v10; // r10
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a3);
if ( a3 )
{
v4 = &a1[a2];
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
LABEL_3:
v8 = overflow_arg_area;
while ( result != v4 )
{
v9 = *a3;
*result = *a3;
if ( v9 )
{
++result;
++a3;
goto LABEL_3;
}
if ( gp_offset > 0x28 )
{
overflow_arg_area = v8 + 8;
va[0].overflow_arg_area = v8 + 8;
v10 = v8 + 8;
}
else
{
v10 = v8;
v8 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a3 = *(char **)v8;
v8 = v10;
if ( !a3 )
goto LABEL_13;
}
result = v4;
}
LABEL_13:
*result = 0;
return result;
}
|
strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x0015a890
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0015a890:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000018
MOV qword ptr [RBP + -0x20],RCX
TEST RDX,RDX
JZ 0x0015a909
ADD RSI,RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x18]
LAB_0015a8bd:
MOV R9,R8
LAB_0015a8c0:
CMP RAX,RSI
JZ 0x0015a906
MOV R10B,byte ptr [RDX]
MOV byte ptr [RAX],R10B
TEST R10B,R10B
JNZ 0x0015a8fe
CMP EDI,0x28
JA 0x0015a8e6
MOV R10,R9
MOV R9D,EDI
ADD R9,RCX
ADD EDI,0x8
MOV dword ptr [RBP + -0x20],EDI
JMP 0x0015a8f1
LAB_0015a8e6:
LEA R8,[R9 + 0x8]
MOV qword ptr [RBP + -0x18],R8
MOV R10,R8
LAB_0015a8f1:
MOV RDX,qword ptr [R9]
MOV R9,R10
TEST RDX,RDX
JNZ 0x0015a8c0
JMP 0x0015a909
LAB_0015a8fe:
INC RAX
INC RDX
JMP 0x0015a8bd
LAB_0015a906:
MOV RAX,RSI
LAB_0015a909:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
char *pcVar3;
int8 *puVar4;
int8 *puVar5;
ulong uVar6;
int8 *puVar7;
int8 local_d8 [22];
uint local_28;
puVar4 = (int8 *)&stack0x00000008;
pcVar2 = param_1;
if (param_3 != (char *)0x0) {
pcVar3 = param_1 + param_2;
local_28 = 0x18;
puVar5 = puVar4;
do {
while( true ) {
pcVar2 = pcVar3;
if (param_1 == pcVar3) goto LAB_0015a909;
cVar1 = *param_3;
*param_1 = cVar1;
if (cVar1 == '\0') break;
param_1 = param_1 + 1;
param_3 = param_3 + 1;
puVar5 = puVar4;
}
if (local_28 < 0x29) {
uVar6 = (ulong)local_28;
local_28 = local_28 + 8;
puVar7 = (int8 *)((long)local_d8 + uVar6);
}
else {
puVar4 = puVar5 + 1;
puVar7 = puVar5;
puVar5 = puVar4;
}
param_3 = (char *)*puVar7;
pcVar2 = param_1;
} while (param_3 != (char *)0x0);
}
LAB_0015a909:
*pcVar2 = '\0';
return;
}
|
|
9,577 |
js_async_from_sync_iterator_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_async_from_sync_iterator_finalizer(JSRuntime *rt, JSValue val)
{
JSAsyncFromSyncIteratorData *s =
JS_GetOpaque(val, JS_CLASS_ASYNC_FROM_SYNC_ITERATOR);
if (s) {
JS_FreeValueRT(rt, s->sync_iter);
JS_FreeValueRT(rt, s->next_method);
js_free_rt(rt, s);
}
}
|
O1
|
c
|
js_async_from_sync_iterator_finalizer:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpl $-0x1, %edx
jne 0x52935
movq (%rsp), %rax
cmpw $0x37, 0x6(%rax)
jne 0x52935
movq 0x30(%rax), %r14
jmp 0x52938
xorl %r14d, %r14d
testq %r14, %r14
je 0x52989
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1d8c6
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x1d8c6
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_async_from_sync_iterator_finalizer:
push r14
push rbx
push rax
mov rbx, rdi
mov [rsp+18h+var_18], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_52935
mov rax, [rsp+18h+var_18]
cmp word ptr [rax+6], 37h ; '7'
jnz short loc_52935
mov r14, [rax+30h]
jmp short loc_52938
loc_52935:
xor r14d, r14d
loc_52938:
test r14, r14
jz short loc_52989
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_FreeValueRT
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov rdi, rbx
call JS_FreeValueRT
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+10h]
mov rdx, [rbx+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
mov rdi, [rbx+40h]
mov rsi, r14
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_52989:
add rsp, 8
pop rbx
pop r14
retn
|
void js_async_from_sync_iterator_finalizer(long long a1, long long a2, int a3)
{
long long v3; // r14
long long v4; // rax
void ( *v5)(_QWORD, long long); // rcx
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 55 )
v3 = *(_QWORD *)(a2 + 48);
else
v3 = 0LL;
if ( v3 )
{
JS_FreeValueRT(a1, *(_DWORD **)v3, *(_QWORD *)(v3 + 8));
JS_FreeValueRT(a1, *(_DWORD **)(v3 + 16), *(_QWORD *)(v3 + 24));
--*(_QWORD *)(a1 + 40);
v4 = (*(long long ( **)(long long))(a1 + 32))(v3);
v5 = *(void ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v4 - 8;
v5(*(_QWORD *)(a1 + 64), v3);
}
}
| |||
9,578 |
js_async_from_sync_iterator_finalizer
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_async_from_sync_iterator_finalizer(JSRuntime *rt, JSValue val)
{
JSAsyncFromSyncIteratorData *s =
JS_GetOpaque(val, JS_CLASS_ASYNC_FROM_SYNC_ITERATOR);
if (s) {
JS_FreeValueRT(rt, s->sync_iter);
JS_FreeValueRT(rt, s->next_method);
js_free_rt(rt, s);
}
}
|
O2
|
c
|
js_async_from_sync_iterator_finalizer:
pushq %r14
pushq %rbx
pushq %rax
cmpl $-0x1, %edx
jne 0x46deb
cmpw $0x37, 0x6(%rsi)
jne 0x46deb
movq 0x30(%rsi), %r14
testq %r14, %r14
je 0x46deb
movq %rdi, %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x18031
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x18031
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x170cb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_async_from_sync_iterator_finalizer:
push r14
push rbx
push rax
cmp edx, 0FFFFFFFFh
jnz short loc_46DEB
cmp word ptr [rsi+6], 37h ; '7'
jnz short loc_46DEB
mov r14, [rsi+30h]
test r14, r14
jz short loc_46DEB
mov rbx, rdi
mov rsi, [r14]
mov rdx, [r14+8]
call JS_FreeValueRT
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov rdi, rbx
call JS_FreeValueRT
mov rdi, rbx
mov rsi, r14
add rsp, 8
pop rbx
pop r14
jmp js_free_rt
loc_46DEB:
add rsp, 8
pop rbx
pop r14
retn
|
long long js_async_from_sync_iterator_finalizer(long long a1, long long a2, int a3)
{
long long v3; // r14
long long result; // rax
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 55 )
{
v3 = *(_QWORD *)(a2 + 48);
if ( v3 )
{
JS_FreeValueRT(a1, *(unsigned int **)v3, *(_QWORD *)(v3 + 8));
JS_FreeValueRT(a1, *(unsigned int **)(v3 + 16), *(_QWORD *)(v3 + 24));
return js_free_rt(a1, v3);
}
}
return result;
}
|
js_async_from_sync_iterator_finalizer:
PUSH R14
PUSH RBX
PUSH RAX
CMP EDX,-0x1
JNZ 0x00146deb
CMP word ptr [RSI + 0x6],0x37
JNZ 0x00146deb
MOV R14,qword ptr [RSI + 0x30]
TEST R14,R14
JZ 0x00146deb
MOV RBX,RDI
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
CALL 0x00118031
MOV RSI,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x18]
MOV RDI,RBX
CALL 0x00118031
MOV RDI,RBX
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001170cb
LAB_00146deb:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void js_async_from_sync_iterator_finalizer(int8 param_1,long param_2,int param_3)
{
int8 *puVar1;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x37)) &&
(puVar1 = *(int8 **)(param_2 + 0x30), puVar1 != (int8 *)0x0)) {
JS_FreeValueRT(param_1,*puVar1,puVar1[1]);
JS_FreeValueRT(param_1,puVar1[2],puVar1[3]);
js_free_rt(param_1,puVar1);
return;
}
return;
}
|
|
9,579 |
mi_split_page
|
eloqsql/storage/myisam/mi_write.c
|
int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
uchar *key, uchar *buff, uchar *key_buff,
my_bool insert_last_key)
{
uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
uchar *key_pos,*pos, *UNINIT_VAR(after_key);
my_off_t new_pos;
MI_KEY_PARAM s_temp;
DBUG_ENTER("mi_split_page");
DBUG_DUMP("buff",(uchar*) buff,mi_getint(buff));
if (info->s->keyinfo+info->lastinx == keyinfo)
info->page_changed=1; /* Info->buff is used */
info->buff_used=1;
nod_flag=mi_test_if_nod(buff);
key_ref_length=2+nod_flag;
if (insert_last_key)
key_pos=_mi_find_last_pos(keyinfo,buff,key_buff, &key_length, &after_key);
else
key_pos=_mi_find_half_pos(nod_flag,keyinfo,buff,key_buff, &key_length,
&after_key);
if (!key_pos)
DBUG_RETURN(-1);
length=(uint) (key_pos-buff);
a_length=mi_getint(buff);
mi_putint(buff,length,nod_flag);
key_pos=after_key;
if (nod_flag)
{
DBUG_PRINT("test",("Splitting nod"));
pos=key_pos-nod_flag;
memcpy((uchar*) info->buff+2,(uchar*) pos,(size_t) nod_flag);
}
/* Move middle item to key and pointer to new page */
if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
DBUG_RETURN(-1);
_mi_kpointer(info,_mi_move_key(keyinfo,key,key_buff),new_pos);
/* Store new page */
if (!(*keyinfo->get_key)(keyinfo,nod_flag,&key_pos,key_buff))
DBUG_RETURN(-1);
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar *) 0,
(uchar*) 0, (uchar*) 0,
key_buff, &s_temp);
length=(uint) ((buff+a_length)-key_pos);
memcpy((uchar*) info->buff+key_ref_length+t_length,(uchar*) key_pos,
(size_t) length);
(*keyinfo->store_key)(keyinfo,info->buff+key_ref_length,&s_temp);
mi_putint(info->buff,length+t_length+key_ref_length,nod_flag);
if (_mi_write_keypage(info,keyinfo,new_pos,DFLT_INIT_HITS,info->buff))
DBUG_RETURN(-1);
DBUG_DUMP("key",(uchar*) key,_mi_keylength(keyinfo,key));
DBUG_RETURN(2); /* Middle key up */
}
|
O0
|
c
|
mi_split_page:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xcf7df
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d4(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jne 0xcf810
movq -0x10(%rbp), %rax
movb $0x1, 0x33c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xcf841
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0xc4(%rbp)
jmp 0xcf84b
xorl %eax, %eax
movl %eax, -0xc4(%rbp)
jmp 0xcf84b
movl -0xc4(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x40(%rbp)
cmpb $0x0, -0x31(%rbp)
je 0xcf882
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
leaq -0x68(%rbp), %r8
callq 0xcfb40
movq %rax, -0x58(%rbp)
jmp 0xcf8a2
movl -0x48(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x4c(%rbp), %r8
leaq -0x68(%rbp), %r9
callq 0xcfe10
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xcf8b7
jmp 0xcf8ab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcfb2a
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, -0x3c(%rbp)
movl -0x48(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x38(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0xb2(%rbp)
movzwl -0xb2(%rbp), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xb8(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xcf97a
jmp 0xcf946
jmp 0xcf948
movq -0x58(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
addq $0x2, %rdi
movq -0x60(%rbp), %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0xc6370
movq %rax, -0x70(%rbp)
cmpq $-0x1, %rax
jne 0xcf9a4
jmp 0xcf998
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcfb2a
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc9c10
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
movq -0x70(%rbp), %rdx
callq 0xc84a0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x48(%rbp), %esi
movq -0x30(%rbp), %rcx
leaq -0x58(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xcf9ff
jmp 0xcf9f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcfb2a
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x48(%rbp), %esi
movq -0x30(%rbp), %r9
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0xb0(%rbp), %r10
movq %r8, %rdx
movq %r8, %rcx
movq %r10, (%rsp)
callq *%rax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
addq %rcx, %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
movl -0x40(%rbp), %eax
addq %rax, %rdi
movl -0x44(%rbp), %eax
addq %rax, %rdi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rsi
movl -0x40(%rbp), %ecx
addq %rcx, %rsi
leaq -0xb0(%rbp), %rdx
callq *%rax
movl -0x48(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
addl -0x40(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0xba(%rbp)
movzwl -0xba(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, 0x1(%rax)
movl -0xc0(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x100(%rax), %r8
movl $0x3, %ecx
callq 0xc6040
cmpl $0x0, %eax
je 0xcfb1d
jmp 0xcfb14
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcfb2a
jmp 0xcfb1f
jmp 0xcfb21
jmp 0xcfb23
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_mi_split_page:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov al, r9b
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_31], al
mov rax, [rbp+var_68]
mov [rbp+var_68], rax
jmp short $+2
loc_CF7DF:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov rcx, [rbp+var_10]
movsxd rcx, dword ptr [rcx+1D4h]
imul rcx, 70h ; 'p'
add rax, rcx
cmp rax, [rbp+var_18]
jnz short loc_CF810
mov rax, [rbp+var_10]
mov byte ptr [rax+33Ch], 1
loc_CF810:
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_CF841
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_C4], eax
jmp short loc_CF84B
loc_CF841:
xor eax, eax
mov [rbp+var_C4], eax
jmp short $+2
loc_CF84B:
mov eax, [rbp+var_C4]
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
add eax, 2
mov [rbp+var_40], eax
cmp [rbp+var_31], 0
jz short loc_CF882
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
lea rcx, [rbp+var_4C]
lea r8, [rbp+var_68]
call _mi_find_last_pos
mov [rbp+var_58], rax
jmp short loc_CF8A2
loc_CF882:
mov edi, [rbp+var_48]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_4C]
lea r9, [rbp+var_68]
call _mi_find_half_pos
mov [rbp+var_58], rax
loc_CF8A2:
cmp [rbp+var_58], 0
jnz short loc_CF8B7
jmp short $+2
loc_CF8AB:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_CFB2A
loc_CF8B7:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_38], eax
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_28]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov [rbp+var_3C], eax
mov edx, [rbp+var_48]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_38]
movzx ecx, cx
add eax, ecx
mov [rbp+var_B2], ax
movzx eax, [rbp+var_B2]
mov [rbp+var_B8], eax
mov eax, [rbp+var_B8]
mov cl, al
mov rax, [rbp+var_28]
mov [rax+1], cl
mov eax, [rbp+var_B8]
shr eax, 8
mov cl, al
mov rax, [rbp+var_28]
mov [rax], cl
mov rax, [rbp+var_68]
mov [rbp+var_58], rax
cmp [rbp+var_48], 0
jz short loc_CF97A
jmp short $+2
loc_CF946:
jmp short $+2
loc_CF948:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_48]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_10]
mov rdi, [rax+100h]
add rdi, 2
mov rsi, [rbp+var_60]
mov eax, [rbp+var_48]
mov edx, eax
call _memcpy
loc_CF97A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 3
call _mi_new
mov [rbp+var_70], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_CF9A4
jmp short $+2
loc_CF998:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_CFB2A
loc_CF9A4:
mov rax, [rbp+var_10]
mov [rbp+var_D0], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_30]
call _mi_move_key
mov rdi, [rbp+var_D0]
mov rsi, rax
mov rdx, [rbp+var_70]
call _mi_kpointer
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_48]
mov rcx, [rbp+var_30]
lea rdx, [rbp+var_58]
call rax
cmp eax, 0
jnz short loc_CF9FF
jmp short $+2
loc_CF9F3:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_CFB2A
loc_CF9FF:
mov rax, [rbp+var_18]
mov rax, [rax+50h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_48]
mov r9, [rbp+var_30]
xor ecx, ecx
mov r8d, ecx
lea r10, [rbp+var_B0]
mov rdx, r8
mov rcx, r8
mov [rsp+0E0h+var_E0], r10
call rax
mov [rbp+var_44], eax
mov rax, [rbp+var_28]
mov ecx, [rbp+var_3C]
add rax, rcx
mov rcx, [rbp+var_58]
sub rax, rcx
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rdi, [rax+100h]
mov eax, [rbp+var_40]
add rdi, rax
mov eax, [rbp+var_44]
add rdi, rax
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call _memcpy
mov rax, [rbp+var_18]
mov rax, [rax+58h]
mov rdi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rsi, [rcx+100h]
mov ecx, [rbp+var_40]
add rsi, rcx
lea rdx, [rbp+var_B0]
call rax
mov edx, [rbp+var_48]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_38]
add ecx, [rbp+var_44]
add ecx, [rbp+var_40]
movzx ecx, cx
add eax, ecx
mov [rbp+var_BA], ax
movzx eax, [rbp+var_BA]
mov [rbp+var_C0], eax
mov eax, [rbp+var_C0]
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax+1], cl
mov eax, [rbp+var_C0]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov [rax], cl
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_70]
mov rax, [rbp+var_10]
mov r8, [rax+100h]
mov ecx, 3
call _mi_write_keypage
cmp eax, 0
jz short loc_CFB1D
jmp short $+2
loc_CFB14:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_CFB2A
loc_CFB1D:
jmp short $+2
loc_CFB1F:
jmp short $+2
loc_CFB21:
jmp short $+2
loc_CFB23:
mov [rbp+var_4], 2
loc_CFB2A:
mov eax, [rbp+var_4]
add rsp, 0E0h
pop rbp
retn
|
long long mi_split_page(_QWORD *a1, long long a2, long long a3, long long a4, unsigned __int8 *a5, char a6)
{
__int16 v6; // ax
_BYTE *v7; // rax
__int16 v8; // ax
_QWORD *v10; // [rsp+10h] [rbp-D0h]
unsigned int v11; // [rsp+1Ch] [rbp-C4h]
__int16 v12; // [rsp+26h] [rbp-BAh]
__int16 v13; // [rsp+28h] [rbp-B8h]
_BYTE v14[64]; // [rsp+30h] [rbp-B0h] BYREF
unsigned long long v15; // [rsp+70h] [rbp-70h]
long long v16; // [rsp+78h] [rbp-68h] BYREF
long long v17; // [rsp+80h] [rbp-60h]
long long last_pos; // [rsp+88h] [rbp-58h] BYREF
_BYTE v19[4]; // [rsp+94h] [rbp-4Ch] BYREF
unsigned int v20; // [rsp+98h] [rbp-48h]
unsigned int v21; // [rsp+9Ch] [rbp-44h]
unsigned int v22; // [rsp+A0h] [rbp-40h]
int v23; // [rsp+A4h] [rbp-3Ch]
unsigned int v24; // [rsp+A8h] [rbp-38h]
char v25; // [rsp+AFh] [rbp-31h]
unsigned __int8 *v26; // [rsp+B0h] [rbp-30h]
long long v27; // [rsp+B8h] [rbp-28h]
long long v28; // [rsp+C0h] [rbp-20h]
long long v29; // [rsp+C8h] [rbp-18h]
_QWORD *v30; // [rsp+D0h] [rbp-10h]
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
if ( 112LL * *((int *)v30 + 117) + *(_QWORD *)(*v30 + 536LL) == a2 )
*((_BYTE *)v30 + 828) = 1;
*((_BYTE *)v30 + 829) = 1;
if ( (*(_BYTE *)v27 & 0x80) != 0 )
v11 = *(_DWORD *)(*v30 + 380LL);
else
v11 = 0;
v20 = v11;
v22 = v11 + 2;
if ( v25 )
last_pos = mi_find_last_pos(v29, v27, v26, v19, &v16);
else
last_pos = mi_find_half_pos(v20, v29, v27, v26, v19, &v16);
if ( last_pos )
{
v24 = last_pos - v27;
v23 = _byteswap_ushort(*(_WORD *)v27) & 0x7FFF;
v6 = 0;
if ( v20 )
v6 = 0x8000;
v13 = v24 + v6;
*(_BYTE *)(v27 + 1) = v24 + v6;
*(_BYTE *)v27 = HIBYTE(v13);
last_pos = v16;
if ( v20 )
{
v17 = last_pos - v20;
memcpy(v30[32] + 2LL, v17, v20);
}
v15 = mi_new(v30, v29, 3);
if ( v15 == -1LL )
{
return (unsigned int)-1;
}
else
{
v10 = v30;
v7 = (_BYTE *)mi_move_key(v29, v28, v26);
mi_kpointer((long long)v10, v7, v15);
if ( (*(unsigned int ( **)(long long, _QWORD, long long *, unsigned __int8 *))(v29 + 72))(
v29,
v20,
&last_pos,
v26) )
{
v21 = (*(long long ( **)(long long, _QWORD, _QWORD, _QWORD, _QWORD, unsigned __int8 *, _BYTE *))(v29 + 80))(
v29,
v20,
0LL,
0LL,
0LL,
v26,
v14);
v24 = v23 + v27 - last_pos;
memcpy(v21 + v22 + v30[32], last_pos, v24);
(*(void ( **)(long long, _QWORD, _BYTE *))(v29 + 88))(v29, v22 + v30[32], v14);
v8 = 0;
if ( v20 )
v8 = 0x8000;
v12 = v22 + v21 + v24 + v8;
*(_BYTE *)(v30[32] + 1LL) = v22 + v21 + v24 + v8;
*(_BYTE *)v30[32] = HIBYTE(v12);
if ( (unsigned int)mi_write_keypage(v30, v29, v15, 3, (unsigned __int16 *)v30[32]) )
return (unsigned int)-1;
else
return 2;
}
else
{
return (unsigned int)-1;
}
}
}
else
{
return (unsigned int)-1;
}
}
|
_mi_split_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV AL,R9B
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 byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001cf7df
LAB_001cf7df:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RCX + 0x1d4]
IMUL RCX,RCX,0x70
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001cf810
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33c],0x1
LAB_001cf810:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001cf841
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0xc4],EAX
JMP 0x001cf84b
LAB_001cf841:
XOR EAX,EAX
MOV dword ptr [RBP + -0xc4],EAX
JMP 0x001cf84b
LAB_001cf84b:
MOV EAX,dword ptr [RBP + -0xc4]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,0x2
MOV dword ptr [RBP + -0x40],EAX
CMP byte ptr [RBP + -0x31],0x0
JZ 0x001cf882
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x4c]
LEA R8,[RBP + -0x68]
CALL 0x001cfb40
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001cf8a2
LAB_001cf882:
MOV EDI,dword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x4c]
LEA R9,[RBP + -0x68]
CALL 0x001cfe10
MOV qword ptr [RBP + -0x58],RAX
LAB_001cf8a2:
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x001cf8b7
JMP 0x001cf8ab
LAB_001cf8ab:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001cfb2a
LAB_001cf8b7:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV dword ptr [RBP + -0x3c],EAX
MOV EDX,dword ptr [RBP + -0x48]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x38]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0xb2],AX
MOVZX EAX,word ptr [RBP + -0xb2]
MOV dword ptr [RBP + -0xb8],EAX
MOV EAX,dword ptr [RBP + -0xb8]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0xb8]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x58],RAX
CMP dword ptr [RBP + -0x48],0x0
JZ 0x001cf97a
JMP 0x001cf946
LAB_001cf946:
JMP 0x001cf948
LAB_001cf948:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x48]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x100]
ADD RDI,0x2
MOV RSI,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + -0x48]
MOV EDX,EAX
CALL 0x0012a0b0
LAB_001cf97a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x3
CALL 0x001c6370
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,-0x1
JNZ 0x001cf9a4
JMP 0x001cf998
LAB_001cf998:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001cfb2a
LAB_001cf9a4:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xd0],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001c9c10
MOV RDI,qword ptr [RBP + -0xd0]
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x001c84a0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x30]
LEA RDX,[RBP + -0x58]
CALL RAX
CMP EAX,0x0
JNZ 0x001cf9ff
JMP 0x001cf9f3
LAB_001cf9f3:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001cfb2a
LAB_001cf9ff:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV R8D,ECX
LEA R10,[RBP + -0xb0]
MOV RDX,R8
MOV RCX,R8
MOV qword ptr [RSP],R10
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,RCX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x100]
MOV EAX,dword ptr [RBP + -0x40]
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x100]
MOV ECX,dword ptr [RBP + -0x40]
ADD RSI,RCX
LEA RDX,[RBP + -0xb0]
CALL RAX
MOV EDX,dword ptr [RBP + -0x48]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x38]
ADD ECX,dword ptr [RBP + -0x44]
ADD ECX,dword ptr [RBP + -0x40]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0xba],AX
MOVZX EAX,word ptr [RBP + -0xba]
MOV dword ptr [RBP + -0xc0],EAX
MOV EAX,dword ptr [RBP + -0xc0]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0xc0]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV byte ptr [RAX],CL
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x100]
MOV ECX,0x3
CALL 0x001c6040
CMP EAX,0x0
JZ 0x001cfb1d
JMP 0x001cfb14
LAB_001cfb14:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001cfb2a
LAB_001cfb1d:
JMP 0x001cfb1f
LAB_001cfb1f:
JMP 0x001cfb21
LAB_001cfb21:
JMP 0x001cfb23
LAB_001cfb23:
MOV dword ptr [RBP + -0x4],0x2
LAB_001cfb2a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xe0
POP RBP
RET
|
int4
_mi_split_page(long *param_1,long param_2,int8 param_3,byte *param_4,int8 param_5,
char param_6)
{
long *plVar1;
short sVar2;
int iVar3;
int8 uVar4;
uint local_cc;
int1 local_b8 [64];
long local_78;
void *local_70;
void *local_68;
void *local_60;
int1 local_54 [4];
uint local_50;
uint local_4c;
uint local_48;
uint local_44;
uint local_40;
char local_39;
int8 local_38;
byte *local_30;
int8 local_28;
long local_20;
long *local_18;
int4 local_c;
if (*(long *)(*param_1 + 0x218) + (long)*(int *)((long)param_1 + 0x1d4) * 0x70 == param_2) {
*(int1 *)((long)param_1 + 0x33c) = 1;
}
*(int1 *)((long)param_1 + 0x33d) = 1;
if ((*param_4 & 0x80) == 0) {
local_cc = 0;
}
else {
local_cc = *(uint *)(*param_1 + 0x17c);
}
local_50 = local_cc;
local_48 = local_cc + 2;
local_39 = param_6;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if (param_6 == '\0') {
local_60 = (void *)_mi_find_half_pos(local_cc,param_2,param_4,param_5,local_54,&local_70);
}
else {
local_60 = (void *)_mi_find_last_pos(param_2,param_4,param_5,local_54,&local_70);
}
if (local_60 == (void *)0x0) {
local_c = 0xffffffff;
}
else {
local_40 = (int)local_60 - (int)local_30;
local_44 = (uint)local_30[1] | (*local_30 & 0x7f) << 8;
sVar2 = 0;
if (local_50 != 0) {
sVar2 = -0x8000;
}
sVar2 = sVar2 + (short)local_40;
local_30[1] = (byte)sVar2;
*local_30 = (byte)((ushort)sVar2 >> 8);
local_60 = local_70;
if (local_50 != 0) {
local_68 = (void *)((long)local_70 - (ulong)local_50);
memcpy((void *)(local_18[0x20] + 2),local_68,(ulong)local_50);
}
local_78 = _mi_new(local_18,local_20,3);
plVar1 = local_18;
if (local_78 == -1) {
local_c = 0xffffffff;
}
else {
uVar4 = _mi_move_key(local_20,local_28,local_38);
_mi_kpointer(plVar1,uVar4,local_78);
iVar3 = (**(code **)(local_20 + 0x48))(local_20,local_50,&local_60,local_38);
if (iVar3 == 0) {
local_c = 0xffffffff;
}
else {
local_4c = (**(code **)(local_20 + 0x50))(local_20,local_50,0,0,0,local_38,local_b8);
local_40 = ((int)local_30 + local_44) - (int)local_60;
memcpy((void *)(local_18[0x20] + (ulong)local_48 + (ulong)local_4c),local_60,(ulong)local_40
);
(**(code **)(local_20 + 0x58))(local_20,local_18[0x20] + (ulong)local_48,local_b8);
sVar2 = 0;
if (local_50 != 0) {
sVar2 = -0x8000;
}
sVar2 = sVar2 + (short)local_40 + (short)local_4c + (short)local_48;
*(char *)(local_18[0x20] + 1) = (char)sVar2;
*(char *)local_18[0x20] = (char)((ushort)sVar2 >> 8);
iVar3 = _mi_write_keypage(local_18,local_20,local_78,3,local_18[0x20]);
if (iVar3 == 0) {
local_c = 2;
}
else {
local_c = 0xffffffff;
}
}
}
}
return local_c;
}
|
|
9,580 |
Slave::loadMasterShips(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
666mxvbee[P]BattleShip/lib/Slave/Slave.cpp
|
bool Slave::loadMasterShips(const std::string& filename) {
std::ifstream in(filename);
if (!in.is_open()) {
std::cerr << "Slave: Unable to open " << filename << " for reading." << std::endl;
return false;
}
settings.clearMasterShips();
std::string line;
while (std::getline(in, line)) {
std::stringstream ss(line);
std::string token;
int ship_type = 0;
char orientation = 'h';
uint64_t x = 0, y = 0;
while (std::getline(ss, token, ',')) {
std::size_t pos = token.find('=');
if (pos == std::string::npos) continue;
std::string key = token.substr(0, pos);
std::string value = token.substr(pos + 1);
if (key == "ship_type") {
ship_type = std::stoi(value);
} else if (key == "orientation") {
orientation = value[0];
} else if (key == "x") {
x = std::stoull(value);
} else if (key == "y") {
y = std::stoull(value);
}
}
settings.addMasterShip(Ship(ship_type, orientation, x, y));
}
in.close();
return true;
}
|
O0
|
cpp
|
Slave::loadMasterShips(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp # imm = 0x520
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4b0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
movl $0x8, %edx
callq 0x7570
movq -0x4a8(%rbp), %rdi
callq 0x7560
movb %al, -0x499(%rbp)
jmp 0x3934e
movb -0x499(%rbp), %al
testb $0x1, %al
jne 0x393ee
jmp 0x3935e
movq 0x23c7b(%rip), %rdi # 0x5cfe0
leaq 0x821e(%rip), %rsi # 0x4158a
callq 0x7370
movq %rax, -0x4b8(%rbp)
jmp 0x3937a
movq -0x4b8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq %rax, -0x4c0(%rbp)
jmp 0x39393
movq -0x4c0(%rbp), %rdi
leaq 0x8012(%rip), %rsi # 0x413b3
callq 0x7370
movq %rax, -0x4c8(%rbp)
jmp 0x393af
movq -0x4c8(%rbp), %rdi
movq 0x23ba3(%rip), %rsi # 0x5cf60
callq 0x73b0
jmp 0x393c4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x3984a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x39864
movq -0x4b0(%rbp), %rax
movq (%rax), %rdi
callq 0xb090
jmp 0x393ff
leaq -0x250(%rbp), %rdi
callq 0x8000
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x7080
movq %rax, -0x4d0(%rbp)
jmp 0x39427
movq -0x4d0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x7440
movb %al, -0x4d1(%rbp)
jmp 0x39445
movb -0x4d1(%rbp), %al
testb $0x1, %al
jne 0x39454
jmp 0x39812
movl $0x10, %edi
movl $0x8, %esi
callq 0xb9f0
movl %eax, -0x4d8(%rbp)
jmp 0x3946b
movl -0x4d8(%rbp), %edx
leaq -0x3d8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x7550
jmp 0x39486
leaq -0x3f8(%rbp), %rdi
callq 0x8000
movl $0x0, -0x3fc(%rbp)
movb $0x68, -0x3fd(%rbp)
movq $0x0, -0x408(%rbp)
movq $0x0, -0x410(%rbp)
leaq -0x3d8(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
movl $0x2c, %edx
callq 0x7670
movq %rax, -0x4e0(%rbp)
jmp 0x394da
movq -0x4e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x7440
movb %al, -0x4e1(%rbp)
jmp 0x394f8
movb -0x4e1(%rbp), %al
testb $0x1, %al
jne 0x39507
jmp 0x39762
leaq -0x3f8(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x398a0
movq %rax, -0x418(%rbp)
cmpq $-0x1, -0x418(%rbp)
jne 0x3955d
jmp 0x394b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x3983c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x397f8
movq -0x418(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x438(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
callq 0x39950
jmp 0x3957d
movq -0x418(%rbp), %rdx
incq %rdx
leaq -0x458(%rbp), %rdi
leaq -0x3f8(%rbp), %rsi
movq $-0x1, %rcx
callq 0x39950
jmp 0x395a3
leaq 0x7ff7(%rip), %rsi # 0x415a1
leaq -0x438(%rbp), %rdi
callq 0xb720
movb %al, -0x4e2(%rbp)
jmp 0x395be
movb -0x4e2(%rbp), %al
testb $0x1, %al
jne 0x395ca
jmp 0x39632
xorl %eax, %eax
movl %eax, %esi
leaq -0x458(%rbp), %rdi
movl $0xa, %edx
callq 0x399b0
movl %eax, -0x4e8(%rbp)
jmp 0x395e7
movl -0x4e8(%rbp), %eax
movl %eax, -0x3fc(%rbp)
jmp 0x39734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x39751
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x458(%rbp), %rdi
callq 0x8070
jmp 0x39751
leaq 0x7f72(%rip), %rsi # 0x415ab
leaq -0x438(%rbp), %rdi
callq 0xb720
movb %al, -0x4e9(%rbp)
jmp 0x3964d
movb -0x4e9(%rbp), %al
testb $0x1, %al
jne 0x39659
jmp 0x39686
xorl %eax, %eax
movl %eax, %esi
leaq -0x458(%rbp), %rdi
callq 0x14050
movq %rax, -0x4f8(%rbp)
jmp 0x39672
movq -0x4f8(%rbp), %rax
movb (%rax), %al
movb %al, -0x3fd(%rbp)
jmp 0x39732
leaq 0x763b(%rip), %rsi # 0x40cc8
leaq -0x438(%rbp), %rdi
callq 0xb720
movb %al, -0x4f9(%rbp)
jmp 0x396a1
movb -0x4f9(%rbp), %al
testb $0x1, %al
jne 0x396ad
jmp 0x396db
xorl %eax, %eax
movl %eax, %esi
leaq -0x458(%rbp), %rdi
movl $0xa, %edx
callq 0xb980
movq %rax, -0x508(%rbp)
jmp 0x396cb
movq -0x508(%rbp), %rax
movq %rax, -0x408(%rbp)
jmp 0x39730
leaq 0x760c(%rip), %rsi # 0x40cee
leaq -0x438(%rbp), %rdi
callq 0xb720
movb %al, -0x509(%rbp)
jmp 0x396f6
movb -0x509(%rbp), %al
testb $0x1, %al
jne 0x39702
jmp 0x3972e
xorl %eax, %eax
movl %eax, %esi
leaq -0x458(%rbp), %rdi
movl $0xa, %edx
callq 0xb980
movq %rax, -0x518(%rbp)
jmp 0x39720
movq -0x518(%rbp), %rax
movq %rax, -0x410(%rbp)
jmp 0x39730
jmp 0x39732
jmp 0x39734
leaq -0x458(%rbp), %rdi
callq 0x8070
leaq -0x438(%rbp), %rdi
callq 0x8070
jmp 0x394b9
leaq -0x438(%rbp), %rdi
callq 0x8070
jmp 0x397f8
movq -0x4b0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x520(%rbp)
movl -0x3fc(%rbp), %esi
movsbl -0x3fd(%rbp), %edx
movq -0x408(%rbp), %rcx
movq -0x410(%rbp), %r8
leaq -0x498(%rbp), %rdi
callq 0x384d0
jmp 0x3979c
movq -0x520(%rbp), %rdi
leaq -0x498(%rbp), %rsi
callq 0xaec0
jmp 0x397b1
leaq -0x498(%rbp), %rdi
callq 0x8500
leaq -0x3f8(%rbp), %rdi
callq 0x8070
leaq -0x3d8(%rbp), %rdi
callq 0x72d0
jmp 0x3940b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x498(%rbp), %rdi
callq 0x8500
leaq -0x3f8(%rbp), %rdi
callq 0x8070
leaq -0x3d8(%rbp), %rdi
callq 0x72d0
jmp 0x3983c
leaq -0x220(%rbp), %rdi
callq 0x7090
jmp 0x39820
movb $0x1, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x8070
jmp 0x3984a
leaq -0x250(%rbp), %rdi
callq 0x8070
jmp 0x39864
leaq -0x220(%rbp), %rdi
callq 0x70b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x520, %rsp # imm = 0x520
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x70b0
movq -0x228(%rbp), %rdi
callq 0x7630
nopl (%rax)
|
_ZN5Slave15loadMasterShipsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 520h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_4B0], rax
mov rsi, [rbp+var_18]
lea rdi, [rbp+var_220]
mov [rbp+var_4A8], rdi
mov edx, 8
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ifstream::basic_ifstream(std::string const&,std::_Ios_Openmode)
mov rdi, [rbp+var_4A8]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv; std::ifstream::is_open(void)
mov [rbp+var_499], al
jmp short $+2
loc_3934E:
mov al, [rbp+var_499]
test al, 1
jnz loc_393EE
jmp short $+2
loc_3935E:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aSlaveUnableToO; "Slave: Unable to open "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_4B8], rax
jmp short $+2
loc_3937A:
mov rdi, [rbp+var_4B8]
mov rsi, [rbp+var_18]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rbp+var_4C0], rax
jmp short $+2
loc_39393:
mov rdi, [rbp+var_4C0]
lea rsi, aForReading; " for reading."
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_4C8], rax
jmp short $+2
loc_393AF:
mov rdi, [rbp+var_4C8]
mov rsi, cs:_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6__ptr
call __ZNSolsEPFRSoS_E; std::ostream::operator<<(std::ostream & (*)(std::ostream &))
jmp short $+2
loc_393C4:
mov [rbp+var_1], 0
mov [rbp+var_230], 1
jmp loc_3984A
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
jmp loc_39864
loc_393EE:
mov rax, [rbp+var_4B0]
mov rdi, [rax]; this
call _ZN8Settings16clearMasterShipsEv; Settings::clearMasterShips(void)
jmp short $+2
loc_393FF:
lea rdi, [rbp+var_250]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
loc_3940B:
lea rdi, [rbp+var_220]
lea rsi, [rbp+var_250]
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov [rbp+var_4D0], rax
jmp short $+2
loc_39427:
mov rdi, [rbp+var_4D0]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
mov [rbp+var_4D1], al
jmp short $+2
loc_39445:
mov al, [rbp+var_4D1]
test al, 1
jnz short loc_39454
jmp loc_39812
loc_39454:
mov edi, 10h
mov esi, 8
call _ZStorSt13_Ios_OpenmodeS_; std::operator|(std::_Ios_Openmode,std::_Ios_Openmode)
mov [rbp+var_4D8], eax
jmp short $+2
loc_3946B:
mov edx, [rbp+var_4D8]
lea rdi, [rbp+var_3D8]
lea rsi, [rbp+var_250]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
jmp short $+2
loc_39486:
lea rdi, [rbp+var_3F8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
mov [rbp+var_3FC], 0
mov [rbp+var_3FD], 68h ; 'h'
mov [rbp+var_408], 0
mov [rbp+var_410], 0
loc_394B9:
lea rdi, [rbp+var_3D8]
lea rsi, [rbp+var_3F8]
mov edx, 2Ch ; ','
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov [rbp+var_4E0], rax
jmp short $+2
loc_394DA:
mov rdi, [rbp+var_4E0]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
mov [rbp+var_4E1], al
jmp short $+2
loc_394F8:
mov al, [rbp+var_4E1]
test al, 1
jnz short loc_39507
jmp loc_39762
loc_39507:
lea rdi, [rbp+var_3F8]
mov esi, 3Dh ; '='
xor eax, eax
mov edx, eax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
mov [rbp+var_418], rax
cmp [rbp+var_418], 0FFFFFFFFFFFFFFFFh
jnz short loc_3955D
jmp short loc_394B9
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
jmp loc_3983C
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
jmp loc_397F8
loc_3955D:
mov rcx, [rbp+var_418]
xor eax, eax
mov edx, eax
lea rdi, [rbp+var_438]
lea rsi, [rbp+var_3F8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_3957D:
mov rdx, [rbp+var_418]
inc rdx
lea rdi, [rbp+var_458]
lea rsi, [rbp+var_3F8]
mov rcx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_395A3:
lea rsi, aShipType_0; "ship_type"
lea rdi, [rbp+var_438]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rbp+var_4E2], al
jmp short $+2
loc_395BE:
mov al, [rbp+var_4E2]
test al, 1
jnz short loc_395CA
jmp short loc_39632
loc_395CA:
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_458]
mov edx, 0Ah
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov [rbp+var_4E8], eax
jmp short $+2
loc_395E7:
mov eax, [rbp+var_4E8]
mov [rbp+var_3FC], eax
jmp loc_39734
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
jmp loc_39751
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
lea rdi, [rbp+var_458]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_39751
loc_39632:
lea rsi, aOrientation_0; "orientation"
lea rdi, [rbp+var_438]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rbp+var_4E9], al
jmp short $+2
loc_3964D:
mov al, [rbp+var_4E9]
test al, 1
jnz short loc_39659
jmp short loc_39686
loc_39659:
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_458]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov [rbp+var_4F8], rax
jmp short $+2
loc_39672:
mov rax, [rbp+var_4F8]
mov al, [rax]
mov [rbp+var_3FD], al
jmp loc_39732
loc_39686:
lea rsi, aCircumflex+9; "x"
lea rdi, [rbp+var_438]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rbp+var_4F9], al
jmp short $+2
loc_396A1:
mov al, [rbp+var_4F9]
test al, 1
jnz short loc_396AD
jmp short loc_396DB
loc_396AD:
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_458]
mov edx, 0Ah
call _ZNSt7__cxx116stoullERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoull(std::string const&,ulong *,int)
mov [rbp+var_508], rax
jmp short $+2
loc_396CB:
mov rax, [rbp+var_508]
mov [rbp+var_408], rax
jmp short loc_39730
loc_396DB:
lea rsi, aFjquvyz+0Ah; "yz"
lea rdi, [rbp+var_438]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rbp+var_509], al
jmp short $+2
loc_396F6:
mov al, [rbp+var_509]
test al, 1
jnz short loc_39702
jmp short loc_3972E
loc_39702:
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_458]
mov edx, 0Ah
call _ZNSt7__cxx116stoullERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoull(std::string const&,ulong *,int)
mov [rbp+var_518], rax
jmp short $+2
loc_39720:
mov rax, [rbp+var_518]
mov [rbp+var_410], rax
loc_3972E:
jmp short $+2
loc_39730:
jmp short $+2
loc_39732:
jmp short $+2
loc_39734:
lea rdi, [rbp+var_458]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_438]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_394B9
loc_39751:
lea rdi, [rbp+var_438]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_397F8
loc_39762:
mov rax, [rbp+var_4B0]
mov rax, [rax]
mov [rbp+var_520], rax
mov esi, [rbp+var_3FC]; int
movsx edx, [rbp+var_3FD]; char
mov rcx, [rbp+var_408]; unsigned __int64
mov r8, [rbp+var_410]; unsigned __int64
lea rdi, [rbp+var_498]; this
call _ZN4ShipC2Eicmm; Ship::Ship(int,char,ulong,ulong)
jmp short $+2
loc_3979C:
mov rdi, [rbp+var_520]; this
lea rsi, [rbp+var_498]; Ship *
call _ZN8Settings13addMasterShipERK4Ship; Settings::addMasterShip(Ship const&)
jmp short $+2
loc_397B1:
lea rdi, [rbp+var_498]; this
call _ZN4ShipD2Ev; Ship::~Ship()
lea rdi, [rbp+var_3F8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_3D8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
jmp loc_3940B
mov rcx, rax
mov eax, edx
mov [rbp+var_228], rcx
mov [rbp+var_22C], eax
lea rdi, [rbp+var_498]; this
call _ZN4ShipD2Ev; Ship::~Ship()
loc_397F8:
lea rdi, [rbp+var_3F8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rbp+var_3D8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
jmp short loc_3983C
loc_39812:
lea rdi, [rbp+var_220]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEE5closeEv; std::ifstream::close(void)
jmp short $+2
loc_39820:
mov [rbp+var_1], 1
mov [rbp+var_230], 1
lea rdi, [rbp+var_250]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_3984A
loc_3983C:
lea rdi, [rbp+var_250]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_39864
loc_3984A:
lea rdi, [rbp+var_220]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov al, [rbp+var_1]
and al, 1
add rsp, 520h
pop rbp
retn
loc_39864:
lea rdi, [rbp+var_220]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov rdi, [rbp+var_228]
call __Unwind_Resume
|
char Slave::loadMasterShips(Settings **a1, long long a2)
{
Settings *v3; // [rsp+0h] [rbp-520h]
_QWORD *v4; // [rsp+40h] [rbp-4E0h]
unsigned int v5; // [rsp+48h] [rbp-4D8h]
_QWORD *v6; // [rsp+50h] [rbp-4D0h]
long long v7; // [rsp+58h] [rbp-4C8h]
long long v8; // [rsp+60h] [rbp-4C0h]
long long v9; // [rsp+68h] [rbp-4B8h]
_BYTE v10[64]; // [rsp+88h] [rbp-498h] BYREF
_BYTE v11[32]; // [rsp+C8h] [rbp-458h] BYREF
_BYTE v12[32]; // [rsp+E8h] [rbp-438h] BYREF
long long v13; // [rsp+108h] [rbp-418h]
unsigned long long v14; // [rsp+110h] [rbp-410h]
unsigned long long v15; // [rsp+118h] [rbp-408h]
char v16; // [rsp+123h] [rbp-3FDh]
int v17; // [rsp+124h] [rbp-3FCh]
_BYTE v18[32]; // [rsp+128h] [rbp-3F8h] BYREF
_BYTE v19[392]; // [rsp+148h] [rbp-3D8h] BYREF
_BYTE v20[32]; // [rsp+2D0h] [rbp-250h] BYREF
int v21; // [rsp+2F0h] [rbp-230h]
_BYTE v22[520]; // [rsp+300h] [rbp-220h] BYREF
long long v23; // [rsp+508h] [rbp-18h]
Settings **v24; // [rsp+510h] [rbp-10h]
char v25; // [rsp+51Fh] [rbp-1h]
v24 = a1;
v23 = a2;
std::ifstream::basic_ifstream(v22, a2, 8LL);
if ( (std::ifstream::is_open(v22) & 1) != 0 )
{
Settings::clearMasterShips(*a1);
std::string::basic_string((long long)v20);
while ( 1 )
{
v6 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v22, v20);
if ( (std::ios::operator bool((char *)v6 + *(_QWORD *)(*v6 - 24LL)) & 1) == 0 )
break;
v5 = std::operator|(0x10u, 8);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v19, v20, v5);
std::string::basic_string((long long)v18);
v17 = 0;
v16 = 104;
v15 = 0LL;
v14 = 0LL;
while ( 1 )
{
v4 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v19, v18, 44LL);
if ( (std::ios::operator bool((char *)v4 + *(_QWORD *)(*v4 - 24LL)) & 1) == 0 )
break;
v13 = std::string::find(v18, 61LL, 0LL);
if ( v13 != -1 )
{
std::string::substr(v12, v18, 0LL, v13);
std::string::substr(v11, v18, v13 + 1, -1LL);
if ( std::operator==<char>((long long)v12, (long long)"ship_type") )
{
v17 = std::stoi(v11, 0LL, 10LL);
}
else if ( std::operator==<char>((long long)v12, (long long)"orientation") )
{
v16 = *(_BYTE *)std::string::operator[]((long long)v11, 0LL);
}
else if ( std::operator==<char>((long long)v12, (long long)"x") )
{
v15 = std::stoull((long long)v11, 0LL, 0xAu);
}
else if ( std::operator==<char>((long long)v12, (long long)&aFjquvyz[5]) )
{
v14 = std::stoull((long long)v11, 0LL, 0xAu);
}
std::string::~string((long long)v11);
std::string::~string((long long)v12);
}
}
v3 = *a1;
Ship::Ship((Ship *)v10, v17, v16, v15, v14);
Settings::addMasterShip(v3, (const Ship *)v10);
Ship::~Ship((Ship *)v10);
std::string::~string((long long)v18);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v19);
}
std::ifstream::close(v22);
v25 = 1;
v21 = 1;
std::string::~string((long long)v20);
}
else
{
v9 = std::operator<<<std::char_traits<char>>(&std::cerr, "Slave: Unable to open ");
v8 = std::operator<<<char>(v9, v23);
v7 = std::operator<<<std::char_traits<char>>(v8, " for reading.");
std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
v25 = 0;
v21 = 1;
}
std::ifstream::~ifstream(v22);
return v25 & 1;
}
|
loadMasterShips:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x520
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x4b0],RAX
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x220]
MOV qword ptr [RBP + -0x4a8],RDI
MOV EDX,0x8
CALL 0x00107570
MOV RDI,qword ptr [RBP + -0x4a8]
LAB_00139341:
CALL 0x00107560
MOV byte ptr [RBP + -0x499],AL
JMP 0x0013934e
LAB_0013934e:
MOV AL,byte ptr [RBP + -0x499]
TEST AL,0x1
JNZ 0x001393ee
JMP 0x0013935e
LAB_0013935e:
MOV RDI,qword ptr [0x0015cfe0]
LEA RSI,[0x14158a]
CALL 0x00107370
MOV qword ptr [RBP + -0x4b8],RAX
JMP 0x0013937a
LAB_0013937a:
MOV RDI,qword ptr [RBP + -0x4b8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00107340
MOV qword ptr [RBP + -0x4c0],RAX
JMP 0x00139393
LAB_00139393:
MOV RDI,qword ptr [RBP + -0x4c0]
LEA RSI,[0x1413b3]
CALL 0x00107370
MOV qword ptr [RBP + -0x4c8],RAX
JMP 0x001393af
LAB_001393af:
MOV RDI,qword ptr [RBP + -0x4c8]
MOV RSI,qword ptr [0x0015cf60]
CALL 0x001073b0
JMP 0x001393c4
LAB_001393c4:
MOV byte ptr [RBP + -0x1],0x0
MOV dword ptr [RBP + -0x230],0x1
JMP 0x0013984a
LAB_001393ee:
MOV RAX,qword ptr [RBP + -0x4b0]
MOV RDI,qword ptr [RAX]
CALL 0x0010b090
JMP 0x001393ff
LAB_001393ff:
LEA RDI,[RBP + -0x250]
CALL 0x00108000
LAB_0013940b:
LEA RDI,[RBP + -0x220]
LEA RSI,[RBP + -0x250]
CALL 0x00107080
MOV qword ptr [RBP + -0x4d0],RAX
JMP 0x00139427
LAB_00139427:
MOV RDI,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
CALL 0x00107440
MOV byte ptr [RBP + -0x4d1],AL
JMP 0x00139445
LAB_00139445:
MOV AL,byte ptr [RBP + -0x4d1]
TEST AL,0x1
JNZ 0x00139454
JMP 0x00139812
LAB_00139454:
MOV EDI,0x10
MOV ESI,0x8
CALL 0x0010b9f0
MOV dword ptr [RBP + -0x4d8],EAX
JMP 0x0013946b
LAB_0013946b:
MOV EDX,dword ptr [RBP + -0x4d8]
LEA RDI,[RBP + -0x3d8]
LEA RSI,[RBP + -0x250]
CALL 0x00107550
JMP 0x00139486
LAB_00139486:
LEA RDI,[RBP + -0x3f8]
CALL 0x00108000
MOV dword ptr [RBP + -0x3fc],0x0
MOV byte ptr [RBP + -0x3fd],0x68
MOV qword ptr [RBP + -0x408],0x0
MOV qword ptr [RBP + -0x410],0x0
LAB_001394b9:
LEA RDI,[RBP + -0x3d8]
LEA RSI,[RBP + -0x3f8]
MOV EDX,0x2c
CALL 0x00107670
MOV qword ptr [RBP + -0x4e0],RAX
JMP 0x001394da
LAB_001394da:
MOV RDI,qword ptr [RBP + -0x4e0]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
CALL 0x00107440
MOV byte ptr [RBP + -0x4e1],AL
JMP 0x001394f8
LAB_001394f8:
MOV AL,byte ptr [RBP + -0x4e1]
TEST AL,0x1
JNZ 0x00139507
JMP 0x00139762
LAB_00139507:
LEA RDI,[RBP + -0x3f8]
MOV ESI,0x3d
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001398a0
MOV qword ptr [RBP + -0x418],RAX
CMP qword ptr [RBP + -0x418],-0x1
JNZ 0x0013955d
JMP 0x001394b9
LAB_0013955d:
MOV RCX,qword ptr [RBP + -0x418]
XOR EAX,EAX
MOV EDX,EAX
LEA RDI,[RBP + -0x438]
LEA RSI,[RBP + -0x3f8]
CALL 0x00139950
JMP 0x0013957d
LAB_0013957d:
MOV RDX,qword ptr [RBP + -0x418]
INC RDX
LAB_00139587:
LEA RDI,[RBP + -0x458]
LEA RSI,[RBP + -0x3f8]
MOV RCX,-0x1
CALL 0x00139950
JMP 0x001395a3
LAB_001395a3:
LEA RSI,[0x1415a1]
LEA RDI,[RBP + -0x438]
CALL 0x0010b720
MOV byte ptr [RBP + -0x4e2],AL
JMP 0x001395be
LAB_001395be:
MOV AL,byte ptr [RBP + -0x4e2]
TEST AL,0x1
JNZ 0x001395ca
JMP 0x00139632
LAB_001395ca:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x458]
MOV EDX,0xa
CALL 0x001399b0
MOV dword ptr [RBP + -0x4e8],EAX
JMP 0x001395e7
LAB_001395e7:
MOV EAX,dword ptr [RBP + -0x4e8]
MOV dword ptr [RBP + -0x3fc],EAX
JMP 0x00139734
LAB_00139632:
LEA RSI,[0x1415ab]
LEA RDI,[RBP + -0x438]
CALL 0x0010b720
MOV byte ptr [RBP + -0x4e9],AL
JMP 0x0013964d
LAB_0013964d:
MOV AL,byte ptr [RBP + -0x4e9]
TEST AL,0x1
JNZ 0x00139659
JMP 0x00139686
LAB_00139659:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x458]
CALL 0x00114050
MOV qword ptr [RBP + -0x4f8],RAX
JMP 0x00139672
LAB_00139672:
MOV RAX,qword ptr [RBP + -0x4f8]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x3fd],AL
JMP 0x00139732
LAB_00139686:
LEA RSI,[0x140cc8]
LEA RDI,[RBP + -0x438]
CALL 0x0010b720
MOV byte ptr [RBP + -0x4f9],AL
JMP 0x001396a1
LAB_001396a1:
MOV AL,byte ptr [RBP + -0x4f9]
TEST AL,0x1
JNZ 0x001396ad
JMP 0x001396db
LAB_001396ad:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x458]
MOV EDX,0xa
CALL 0x0010b980
MOV qword ptr [RBP + -0x508],RAX
JMP 0x001396cb
LAB_001396cb:
MOV RAX,qword ptr [RBP + -0x508]
MOV qword ptr [RBP + -0x408],RAX
JMP 0x00139730
LAB_001396db:
LEA RSI,[0x140cee]
LEA RDI,[RBP + -0x438]
CALL 0x0010b720
MOV byte ptr [RBP + -0x509],AL
JMP 0x001396f6
LAB_001396f6:
MOV AL,byte ptr [RBP + -0x509]
TEST AL,0x1
JNZ 0x00139702
JMP 0x0013972e
LAB_00139702:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x458]
MOV EDX,0xa
CALL 0x0010b980
MOV qword ptr [RBP + -0x518],RAX
JMP 0x00139720
LAB_00139720:
MOV RAX,qword ptr [RBP + -0x518]
MOV qword ptr [RBP + -0x410],RAX
LAB_0013972e:
JMP 0x00139730
LAB_00139730:
JMP 0x00139732
LAB_00139732:
JMP 0x00139734
LAB_00139734:
LEA RDI,[RBP + -0x458]
CALL 0x00108070
LEA RDI,[RBP + -0x438]
CALL 0x00108070
JMP 0x001394b9
LAB_00139762:
MOV RAX,qword ptr [RBP + -0x4b0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x520],RAX
MOV ESI,dword ptr [RBP + -0x3fc]
MOVSX EDX,byte ptr [RBP + -0x3fd]
MOV RCX,qword ptr [RBP + -0x408]
MOV R8,qword ptr [RBP + -0x410]
LAB_0013978e:
LEA RDI,[RBP + -0x498]
CALL 0x001384d0
JMP 0x0013979c
LAB_0013979c:
MOV RDI,qword ptr [RBP + -0x520]
LEA RSI,[RBP + -0x498]
CALL 0x0010aec0
JMP 0x001397b1
LAB_001397b1:
LEA RDI,[RBP + -0x498]
CALL 0x00108500
LEA RDI,[RBP + -0x3f8]
CALL 0x00108070
LEA RDI,[RBP + -0x3d8]
CALL 0x001072d0
JMP 0x0013940b
LAB_00139812:
LEA RDI,[RBP + -0x220]
CALL 0x00107090
LAB_0013981e:
JMP 0x00139820
LAB_00139820:
MOV byte ptr [RBP + -0x1],0x1
MOV dword ptr [RBP + -0x230],0x1
LEA RDI,[RBP + -0x250]
CALL 0x00108070
JMP 0x0013984a
LAB_0013984a:
LEA RDI,[RBP + -0x220]
CALL 0x001070b0
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x520
POP RBP
RET
|
/* Slave::loadMasterShips(std::__cxx11::string const&) */
ulong __thiscall Slave::loadMasterShips(Slave *this,string *param_1)
{
Settings *this_00;
byte bVar1;
bool bVar2;
int4 uVar3;
ostream *poVar4;
istream *piVar5;
char *pcVar6;
int8 uVar7;
Ship local_4a0 [64];
string local_460 [32];
string local_440 [32];
long local_420;
ulong local_418;
ulong local_410;
char local_405;
int local_404;
string local_400 [32];
stringstream local_3e0 [392];
string local_258 [32];
int4 local_238;
ifstream local_228 [520];
string *local_20;
Slave *local_18;
int1 local_9;
local_20 = param_1;
local_18 = this;
std::ifstream::ifstream(local_228,param_1,8);
/* try { // try from 00139341 to 001393fc has its CatchHandler @ 001393d7 */
bVar1 = std::ifstream::is_open();
if ((bVar1 & 1) == 0) {
poVar4 = std::operator<<((ostream *)PTR_cerr_0015cfe0,"Slave: Unable to open ");
poVar4 = std::operator<<(poVar4,local_20);
poVar4 = std::operator<<(poVar4," for reading.");
std::ostream::operator<<
(poVar4,(_func_ostream_ptr_ostream_ptr *)PTR_endl<char,std_char_traits<char>>_0015cf60
);
local_9 = 0;
local_238 = 1;
}
else {
Settings::clearMasterShips(*(Settings **)this);
std::__cxx11::string::string(local_258);
while( true ) {
/* try { // try from 0013940b to 00139483 has its CatchHandler @ 0013952f */
piVar5 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_228,local_258);
bVar2 = std::ios::operator_cast_to_bool((ios *)(piVar5 + *(long *)(*(long *)piVar5 + -0x18)));
if (!bVar2) break;
uVar3 = std::operator|(0x10,8);
std::__cxx11::stringstream::stringstream(local_3e0,local_258,uVar3);
std::__cxx11::string::string(local_400);
local_404 = 0;
local_405 = 'h';
local_410 = 0;
local_418 = 0;
while( true ) {
/* try { // try from 001394b9 to 0013957a has its CatchHandler @ 00139546 */
piVar5 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_3e0,local_400,',');
bVar2 = std::ios::operator_cast_to_bool
((ios *)(piVar5 + *(long *)(*(long *)piVar5 + -0x18)));
if (!bVar2) break;
local_420 = std::__cxx11::string::find(local_400,'=',0);
if (local_420 != -1) {
std::__cxx11::string::substr((ulong)local_440,(ulong)local_400);
/* try { // try from 00139587 to 001395a0 has its CatchHandler @ 001395f8 */
std::__cxx11::string::substr((ulong)local_460,(ulong)local_400);
/* try { // try from 001395a3 to 00139716 has its CatchHandler @ 0013960f */
bVar2 = std::operator==(local_440,"ship_type");
if (bVar2) {
local_404 = std::__cxx11::stoi(local_460,(ulong *)0x0,10);
}
else {
bVar2 = std::operator==(local_440,"orientation");
if (bVar2) {
pcVar6 = (char *)std::__cxx11::string::operator[](local_460,0);
local_405 = *pcVar6;
}
else {
bVar2 = std::operator==(local_440,"x");
if (bVar2) {
local_410 = std::__cxx11::stoull(local_460,(ulong *)0x0,10);
}
else {
bVar2 = std::operator==(local_440,"y");
if (bVar2) {
local_418 = std::__cxx11::stoull(local_460,(ulong *)0x0,10);
}
}
}
}
std::__cxx11::string::~string(local_460);
std::__cxx11::string::~string(local_440);
}
}
this_00 = *(Settings **)this;
/* try { // try from 0013978e to 00139799 has its CatchHandler @ 00139546 */
Ship::Ship(local_4a0,local_404,local_405,local_410,local_418);
/* try { // try from 0013979c to 001397ae has its CatchHandler @ 001397da */
Settings::addMasterShip(this_00,local_4a0);
Ship::~Ship(local_4a0);
std::__cxx11::string::~string(local_400);
std::__cxx11::stringstream::~stringstream(local_3e0);
}
/* try { // try from 00139812 to 0013981d has its CatchHandler @ 0013952f */
std::ifstream::close();
local_9 = 1;
local_238 = 1;
std::__cxx11::string::~string(local_258);
}
uVar7 = std::ifstream::~ifstream(local_228);
return CONCAT71((int7)((ulong)uVar7 >> 8),local_9) & 0xffffffffffffff01;
}
|
|
9,581 |
Slave::loadMasterShips(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
666mxvbee[P]BattleShip/lib/Slave/Slave.cpp
|
bool Slave::loadMasterShips(const std::string& filename) {
std::ifstream in(filename);
if (!in.is_open()) {
std::cerr << "Slave: Unable to open " << filename << " for reading." << std::endl;
return false;
}
settings.clearMasterShips();
std::string line;
while (std::getline(in, line)) {
std::stringstream ss(line);
std::string token;
int ship_type = 0;
char orientation = 'h';
uint64_t x = 0, y = 0;
while (std::getline(ss, token, ',')) {
std::size_t pos = token.find('=');
if (pos == std::string::npos) continue;
std::string key = token.substr(0, pos);
std::string value = token.substr(pos + 1);
if (key == "ship_type") {
ship_type = std::stoi(value);
} else if (key == "orientation") {
orientation = value[0];
} else if (key == "x") {
x = std::stoull(value);
} else if (key == "y") {
y = std::stoull(value);
}
}
settings.addMasterShip(Ship(ship_type, orientation, x, y));
}
in.close();
return true;
}
|
O2
|
cpp
|
Slave::loadMasterShips(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 $0x458, %rsp # imm = 0x458
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc8(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x5500
leaq 0x140(%rsp), %rdi
callq 0x5080
movb %al, 0x7(%rsp)
testb %al, %al
je 0x13e0c
movq %r14, 0x20(%rsp)
movq (%r14), %rdi
callq 0x6928
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x68(%rsp), %r14
leaq 0x2d0(%rsp), %rbp
leaq 0x48(%rsp), %r15
pushq $0x2c
popq %rbx
pushq $0x3d
popq %r12
leaq 0x88(%rsp), %r13
leaq 0xc8(%rsp), %rdi
movq %r14, %rsi
callq 0x5060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13e43
movq %rbp, %rdi
movq %r14, %rsi
pushq $0x18
popq %rdx
callq 0x54f0
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
andq $0x0, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
movb $0x68, 0x6(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x55c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13db6
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x13f04
cmpq $-0x1, %rax
je 0x13ca8
movq %rax, %r14
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x13f56
incq %r14
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
pushq $-0x1
popq %rcx
callq 0x13f56
movq %r13, %r14
movq %r13, %rdi
leaq 0x4807(%rip), %rsi # 0x18517
callq 0x6b65
testb %al, %al
je 0x13d2f
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x13f93
movq %rax, 0x18(%rsp)
jmp 0x13d9f
movq %r14, %rdi
leaq 0x47e8(%rip), %rsi # 0x18521
callq 0x6b65
testb %al, %al
je 0x13d4f
movq 0x28(%rsp), %rax
movb (%rax), %al
movb %al, 0x6(%rsp)
jmp 0x13d9f
movq %r14, %rdi
leaq 0x3ee7(%rip), %rsi # 0x17c40
callq 0x6b65
testb %al, %al
je 0x13d78
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x6c09
movq %rax, 0x10(%rsp)
jmp 0x13d9f
movq %r14, %rdi
leaq 0x3ee4(%rip), %rsi # 0x17c66
callq 0x6b65
testb %al, %al
je 0x13d9f
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x6c09
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5bc0
movq %r13, %rdi
callq 0x5bc0
jmp 0x13ca8
movq 0x20(%rsp), %rax
movq (%rax), %r14
movsbl 0x6(%rsp), %edx
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x135c0
movq %r14, %rdi
movq %r13, %rsi
callq 0x6838
leaq 0x68(%rsp), %r14
leaq 0xa0(%rsp), %rdi
callq 0x5c8e
movq %r15, %rdi
callq 0x5bc0
movq %rbp, %rdi
callq 0x52b0
jmp 0x13c43
movq 0x111d5(%rip), %rdi # 0x24fe8
leaq 0x46e6(%rip), %rsi # 0x18500
callq 0x5340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5310
leaq 0x44f8(%rip), %rsi # 0x18329
movq %rax, %rdi
callq 0x5340
movq %rax, %rdi
callq 0x5190
jmp 0x13e5a
leaq 0xc8(%rsp), %rdi
callq 0x5070
leaq 0x68(%rsp), %rdi
callq 0x5bc0
leaq 0xc8(%rsp), %rdi
callq 0x5090
movb 0x7(%rsp), %al
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ebd
movq %rax, %rbx
jmp 0x13ee6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5bc0
jmp 0x13e96
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5bc0
jmp 0x13ec5
jmp 0x13ec2
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x5c8e
jmp 0x13ec5
jmp 0x13ec2
jmp 0x13ebd
movq %rax, %rbx
jmp 0x13edc
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5bc0
leaq 0x2d0(%rsp), %rdi
callq 0x52b0
leaq 0x68(%rsp), %rdi
callq 0x5bc0
leaq 0xc8(%rsp), %rdi
callq 0x5090
movq %rbx, %rdi
callq 0x5590
nop
|
_ZN5Slave15loadMasterShipsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 458h
mov rbx, rsi
mov r14, rdi
lea rdi, [rsp+488h+var_3C0]
push 8
pop rdx
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ifstream::basic_ifstream(std::string const&,std::_Ios_Openmode)
lea rdi, [rsp+488h+var_348]
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
mov [rsp+488h+var_481], al
test al, al
jz loc_13E0C
mov [rsp+488h+var_468], r14
mov rdi, [r14]; this
call _ZN8Settings16clearMasterShipsEv; Settings::clearMasterShips(void)
lea rax, [rsp+488h+var_410]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea r14, [rsp+488h+var_420]
lea rbp, [rsp+488h+var_1B8]
lea r15, [rsp+488h+var_440]
push 2Ch ; ','
pop rbx
push 3Dh ; '='
pop r12
lea r13, [rsp+488h+var_400]
loc_13C43:
lea rdi, [rsp+488h+var_3C0]
mov rsi, r14
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz loc_13E43
mov rdi, rbp
mov rsi, r14
push 18h
pop rdx
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(std::string const&,std::_Ios_Openmode)
lea rax, [rsp+488h+var_430]
mov [rsp+488h+var_440], rax
and [rsp+488h+var_438], 0
mov [rsp+488h+var_430], 0
mov [rsp+488h+var_482], 68h ; 'h'
mov qword ptr [rsp+488h+var_470], 0
mov [rsp+488h+var_478], 0
mov [rsp+488h+var_480], 0
loc_13CA8:
mov rdi, rbp
mov rsi, r15
mov edx, ebx
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz loc_13DB6
mov rdi, r15
mov esi, r12d
xor edx, edx
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_13CA8
mov r14, rax
mov rdi, r13
mov rsi, r15
xor edx, edx
mov rcx, rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
inc r14
lea rdi, [rsp+488h+var_460]
mov rsi, r15
mov rdx, r14
push 0FFFFFFFFFFFFFFFFh
pop rcx
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov r14, r13
mov rdi, r13
lea rsi, aShipType_0; "ship_type"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_13D2F
lea rdi, [rsp+488h+var_460]
xor esi, esi
push 0Ah
pop rdx
call _ZNSt7__cxx114stoiERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoi(std::string const&,ulong *,int)
mov qword ptr [rsp+488h+var_470], rax
jmp short loc_13D9F
loc_13D2F:
mov rdi, r14
lea rsi, aOrientation_0; "orientation"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_13D4F
mov rax, [rsp+488h+var_460]
mov al, [rax]
mov [rsp+488h+var_482], al
jmp short loc_13D9F
loc_13D4F:
mov rdi, r14
lea rsi, aCircumflex+9; "x"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_13D78
lea rdi, [rsp+488h+var_460]
xor esi, esi
push 0Ah
pop rdx
call _ZNSt7__cxx116stoullERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoull(std::string const&,ulong *,int)
mov [rsp+488h+var_478], rax
jmp short loc_13D9F
loc_13D78:
mov rdi, r14
lea rsi, aFjquvyz+0Ah; "yz"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_13D9F
lea rdi, [rsp+488h+var_460]
xor esi, esi
push 0Ah
pop rdx
call _ZNSt7__cxx116stoullERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stoull(std::string const&,ulong *,int)
mov [rsp+488h+var_480], rax
loc_13D9F:
lea rdi, [rsp+488h+var_460]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_13CA8
loc_13DB6:
mov rax, [rsp+488h+var_468]
mov r14, [rax]
movsx edx, [rsp+488h+var_482]; char
mov rdi, r13; this
mov rsi, qword ptr [rsp+488h+var_470]; int
mov rcx, [rsp+488h+var_478]; unsigned __int64
mov r8, [rsp+488h+var_480]; unsigned __int64
call _ZN4ShipC2Eicmm; Ship::Ship(int,char,ulong,ulong)
mov rdi, r14; this
mov rsi, r13; Ship *
call _ZN8Settings13addMasterShipERK4Ship; Settings::addMasterShip(Ship const&)
lea r14, [rsp+488h+var_420]
lea rdi, [rsp+488h+var_3E8]
call _ZNSt13_Bvector_baseISaIbEED2Ev; std::_Bvector_base<std::allocator<bool>>::~_Bvector_base()
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
jmp loc_13C43
loc_13E0C:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aSlaveUnableToO; "Slave: Unable to open "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, rbx
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rsi, aForReading; " for reading."
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
jmp short loc_13E5A
loc_13E43:
lea rdi, [rsp+488h+var_3C0]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEE5closeEv; std::ifstream::close(void)
lea rdi, [rsp+488h+var_420]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_13E5A:
lea rdi, [rsp+488h+var_3C0]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov al, [rsp+488h+var_481]
add rsp, 458h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_13EBD
mov rbx, rax
jmp short loc_13EE6
mov rbx, rax
lea rdi, [rsp+arg_20]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13E96
mov rbx, rax
loc_13E96:
lea rdi, [rsp+arg_80]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13EC5
jmp short loc_13EC2
mov rbx, rax
lea rdi, [rsp+arg_98]
call _ZNSt13_Bvector_baseISaIbEED2Ev; std::_Bvector_base<std::allocator<bool>>::~_Bvector_base()
jmp short loc_13EC5
jmp short loc_13EC2
jmp short $+2
loc_13EBD:
mov rbx, rax
jmp short loc_13EDC
loc_13EC2:
mov rbx, rax
loc_13EC5:
lea rdi, [rsp+arg_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_2C8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
loc_13EDC:
lea rdi, [rsp+arg_60]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_13EE6:
lea rdi, [rsp+arg_C0]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov rdi, rbx
call __Unwind_Resume
|
char Slave::loadMasterShips(Settings **a1, long long a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rax
long long v4; // rax
long long v5; // r14
Settings *v6; // r14
long long v7; // rax
long long v8; // rax
long long v9; // rax
char v11; // [rsp+6h] [rbp-482h]
char is_open; // [rsp+7h] [rbp-481h]
unsigned long long v13; // [rsp+8h] [rbp-480h]
unsigned long long v14; // [rsp+10h] [rbp-478h]
int v15; // [rsp+18h] [rbp-470h]
_QWORD v16[4]; // [rsp+28h] [rbp-460h] BYREF
_QWORD v17[2]; // [rsp+48h] [rbp-440h] BYREF
char v18; // [rsp+58h] [rbp-430h] BYREF
_QWORD v19[2]; // [rsp+68h] [rbp-420h] BYREF
char v20; // [rsp+78h] [rbp-410h] BYREF
_BYTE v21[24]; // [rsp+88h] [rbp-400h] BYREF
_BYTE v22[120]; // [rsp+C8h] [rbp-3C0h] BYREF
_BYTE v23[400]; // [rsp+140h] [rbp-348h] BYREF
_BYTE v24[440]; // [rsp+2D0h] [rbp-1B8h] BYREF
std::ifstream::basic_ifstream(v22, a2, 8LL);
is_open = std::__basic_file<char>::is_open(v23);
if ( is_open )
{
Settings::clearMasterShips(*a1);
v19[0] = &v20;
v19[1] = 0LL;
v20 = 0;
while ( 1 )
{
v2 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v22, v19);
if ( (*((_BYTE *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) & 5) != 0 )
break;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v24, v19, 24LL);
v17[0] = &v18;
v17[1] = 0LL;
v18 = 0;
v11 = 104;
v15 = 0;
v14 = 0LL;
v13 = 0LL;
while ( 1 )
{
v3 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v24, v17, 44LL);
if ( (*((_BYTE *)v3 + *(_QWORD *)(*v3 - 24LL) + 32) & 5) != 0 )
break;
v4 = std::string::find(v17, 61LL, 0LL);
if ( v4 != -1 )
{
v5 = v4;
std::string::substr(v21, v17, 0LL, v4);
std::string::substr(v16, v17, v5 + 1, -1LL);
if ( std::operator==<char>((long long)v21) )
{
v15 = std::stoi(v16, 0LL, 10LL);
}
else if ( std::operator==<char>((long long)v21) )
{
v11 = *(_BYTE *)v16[0];
}
else if ( std::operator==<char>((long long)v21) )
{
v14 = std::stoull(v16, 0LL, 0xAu);
}
else if ( std::operator==<char>((long long)v21) )
{
v13 = std::stoull(v16, 0LL, 0xAu);
}
std::string::~string();
std::string::~string();
}
}
v6 = *a1;
Ship::Ship((Ship *)v21, v15, v11, v14, v13);
Settings::addMasterShip(v6, (const Ship *)v21);
std::_Bvector_base<std::allocator<bool>>::~_Bvector_base();
std::string::~string();
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v24);
}
std::ifstream::close(v22);
std::string::~string();
}
else
{
v7 = std::operator<<<std::char_traits<char>>(&std::cerr, "Slave: Unable to open ");
v8 = std::operator<<<char>(v7, a2);
v9 = std::operator<<<std::char_traits<char>>(v8, " for reading.");
std::endl<char,std::char_traits<char>>(v9);
}
std::ifstream::~ifstream(v22);
return is_open;
}
|
loadMasterShips:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x458
MOV RBX,RSI
MOV R14,RDI
LEA RDI,[RSP + 0xc8]
PUSH 0x8
POP RDX
CALL 0x00105500
LEA RDI,[RSP + 0x140]
CALL 0x00105080
MOV byte ptr [RSP + 0x7],AL
TEST AL,AL
JZ 0x00113e0c
MOV qword ptr [RSP + 0x20],R14
MOV RDI,qword ptr [R14]
LAB_00113c0c:
CALL 0x00106928
LEA RAX,[RSP + 0x78]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA R14,[RSP + 0x68]
LEA RBP,[RSP + 0x2d0]
LEA R15,[RSP + 0x48]
PUSH 0x2c
POP RBX
PUSH 0x3d
POP R12
LEA R13,[RSP + 0x88]
LAB_00113c43:
LEA RDI,[RSP + 0xc8]
MOV RSI,R14
CALL 0x00105060
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00113e43
LAB_00113c65:
MOV RDI,RBP
MOV RSI,R14
PUSH 0x18
POP RDX
CALL 0x001054f0
LEA RAX,[RSP + 0x58]
MOV qword ptr [RSP + 0x48],RAX
AND qword ptr [RSP + 0x50],0x0
MOV byte ptr [RSP + 0x58],0x0
MOV byte ptr [RSP + 0x6],0x68
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
LAB_00113ca8:
MOV RDI,RBP
MOV RSI,R15
MOV EDX,EBX
CALL 0x001055c0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00113db6
MOV RDI,R15
MOV ESI,R12D
XOR EDX,EDX
CALL 0x00113f04
CMP RAX,-0x1
JZ 0x00113ca8
LAB_00113cda:
MOV R14,RAX
MOV RDI,R13
MOV RSI,R15
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00113f56
INC R14
LAB_00113cf0:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV RDX,R14
PUSH -0x1
POP RCX
CALL 0x00113f56
MOV R14,R13
MOV RDI,R13
LEA RSI,[0x118517]
CALL 0x00106b65
TEST AL,AL
JZ 0x00113d2f
LAB_00113d19:
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
PUSH 0xa
POP RDX
CALL 0x00113f93
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00113d9f
LAB_00113d2f:
MOV RDI,R14
LEA RSI,[0x118521]
CALL 0x00106b65
TEST AL,AL
JZ 0x00113d4f
MOV RAX,qword ptr [RSP + 0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x6],AL
JMP 0x00113d9f
LAB_00113d4f:
MOV RDI,R14
LEA RSI,[0x117c40]
CALL 0x00106b65
TEST AL,AL
JZ 0x00113d78
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
PUSH 0xa
POP RDX
CALL 0x00106c09
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00113d9f
LAB_00113d78:
MOV RDI,R14
LEA RSI,[0x117c66]
CALL 0x00106b65
TEST AL,AL
JZ 0x00113d9f
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
PUSH 0xa
POP RDX
CALL 0x00106c09
MOV qword ptr [RSP + 0x8],RAX
LAB_00113d9f:
LEA RDI,[RSP + 0x28]
CALL 0x00105bc0
MOV RDI,R13
CALL 0x00105bc0
JMP 0x00113ca8
LAB_00113db6:
MOV RAX,qword ptr [RSP + 0x20]
MOV R14,qword ptr [RAX]
LAB_00113dbe:
MOVSX EDX,byte ptr [RSP + 0x6]
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x8]
CALL 0x001135c0
LAB_00113dda:
MOV RDI,R14
MOV RSI,R13
CALL 0x00106838
LEA R14,[RSP + 0x68]
LEA RDI,[RSP + 0xa0]
CALL 0x00105c8e
MOV RDI,R15
CALL 0x00105bc0
MOV RDI,RBP
CALL 0x001052b0
JMP 0x00113c43
LAB_00113e0c:
MOV RDI,qword ptr [0x00124fe8]
LEA RSI,[0x118500]
CALL 0x00105340
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00105310
LEA RSI,[0x118329]
MOV RDI,RAX
CALL 0x00105340
MOV RDI,RAX
CALL 0x00105190
JMP 0x00113e5a
LAB_00113e43:
LEA RDI,[RSP + 0xc8]
CALL 0x00105070
LAB_00113e50:
LEA RDI,[RSP + 0x68]
CALL 0x00105bc0
LAB_00113e5a:
LEA RDI,[RSP + 0xc8]
CALL 0x00105090
MOV AL,byte ptr [RSP + 0x7]
ADD RSP,0x458
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Slave::loadMasterShips(std::__cxx11::string const&) */
char __thiscall Slave::loadMasterShips(Slave *this,string *param_1)
{
Settings *this_00;
char cVar1;
bool bVar2;
int iVar3;
istream *piVar4;
long lVar5;
ostream *poVar6;
char local_482;
ulong local_480;
ulong local_478;
char *local_460 [4];
int1 *local_440;
int8 local_438;
int1 local_430 [16];
int1 *local_420;
int8 local_418;
int1 local_410 [16];
string local_400 [24];
_Bvector_base<std::allocator<bool>> local_3e8 [40];
ifstream local_3c0 [520];
istream local_1b8 [392];
std::ifstream::ifstream(local_3c0,param_1,8);
cVar1 = std::__basic_file<char>::is_open();
if (cVar1 == '\0') {
/* try { // try from 00113e0c to 00113e40 has its CatchHandler @ 00113e7f */
poVar6 = std::operator<<((ostream *)PTR_cerr_00124fe8,"Slave: Unable to open ");
poVar6 = std::operator<<(poVar6,param_1);
poVar6 = std::operator<<(poVar6," for reading.");
std::endl<char,std::char_traits<char>>(poVar6);
}
else {
/* try { // try from 00113c0c to 00113c10 has its CatchHandler @ 00113e7f */
Settings::clearMasterShips(*(Settings **)this);
local_420 = local_410;
local_418 = 0;
local_410[0] = 0;
while( true ) {
/* try { // try from 00113c43 to 00113c52 has its CatchHandler @ 00113ebd */
piVar4 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_3c0,(string *)&local_420);
if (((byte)piVar4[*(long *)(*(long *)piVar4 + -0x18) + 0x20] & 5) != 0) break;
/* try { // try from 00113c65 to 00113c72 has its CatchHandler @ 00113ebb */
std::__cxx11::stringstream::stringstream((stringstream *)local_1b8,(string *)&local_420,0x18);
local_440 = local_430;
local_438 = 0;
local_430[0] = 0;
local_482 = 'h';
iVar3 = 0;
local_478 = 0;
local_480 = 0;
while( true ) {
/* try { // try from 00113ca8 to 00113cb4 has its CatchHandler @ 00113ec2 */
piVar4 = std::getline<char,std::char_traits<char>,std::allocator<char>>
(local_1b8,(string *)&local_440,',');
if (((byte)piVar4[*(long *)(*(long *)piVar4 + -0x18) + 0x20] & 5) != 0) break;
lVar5 = std::__cxx11::string::find((string *)&local_440,'=',0);
if (lVar5 != -1) {
/* try { // try from 00113cda to 00113cec has its CatchHandler @ 00113ea5 */
std::__cxx11::string::substr((ulong)local_400,(ulong)&local_440);
/* try { // try from 00113cf0 to 00113d02 has its CatchHandler @ 00113e93 */
std::__cxx11::string::substr((ulong)local_460,(ulong)&local_440);
bVar2 = std::operator==(local_400,"ship_type");
if (bVar2) {
/* try { // try from 00113d19 to 00113d9e has its CatchHandler @ 00113e84 */
iVar3 = std::__cxx11::stoi((string *)local_460,(ulong *)0x0,10);
}
else {
bVar2 = std::operator==(local_400,"orientation");
if (bVar2) {
local_482 = *local_460[0];
}
else {
bVar2 = std::operator==(local_400,"x");
if (bVar2) {
local_478 = std::__cxx11::stoull((string *)local_460,(ulong *)0x0,10);
}
else {
bVar2 = std::operator==(local_400,"y");
if (bVar2) {
local_480 = std::__cxx11::stoull((string *)local_460,(ulong *)0x0,10);
}
}
}
}
std::__cxx11::string::~string((string *)local_460);
std::__cxx11::string::~string(local_400);
}
}
this_00 = *(Settings **)this;
/* try { // try from 00113dbe to 00113dd9 has its CatchHandler @ 00113eb9 */
Ship::Ship((Ship *)local_400,iVar3,local_482,local_478,local_480);
/* try { // try from 00113dda to 00113de4 has its CatchHandler @ 00113ea7 */
Settings::addMasterShip(this_00,(Ship *)local_400);
std::_Bvector_base<std::allocator<bool>>::~_Bvector_base(local_3e8);
std::__cxx11::string::~string((string *)&local_440);
std::__cxx11::stringstream::~stringstream((stringstream *)local_1b8);
}
/* try { // try from 00113e43 to 00113e4f has its CatchHandler @ 00113e7d */
std::ifstream::close();
std::__cxx11::string::~string((string *)&local_420);
}
std::ifstream::~ifstream(local_3c0);
return cVar1;
}
|
|
9,582 |
my_interval_timer
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
}
|
O3
|
c
|
my_interval_timer:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x242a0
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
addq 0x8(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
|
my_interval_timer:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
lea rbx, [rbp+var_18]
mov edi, 1
mov rsi, rbx
call _clock_gettime
imul rax, [rbx], 3B9ACA00h
add rax, [rbx+8]
add rsp, 18h
pop rbx
pop rbp
retn
|
long long my_interval_timer()
{
_QWORD v1[3]; // [rsp+8h] [rbp-18h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
|
my_interval_timer:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
LEA RBX,[RBP + -0x18]
MOV EDI,0x1
MOV RSI,RBX
CALL 0x001242a0
IMUL RAX,qword ptr [RBX],0x3b9aca00
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_20;
clock_gettime(1,&local_20);
return local_20.tv_sec * 1000000000 + local_20.tv_nsec;
}
|
|
9,583 |
string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&)
|
monkey531[P]llama/common/common.cpp
|
std::string string_from(const struct llama_context * ctx, const std::vector<llama_token> & tokens) {
std::stringstream buf;
buf << "[ ";
bool first = true;
for (const auto & token : tokens) {
if (!first) {
buf << ", ";
} else {
first = false;
}
auto detokenized = common_token_to_piece(ctx, token);
detokenized.erase(
std::remove_if(
detokenized.begin(),
detokenized.end(),
[](const unsigned char c) { return !std::isprint(c); }),
detokenized.end());
buf << "'" << detokenized << "'"
<< ":" << std::to_string(token);
}
buf << " ]";
return buf.str();
}
|
O0
|
cpp
|
string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&):
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x59530
leaq 0x118(%rsp), %rdi
leaq 0x122bcb(%rip), %rsi # 0x20d4a3
callq 0x599f0
jmp 0xea8df
movb $0x1, 0xfb(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x8f0c0
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x8f0f0
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf5230
testb $0x1, %al
jne 0xea93f
jmp 0xeab78
leaq 0xe8(%rsp), %rdi
callq 0xf5270
movq %rax, 0xd8(%rsp)
testb $0x1, 0xfb(%rsp)
jne 0xea98f
leaq 0x118(%rsp), %rdi
leaq 0x1234ed(%rip), %rsi # 0x20de5a
callq 0x599f0
jmp 0xea974
jmp 0xea997
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0xeabbc
movb $0x0, 0xfb(%rsp)
movq 0x298(%rsp), %rsi
movq 0xd8(%rsp), %rax
movl (%rax), %edx
leaq 0xb8(%rsp), %rdi
movl $0x1, %ecx
callq 0xeabe0
jmp 0xea9bd
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x59830
movq 0x38(%rsp), %rdi
movq %rax, 0xa0(%rsp)
callq 0x59930
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xeac50
movq %rax, 0x40(%rsp)
jmp 0xeaa05
movq 0x40(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xbb8f0
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x59930
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xbb8f0
movq 0x28(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x59770
movq %rax, 0x30(%rsp)
jmp 0xeaa77
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x118(%rsp), %rdi
leaq 0x121684(%rip), %rsi # 0x20c114
callq 0x599f0
movq %rax, 0x20(%rsp)
jmp 0xeaa9c
movq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x59520
movq %rax, 0x18(%rsp)
jmp 0xeaab5
movq 0x18(%rsp), %rdi
leaq 0x121653(%rip), %rsi # 0x20c114
callq 0x599f0
movq %rax, 0x10(%rsp)
jmp 0xeaacd
movq 0x10(%rsp), %rdi
leaq 0x1234cc(%rip), %rsi # 0x20dfa5
callq 0x599f0
movq %rax, 0x8(%rsp)
jmp 0xeaae5
movq 0xd8(%rsp), %rax
movl (%rax), %esi
leaq 0x58(%rsp), %rdi
callq 0x9fb90
jmp 0xeaafb
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x59520
jmp 0xeab0c
leaq 0x58(%rsp), %rdi
callq 0x5a4d8
leaq 0xb8(%rsp), %rdi
callq 0x5a4d8
leaq 0xe8(%rsp), %rdi
callq 0xf5280
jmp 0xea921
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0xeab69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5a4d8
leaq 0xb8(%rsp), %rdi
callq 0x5a4d8
jmp 0xeabbc
leaq 0x118(%rsp), %rdi
leaq 0x12291f(%rip), %rsi # 0x20d4a6
callq 0x599f0
jmp 0xeab8e
movq 0x48(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x59c50
jmp 0xeaba2
leaq 0x108(%rsp), %rdi
callq 0x59650
movq 0x50(%rsp), %rax
addq $0x2a8, %rsp # imm = 0x2A8
retq
leaq 0x108(%rsp), %rdi
callq 0x59650
movq 0x100(%rsp), %rdi
callq 0x59b80
nopw %cs:(%rax,%rax)
|
_Z11string_fromB5cxx11PK13llama_contextRKSt6vectorIiSaIiEE:
sub rsp, 2A8h
mov [rsp+2A8h+var_260], rdi
mov rax, rdi
mov [rsp+2A8h+var_258], rax
mov [rsp+2A8h+var_8], rdi
mov [rsp+2A8h+var_10], rsi
mov [rsp+2A8h+var_18], rdx
lea rdi, [rsp+2A8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_20D4A3; "[ "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_EA8DF:
mov [rsp+2A8h+var_1AD], 1
mov rax, [rsp+2A8h+var_18]
mov [rsp+2A8h+var_1B8], rax
mov rdi, [rsp+2A8h+var_1B8]
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rsp+2A8h+var_1C0], rax
mov rdi, [rsp+2A8h+var_1B8]
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rsp+2A8h+var_1C8], rax
loc_EA921:
lea rdi, [rsp+2A8h+var_1C0]
lea rsi, [rsp+2A8h+var_1C8]
call _ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&)
test al, 1
jnz short loc_EA93F
jmp loc_EAB78
loc_EA93F:
lea rdi, [rsp+2A8h+var_1C0]
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(void)
mov [rsp+2A8h+var_1D0], rax
test [rsp+2A8h+var_1AD], 1
jnz short loc_EA98F
lea rdi, [rsp+2A8h+var_190]
lea rsi, aZuD+6; ", "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_EA974:
jmp short loc_EA997
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_EABBC
loc_EA98F:
mov [rsp+2A8h+var_1AD], 0
loc_EA997:
mov rsi, [rsp+2A8h+var_10]
mov rax, [rsp+2A8h+var_1D0]
mov edx, [rax]
lea rdi, [rsp+2A8h+var_1F0]
mov ecx, 1
call _Z21common_token_to_pieceB5cxx11PK13llama_contextib; common_token_to_piece(llama_context const*,int,bool)
jmp short $+2
loc_EA9BD:
lea rdi, [rsp+2A8h+var_1F0]
mov [rsp+2A8h+var_270], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rdi, [rsp+2A8h+var_270]
mov [rsp+2A8h+var_208], rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+2A8h+var_210], rax
mov rdi, [rsp+2A8h+var_208]
mov rsi, [rsp+2A8h+var_210]
call _ZSt9remove_ifIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEZ11string_fromPK13llama_contextRKSt6vectorIiSaIiEEE3$_0ET_SJ_SJ_T0_; std::remove_if<__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0)
mov [rsp+2A8h+var_268], rax
jmp short $+2
loc_EAA05:
mov rax, [rsp+2A8h+var_268]
mov [rsp+2A8h+var_200], rax
lea rdi, [rsp+2A8h+var_1F8]
lea rsi, [rsp+2A8h+var_200]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
lea rdi, [rsp+2A8h+var_1F0]
mov [rsp+2A8h+var_280], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+2A8h+var_228], rax
lea rdi, [rsp+2A8h+var_220]
lea rsi, [rsp+2A8h+var_228]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rdi, [rsp+2A8h+var_280]
mov rsi, [rsp+2A8h+var_1F8]
mov rdx, [rsp+2A8h+var_220]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEN9__gnu_cxx17__normal_iteratorIPKcS4_EES9_; std::string::erase(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
mov [rsp+2A8h+var_278], rax
jmp short $+2
loc_EAA77:
mov rax, [rsp+2A8h+var_278]
mov [rsp+2A8h+var_230], rax
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_20C112+2; "'"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_288], rax
jmp short $+2
loc_EAA9C:
mov rdi, [rsp+2A8h+var_288]
lea rsi, [rsp+2A8h+var_1F0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+2A8h+var_290], rax
jmp short $+2
loc_EAAB5:
mov rdi, [rsp+2A8h+var_290]
lea rsi, asc_20C112+2; "'"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_298], rax
jmp short $+2
loc_EAACD:
mov rdi, [rsp+2A8h+var_298]
lea rsi, aArgumentNeedle_0+11h; ":"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_2A0], rax
jmp short $+2
loc_EAAE5:
mov rax, [rsp+2A8h+var_1D0]
mov esi, [rax]; int
lea rdi, [rsp+2A8h+var_250]; this
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
jmp short $+2
loc_EAAFB:
mov rdi, [rsp+2A8h+var_2A0]
lea rsi, [rsp+2A8h+var_250]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_EAB0C:
lea rdi, [rsp+2A8h+var_250]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+2A8h+var_1F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+2A8h+var_1C0]
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(void)
jmp loc_EA921
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_EAB69
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EAB69:
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_EABBC
loc_EAB78:
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_20D4A6; " ]"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_EAB8E:
mov rdi, [rsp+2A8h+var_260]
lea rsi, [rsp+2A8h+var_1A0]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_EABA2:
lea rdi, [rsp+2A8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rsp+2A8h+var_258]
add rsp, 2A8h
retn
loc_EABBC:
lea rdi, [rsp+arg_100]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, [rsp+arg_F8]
call __Unwind_Resume
|
long long string_from[abi:cxx11](long long a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-2A0h]
long long v5; // [rsp+10h] [rbp-298h]
long long v6; // [rsp+18h] [rbp-290h]
long long v7; // [rsp+20h] [rbp-288h]
_BYTE v8[32]; // [rsp+58h] [rbp-250h] BYREF
long long v9; // [rsp+78h] [rbp-230h]
long long v10; // [rsp+80h] [rbp-228h] BYREF
long long v11; // [rsp+88h] [rbp-220h] BYREF
long long v12; // [rsp+98h] [rbp-210h]
long long v13; // [rsp+A0h] [rbp-208h]
long long v14; // [rsp+A8h] [rbp-200h] BYREF
long long v15; // [rsp+B0h] [rbp-1F8h] BYREF
_BYTE v16[32]; // [rsp+B8h] [rbp-1F0h] BYREF
int *v17; // [rsp+D8h] [rbp-1D0h]
long long v18; // [rsp+E0h] [rbp-1C8h] BYREF
long long v19; // [rsp+E8h] [rbp-1C0h] BYREF
long long v20; // [rsp+F0h] [rbp-1B8h]
char v21; // [rsp+FBh] [rbp-1ADh]
_BYTE v22[16]; // [rsp+108h] [rbp-1A0h] BYREF
_BYTE v23[376]; // [rsp+118h] [rbp-190h] BYREF
long long v24; // [rsp+290h] [rbp-18h]
long long v25; // [rsp+298h] [rbp-10h]
long long v26; // [rsp+2A0h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v22);
std::operator<<<std::char_traits<char>>(v23, "[ ");
v21 = 1;
v20 = v24;
v19 = std::vector<int>::begin(v24);
v18 = std::vector<int>::end(v20);
while ( (__gnu_cxx::operator!=<int const*,std::vector<int>>(&v19, &v18) & 1) != 0 )
{
v17 = (int *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(&v19);
if ( (v21 & 1) != 0 )
v21 = 0;
else
std::operator<<<std::char_traits<char>>(v23, ", ");
common_token_to_piece[abi:cxx11](v16, v25, (unsigned int)*v17, 1LL);
v13 = std::string::begin(v16);
v12 = std::string::end(v16);
v14 = std::remove_if<__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0>(
v13,
v12);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v15, (long long)&v14);
v10 = std::string::end(v16);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v11, (long long)&v10);
v9 = std::string::erase(v16, v15, v11);
v7 = std::operator<<<std::char_traits<char>>(v23, "'");
v6 = std::operator<<<char>(v7, v16);
v5 = std::operator<<<std::char_traits<char>>(v6, "'");
v4 = std::operator<<<std::char_traits<char>>(v5, ":");
std::to_string((std::__cxx11 *)v8, *v17);
std::operator<<<char>(v4, v8);
std::string::~string(v8);
std::string::~string(v16);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(&v19);
}
std::operator<<<std::char_traits<char>>(v23, " ]");
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v22);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v22);
return a1;
}
|
string_from[abi:cxx11]:
SUB RSP,0x2a8
MOV qword ptr [RSP + 0x48],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x2a0],RDI
MOV qword ptr [RSP + 0x298],RSI
MOV qword ptr [RSP + 0x290],RDX
LEA RDI,[RSP + 0x108]
CALL 0x00159530
LEA RDI,[RSP + 0x118]
LAB_001ea8d1:
LEA RSI,[0x30d4a3]
CALL 0x001599f0
JMP 0x001ea8df
LAB_001ea8df:
MOV byte ptr [RSP + 0xfb],0x1
MOV RAX,qword ptr [RSP + 0x290]
MOV qword ptr [RSP + 0xf0],RAX
MOV RDI,qword ptr [RSP + 0xf0]
CALL 0x0018f0c0
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xf0]
CALL 0x0018f0f0
MOV qword ptr [RSP + 0xe0],RAX
LAB_001ea921:
LEA RDI,[RSP + 0xe8]
LEA RSI,[RSP + 0xe0]
CALL 0x001f5230
TEST AL,0x1
JNZ 0x001ea93f
JMP 0x001eab78
LAB_001ea93f:
LEA RDI,[RSP + 0xe8]
CALL 0x001f5270
MOV qword ptr [RSP + 0xd8],RAX
TEST byte ptr [RSP + 0xfb],0x1
JNZ 0x001ea98f
LEA RDI,[RSP + 0x118]
LEA RSI,[0x30de5a]
CALL 0x001599f0
JMP 0x001ea974
LAB_001ea974:
JMP 0x001ea997
LAB_001ea98f:
MOV byte ptr [RSP + 0xfb],0x0
LAB_001ea997:
MOV RSI,qword ptr [RSP + 0x298]
MOV RAX,qword ptr [RSP + 0xd8]
MOV EDX,dword ptr [RAX]
LEA RDI,[RSP + 0xb8]
MOV ECX,0x1
CALL 0x001eabe0
JMP 0x001ea9bd
LAB_001ea9bd:
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x00159830
MOV RDI,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa0],RAX
CALL 0x00159930
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
LAB_001ea9f9:
CALL 0x001eac50
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001eaa05
LAB_001eaa05:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0xa8]
CALL 0x001bb8f0
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x00159930
MOV qword ptr [RSP + 0x80],RAX
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x80]
CALL 0x001bb8f0
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00159770
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001eaa77
LAB_001eaa77:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x118]
LEA RSI,[0x30c114]
CALL 0x001599f0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001eaa9c
LAB_001eaa9c:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xb8]
CALL 0x00159520
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001eaab5
LAB_001eaab5:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x30c114]
CALL 0x001599f0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001eaacd
LAB_001eaacd:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x30dfa5]
CALL 0x001599f0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001eaae5
LAB_001eaae5:
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
LEA RDI,[RSP + 0x58]
CALL 0x0019fb90
JMP 0x001eaafb
LAB_001eaafb:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x58]
CALL 0x00159520
JMP 0x001eab0c
LAB_001eab0c:
LEA RDI,[RSP + 0x58]
CALL 0x0015a4d8
LEA RDI,[RSP + 0xb8]
CALL 0x0015a4d8
LEA RDI,[RSP + 0xe8]
CALL 0x001f5280
JMP 0x001ea921
LAB_001eab78:
LEA RDI,[RSP + 0x118]
LAB_001eab80:
LEA RSI,[0x30d4a6]
CALL 0x001599f0
JMP 0x001eab8e
LAB_001eab8e:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x108]
CALL 0x00159c50
LAB_001eaba0:
JMP 0x001eaba2
LAB_001eaba2:
LEA RDI,[RSP + 0x108]
CALL 0x00159650
MOV RAX,qword ptr [RSP + 0x50]
ADD RSP,0x2a8
RET
|
/* string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int> > const&) */
llama_context * string_from_abi_cxx11_(llama_context *param_1,vector *param_2)
{
bool bVar1;
ostream *poVar2;
vector<int,std::allocator<int>> *in_RDX;
__cxx11 local_250 [32];
int8 local_230;
int8 local_228;
int8 local_220 [2];
int8 local_210;
int8 local_208;
int8 local_200;
int8 local_1f8;
llama_context local_1f0 [32];
int *local_1d0;
int8 local_1c8;
int8 local_1c0;
vector<int,std::allocator<int>> *local_1b8;
byte local_1ad;
stringstream local_1a0 [16];
ostream local_190 [376];
vector<int,std::allocator<int>> *local_18;
vector *local_10;
llama_context *local_8;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
std::__cxx11::stringstream::stringstream(local_1a0);
/* try { // try from 001ea8d1 to 001ea9ba has its CatchHandler @ 001ea976 */
std::operator<<(local_190,"[ ");
local_1ad = 1;
local_1b8 = local_18;
local_1c0 = std::vector<int,std::allocator<int>>::begin(local_18);
local_1c8 = std::vector<int,std::allocator<int>>::end(local_1b8);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_1c0,(__normal_iterator *)&local_1c8);
if (!bVar1) break;
local_1d0 = (int *)__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>
::operator*((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>
*)&local_1c0);
if ((local_1ad & 1) == 0) {
std::operator<<(local_190,", ");
}
else {
local_1ad = 0;
}
common_token_to_piece_abi_cxx11_(local_1f0,(int)local_10,SUB41(*local_1d0,0));
local_208 = std::__cxx11::string::begin();
local_210 = std::__cxx11::string::end();
/* try { // try from 001ea9f9 to 001eaaf8 has its CatchHandler @ 001eab35 */
local_200 = std::
remove_if<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>,string_from(llama_context_const*,std::vector<int,std::allocator<int>>const&)::__0>
(local_208,local_210);
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_1f8,
(__normal_iterator *)&local_200);
local_228 = std::__cxx11::string::end();
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)local_220,
(__normal_iterator *)&local_228);
local_230 = std::__cxx11::string::erase(local_1f0,local_1f8,local_220[0]);
poVar2 = std::operator<<(local_190,"\'");
poVar2 = std::operator<<(poVar2,(string *)local_1f0);
poVar2 = std::operator<<(poVar2,"\'");
poVar2 = std::operator<<(poVar2,":");
std::__cxx11::to_string(local_250,*local_1d0);
/* try { // try from 001eaafb to 001eab09 has its CatchHandler @ 001eab4b */
std::operator<<(poVar2,(string *)local_250);
std::__cxx11::string::~string((string *)local_250);
std::__cxx11::string::~string((string *)local_1f0);
__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_1c0);
}
/* try { // try from 001eab80 to 001eab9f has its CatchHandler @ 001ea976 */
std::operator<<(local_190," ]");
std::__cxx11::stringstream::str();
std::__cxx11::stringstream::~stringstream(local_1a0);
return param_1;
}
|
|
9,584 |
string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&)
|
monkey531[P]llama/common/common.cpp
|
std::string string_from(const struct llama_context * ctx, const std::vector<llama_token> & tokens) {
std::stringstream buf;
buf << "[ ";
bool first = true;
for (const auto & token : tokens) {
if (!first) {
buf << ", ";
} else {
first = false;
}
auto detokenized = common_token_to_piece(ctx, token);
detokenized.erase(
std::remove_if(
detokenized.begin(),
detokenized.end(),
[](const unsigned char c) { return !std::isprint(c); }),
detokenized.end());
buf << "'" << detokenized << "'"
<< ":" << std::to_string(token);
}
buf << " ]";
return buf.str();
}
|
O3
|
cpp
|
string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %rbx
movq %rsi, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1a610
leaq 0x70(%rsp), %r14
leaq 0x7c0d8(%rip), %rsi # 0xedadf
movl $0x2, %edx
movq %r14, %rdi
callq 0x1a9a0
movq (%rbx), %r13
movq 0x8(%rbx), %rax
movq %rax, 0x50(%rsp)
cmpq %rax, %r13
je 0x71ce1
movb $0x1, %al
testb $0x1, %al
jne 0x71a43
movl $0x2, %edx
movq %r14, %rdi
leaq 0x7ca45(%rip), %rsi # 0xee483
callq 0x1a9a0
movl (%r13), %ebx
movq 0x58(%rsp), %rdi
callq 0x1a760
movq %rax, %rdi
callq 0x1b0e0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x74b7d
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %rax
leaq (%r15,%rax), %rbx
movq %rax, %r14
sarq $0x2, %r14
movq %r15, %rbp
testq %r14, %r14
jle 0x71aeb
andq $-0x4, %rax
movq %rax, %rbp
addq %r15, %rbp
incq %r14
leaq 0x3(%r15), %r12
movzbl -0x3(%r12), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b40
movzbl -0x2(%r12), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b46
movzbl -0x1(%r12), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b4c
movzbl (%r12), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b4f
decq %r14
addq $0x4, %r12
cmpq $0x1, %r14
jg 0x71a9b
movq %rbx, %rax
subq %rbp, %rax
cmpq $0x1, %rax
je 0x71b2c
cmpq $0x2, %rax
leaq 0x70(%rsp), %r14
je 0x71b1c
cmpq $0x3, %rax
jne 0x71cd9
movzbl (%rbp), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b3b
incq %rbp
movzbl (%rbp), %edi
callq 0x1af30
testl %eax, %eax
je 0x71b3b
incq %rbp
movzbl (%rbp), %edi
callq 0x1af30
testl %eax, %eax
cmovneq %rbx, %rbp
movq %rbp, %r12
jmp 0x71b4f
addq $-0x3, %r12
jmp 0x71b4f
addq $-0x2, %r12
jmp 0x71b4f
decq %r12
cmpq %rbx, %r12
sete %al
leaq 0x1(%r12), %r14
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0x71b88
movb (%r14), %bpl
movzbl %bpl, %edi
callq 0x1af30
testl %eax, %eax
je 0x71b7b
movb %bpl, (%r12)
incq %r12
incq %r14
cmpq %rbx, %r14
jne 0x71b64
movq 0x8(%rsp), %r15
leaq 0x70(%rsp), %r14
movq %r12, %rax
subq %r15, %rax
movq %rax, 0x10(%rsp)
movb $0x0, (%r12)
movl $0x1, %edx
movq %r14, %rdi
leaq 0x7afc5(%rip), %rsi # 0xecb71
callq 0x1a9a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x1a9a0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7af9c(%rip), %rsi # 0xecb71
callq 0x1a9a0
movl $0x1, %edx
movq %r12, %rdi
leaq 0x7c9e5(%rip), %rsi # 0xee5ce
callq 0x1a9a0
movl (%r13), %ebp
movl %ebp, %ebx
negl %ebx
cmovsl %ebp, %ebx
movl $0x1, %r15d
cmpl $0xa, %ebx
jb 0x71c4a
movl $0x4, %r15d
movl %ebx, %eax
cmpl $0x63, %eax
jbe 0x71c41
cmpl $0x3e7, %eax # imm = 0x3E7
jbe 0x71c47
cmpl $0x2710, %eax # imm = 0x2710
jb 0x71c4a
movl %eax, %ecx
movl $0xd1b71759, %edx # imm = 0xD1B71759
imulq %rdx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r15d
cmpl $0x1869f, %eax # imm = 0x1869F
movl %ecx, %eax
ja 0x71c0c
addl $-0x3, %r15d
jmp 0x71c4a
addl $-0x2, %r15d
jmp 0x71c4a
decl %r15d
shrl $0x1f, %ebp
leal (%r15,%rbp), %esi
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x2d, %edx
callq 0x1a9d0
addq 0x28(%rsp), %rbp
movq %rbp, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x57d3d
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x1a9a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x71caa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a890
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x71cc6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
addq $0x4, %r13
xorl %eax, %eax
cmpq 0x50(%rsp), %r13
jne 0x71a2b
jmp 0x71ce1
movq %rbx, %r12
jmp 0x71b8d
leaq 0x7bdfa(%rip), %rsi # 0xedae2
movl $0x2, %edx
movq %r14, %rdi
callq 0x1a9a0
movq 0x48(%rsp), %rbx
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ad50
movq 0xb820a(%rip), %rsi # 0x129f18
leaq 0x60(%rsp), %rdi
callq 0x1a650
leaq 0xe0(%rsp), %rdi
callq 0x1a2a0
movq %rbx, %rax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x71d63
jmp 0x71d63
jmp 0x71d63
jmp 0x71d68
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x71d6b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0x71d6b
movq %rax, %rbx
jmp 0x71d87
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x71d87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
movq 0xb818a(%rip), %rsi # 0x129f18
leaq 0x60(%rsp), %rdi
callq 0x1a650
leaq 0xe0(%rsp), %rdi
callq 0x1a2a0
movq %rbx, %rdi
callq 0x1af20
|
_Z11string_fromB5cxx11PK13llama_contextRKSt6vectorIiSaIiEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1E8h
mov rbx, rdx
mov [rsp+218h+var_1C0], rsi
mov [rsp+218h+var_1D0], rdi
lea rdi, [rsp+218h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea r14, [rsp+218h+var_1A8]
lea rsi, asc_EDADF; "[ "
mov edx, 2
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r13, [rbx]
mov rax, [rbx+8]
mov [rsp+218h+var_1C8], rax
cmp r13, rax
jz loc_71CE1
mov al, 1
loc_71A2B:
test al, 1
jnz short loc_71A43
mov edx, 2
mov rdi, r14
lea rsi, aZuD+6; ", "
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_71A43:
mov ebx, [r13+0]
mov rdi, [rsp+218h+var_1C0]
call _llama_get_model
mov rdi, rax
call _llama_model_get_vocab
lea rdi, [rsp+218h+var_210]
mov rsi, rax
mov edx, ebx
mov ecx, 1
call _Z21common_token_to_pieceB5cxx11PK11llama_vocabib; common_token_to_piece(llama_vocab const*,int,bool)
mov r15, [rsp+218h+var_210]
mov rax, [rsp+218h+var_208]
lea rbx, [r15+rax]
mov r14, rax
sar r14, 2
mov rbp, r15
test r14, r14
jle short loc_71AEB
and rax, 0FFFFFFFFFFFFFFFCh
mov rbp, rax
add rbp, r15
inc r14
lea r12, [r15+3]
loc_71A9B:
movzx edi, byte ptr [r12-3]
call _isprint
test eax, eax
jz loc_71B40
movzx edi, byte ptr [r12-2]
call _isprint
test eax, eax
jz loc_71B46
movzx edi, byte ptr [r12-1]
call _isprint
test eax, eax
jz short loc_71B4C
movzx edi, byte ptr [r12]
call _isprint
test eax, eax
jz short loc_71B4F
dec r14
add r12, 4
cmp r14, 1
jg short loc_71A9B
loc_71AEB:
mov rax, rbx
sub rax, rbp
cmp rax, 1
jz short loc_71B2C
cmp rax, 2
lea r14, [rsp+218h+var_1A8]
jz short loc_71B1C
cmp rax, 3
jnz loc_71CD9
movzx edi, byte ptr [rbp+0]
call _isprint
test eax, eax
jz short loc_71B3B
inc rbp
loc_71B1C:
movzx edi, byte ptr [rbp+0]
call _isprint
test eax, eax
jz short loc_71B3B
inc rbp
loc_71B2C:
movzx edi, byte ptr [rbp+0]
call _isprint
test eax, eax
cmovnz rbp, rbx
loc_71B3B:
mov r12, rbp
jmp short loc_71B4F
loc_71B40:
add r12, 0FFFFFFFFFFFFFFFDh
jmp short loc_71B4F
loc_71B46:
add r12, 0FFFFFFFFFFFFFFFEh
jmp short loc_71B4F
loc_71B4C:
dec r12
loc_71B4F:
cmp r12, rbx
setz al
lea r14, [r12+1]
cmp r14, rbx
setz cl
or cl, al
jnz short loc_71B88
loc_71B64:
mov bpl, [r14]
movzx edi, bpl
call _isprint
test eax, eax
jz short loc_71B7B
mov [r12], bpl
inc r12
loc_71B7B:
inc r14
cmp r14, rbx
jnz short loc_71B64
mov r15, [rsp+218h+var_210]
loc_71B88:
lea r14, [rsp+218h+var_1A8]
loc_71B8D:
mov rax, r12
sub rax, r15
mov [rsp+218h+var_208], rax
mov byte ptr [r12], 0
mov edx, 1
mov rdi, r14
lea rsi, asc_ECB6F+2; "'"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+218h+var_210]
mov rdx, [rsp+218h+var_208]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r12, rax
mov edx, 1
mov rdi, rax
lea rsi, asc_ECB6F+2; "'"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
mov rdi, r12
lea rsi, aArgumentNeedle_0+11h; ":"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov ebp, [r13+0]
mov ebx, ebp
neg ebx
cmovs ebx, ebp
mov r15d, 1
cmp ebx, 0Ah
jb short loc_71C4A
mov r15d, 4
mov eax, ebx
loc_71C0C:
cmp eax, 63h ; 'c'
jbe short loc_71C41
cmp eax, 3E7h
jbe short loc_71C47
cmp eax, 2710h
jb short loc_71C4A
mov ecx, eax
mov edx, 0D1B71759h
imul rcx, rdx
shr rcx, 2Dh
add r15d, 4
cmp eax, 1869Fh
mov eax, ecx
ja short loc_71C0C
add r15d, 0FFFFFFFDh
jmp short loc_71C4A
loc_71C41:
add r15d, 0FFFFFFFEh
jmp short loc_71C4A
loc_71C47:
dec r15d
loc_71C4A:
shr ebp, 1Fh
lea esi, [r15+rbp]
lea rax, [rsp+218h+var_1E0]
mov [rsp+218h+var_1F0], rax
lea rdi, [rsp+218h+var_1F0]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add rbp, [rsp+218h+var_1F0]
mov rdi, rbp
mov esi, r15d
mov edx, ebx
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
mov rsi, [rsp+218h+var_1F0]
mov rdx, [rsp+218h+var_1E8]
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+218h+var_1F0]; void *
lea rax, [rsp+218h+var_1E0]
cmp rdi, rax
jz short loc_71CAA
mov rsi, [rsp+218h+var_1E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71CAA:
mov rdi, [rsp+218h+var_210]; void *
lea rax, [rsp+218h+var_200]
cmp rdi, rax
jz short loc_71CC6
mov rsi, [rsp+218h+var_200]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71CC6:
add r13, 4
xor eax, eax
cmp r13, [rsp+218h+var_1C8]
jnz loc_71A2B
jmp short loc_71CE1
loc_71CD9:
mov r12, rbx
jmp loc_71B8D
loc_71CE1:
lea rsi, asc_EDAE2; " ]"
mov edx, 2
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rsp+218h+var_1D0]
lea rsi, [rsp+218h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+218h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+218h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_71D63
jmp short loc_71D63
jmp short loc_71D63
jmp short loc_71D68
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
lea rax, [rsp+arg_30]
cmp rdi, rax
jz short loc_71D6B
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_71D6B
loc_71D63:
mov rbx, rax
jmp short loc_71D87
loc_71D68:
mov rbx, rax
loc_71D6B:
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
cmp rdi, rax
jz short loc_71D87
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71D87:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_58]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_D8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
|
long long string_from[abi:cxx11](long long a1, long long a2, unsigned int **a3)
{
unsigned int *v4; // r13
char v5; // al
unsigned int v6; // ebx
long long model; // rax
long long vocab; // rax
_BYTE *v9; // r15
char *v10; // rbx
char *v11; // rbp
long long v12; // r14
char *v13; // r12
signed long long v14; // rax
char *v15; // r14
char v16; // bp
long long v17; // r12
unsigned int v18; // ebx
int v19; // r15d
unsigned int v20; // eax
bool v21; // cc
unsigned int v22; // ebp
long long v23; // rbx
void *v25; // [rsp+8h] [rbp-210h] BYREF
long long v26; // [rsp+10h] [rbp-208h]
long long v27; // [rsp+18h] [rbp-200h] BYREF
void *v28[2]; // [rsp+28h] [rbp-1F0h] BYREF
_QWORD v29[2]; // [rsp+38h] [rbp-1E0h] BYREF
long long v30; // [rsp+48h] [rbp-1D0h]
unsigned int *v31; // [rsp+50h] [rbp-1C8h]
long long v32; // [rsp+58h] [rbp-1C0h]
_BYTE v33[16]; // [rsp+60h] [rbp-1B8h] BYREF
char v34[8]; // [rsp+70h] [rbp-1A8h] BYREF
char v35[104]; // [rsp+78h] [rbp-1A0h] BYREF
char v36[312]; // [rsp+E0h] [rbp-138h] BYREF
v32 = a2;
v30 = a1;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v33);
std::__ostream_insert<char,std::char_traits<char>>(v34, "[ ", 2LL);
v4 = *a3;
v31 = a3[1];
if ( v4 != v31 )
{
v5 = 1;
while ( 1 )
{
if ( (v5 & 1) == 0 )
std::__ostream_insert<char,std::char_traits<char>>(v34, ", ", 2LL);
v6 = *v4;
model = llama_get_model(v32);
vocab = llama_model_get_vocab(model);
common_token_to_piece[abi:cxx11](&v25, vocab, v6, 1LL);
v9 = v25;
v10 = (char *)v25 + v26;
v11 = (char *)v25;
if ( v26 >> 2 > 0 )
break;
LABEL_12:
v14 = v10 - v11;
if ( v10 - v11 == 1 )
goto LABEL_19;
if ( v14 == 2 )
goto LABEL_17;
if ( v14 == 3 )
{
if ( (unsigned int)isprint((unsigned __int8)*v11) )
{
++v11;
LABEL_17:
if ( (unsigned int)isprint((unsigned __int8)*v11) )
{
++v11;
LABEL_19:
if ( (unsigned int)isprint((unsigned __int8)*v11) )
v11 = v10;
}
}
v13 = v11;
LABEL_25:
v15 = v13 + 1;
if ( v13 != v10 && v13 + 1 != v10 )
{
do
{
v16 = *v15;
if ( (unsigned int)isprint((unsigned __int8)*v15) )
*v13++ = v16;
++v15;
}
while ( v15 != v10 );
v9 = v25;
}
goto LABEL_30;
}
v13 = v10;
LABEL_30:
v26 = v13 - v9;
*v13 = 0;
std::__ostream_insert<char,std::char_traits<char>>(v34, "'", 1LL);
v17 = std::__ostream_insert<char,std::char_traits<char>>(v34, v25, v26);
std::__ostream_insert<char,std::char_traits<char>>(v17, "'", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(v17, ":", 1LL);
v18 = -*v4;
if ( (int)*v4 > 0 )
v18 = *v4;
v19 = 1;
if ( v18 >= 0xA )
{
v19 = 4;
v20 = v18;
while ( 1 )
{
if ( v20 <= 0x63 )
{
v19 -= 2;
goto LABEL_41;
}
if ( v20 <= 0x3E7 )
break;
if ( v20 < 0x2710 )
goto LABEL_41;
v19 += 4;
v21 = v20 <= 0x1869F;
v20 /= 0x2710u;
if ( v21 )
{
v19 -= 3;
goto LABEL_41;
}
}
--v19;
}
LABEL_41:
v22 = *v4 >> 31;
v28[0] = v29;
std::string::_M_construct(v28, v19 + v22, 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v28[0] + v22, v19, v18);
std::__ostream_insert<char,std::char_traits<char>>(v17, v28[0], v28[1]);
if ( v28[0] != v29 )
operator delete(v28[0], v29[0] + 1LL);
if ( v25 != &v27 )
operator delete(v25, v27 + 1);
++v4;
v5 = 0;
if ( v4 == v31 )
goto LABEL_48;
}
v11 = (char *)v25 + (v26 & 0xFFFFFFFFFFFFFFFCLL);
v12 = (v26 >> 2) + 1;
v13 = (char *)v25 + 3;
while ( 1 )
{
if ( !(unsigned int)isprint((unsigned __int8)*(v13 - 3)) )
{
v13 -= 3;
goto LABEL_25;
}
if ( !(unsigned int)isprint((unsigned __int8)*(v13 - 2)) )
{
v13 -= 2;
goto LABEL_25;
}
if ( !(unsigned int)isprint((unsigned __int8)*(v13 - 1)) )
break;
if ( !(unsigned int)isprint((unsigned __int8)*v13) )
goto LABEL_25;
--v12;
v13 += 4;
if ( v12 <= 1 )
goto LABEL_12;
}
--v13;
goto LABEL_25;
}
LABEL_48:
std::__ostream_insert<char,std::char_traits<char>>(v34, " ]", 2LL);
v23 = v30;
std::stringbuf::str(v30, v35);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v33,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v36);
return v23;
}
|
string_from[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1e8
MOV RBX,RDX
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x48],RDI
LEA RDI,[RSP + 0x60]
CALL 0x0011a610
LEA R14,[RSP + 0x70]
LAB_00171a00:
LEA RSI,[0x1edadf]
MOV EDX,0x2
MOV RDI,R14
CALL 0x0011a9a0
MOV R13,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RSP + 0x50],RAX
CMP R13,RAX
JZ 0x00171ce1
MOV AL,0x1
LAB_00171a2b:
TEST AL,0x1
JNZ 0x00171a43
LAB_00171a2f:
MOV EDX,0x2
MOV RDI,R14
LEA RSI,[0x1ee483]
CALL 0x0011a9a0
LAB_00171a43:
MOV EBX,dword ptr [R13]
LAB_00171a47:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0011a760
MOV RDI,RAX
CALL 0x0011b0e0
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
MOV EDX,EBX
MOV ECX,0x1
CALL 0x00174b7d
MOV R15,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
LEA RBX,[R15 + RAX*0x1]
MOV R14,RAX
SAR R14,0x2
MOV RBP,R15
TEST R14,R14
JLE 0x00171aeb
AND RAX,-0x4
MOV RBP,RAX
ADD RBP,R15
INC R14
LEA R12,[R15 + 0x3]
LAB_00171a9b:
MOVZX EDI,byte ptr [R12 + -0x3]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b40
MOVZX EDI,byte ptr [R12 + -0x2]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b46
MOVZX EDI,byte ptr [R12 + -0x1]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b4c
MOVZX EDI,byte ptr [R12]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b4f
DEC R14
ADD R12,0x4
CMP R14,0x1
JG 0x00171a9b
LAB_00171aeb:
MOV RAX,RBX
SUB RAX,RBP
CMP RAX,0x1
JZ 0x00171b2c
CMP RAX,0x2
LEA R14,[RSP + 0x70]
JZ 0x00171b1c
CMP RAX,0x3
JNZ 0x00171cd9
MOVZX EDI,byte ptr [RBP]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b3b
INC RBP
LAB_00171b1c:
MOVZX EDI,byte ptr [RBP]
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b3b
INC RBP
LAB_00171b2c:
MOVZX EDI,byte ptr [RBP]
CALL 0x0011af30
TEST EAX,EAX
CMOVNZ RBP,RBX
LAB_00171b3b:
MOV R12,RBP
JMP 0x00171b4f
LAB_00171b40:
ADD R12,-0x3
JMP 0x00171b4f
LAB_00171b46:
ADD R12,-0x2
JMP 0x00171b4f
LAB_00171b4c:
DEC R12
LAB_00171b4f:
CMP R12,RBX
SETZ AL
LEA R14,[R12 + 0x1]
CMP R14,RBX
SETZ CL
OR CL,AL
JNZ 0x00171b88
LAB_00171b64:
MOV BPL,byte ptr [R14]
MOVZX EDI,BPL
CALL 0x0011af30
TEST EAX,EAX
JZ 0x00171b7b
MOV byte ptr [R12],BPL
INC R12
LAB_00171b7b:
INC R14
CMP R14,RBX
JNZ 0x00171b64
MOV R15,qword ptr [RSP + 0x8]
LAB_00171b88:
LEA R14,[RSP + 0x70]
LAB_00171b8d:
MOV RAX,R12
SUB RAX,R15
MOV qword ptr [RSP + 0x10],RAX
MOV byte ptr [R12],0x0
LAB_00171b9d:
MOV EDX,0x1
MOV RDI,R14
LEA RSI,[0x1ecb71]
CALL 0x0011a9a0
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x0011a9a0
MOV R12,RAX
MOV EDX,0x1
MOV RDI,RAX
LEA RSI,[0x1ecb71]
CALL 0x0011a9a0
MOV EDX,0x1
MOV RDI,R12
LEA RSI,[0x1ee5ce]
CALL 0x0011a9a0
MOV EBP,dword ptr [R13]
MOV EBX,EBP
NEG EBX
CMOVS EBX,EBP
MOV R15D,0x1
CMP EBX,0xa
JC 0x00171c4a
MOV R15D,0x4
MOV EAX,EBX
LAB_00171c0c:
CMP EAX,0x63
JBE 0x00171c41
CMP EAX,0x3e7
JBE 0x00171c47
CMP EAX,0x2710
JC 0x00171c4a
MOV ECX,EAX
MOV EDX,0xd1b71759
IMUL RCX,RDX
SHR RCX,0x2d
ADD R15D,0x4
CMP EAX,0x1869f
MOV EAX,ECX
JA 0x00171c0c
ADD R15D,-0x3
JMP 0x00171c4a
LAB_00171c41:
ADD R15D,-0x2
JMP 0x00171c4a
LAB_00171c47:
DEC R15D
LAB_00171c4a:
SHR EBP,0x1f
LEA ESI,[R15 + RBP*0x1]
LEA RAX,[RSP + 0x38]
MOV qword ptr [RSP + 0x28],RAX
LAB_00171c5b:
LEA RDI,[RSP + 0x28]
MOV EDX,0x2d
CALL 0x0011a9d0
ADD RBP,qword ptr [RSP + 0x28]
MOV RDI,RBP
MOV ESI,R15D
MOV EDX,EBX
CALL 0x00157d3d
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
LAB_00171c86:
MOV RDI,R12
CALL 0x0011a9a0
MOV RDI,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x38]
CMP RDI,RAX
JZ 0x00171caa
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a890
LAB_00171caa:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00171cc6
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a890
LAB_00171cc6:
ADD R13,0x4
XOR EAX,EAX
CMP R13,qword ptr [RSP + 0x50]
JNZ 0x00171a2b
JMP 0x00171ce1
LAB_00171cd9:
MOV R12,RBX
JMP 0x00171b8d
LAB_00171ce1:
LEA RSI,[0x1edae2]
MOV EDX,0x2
MOV RDI,R14
CALL 0x0011a9a0
MOV RBX,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x78]
MOV RDI,RBX
CALL 0x0011ad50
LAB_00171d07:
MOV RSI,qword ptr [0x00229f18]
LEA RDI,[RSP + 0x60]
CALL 0x0011a650
LEA RDI,[RSP + 0xe0]
CALL 0x0011a2a0
MOV RAX,RBX
ADD RSP,0x1e8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int> > const&) */
llama_context * string_from_abi_cxx11_(llama_context *param_1,vector *param_2)
{
byte *pbVar1;
byte bVar2;
uint uVar3;
uint uVar4;
llama_context *plVar5;
uint uVar6;
bool bVar7;
int iVar8;
uint uVar9;
int8 uVar10;
ostream *poVar11;
ulong uVar12;
int8 *in_RDX;
byte *pbVar13;
byte *pbVar14;
uint *puVar15;
long lVar16;
uint uVar17;
byte *pbVar18;
byte *local_210;
ulong local_208;
long local_200 [2];
long *local_1f0;
long local_1e8;
long local_1e0 [2];
llama_context *local_1d0;
uint *local_1c8;
vector *local_1c0;
stringstream local_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
local_1d0 = param_1;
local_1c0 = param_2;
std::__cxx11::stringstream::stringstream(local_1b8);
/* try { // try from 00171a00 to 00171a13 has its CatchHandler @ 00171d3a */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"[ ",2);
puVar15 = (uint *)*in_RDX;
local_1c8 = (uint *)in_RDX[1];
if (puVar15 != local_1c8) {
bVar7 = true;
do {
if (!bVar7) {
/* try { // try from 00171a2f to 00171a42 has its CatchHandler @ 00171d3e */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,", ",2);
}
uVar3 = *puVar15;
/* try { // try from 00171a47 to 00171a6c has its CatchHandler @ 00171d63 */
uVar10 = llama_get_model(local_1c0);
iVar8 = llama_model_get_vocab(uVar10);
common_token_to_piece_abi_cxx11_((llama_vocab *)&local_210,iVar8,SUB41(uVar3,0));
pbVar18 = local_210;
pbVar1 = local_210 + local_208;
pbVar13 = local_210;
if (0 < (long)local_208 >> 2) {
pbVar13 = local_210 + (local_208 & 0xfffffffffffffffc);
lVar16 = ((long)local_208 >> 2) + 1;
pbVar14 = local_210 + 3;
do {
iVar8 = isprint((uint)pbVar14[-3]);
if (iVar8 == 0) {
pbVar14 = pbVar14 + -3;
goto LAB_00171b4f;
}
iVar8 = isprint((uint)pbVar14[-2]);
if (iVar8 == 0) {
pbVar14 = pbVar14 + -2;
goto LAB_00171b4f;
}
iVar8 = isprint((uint)pbVar14[-1]);
if (iVar8 == 0) {
pbVar14 = pbVar14 + -1;
goto LAB_00171b4f;
}
iVar8 = isprint((uint)*pbVar14);
if (iVar8 == 0) goto LAB_00171b4f;
lVar16 = lVar16 + -1;
pbVar14 = pbVar14 + 4;
} while (1 < lVar16);
}
lVar16 = (long)pbVar1 - (long)pbVar13;
if (lVar16 == 1) {
LAB_00171b2c:
iVar8 = isprint((uint)*pbVar13);
pbVar14 = pbVar13;
if (iVar8 != 0) {
pbVar14 = pbVar1;
}
LAB_00171b4f:
pbVar13 = pbVar14 + 1;
if (pbVar13 != pbVar1 && pbVar14 != pbVar1) {
do {
bVar2 = *pbVar13;
iVar8 = isprint((uint)bVar2);
if (iVar8 != 0) {
*pbVar14 = bVar2;
pbVar14 = pbVar14 + 1;
}
pbVar13 = pbVar13 + 1;
pbVar18 = local_210;
} while (pbVar13 != pbVar1);
}
}
else {
if (lVar16 == 2) {
LAB_00171b1c:
iVar8 = isprint((uint)*pbVar13);
pbVar14 = pbVar13;
if (iVar8 != 0) {
pbVar13 = pbVar13 + 1;
goto LAB_00171b2c;
}
goto LAB_00171b4f;
}
pbVar14 = pbVar1;
if (lVar16 == 3) {
iVar8 = isprint((uint)*pbVar13);
pbVar14 = pbVar13;
if (iVar8 != 0) {
pbVar13 = pbVar13 + 1;
goto LAB_00171b1c;
}
goto LAB_00171b4f;
}
}
local_208 = (long)pbVar14 - (long)pbVar18;
*pbVar14 = 0;
/* try { // try from 00171b9d to 00171bed has its CatchHandler @ 00171d68 */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\'",1);
poVar11 = std::__ostream_insert<char,std::char_traits<char>>
(local_1a8,(char *)local_210,local_208);
std::__ostream_insert<char,std::char_traits<char>>(poVar11,"\'",1);
std::__ostream_insert<char,std::char_traits<char>>(poVar11,":",1);
uVar3 = *puVar15;
uVar4 = -uVar3;
if (0 < (int)uVar3) {
uVar4 = uVar3;
}
uVar17 = 1;
if (9 < uVar4) {
uVar12 = (ulong)uVar4;
uVar6 = 4;
do {
uVar17 = uVar6;
uVar9 = (uint)uVar12;
if (uVar9 < 100) {
uVar17 = uVar17 - 2;
goto LAB_00171c4a;
}
if (uVar9 < 1000) {
uVar17 = uVar17 - 1;
goto LAB_00171c4a;
}
if (uVar9 < 10000) goto LAB_00171c4a;
uVar12 = uVar12 / 10000;
uVar6 = uVar17 + 4;
} while (99999 < uVar9);
uVar17 = uVar17 + 1;
}
LAB_00171c4a:
local_1f0 = local_1e0;
/* try { // try from 00171c5b to 00171c69 has its CatchHandler @ 00171d40 */
std::__cxx11::string::_M_construct
((ulong)&local_1f0,(char)uVar17 - (char)((int)uVar3 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((long)local_1f0 + (ulong)(uVar3 >> 0x1f)),uVar17,uVar4);
/* try { // try from 00171c86 to 00171c8d has its CatchHandler @ 00171d42 */
std::__ostream_insert<char,std::char_traits<char>>(poVar11,(char *)local_1f0,local_1e8);
if (local_1f0 != local_1e0) {
operator_delete(local_1f0,local_1e0[0] + 1);
}
if (local_210 != (byte *)local_200) {
operator_delete(local_210,local_200[0] + 1);
}
puVar15 = puVar15 + 1;
bVar7 = false;
} while (puVar15 != local_1c8);
}
/* try { // try from 00171ce1 to 00171d06 has its CatchHandler @ 00171d3c */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8," ]",2);
plVar5 = local_1d0;
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(local_1b8);
std::ios_base::~ios_base(local_138);
return plVar5;
}
|
|
9,585 |
ma_find_writepos
|
eloqsql/storage/maria/ma_dynrec.c
|
static int _ma_find_writepos(MARIA_HA *info,
ulong reclength, /* record length */
my_off_t *filepos, /* Return file pos */
ulong *length) /* length of block at filepos */
{
MARIA_BLOCK_INFO block_info;
ulong tmp;
DBUG_ENTER("_ma_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 (!(_ma_get_block_info(info, &block_info, info->dfile.file,
info->s->state.dellink) &
BLOCK_DELETED))
{
DBUG_PRINT("error",("Delete link crashed"));
_ma_set_fatal_error_with_share(info->s, 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+MARIA_DYN_ALIGN_SIZE-1) &
(~ (ulong) (MARIA_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 > MARIA_MAX_BLOCK_LENGTH)
tmp=MARIA_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);
}
|
O0
|
c
|
ma_find_writepos:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x88(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpq $-0x1, 0xc8(%rax)
je 0x52fe9
movq -0x70(%rbp), %rax
cmpb $0x0, 0x681(%rax)
jne 0x52fe9
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movq -0x70(%rbp), %rax
movl $0x1, 0x598(%rax)
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x480(%rax), %edx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0xc8(%rax), %rcx
leaq -0x60(%rbp), %rsi
callq 0x4fde0
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x52f99
jmp 0x52f7a
jmp 0x52f7c
movq -0x70(%rbp), %rax
movq (%rax), %rdi
movl $0x7f, %esi
callq 0x39c00
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0x53119
movq -0x20(%rbp), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xc8(%rax)
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rdx
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
jmp 0x53110
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x80(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
addq $0x3, %rax
movq -0x78(%rbp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0xffed, %rsi # imm = 0xFFED
cmovael %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x5304d
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x3b8(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x53067
movq -0x90(%rbp), %rax
addq $0x4, %rax
subq $0x1, %rax
andq $-0x4, %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
movq 0x368(%rcx), %rcx
subq -0x90(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x530a1
callq 0xfdd30
movl $0x87, (%rax)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0x53119
cmpq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
jbe 0x530b9
movq $0xfffffc, -0x90(%rbp) # imm = 0xFFFFFC
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
movq -0x90(%rbp), %rcx
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0xc0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc0(%rax)
movq -0x70(%rbp), %rax
movl 0x624(%rax), %ecx
orl $0x100, %ecx # imm = 0x100
movl %ecx, 0x624(%rax)
jmp 0x53112
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x53143
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x29230
nopl (%rax,%rax)
|
_ma_find_writepos:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov [rbp+var_88], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
cmp qword ptr [rax+0C8h], 0FFFFFFFFFFFFFFFFh
jz loc_52FE9
mov rax, [rbp+var_70]
cmp byte ptr [rax+681h], 0
jnz loc_52FE9
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+0C8h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov [rbp+var_10], 0
mov rax, [rbp+var_70]
mov dword ptr [rax+598h], 1
mov rdi, [rbp+var_70]
mov rax, [rbp+var_70]
mov edx, [rax+480h]
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+0C8h]
lea rsi, [rbp+var_60]
call _ma_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_52F99
jmp short $+2
loc_52F7A:
jmp short $+2
loc_52F7C:
mov rax, [rbp+var_70]
mov rdi, [rax]
mov esi, 7Fh
call _ma_set_fatal_error_with_share
mov [rbp+var_64], 0FFFFFFFFh
jmp loc_53119
loc_52F99:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rax+0C8h], rcx
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rcx, [rax+8]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+8], rcx
mov rdx, [rbp+var_38]
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_88]
mov [rax], rcx
jmp loc_53110
loc_52FE9:
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rcx, [rax+28h]
mov rax, [rbp+var_80]
mov [rax], rcx
mov rax, [rbp+var_78]
add rax, 3
mov rsi, [rbp+var_78]
xor ecx, ecx
mov edx, 1
cmp rsi, 0FFEDh
cmovnb ecx, edx
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_90], rax
mov rcx, [rbp+var_70]
mov rcx, [rcx]
cmp rax, [rcx+3B8h]
jnb short loc_5304D
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+3B8h]
mov [rbp+var_90], rax
jmp short loc_53067
loc_5304D:
mov rax, [rbp+var_90]
add rax, 4
sub rax, 1
and rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_90], rax
loc_53067:
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rax, [rax+28h]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
mov rcx, [rcx+368h]
sub rcx, [rbp+var_90]
cmp rax, rcx
jbe short loc_530A1
call _my_thread_var
mov dword ptr [rax], 87h
mov [rbp+var_64], 0FFFFFFFFh
jmp short loc_53119
loc_530A1:
cmp [rbp+var_90], 0FFFFFCh
jbe short loc_530B9
mov [rbp+var_90], 0FFFFFCh
loc_530B9:
mov rcx, [rbp+var_90]
mov rax, [rbp+var_88]
mov [rax], rcx
mov rcx, [rbp+var_90]
mov rax, [rbp+var_70]
mov rax, [rax+20h]
add rcx, [rax+28h]
mov [rax+28h], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+0C0h]
add rcx, 1
mov [rax+0C0h], rcx
mov rax, [rbp+var_70]
mov ecx, [rax+624h]
or ecx, 100h
mov [rax+624h], ecx
loc_53110:
jmp short $+2
loc_53112:
mov [rbp+var_64], 0
loc_53119:
mov eax, [rbp+var_64]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_53143
mov eax, [rbp+var_94]
add rsp, 0A0h
pop rbp
retn
loc_53143:
call ___stack_chk_fail
|
long long ma_find_writepos(long long *a1, const char *a2, _QWORD *a3, unsigned long long *a4, long long a5, int a6)
{
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
int v9; // r9d
unsigned long long v11; // [rsp+10h] [rbp-90h]
unsigned long long v12; // [rsp+10h] [rbp-90h]
unsigned __int8 v15[40]; // [rsp+40h] [rbp-60h] BYREF
unsigned long long v16; // [rsp+68h] [rbp-38h]
long long v17; // [rsp+80h] [rbp-20h]
int v18; // [rsp+90h] [rbp-10h]
unsigned long long v19; // [rsp+98h] [rbp-8h]
v19 = __readfsqword(0x28u);
if ( *(_QWORD *)(*a1 + 200) == -1LL || *((_BYTE *)a1 + 1665) )
{
*a3 = *(_QWORD *)(a1[4] + 40);
v11 = (unsigned long long)&a2[((unsigned long long)a2 >= 0xFFED) + 3];
if ( v11 >= *(_QWORD *)(*a1 + 952) )
v12 = (v11 + 3) & 0xFFFFFFFFFFFFFFFCLL;
else
v12 = *(_QWORD *)(*a1 + 952);
if ( *(_QWORD *)(a1[4] + 40) > *(_QWORD *)(*a1 + 872) - v12 )
{
*(_DWORD *)my_thread_var(a1, a2) = 135;
return (unsigned int)-1;
}
if ( v12 > 0xFFFFFC )
v12 = 16777212LL;
*a4 = v12;
*(_QWORD *)(a1[4] + 40) += v12;
++*(_QWORD *)(*a1 + 192);
*((_DWORD *)a1 + 393) |= 0x100u;
return 0;
}
*a3 = *(_QWORD *)(*a1 + 200);
v18 = 0;
*((_DWORD *)a1 + 358) = 1;
if ( (ma_get_block_info((long long)a1, v15, *((unsigned int *)a1 + 288), *(_QWORD *)(*a1 + 200), a5, a6) & 4) != 0 )
{
*(_QWORD *)(*a1 + 200) = v17;
--*(_QWORD *)(a1[4] + 8);
*(_QWORD *)(a1[4] + 16) -= v16;
*a4 = v16;
return 0;
}
ma_set_fatal_error_with_share(*a1, 127, v6, v7, v8, v9);
return (unsigned int)-1;
}
|
_ma_find_writepos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV qword ptr [RBP + -0x88],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0xc8],-0x1
JZ 0x00152fe9
MOV RAX,qword ptr [RBP + -0x70]
CMP byte ptr [RAX + 0x681],0x0
JNZ 0x00152fe9
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0xc8]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + 0x598],0x1
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RAX + 0x480]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0xc8]
LEA RSI,[RBP + -0x60]
CALL 0x0014fde0
AND EAX,0x4
CMP EAX,0x0
JNZ 0x00152f99
JMP 0x00152f7a
LAB_00152f7a:
JMP 0x00152f7c
LAB_00152f7c:
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,qword ptr [RAX]
MOV ESI,0x7f
CALL 0x00139c00
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x00153119
LAB_00152f99:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0xc8],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
JMP 0x00153110
LAB_00152fe9:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x3
MOV RSI,qword ptr [RBP + -0x78]
XOR ECX,ECX
MOV EDX,0x1
CMP RSI,0xffed
CMOVNC ECX,EDX
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0015304d
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3b8]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00153067
LAB_0015304d:
MOV RAX,qword ptr [RBP + -0x90]
ADD RAX,0x4
SUB RAX,0x1
AND RAX,-0x4
MOV qword ptr [RBP + -0x90],RAX
LAB_00153067:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x368]
SUB RCX,qword ptr [RBP + -0x90]
CMP RAX,RCX
JBE 0x001530a1
CALL 0x001fdd30
MOV dword ptr [RAX],0x87
MOV dword ptr [RBP + -0x64],0xffffffff
JMP 0x00153119
LAB_001530a1:
CMP qword ptr [RBP + -0x90],0xfffffc
JBE 0x001530b9
MOV qword ptr [RBP + -0x90],0xfffffc
LAB_001530b9:
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0xc0]
ADD RCX,0x1
MOV qword ptr [RAX + 0xc0],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x624]
OR ECX,0x100
MOV dword ptr [RAX + 0x624],ECX
LAB_00153110:
JMP 0x00153112
LAB_00153112:
MOV dword ptr [RBP + -0x64],0x0
LAB_00153119:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00153143
MOV EAX,dword ptr [RBP + -0x94]
ADD RSP,0xa0
POP RBP
RET
LAB_00153143:
CALL 0x00129230
|
int4 _ma_find_writepos(long *param_1,ulong param_2,int8 *param_3,ulong *param_4)
{
uint uVar1;
ulong uVar2;
int4 *puVar3;
long in_FS_OFFSET;
ulong local_98;
int4 local_6c;
int1 local_68 [40];
ulong local_40;
int8 local_28;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((*(long *)(*param_1 + 200) == -1) || (*(char *)((long)param_1 + 0x681) != '\0')) {
*param_3 = *(int8 *)(param_1[4] + 0x28);
uVar2 = param_2 + 3 + (long)(int)(uint)(0xffec < param_2);
if (uVar2 < *(ulong *)(*param_1 + 0x3b8)) {
local_98 = *(ulong *)(*param_1 + 0x3b8);
}
else {
local_98 = uVar2 + 3 & 0xfffffffffffffffc;
}
if (*(long *)(*param_1 + 0x368) - local_98 < *(ulong *)(param_1[4] + 0x28)) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x87;
local_6c = 0xffffffff;
goto LAB_00153119;
}
if (0xfffffc < local_98) {
local_98 = 0xfffffc;
}
*param_4 = local_98;
*(ulong *)(param_1[4] + 0x28) = local_98 + *(long *)(param_1[4] + 0x28);
*(long *)(*param_1 + 0xc0) = *(long *)(*param_1 + 0xc0) + 1;
*(uint *)((long)param_1 + 0x624) = *(uint *)((long)param_1 + 0x624) | 0x100;
}
else {
*param_3 = *(int8 *)(*param_1 + 200);
local_18 = 0;
*(int4 *)(param_1 + 0xb3) = 1;
uVar1 = _ma_get_block_info(param_1,local_68,(int)param_1[0x90],*(int8 *)(*param_1 + 200));
if ((uVar1 & 4) == 0) {
_ma_set_fatal_error_with_share(*param_1,0x7f);
local_6c = 0xffffffff;
goto LAB_00153119;
}
*(int8 *)(*param_1 + 200) = local_28;
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + -1;
*(ulong *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) - local_40;
*param_4 = local_40;
}
local_6c = 0;
LAB_00153119:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_6c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
9,586 |
link_to_changed_list
|
eloqsql/mysys/mf_keycache.c
|
static void link_to_changed_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT(!(block->status & BLOCK_CHANGED));
DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
unlink_changed(block);
link_changed(block,
&keycache->changed_blocks[FILE_HASH(block->hash_link->file, keycache)]);
block->status|=BLOCK_CHANGED;
keycache->blocks_changed++;
keycache->global_blocks_changed++;
}
|
O0
|
c
|
link_to_changed_list:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xe92e2
jmp 0xe92e4
jmp 0xe92e6
jmp 0xe92e8
jmp 0xe92ea
movq -0x10(%rbp), %rdi
callq 0xe6ca0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0xe6f00
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x138(%rax)
addq $0x10, %rsp
popq %rbp
retq
|
link_to_changed_list_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_E92E2:
jmp short $+2
loc_E92E4:
jmp short $+2
loc_E92E6:
jmp short $+2
loc_E92E8:
jmp short $+2
loc_E92EA:
mov rdi, [rbp+var_10]
call unlink_changed_0
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax+128h]
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov eax, [rax+18h]
mov rcx, [rbp+var_8]
mov ecx, [rcx+3Ch]
sub ecx, 1
and eax, ecx
mov eax, eax
shl rax, 3
add rsi, rax
call link_changed_0
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
or ecx, 20h
mov [rax+50h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+60h]
add rcx, 1
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+138h]
add rcx, 1
mov [rax+138h], rcx
add rsp, 10h
pop rbp
retn
|
long long link_to_changed_list_0(long long a1, long long a2)
{
long long result; // rax
unlink_changed_0(a2);
link_changed_0(
a2,
(long long *)(8LL * ((unsigned int)(*(_DWORD *)(a1 + 60) - 1) & *(_DWORD *)(*(_QWORD *)(a2 + 32) + 24LL))
+ *(_QWORD *)(a1 + 296)));
*(_DWORD *)(a2 + 80) |= 0x20u;
++*(_QWORD *)(a1 + 96);
result = a1;
++*(_QWORD *)(a1 + 312);
return result;
}
|
link_to_changed_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001e92e2
LAB_001e92e2:
JMP 0x001e92e4
LAB_001e92e4:
JMP 0x001e92e6
LAB_001e92e6:
JMP 0x001e92e8
LAB_001e92e8:
JMP 0x001e92ea
LAB_001e92ea:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e6ca0
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x128]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV EAX,dword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3c]
SUB ECX,0x1
AND EAX,ECX
MOV EAX,EAX
SHL RAX,0x3
ADD RSI,RAX
CALL 0x001e6f00
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x20
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x60]
ADD RCX,0x1
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x138]
ADD RCX,0x1
MOV qword ptr [RAX + 0x138],RCX
ADD RSP,0x10
POP RBP
RET
|
void link_to_changed_list(long param_1,long param_2)
{
unlink_changed(param_2);
link_changed(param_2,*(long *)(param_1 + 0x128) +
(ulong)(*(uint *)(*(long *)(param_2 + 0x20) + 0x18) &
*(int *)(param_1 + 0x3c) - 1U) * 8);
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 0x20;
*(long *)(param_1 + 0x60) = *(long *)(param_1 + 0x60) + 1;
*(long *)(param_1 + 0x138) = *(long *)(param_1 + 0x138) + 1;
return;
}
|
|
9,587 |
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 0x449e2
orl $0x1, %ecx
movl %ecx, 0x618(%rdi)
addq $0x6, %rax
movq %rax, 0x610(%rdi)
jmp 0x449eb
cmpb $0x0, 0x688(%rdi)
je 0x449cc
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_449E2
loc_449CC:
or ecx, 1
mov [rdi+618h], ecx
add rax, 6
mov [rdi+610h], rax
jmp short loc_449EB
loc_449E2:
cmp byte ptr [rdi+688h], 0
jz short loc_449CC
loc_449EB:
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 0x001449e2
LAB_001449cc:
OR ECX,0x1
MOV dword ptr [RDI + 0x618],ECX
ADD RAX,0x6
MOV qword ptr [RDI + 0x610],RAX
JMP 0x001449eb
LAB_001449e2:
CMP byte ptr [RDI + 0x688],0x0
JZ 0x001449cc
LAB_001449eb:
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;
}
|
|
9,588 |
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(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
|
void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (move semantics)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->push_back(std::move(val));
set_parent(m_data.m_value.array->back(), old_capacity);
// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0x63150
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x25270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x4adea
jmp 0x63155
cmpl $0x2, %eax
jne 0x63169
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4bbc4
movl $0x20, %edi
callq 0x25790
movq %rax, %rbx
movq %r14, %rdi
callq 0x63928
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x110b15(%rip), %rsi # 0x173ca2
leaq 0x10(%rsp), %rdi
callq 0x638a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x134, %esi # imm = 0x134
movq %r14, %rcx
callq 0x636cc
xorl %ebp, %ebp
leaq 0x177128(%rip), %rsi # 0x1da2e0
leaq 0x210a3(%rip), %rdx # 0x84262
movq %rbx, %rdi
callq 0x25c00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x631e5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0x631ef
jmp 0x631f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x26150
movq %r14, %rdi
callq 0x25ca0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_63150
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_63155
loc_63150:
cmp eax, 2
jnz short loc_63169
loc_63155:
mov rdi, [r14+8]
mov rsi, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
loc_63169:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUsePushB; "cannot use push_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 134h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_631E5
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_631E5:
test bpl, bpl
jnz short loc_631EF
jmp short loc_631F7
mov r14, rax
loc_631EF:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_631F7:
mov rdi, r14
call __Unwind_Resume
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x00163150
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x00125270
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0014adea
JMP 0x00163155
LAB_00163150:
CMP EAX,0x2
JNZ 0x00163169
LAB_00163155:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x0014bbc4
LAB_00163169:
MOV EDI,0x20
CALL 0x00125790
MOV RBX,RAX
MOV RDI,R14
CALL 0x00163928
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00163186:
LEA RSI,[0x273ca2]
LEA RDI,[RSP + 0x10]
CALL 0x001638a0
MOV BPL,0x1
LAB_0016319a:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x134
MOV RCX,R14
CALL 0x001636cc
XOR EBP,EBP
LEA RSI,[0x2da2e0]
LEA RDX,[0x184262]
MOV RDI,RBX
CALL 0x00125c00
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&&) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
int8 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
else if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 00163186 to 00163196 has its CatchHandler @ 001631ec */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"cannot use push_back() with ",&local_40);
/* try { // try from 0016319a to 001631c6 has its CatchHandler @ 001631c7 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x134,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
|
||
9,589 |
start_timer
|
eloqsql/unittest/mytap/tap.c
|
static ulong start_timer(void)
{
#if defined(_WIN32)
return clock();
#else
struct tms tms_tmp;
return times(&tms_tmp);
#endif
}
|
O0
|
c
|
start_timer:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x20(%rbp), %rdi
callq 0x2a190
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
start_timer:
push rbp
mov rbp, rsp
sub rsp, 20h
lea rdi, [rbp+var_20]
call _times
add rsp, 20h
pop rbp
retn
|
long long start_timer()
{
_BYTE v1[32]; // [rsp+0h] [rbp-20h] BYREF
return times(v1);
}
|
start_timer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
LEA RDI,[RBP + -0x20]
CALL 0x0012a190
ADD RSP,0x20
POP RBP
RET
|
void start_timer(void)
{
tms local_28;
times(&local_28);
return;
}
|
|
9,590 |
mthd_stmt_read_all_rows
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int mthd_stmt_read_all_rows(MYSQL_STMT *stmt)
{
MYSQL_DATA *result= &stmt->result;
MYSQL_ROWS *current, **pprevious;
ulong packet_len;
unsigned char *p;
pprevious= &result->data;
while ((packet_len = ma_net_safe_read(stmt->mysql)) != packet_error)
{
p= stmt->mysql->net.read_pos;
if (packet_len > 7 || p[0] != 254)
{
/* allocate space for rows */
if (!(current= (MYSQL_ROWS *)ma_alloc_root(&result->alloc, sizeof(MYSQL_ROWS) + packet_len)))
{
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(1);
}
current->data= (MYSQL_ROW)(current + 1);
*pprevious= current;
pprevious= ¤t->next;
/* copy binary row, we will encode it during mysql_stmt_fetch */
memcpy((char *)current->data, (char *)p, packet_len);
if (stmt->update_max_length)
{
uchar *null_ptr, bit_offset= 4;
uchar *cp= p;
unsigned int i;
cp++; /* skip first byte */
null_ptr= cp;
cp+= (stmt->field_count + 9) / 8;
for (i=0; i < stmt->field_count; i++)
{
if (!(*null_ptr & bit_offset))
{
if (mysql_ps_fetch_functions[stmt->fields[i].type].pack_len < 0)
{
/* We need to calculate the sizes for date and time types */
size_t len= net_field_length(&cp);
switch(stmt->fields[i].type) {
case MYSQL_TYPE_TIME:
case MYSQL_TYPE_DATE:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
stmt->fields[i].max_length= mysql_ps_fetch_functions[stmt->fields[i].type].max_len;
break;
default:
if (len > stmt->fields[i].max_length)
stmt->fields[i].max_length= (ulong)len;
break;
}
cp+= len;
}
else
{
if (stmt->fields[i].flags & ZEROFILL_FLAG)
{
/* The -1 is because a ZEROFILL:ed field is always unsigned */
size_t len= MAX(stmt->fields[i].length, mysql_ps_fetch_functions[stmt->fields[i].type].max_len-1);
if (len > stmt->fields[i].max_length)
stmt->fields[i].max_length= (unsigned long)len;
}
else if (!stmt->fields[i].max_length)
{
stmt->fields[i].max_length= mysql_ps_fetch_functions[stmt->fields[i].type].max_len;
if (stmt->fields[i].flags & UNSIGNED_FLAG &&
stmt->fields[i].type != MYSQL_TYPE_INT24 &&
stmt->fields[i].type != MYSQL_TYPE_LONGLONG)
{
/*
Unsigned integers has one character less than signed integers
as '-' is counted as part of max_length
*/
stmt->fields[i].max_length--;
}
}
cp+= mysql_ps_fetch_functions[stmt->fields[i].type].pack_len;
}
}
if (!((bit_offset <<=1) & 255))
{
bit_offset= 1; /* To next byte */
null_ptr++;
}
}
}
current->length= packet_len;
result->rows++;
} else /* end of stream */
{
*pprevious= 0;
/* sace status info */
p++;
stmt->upsert_status.warning_count= stmt->mysql->warning_count= uint2korr(p);
p+=2;
stmt->upsert_status.server_status= stmt->mysql->server_status= uint2korr(p);
stmt->result_cursor= result->data;
return(0);
}
}
stmt->result_cursor= 0;
SET_CLIENT_STMT_ERROR(stmt, stmt->mysql->net.last_errno, stmt->mysql->net.sqlstate,
stmt->mysql->net.last_error);
return(1);
}
|
O3
|
c
|
mthd_stmt_read_all_rows:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x179f7
movq %rax, %r15
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r15
je 0x20af2
leaq 0x80(%rbx), %r14
leaq 0x90(%rbx), %rax
movq %rax, -0x38(%rbp)
movq 0x38(%rbx), %rax
movq 0x20(%rax), %r13
cmpq $0x7, %r15
ja 0x20922
cmpb $-0x2, (%r13)
je 0x20ba7
leaq 0x18(%r15), %rsi
movq -0x38(%rbp), %rdi
callq 0x2022f
testq %rax, %rax
je 0x20b41
movq %rax, %r12
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq %r12, (%r14)
movq 0x8(%r12), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x13390
cmpb $0x0, 0x313(%rbx)
je 0x20ac9
movq %r12, -0x40(%rbp)
movq %r15, -0x48(%rbp)
movl 0x60(%rbx), %eax
leal 0x9(%rax), %ecx
shrl $0x3, %ecx
addq %r13, %rcx
incq %rcx
movq %rcx, -0x30(%rbp)
testl %eax, %eax
leaq 0x2d7c8(%rip), %rsi # 0x4e150
movl $0x1, %edi
je 0x20ac1
incq %r13
movl $0x4, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movzbl (%r13), %eax
testl %eax, %r14d
jne 0x20a7c
movq 0x58(%rbx), %rax
movl 0x70(%rax,%r15), %ecx
leaq (%rcx,%rcx,2), %rcx
cmpl $0x0, 0x8(%rsi,%rcx,8)
js 0x20a05
leaq (%rsi,%rcx,8), %rcx
testb $0x40, 0x64(%rax,%r15)
jne 0x20a47
cmpq $0x0, 0x40(%rax,%r15)
jne 0x20a66
movq 0x10(%rcx), %rcx
movq %rcx, 0x40(%rax,%r15)
movq 0x58(%rbx), %rax
testb $0x20, 0x64(%rax,%r15)
je 0x20a66
movl 0x70(%rax,%r15), %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
je 0x20a66
decq 0x40(%rax,%r15)
jmp 0x20a66
leaq -0x30(%rbp), %rdi
callq 0x17dd5
movq 0x58(%rbx), %rcx
movl 0x70(%rcx,%r15), %edx
cmpq $0xc, %rdx
ja 0x20aa7
movl $0x1c80, %esi # imm = 0x1C80
btl %edx, %esi
jae 0x20aa7
leaq (%rdx,%rdx,2), %rdx
leaq 0x2d71a(%rip), %rsi # 0x4e150
movq 0x10(%rsi,%rdx,8), %rdx
movq %rdx, 0x40(%rcx,%r15)
movl $0x1, %edi
jmp 0x20a78
movq 0x38(%rax,%r15), %rdx
movq 0x10(%rcx), %rcx
decq %rcx
cmpq %rcx, %rdx
cmovaq %rdx, %rcx
cmpq 0x40(%rax,%r15), %rcx
jbe 0x20a66
movq %rcx, 0x40(%rax,%r15)
movq 0x58(%rbx), %rax
movl 0x70(%rax,%r15), %eax
leaq (%rax,%rax,2), %rax
movslq 0x8(%rsi,%rax,8), %rax
addq %rax, -0x30(%rbp)
movzbl %r14b, %eax
leal (%rax,%rax), %r14d
xorl %ecx, %ecx
testb $0x7f, %al
sete %cl
cmovel %edi, %r14d
addq %rcx, %r13
incq %r12
movl 0x60(%rbx), %eax
subq $-0x80, %r15
cmpq %rax, %r12
jb 0x209a2
jmp 0x20ac1
cmpq 0x40(%rcx,%r15), %rax
leaq 0x2d69d(%rip), %rsi # 0x4e150
movl $0x1, %edi
jbe 0x20a78
movq %rax, 0x40(%rcx,%r15)
jmp 0x20a78
movq -0x48(%rbp), %r15
movq -0x40(%rbp), %r12
movq %r15, 0x10(%r12)
incq 0xc8(%rbx)
movq 0x38(%rbx), %rdi
callq 0x179f7
movq %rax, %r15
movq %r12, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r15
jne 0x20909
movq $0x0, 0xe0(%rbx)
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
jmp 0x20b82
movl $0x7d8, 0x108(%rbx) # imm = 0x7D8
leaq 0x30d(%rbx), %rdi
leaq 0x2d0b7(%rip), %rax # 0x4dc10
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2d0a2(%rip), %rax # 0x4dc20
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, (%r14)
movzwl 0x1(%r13), %eax
movq 0x38(%rbx), %rcx
movl %eax, 0x388(%rcx)
movl %eax, 0xf0(%rbx)
movzwl 0x3(%r13), %eax
movq 0x38(%rbx), %rcx
movl %eax, 0x380(%rcx)
movl %eax, 0xf4(%rbx)
movq 0x80(%rbx), %rax
movq %rax, 0xe0(%rbx)
xorl %eax, %eax
jmp 0x20b98
|
mthd_stmt_read_all_rows:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rdi, [rdi+38h]
call ma_net_safe_read
mov r15, rax
mov eax, 0FFFFFFFFh
cmp r15, rax
jz loc_20AF2
lea r14, [rbx+80h]
lea rax, [rbx+90h]
mov [rbp+var_38], rax
loc_20909:
mov rax, [rbx+38h]
mov r13, [rax+20h]
cmp r15, 7
ja short loc_20922
cmp byte ptr [r13+0], 0FEh
jz loc_20BA7
loc_20922:
lea rsi, [r15+18h]
mov rdi, [rbp+var_38]
call ma_alloc_root
test rax, rax
jz loc_20B41
mov r12, rax
add rax, 18h
mov [r12+8], rax
mov [r14], r12
mov rdi, [r12+8]
mov rsi, r13
mov rdx, r15
call _memcpy
cmp byte ptr [rbx+313h], 0
jz loc_20AC9
mov [rbp+var_40], r12
mov [rbp+var_48], r15
mov eax, [rbx+60h]
lea ecx, [rax+9]
shr ecx, 3
add rcx, r13
inc rcx
mov [rbp+var_30], rcx
test eax, eax
lea rsi, mysql_ps_fetch_functions
mov edi, 1
jz loc_20AC1
inc r13
mov r14d, 4
xor r15d, r15d
xor r12d, r12d
loc_209A2:
movzx eax, byte ptr [r13+0]
test r14d, eax
jnz loc_20A7C
mov rax, [rbx+58h]
mov ecx, [rax+r15+70h]
lea rcx, [rcx+rcx*2]
cmp dword ptr [rsi+rcx*8+8], 0
js short loc_20A05
lea rcx, [rsi+rcx*8]
test byte ptr [rax+r15+64h], 40h
jnz short loc_20A47
cmp qword ptr [rax+r15+40h], 0
jnz loc_20A66
mov rcx, [rcx+10h]
mov [rax+r15+40h], rcx
mov rax, [rbx+58h]
test byte ptr [rax+r15+64h], 20h
jz short loc_20A66
mov ecx, [rax+r15+70h]
and ecx, 0FFFFFFFEh
cmp ecx, 8
jz short loc_20A66
dec qword ptr [rax+r15+40h]
jmp short loc_20A66
loc_20A05:
lea rdi, [rbp+var_30]
call net_field_length
mov rcx, [rbx+58h]
mov edx, [rcx+r15+70h]
cmp rdx, 0Ch
ja loc_20AA7
mov esi, 1C80h
bt esi, edx
jnb short loc_20AA7
lea rdx, [rdx+rdx*2]
lea rsi, mysql_ps_fetch_functions
mov rdx, [rsi+rdx*8+10h]
mov [rcx+r15+40h], rdx
mov edi, 1
jmp short loc_20A78
loc_20A47:
mov rdx, [rax+r15+38h]
mov rcx, [rcx+10h]
dec rcx
cmp rdx, rcx
cmova rcx, rdx
cmp rcx, [rax+r15+40h]
jbe short loc_20A66
mov [rax+r15+40h], rcx
loc_20A66:
mov rax, [rbx+58h]
mov eax, [rax+r15+70h]
lea rax, [rax+rax*2]
movsxd rax, dword ptr [rsi+rax*8+8]
loc_20A78:
add [rbp+var_30], rax
loc_20A7C:
movzx eax, r14b
lea r14d, [rax+rax]
xor ecx, ecx
test al, 7Fh
setz cl
cmovz r14d, edi
add r13, rcx
inc r12
mov eax, [rbx+60h]
sub r15, 0FFFFFFFFFFFFFF80h
cmp r12, rax
jb loc_209A2
jmp short loc_20AC1
loc_20AA7:
cmp rax, [rcx+r15+40h]
lea rsi, mysql_ps_fetch_functions
mov edi, 1
jbe short loc_20A78
mov [rcx+r15+40h], rax
jmp short loc_20A78
loc_20AC1:
mov r15, [rbp+var_48]
mov r12, [rbp+var_40]
loc_20AC9:
mov [r12+10h], r15
inc qword ptr [rbx+0C8h]
mov rdi, [rbx+38h]
call ma_net_safe_read
mov r15, rax
mov r14, r12
mov eax, 0FFFFFFFFh
cmp r15, rax
jnz loc_20909
loc_20AF2:
mov qword ptr [rbx+0E0h], 0
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
jmp short loc_20B82
loc_20B41:
mov dword ptr [rbx+108h], 7D8h
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
loc_20B82:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov eax, 1
loc_20B98:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_20BA7:
mov qword ptr [r14], 0
movzx eax, word ptr [r13+1]
mov rcx, [rbx+38h]
mov [rcx+388h], eax
mov [rbx+0F0h], eax
movzx eax, word ptr [r13+3]
mov rcx, [rbx+38h]
mov [rcx+380h], eax
mov [rbx+0F4h], eax
mov rax, [rbx+80h]
mov [rbx+0E0h], rax
xor eax, eax
jmp short loc_20B98
|
long long mthd_stmt_read_all_rows(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
unsigned long long v7; // r15
char **v8; // r14
_BYTE *v9; // r13
char *v10; // rax
char *v11; // r12
void *v12; // rsi
unsigned long long v13; // rdx
long long v14; // rcx
unsigned long long v15; // r8
int v16; // r9d
int v17; // eax
_BYTE *v18; // r13
char v19; // r14
long long v20; // r15
unsigned long long v21; // r12
long long v22; // rax
char *v23; // rcx
long long v24; // rax
unsigned long long v25; // rax
long long v26; // rcx
int v27; // esi
unsigned long long v28; // rcx
char v29; // al
long long v30; // rsi
long long v31; // rdi
char *v32; // rsi
int v34; // eax
int v35; // eax
unsigned long long v36; // [rsp+8h] [rbp-48h]
char *v37; // [rsp+10h] [rbp-40h]
unsigned __int8 *v38; // [rsp+20h] [rbp-30h] BYREF
v7 = ma_net_safe_read(*(_QWORD *)(a1 + 56), a2, a3, a4, a5, a6);
if ( v7 == 0xFFFFFFFF )
{
LABEL_33:
*(_QWORD *)(a1 + 224) = 0LL;
v30 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v30 + 144);
strncpy(a1 + 781, v30 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v31 = a1 + 268;
v32 = (char *)(*(_QWORD *)(a1 + 56) + 151LL);
LABEL_35:
strncpy(v31, v32, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1LL;
}
else
{
v8 = (char **)(a1 + 128);
while ( 1 )
{
v9 = *(_BYTE **)(*(_QWORD *)(a1 + 56) + 32LL);
if ( v7 <= 7 && *v9 == 0xFE )
break;
v10 = ma_alloc_root(a1 + 144, v7 + 24);
if ( !v10 )
{
*(_DWORD *)(a1 + 264) = 2008;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v31 = a1 + 268;
v32 = client_errors[8];
goto LABEL_35;
}
v11 = v10;
*((_QWORD *)v10 + 1) = v10 + 24;
*v8 = v10;
v12 = v9;
memcpy(*((_QWORD *)v10 + 1), v9, v7);
if ( *(_BYTE *)(a1 + 787) )
{
v37 = v11;
v36 = v7;
v17 = *(_DWORD *)(a1 + 96);
v14 = (long long)&v9[((unsigned int)(v17 + 9) >> 3) + 1];
v38 = (unsigned __int8 *)v14;
v12 = &mysql_ps_fetch_functions;
if ( v17 )
{
v18 = v9 + 1;
v19 = 4;
v20 = 0LL;
v21 = 0LL;
do
{
if ( (*v18 & (unsigned __int8)v19) == 0 )
{
v22 = *(_QWORD *)(a1 + 88);
if ( *((int *)&mysql_ps_fetch_functions + 6 * *(unsigned int *)(v22 + v20 + 112) + 2) < 0 )
{
v25 = net_field_length(&v38);
v26 = *(_QWORD *)(a1 + 88);
v13 = *(unsigned int *)(v26 + v20 + 112);
if ( v13 <= 0xC && (v27 = 7296, _bittest(&v27, v13)) )
{
v12 = &mysql_ps_fetch_functions;
v13 = *((_QWORD *)&mysql_ps_fetch_functions + 3 * v13 + 2);
*(_QWORD *)(v26 + v20 + 64) = v13;
}
else
{
v12 = &mysql_ps_fetch_functions;
if ( v25 > *(_QWORD *)(v26 + v20 + 64) )
*(_QWORD *)(v26 + v20 + 64) = v25;
}
}
else
{
v23 = (char *)&mysql_ps_fetch_functions + 24 * *(unsigned int *)(v22 + v20 + 112);
if ( (*(_BYTE *)(v22 + v20 + 100) & 0x40) != 0 )
{
v13 = *(_QWORD *)(v22 + v20 + 56);
v28 = *((_QWORD *)v23 + 2) - 1LL;
if ( v13 > v28 )
v28 = *(_QWORD *)(v22 + v20 + 56);
if ( v28 > *(_QWORD *)(v22 + v20 + 64) )
*(_QWORD *)(v22 + v20 + 64) = v28;
}
else if ( !*(_QWORD *)(v22 + v20 + 64) )
{
*(_QWORD *)(v22 + v20 + 64) = *((_QWORD *)v23 + 2);
v24 = *(_QWORD *)(a1 + 88);
if ( (*(_BYTE *)(v24 + v20 + 100) & 0x20) != 0 && (*(_DWORD *)(v24 + v20 + 112) & 0xFFFFFFFE) != 8 )
--*(_QWORD *)(v24 + v20 + 64);
}
v25 = *((int *)&mysql_ps_fetch_functions + 6 * *(unsigned int *)(*(_QWORD *)(a1 + 88) + v20 + 112) + 2);
}
v38 += v25;
}
v29 = v19;
v19 *= 2;
v14 = (v29 & 0x7F) == 0;
if ( (v29 & 0x7F) == 0 )
v19 = 1;
v18 += v14;
++v21;
v20 += 128LL;
}
while ( v21 < *(unsigned int *)(a1 + 96) );
}
v7 = v36;
v11 = v37;
}
*((_QWORD *)v11 + 2) = v7;
++*(_QWORD *)(a1 + 200);
v7 = ma_net_safe_read(*(_QWORD *)(a1 + 56), (long long)v12, v13, v14, v15, v16);
v8 = (char **)v11;
if ( v7 == 0xFFFFFFFF )
goto LABEL_33;
}
*v8 = 0LL;
v34 = *(unsigned __int16 *)(v9 + 1);
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 904LL) = v34;
*(_DWORD *)(a1 + 240) = v34;
v35 = *(unsigned __int16 *)(v9 + 3);
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 896LL) = v35;
*(_DWORD *)(a1 + 244) = v35;
*(_QWORD *)(a1 + 224) = *(_QWORD *)(a1 + 128);
return 0LL;
}
}
|
mthd_stmt_read_all_rows:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x38]
CALL 0x001179f7
MOV R15,RAX
MOV EAX,0xffffffff
CMP R15,RAX
JZ 0x00120af2
LEA R14,[RBX + 0x80]
LEA RAX,[RBX + 0x90]
MOV qword ptr [RBP + -0x38],RAX
LAB_00120909:
MOV RAX,qword ptr [RBX + 0x38]
MOV R13,qword ptr [RAX + 0x20]
CMP R15,0x7
JA 0x00120922
CMP byte ptr [R13],0xfe
JZ 0x00120ba7
LAB_00120922:
LEA RSI,[R15 + 0x18]
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0012022f
TEST RAX,RAX
JZ 0x00120b41
MOV R12,RAX
ADD RAX,0x18
MOV qword ptr [R12 + 0x8],RAX
MOV qword ptr [R14],R12
MOV RDI,qword ptr [R12 + 0x8]
MOV RSI,R13
MOV RDX,R15
CALL 0x00113390
CMP byte ptr [RBX + 0x313],0x0
JZ 0x00120ac9
MOV qword ptr [RBP + -0x40],R12
MOV qword ptr [RBP + -0x48],R15
MOV EAX,dword ptr [RBX + 0x60]
LEA ECX,[RAX + 0x9]
SHR ECX,0x3
ADD RCX,R13
INC RCX
MOV qword ptr [RBP + -0x30],RCX
TEST EAX,EAX
LEA RSI,[0x14e150]
MOV EDI,0x1
JZ 0x00120ac1
INC R13
MOV R14D,0x4
XOR R15D,R15D
XOR R12D,R12D
LAB_001209a2:
MOVZX EAX,byte ptr [R13]
TEST R14D,EAX
JNZ 0x00120a7c
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RAX + R15*0x1 + 0x70]
LEA RCX,[RCX + RCX*0x2]
CMP dword ptr [RSI + RCX*0x8 + 0x8],0x0
JS 0x00120a05
LEA RCX,[RSI + RCX*0x8]
TEST byte ptr [RAX + R15*0x1 + 0x64],0x40
JNZ 0x00120a47
CMP qword ptr [RAX + R15*0x1 + 0x40],0x0
JNZ 0x00120a66
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + R15*0x1 + 0x40],RCX
MOV RAX,qword ptr [RBX + 0x58]
TEST byte ptr [RAX + R15*0x1 + 0x64],0x20
JZ 0x00120a66
MOV ECX,dword ptr [RAX + R15*0x1 + 0x70]
AND ECX,0xfffffffe
CMP ECX,0x8
JZ 0x00120a66
DEC qword ptr [RAX + R15*0x1 + 0x40]
JMP 0x00120a66
LAB_00120a05:
LEA RDI,[RBP + -0x30]
CALL 0x00117dd5
MOV RCX,qword ptr [RBX + 0x58]
MOV EDX,dword ptr [RCX + R15*0x1 + 0x70]
CMP RDX,0xc
JA 0x00120aa7
MOV ESI,0x1c80
BT ESI,EDX
JNC 0x00120aa7
LEA RDX,[RDX + RDX*0x2]
LEA RSI,[0x14e150]
MOV RDX,qword ptr [RSI + RDX*0x8 + 0x10]
MOV qword ptr [RCX + R15*0x1 + 0x40],RDX
MOV EDI,0x1
JMP 0x00120a78
LAB_00120a47:
MOV RDX,qword ptr [RAX + R15*0x1 + 0x38]
MOV RCX,qword ptr [RCX + 0x10]
DEC RCX
CMP RDX,RCX
CMOVA RCX,RDX
CMP RCX,qword ptr [RAX + R15*0x1 + 0x40]
JBE 0x00120a66
MOV qword ptr [RAX + R15*0x1 + 0x40],RCX
LAB_00120a66:
MOV RAX,qword ptr [RBX + 0x58]
MOV EAX,dword ptr [RAX + R15*0x1 + 0x70]
LEA RAX,[RAX + RAX*0x2]
MOVSXD RAX,dword ptr [RSI + RAX*0x8 + 0x8]
LAB_00120a78:
ADD qword ptr [RBP + -0x30],RAX
LAB_00120a7c:
MOVZX EAX,R14B
LEA R14D,[RAX + RAX*0x1]
XOR ECX,ECX
TEST AL,0x7f
SETZ CL
CMOVZ R14D,EDI
ADD R13,RCX
INC R12
MOV EAX,dword ptr [RBX + 0x60]
SUB R15,-0x80
CMP R12,RAX
JC 0x001209a2
JMP 0x00120ac1
LAB_00120aa7:
CMP RAX,qword ptr [RCX + R15*0x1 + 0x40]
LEA RSI,[0x14e150]
MOV EDI,0x1
JBE 0x00120a78
MOV qword ptr [RCX + R15*0x1 + 0x40],RAX
JMP 0x00120a78
LAB_00120ac1:
MOV R15,qword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x40]
LAB_00120ac9:
MOV qword ptr [R12 + 0x10],R15
INC qword ptr [RBX + 0xc8]
MOV RDI,qword ptr [RBX + 0x38]
CALL 0x001179f7
MOV R15,RAX
MOV R14,R12
MOV EAX,0xffffffff
CMP R15,RAX
JNZ 0x00120909
LAB_00120af2:
MOV qword ptr [RBX + 0xe0],0x0
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
JMP 0x00120b82
LAB_00120b41:
MOV dword ptr [RBX + 0x108],0x7d8
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x14dc10]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x14dc20]
MOV RSI,qword ptr [RAX + 0x40]
LAB_00120b82:
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV EAX,0x1
LAB_00120b98:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00120ba7:
MOV qword ptr [R14],0x0
MOVZX EAX,word ptr [R13 + 0x1]
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x388],EAX
MOV dword ptr [RBX + 0xf0],EAX
MOVZX EAX,word ptr [R13 + 0x3]
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x380],EAX
MOV dword ptr [RBX + 0xf4],EAX
MOV RAX,qword ptr [RBX + 0x80]
MOV qword ptr [RBX + 0xe0],RAX
XOR EAX,EAX
JMP 0x00120b98
|
int8 mthd_stmt_read_all_rows(long param_1)
{
long *plVar1;
ushort uVar2;
uint uVar3;
long lVar4;
ulong uVar5;
ulong __n;
int8 *puVar6;
ulong uVar7;
ulong uVar8;
char *pcVar9;
ulong uVar10;
byte *pbVar11;
byte bVar12;
int8 *puVar13;
long lVar14;
bool bVar15;
char *local_38;
__n = ma_net_safe_read(*(int8 *)(param_1 + 0x38));
if (__n != 0xffffffff) {
puVar13 = (int8 *)(param_1 + 0x80);
do {
pcVar9 = *(char **)(*(long *)(param_1 + 0x38) + 0x20);
if ((__n < 8) && (*pcVar9 == -2)) {
*puVar13 = 0;
uVar2 = *(ushort *)(pcVar9 + 1);
*(uint *)(*(long *)(param_1 + 0x38) + 0x388) = (uint)uVar2;
*(uint *)(param_1 + 0xf0) = (uint)uVar2;
uVar2 = *(ushort *)(pcVar9 + 3);
*(uint *)(*(long *)(param_1 + 0x38) + 0x380) = (uint)uVar2;
*(uint *)(param_1 + 0xf4) = (uint)uVar2;
*(int8 *)(param_1 + 0xe0) = *(int8 *)(param_1 + 0x80);
return 0;
}
puVar6 = (int8 *)ma_alloc_root(param_1 + 0x90,__n + 0x18);
if (puVar6 == (int8 *)0x0) {
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
pcVar9 = PTR_s_Client_run_out_of_memory_0014dc60;
goto LAB_00120b82;
}
puVar6[1] = puVar6 + 3;
*puVar13 = puVar6;
memcpy((void *)puVar6[1],pcVar9,__n);
if ((*(char *)(param_1 + 0x313) != '\0') &&
(local_38 = pcVar9 + (ulong)(*(int *)(param_1 + 0x60) + 9U >> 3) + 1,
*(int *)(param_1 + 0x60) != 0)) {
pbVar11 = (byte *)(pcVar9 + 1);
bVar12 = 4;
lVar14 = 0;
uVar10 = 0;
do {
if ((bVar12 & *pbVar11) == 0) {
lVar4 = *(long *)(param_1 + 0x58);
uVar7 = (ulong)*(uint *)(lVar4 + 0x70 + lVar14);
if ((int)(&DAT_0014e158)[uVar7 * 6] < 0) {
uVar7 = net_field_length(&local_38);
lVar4 = *(long *)(param_1 + 0x58);
uVar3 = *(uint *)(lVar4 + 0x70 + lVar14);
if (((ulong)uVar3 < 0xd) && ((0x1c80U >> (uVar3 & 0x1f) & 1) != 0)) {
*(int8 *)(lVar4 + 0x40 + lVar14) = (&DAT_0014e160)[(ulong)uVar3 * 3];
}
else if (*(ulong *)(lVar4 + 0x40 + lVar14) < uVar7) {
*(ulong *)(lVar4 + 0x40 + lVar14) = uVar7;
}
}
else {
if ((*(byte *)(lVar4 + 100 + lVar14) & 0x40) == 0) {
if (*(long *)(lVar4 + 0x40 + lVar14) == 0) {
*(int8 *)(lVar4 + 0x40 + lVar14) = (&DAT_0014e160)[uVar7 * 3];
lVar4 = *(long *)(param_1 + 0x58);
if (((*(byte *)(lVar4 + 100 + lVar14) & 0x20) != 0) &&
((*(uint *)(lVar4 + 0x70 + lVar14) & 0xfffffffe) != 8)) {
plVar1 = (long *)(lVar4 + 0x40 + lVar14);
*plVar1 = *plVar1 + -1;
}
}
}
else {
uVar5 = *(ulong *)(lVar4 + 0x38 + lVar14);
uVar8 = (&DAT_0014e160)[uVar7 * 3] - 1;
if ((&DAT_0014e160)[uVar7 * 3] - 1 < uVar5) {
uVar8 = uVar5;
}
if (*(ulong *)(lVar4 + 0x40 + lVar14) < uVar8) {
*(ulong *)(lVar4 + 0x40 + lVar14) = uVar8;
}
}
uVar7 = (ulong)(int)(&DAT_0014e158)
[(ulong)*(uint *)(*(long *)(param_1 + 0x58) + 0x70 + lVar14) * 6];
}
local_38 = local_38 + uVar7;
}
bVar15 = (bVar12 & 0x7f) == 0;
bVar12 = bVar12 * '\x02';
if (bVar15) {
bVar12 = 1;
}
pbVar11 = pbVar11 + bVar15;
uVar10 = uVar10 + 1;
lVar14 = lVar14 + 0x80;
} while (uVar10 < *(uint *)(param_1 + 0x60));
}
puVar6[2] = __n;
*(long *)(param_1 + 200) = *(long *)(param_1 + 200) + 1;
__n = ma_net_safe_read(*(int8 *)(param_1 + 0x38));
puVar13 = puVar6;
} while (__n != 0xffffffff);
}
*(int8 *)(param_1 + 0xe0) = 0;
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
pcVar9 = (char *)(*(long *)(param_1 + 0x38) + 0x97);
LAB_00120b82:
strncpy((char *)(param_1 + 0x10c),pcVar9,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
|
|
9,591 |
my_like_range_win1250ch
|
eloqsql/strings/ctype-win1250ch.c
|
static my_bool
my_like_range_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length)
{
int only_min_found= 1;
const char *end = ptr + ptr_length;
char *min_org = min_str;
char *min_end = min_str + res_length;
/* return 1; */
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == escape && ptr+1 != end)
ptr++; /* Skip escape */
else if (*ptr == w_one || *ptr == w_many) /* '_' or '%' in SQL */
break;
*min_str= like_range_prefix_min_win1250ch[(uint) (uchar) (*ptr)];
if (*min_str != min_sort_char)
only_min_found= 0;
min_str++;
*max_str++= like_range_prefix_max_win1250ch[(uint) (uchar) (*ptr)];
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char;
*max_str++ = max_sort_char;
}
return (only_min_found);
}
|
O3
|
c
|
my_like_range_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r13
movq 0x10(%rbp), %r8
leaq (%r8,%r13), %r11
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %dil
orb %al, %dil
movb $0x1, %al
jne 0x5cb72
addq %rsi, %rdx
leaq -0x1(%r8), %rbx
movb $0x1, %al
leaq 0x284f95(%rip), %r12 # 0x2e1a90
leaq 0x28508e(%rip), %rdi # 0x2e1b90
movb (%rsi), %r14b
cmpb %cl, %r14b
setne %r9b
leaq 0x1(%rsi), %r15
cmpq %rdx, %r15
sete %r8b
orb %r9b, %r8b
cmpb $0x1, %r8b
jne 0x5cb2f
cmpb -0x30(%rbp), %r14b
je 0x5cb72
movq %rsi, %r15
cmpb -0x2c(%rbp), %r14b
je 0x5cb72
movzbl (%r15), %esi
cmpq $0x20, %rsi
movb (%rsi,%r12), %sil
movb %sil, (%r13)
movzbl %al, %eax
movl $0x0, %esi
cmovnel %esi, %eax
incq %r13
movzbl (%r15), %esi
movb (%rsi,%rdi), %sil
movb %sil, (%r10)
incq %r10
movq %r15, %rsi
incq %rsi
cmpq %rdx, %rsi
je 0x5cb72
leaq -0x1(%rbx), %r8
testq %rbx, %rbx
movq %r8, %rbx
jne 0x5cb02
movq %r13, %rcx
subq 0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
testb $0x10, 0xc(%rdx)
movq 0x10(%rbp), %rsi
cmoveq %rsi, %rcx
movq 0x28(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x30(%rbp), %rcx
movq %rsi, (%rcx)
cmpq %r11, %r13
je 0x5cbad
movb $0x20, (%r13)
incq %r13
movb $-0x1, (%r10)
incq %r10
jmp 0x5cb97
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_like_range_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov [rbp+var_2C], r9d
mov [rbp+var_30], r8d
mov [rbp+var_38], rdi
mov r10, [rbp+arg_10]
mov r13, [rbp+arg_8]
mov r8, [rbp+arg_0]
lea r11, [r8+r13]
test rdx, rdx
setz al
test r8, r8
setz dil
or dil, al
mov al, 1
jnz loc_5CB72
add rdx, rsi
lea rbx, [r8-1]
mov al, 1
lea r12, like_range_prefix_min_win1250ch
lea rdi, like_range_prefix_max_win1250ch
loc_5CB02:
mov r14b, [rsi]
cmp r14b, cl
setnz r9b
lea r15, [rsi+1]
cmp r15, rdx
setz r8b
or r8b, r9b
cmp r8b, 1
jnz short loc_5CB2F
cmp r14b, byte ptr [rbp+var_30]
jz short loc_5CB72
mov r15, rsi
cmp r14b, byte ptr [rbp+var_2C]
jz short loc_5CB72
loc_5CB2F:
movzx esi, byte ptr [r15]
cmp rsi, 20h ; ' '
mov sil, [rsi+r12]
mov [r13+0], sil
movzx eax, al
mov esi, 0
cmovnz eax, esi
inc r13
movzx esi, byte ptr [r15]
mov sil, [rsi+rdi]
mov [r10], sil
inc r10
mov rsi, r15
inc rsi
cmp rsi, rdx
jz short loc_5CB72
lea r8, [rbx-1]
test rbx, rbx
mov rbx, r8
jnz short loc_5CB02
loc_5CB72:
mov rcx, r13
sub rcx, [rbp+arg_8]
mov rdx, [rbp+var_38]
test byte ptr [rdx+0Ch], 10h
mov rsi, [rbp+arg_0]
cmovz rcx, rsi
mov rdx, [rbp+arg_18]
mov [rdx], rcx
mov rcx, [rbp+arg_20]
mov [rcx], rsi
loc_5CB97:
cmp r13, r11
jz short loc_5CBAD
mov byte ptr [r13+0], 20h ; ' '
inc r13
mov byte ptr [r10], 0FFh
inc r10
jmp short loc_5CB97
loc_5CBAD:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char my_like_range_win1250ch(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 a4,
char a5,
char a6,
long long a7,
long long a8,
_BYTE *a9,
long long *a10,
_QWORD *a11)
{
_BYTE *v12; // r13
char result; // al
unsigned __int8 *v14; // rdx
long long v15; // rbx
unsigned __int8 v16; // r14
unsigned __int8 *v17; // r15
long long v18; // rsi
long long v20; // rcx
v12 = (_BYTE *)a8;
result = 1;
if ( a3 != 0 && a7 != 0 )
{
v14 = &a2[a3];
v15 = a7 - 1;
result = 1;
do
{
v16 = *a2;
v17 = a2 + 1;
if ( *a2 != a4 || a2 + 1 == v14 )
{
if ( v16 == a5 )
break;
v17 = a2;
if ( v16 == a6 )
break;
}
v18 = *v17;
*v12 = like_range_prefix_min_win1250ch[v18];
if ( v18 != 32 )
result = 0;
++v12;
*a9++ = like_range_prefix_max_win1250ch[*v17];
a2 = v17 + 1;
if ( v17 + 1 == v14 )
break;
}
while ( v15-- != 0 );
}
v20 = (long long)&v12[-a8];
if ( (*(_BYTE *)(a1 + 12) & 0x10) == 0 )
v20 = a7;
*a10 = v20;
*a11 = a7;
while ( v12 != (_BYTE *)(a7 + a8) )
{
*v12++ = 32;
*a9++ = -1;
}
return result;
}
|
my_like_range_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [RBP + -0x2c],R9D
MOV dword ptr [RBP + -0x30],R8D
MOV qword ptr [RBP + -0x38],RDI
MOV R10,qword ptr [RBP + 0x20]
MOV R13,qword ptr [RBP + 0x18]
MOV R8,qword ptr [RBP + 0x10]
LEA R11,[R8 + R13*0x1]
TEST RDX,RDX
SETZ AL
TEST R8,R8
SETZ DIL
OR DIL,AL
MOV AL,0x1
JNZ 0x0015cb72
ADD RDX,RSI
LEA RBX,[R8 + -0x1]
MOV AL,0x1
LEA R12,[0x3e1a90]
LEA RDI,[0x3e1b90]
LAB_0015cb02:
MOV R14B,byte ptr [RSI]
CMP R14B,CL
SETNZ R9B
LEA R15,[RSI + 0x1]
CMP R15,RDX
SETZ R8B
OR R8B,R9B
CMP R8B,0x1
JNZ 0x0015cb2f
CMP R14B,byte ptr [RBP + -0x30]
JZ 0x0015cb72
MOV R15,RSI
CMP R14B,byte ptr [RBP + -0x2c]
JZ 0x0015cb72
LAB_0015cb2f:
MOVZX ESI,byte ptr [R15]
CMP RSI,0x20
MOV SIL,byte ptr [RSI + R12*0x1]
MOV byte ptr [R13],SIL
MOVZX EAX,AL
MOV ESI,0x0
CMOVNZ EAX,ESI
INC R13
MOVZX ESI,byte ptr [R15]
MOV SIL,byte ptr [RSI + RDI*0x1]
MOV byte ptr [R10],SIL
INC R10
MOV RSI,R15
INC RSI
CMP RSI,RDX
JZ 0x0015cb72
LEA R8,[RBX + -0x1]
TEST RBX,RBX
MOV RBX,R8
JNZ 0x0015cb02
LAB_0015cb72:
MOV RCX,R13
SUB RCX,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + -0x38]
TEST byte ptr [RDX + 0xc],0x10
MOV RSI,qword ptr [RBP + 0x10]
CMOVZ RCX,RSI
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [RDX],RCX
MOV RCX,qword ptr [RBP + 0x30]
MOV qword ptr [RCX],RSI
LAB_0015cb97:
CMP R13,R11
JZ 0x0015cbad
MOV byte ptr [R13],0x20
INC R13
MOV byte ptr [R10],0xff
INC R10
JMP 0x0015cb97
LAB_0015cbad:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
my_like_range_win1250ch
(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,int1 *param_8,int1 *param_9,long *param_10,long *param_11)
{
byte bVar1;
int8 uVar2;
byte *pbVar3;
long lVar4;
int1 *puVar5;
byte *pbVar6;
uVar2 = 1;
puVar5 = param_8;
if (param_7 != 0 && param_3 != 0) {
pbVar3 = param_2 + param_3;
uVar2 = 1;
lVar4 = param_7;
while( true ) {
lVar4 = lVar4 + -1;
bVar1 = *param_2;
pbVar6 = param_2 + 1;
if ((param_2 + 1 == pbVar3 || bVar1 != param_4) &&
((bVar1 == param_5 || (pbVar6 = param_2, bVar1 == param_6)))) break;
bVar1 = *pbVar6;
*puVar5 = like_range_prefix_min_win1250ch[bVar1];
if ((ulong)bVar1 != 0x20) {
uVar2 = 0;
}
puVar5 = puVar5 + 1;
*param_9 = like_range_prefix_max_win1250ch[*pbVar6];
param_9 = param_9 + 1;
param_2 = pbVar6 + 1;
if ((param_2 == pbVar3) || (lVar4 == 0)) break;
}
}
lVar4 = (long)puVar5 - (long)param_8;
if ((*(byte *)(param_1 + 0xc) & 0x10) == 0) {
lVar4 = param_7;
}
*param_10 = lVar4;
*param_11 = param_7;
for (; puVar5 != param_8 + param_7; puVar5 = puVar5 + 1) {
*puVar5 = 0x20;
*param_9 = 0xff;
param_9 = param_9 + 1;
}
return uVar2;
}
|
|
9,592 |
b2d
|
eloqsql/strings/dtoa.c
|
static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
}
|
O0
|
c
|
b2d:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x72610
movl %eax, -0x30(%rbp)
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0xb, -0x30(%rbp)
jge 0x727ad
movl -0x28(%rbp), %eax
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x7277c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x72783
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x72783
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x15, %ecx
shll %cl, %eax
movl -0x24(%rbp), %edx
movl $0xb, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x72869
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x727ce
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0x727d5
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x727d5
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
subl $0xb, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0x72856
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl -0x2c(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x7282b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x18(%rbp)
movl -0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x72832
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x72832
movl -0x44(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
movl -0x28(%rbp), %edx
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x72867
movl -0x28(%rbp), %eax
orl $0x3ff00000, %eax # imm = 0x3FF00000
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x72869
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
b2d:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_28], eax
mov edi, [rbp+var_28]
call hi0bits
mov [rbp+var_30], eax
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], ecx
cmp [rbp+var_30], 0Bh
jge short loc_727AD
mov eax, [rbp+var_28]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr eax, cl
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_7277C
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_3C], eax
jmp short loc_72783
loc_7277C:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_72783:
mov eax, [rbp+var_3C]
mov [rbp+var_24], eax
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
add ecx, 15h
shl eax, cl
mov edx, [rbp+var_24]
mov ecx, 0Bh
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp loc_72869
loc_727AD:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_727CE
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_40], eax
jmp short loc_727D5
loc_727CE:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_727D5:
mov eax, [rbp+var_40]
mov [rbp+var_2C], eax
mov eax, [rbp+var_30]
sub eax, 0Bh
mov [rbp+var_30], eax
cmp eax, 0
jz short loc_72856
mov eax, [rbp+var_28]
mov ecx, [rbp+var_30]
shl eax, cl
or eax, 3FF00000h
mov edx, [rbp+var_2C]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38+4], eax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe short loc_7282B
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_18], rcx
mov eax, [rax-4]
mov [rbp+var_44], eax
jmp short loc_72832
loc_7282B:
xor eax, eax
mov [rbp+var_44], eax
jmp short $+2
loc_72832:
mov eax, [rbp+var_44]
mov [rbp+var_28], eax
mov eax, [rbp+var_2C]
mov ecx, [rbp+var_30]
shl eax, cl
mov edx, [rbp+var_28]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shr edx, cl
mov ecx, edx
or eax, ecx
mov dword ptr [rbp+var_38], eax
jmp short loc_72867
loc_72856:
mov eax, [rbp+var_28]
or eax, 3FF00000h
mov dword ptr [rbp+var_38+4], eax
mov eax, [rbp+var_2C]
mov dword ptr [rbp+var_38], eax
loc_72867:
jmp short $+2
loc_72869:
movsd xmm0, [rbp+var_38]
add rsp, 50h
pop rbp
retn
|
double b2d(long long a1, _DWORD *a2)
{
int *v2; // rax
unsigned int v4; // [rsp+Ch] [rbp-44h]
unsigned int v5; // [rsp+10h] [rbp-40h]
unsigned int v6; // [rsp+14h] [rbp-3Ch]
long long v7; // [rsp+18h] [rbp-38h]
int v8; // [rsp+20h] [rbp-30h]
int v9; // [rsp+20h] [rbp-30h]
long long v10; // [rsp+24h] [rbp-2Ch]
unsigned long long v11; // [rsp+30h] [rbp-20h]
int *v12; // [rsp+38h] [rbp-18h]
v11 = *(_QWORD *)a1;
v12 = (int *)(4LL * *(int *)(a1 + 20) + *(_QWORD *)a1 - 4);
HIDWORD(v10) = *v12;
v8 = hi0bits(*v12);
*a2 = 32 - v8;
if ( v8 >= 11 )
{
if ( (unsigned long long)v12 <= v11 )
{
v5 = 0;
}
else
{
v2 = v12--;
v5 = *(v2 - 1);
}
LODWORD(v10) = v5;
v9 = v8 - 11;
if ( v9 )
{
HIDWORD(v7) = (v5 >> (32 - v9)) | (HIDWORD(v10) << v9) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v4 = 0;
else
v4 = *(v12 - 1);
LODWORD(v7) = (v4 >> (32 - v9)) | (v5 << v9);
}
else
{
v7 = v10 | 0x3FF0000000000000LL;
}
}
else
{
HIDWORD(v7) = (HIDWORD(v10) >> (11 - v8)) | 0x3FF00000;
if ( (unsigned long long)v12 <= v11 )
v6 = 0;
else
v6 = *(v12 - 1);
LODWORD(v7) = (v6 >> (11 - v8)) | (HIDWORD(v10) << (v8 + 21));
}
return *(double *)&v7;
}
|
b2d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV EDI,dword ptr [RBP + -0x28]
CALL 0x00172610
MOV dword ptr [RBP + -0x30],EAX
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x30],0xb
JGE 0x001727ad
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EAX,CL
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0017277c
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00172783
LAB_0017277c:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00172783
LAB_00172783:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
ADD ECX,0x15
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x24]
MOV ECX,0xb
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00172869
LAB_001727ad:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001727ce
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001727d5
LAB_001727ce:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001727d5
LAB_001727d5:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x30]
SUB EAX,0xb
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0x0
JZ 0x00172856
MOV EAX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
OR EAX,0x3ff00000
MOV EDX,dword ptr [RBP + -0x2c]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0017282b
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x18],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00172832
LAB_0017282b:
XOR EAX,EAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00172832
LAB_00172832:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
MOV EDX,dword ptr [RBP + -0x28]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHR EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00172867
LAB_00172856:
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,0x3ff00000
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
LAB_00172867:
JMP 0x00172869
LAB_00172869:
MOVSD XMM0,qword ptr [RBP + -0x38]
ADD RSP,0x50
POP RBP
RET
|
int8 b2d(ulong *param_1,int *param_2)
{
uint uVar1;
ulong uVar2;
char cVar3;
int iVar4;
long lVar5;
byte bVar6;
int4 local_4c;
int4 local_48;
int4 local_44;
int4 local_40;
int4 uStack_3c;
int8 local_20;
uVar2 = *param_1;
lVar5 = uVar2 + (long)*(int *)((long)param_1 + 0x14) * 4;
local_20 = lVar5 - 4;
uVar1 = *(uint *)(lVar5 + -4);
iVar4 = hi0bits(uVar1);
*param_2 = 0x20 - iVar4;
if (iVar4 < 0xb) {
cVar3 = (char)iVar4;
uStack_3c = uVar1 >> (0xbU - cVar3 & 0x1f) | 0x3ff00000;
if (uVar2 < local_20) {
local_44 = *(uint *)(lVar5 + -8);
}
else {
local_44 = 0;
}
local_40 = uVar1 << (cVar3 + 0x15U & 0x1f) | local_44 >> (0xbU - cVar3 & 0x1f);
}
else {
if (uVar2 < local_20) {
local_20 = lVar5 - 8;
local_48 = *(uint *)(lVar5 + -8);
}
else {
local_48 = 0;
}
if (iVar4 + -0xb == 0) {
uStack_3c = uVar1 | 0x3ff00000;
local_40 = local_48;
}
else {
bVar6 = (byte)(iVar4 + -0xb);
uStack_3c = uVar1 << (bVar6 & 0x1f) | 0x3ff00000 | local_48 >> (0x20 - bVar6 & 0x1f);
if (uVar2 < local_20) {
local_4c = *(uint *)(local_20 - 4);
}
else {
local_4c = 0;
}
local_40 = local_48 << (bVar6 & 0x1f) | local_4c >> (0x20 - bVar6 & 0x1f);
}
}
return CONCAT44(uStack_3c,local_40);
}
|
|
9,593 |
b2d
|
eloqsql/strings/dtoa.c
|
static double b2d(Bigint *a, int *e)
{
ULong *xa, *xa0, w, y, z;
int k;
U d;
#define d0 word0(&d)
#define d1 word1(&d)
xa0= a->p.x;
xa= xa0 + a->wds;
y= *--xa;
k= hi0bits(y);
*e= 32 - k;
if (k < Ebits)
{
d0= Exp_1 | y >> (Ebits - k);
w= xa > xa0 ? *--xa : 0;
d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
goto ret_d;
}
z= xa > xa0 ? *--xa : 0;
if (k-= Ebits)
{
d0= Exp_1 | y << k | z >> (32 - k);
y= xa > xa0 ? *--xa : 0;
d1= z << k | y >> (32 - k);
}
else
{
d0= Exp_1 | y;
d1= z;
}
ret_d:
#undef d0
#undef d1
return dval(&d);
}
|
O3
|
c
|
b2d:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movslq %esi, %rax
leaq (%rdi,%rax,4), %r13
leaq (%rdi,%rax,4), %r12
addq $-0x4, %r12
movl (%r12), %ebx
movl %ebx, %edi
callq 0x57de6
movl $0x20, %ecx
subl %eax, %ecx
movl %ecx, (%r15)
cmpl $0xa, %eax
ja 0x57eb4
movl $0xb, %edx
subl %eax, %edx
movl %ebx, %esi
movl %edx, %ecx
shrl %cl, %esi
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x57ea7
movl -0x8(%r13), %edi
leal 0x15(%rax), %ecx
shll %cl, %ebx
movl %edx, %ecx
shrl %cl, %edi
orl %ebx, %edi
jmp 0x57efb
xorl %edi, %edi
cmpq %r14, %r12
jbe 0x57ec6
movl -0x8(%r13), %edi
addq $-0x8, %r13
movq %r13, %r12
movl %eax, %edx
addl $-0xb, %edx
je 0x57ef9
movl %edx, %ecx
shll %cl, %ebx
movl $0x2b, %esi
subl %eax, %esi
movl %edi, %eax
movl %esi, %ecx
shrl %cl, %eax
xorl %r8d, %r8d
cmpq %r14, %r12
jbe 0x57eeb
movl -0x4(%r12), %r8d
movl %edx, %ecx
shll %cl, %edi
movl %esi, %ecx
shrl %cl, %r8d
orl %eax, %ebx
orl %r8d, %edi
movl %ebx, %esi
orl $0x3ff00000, %esi # imm = 0x3FF00000
shlq $0x20, %rsi
movl %edi, %eax
orq %rsi, %rax
movq %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
b2d:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r14, rdi
movsxd rax, esi
lea r13, [rdi+rax*4]
lea r12, [rdi+rax*4]
add r12, 0FFFFFFFFFFFFFFFCh
mov ebx, [r12]
mov edi, ebx
call hi0bits
mov ecx, 20h ; ' '
sub ecx, eax
mov [r15], ecx
cmp eax, 0Ah
ja short loc_57EB4
mov edx, 0Bh
sub edx, eax
mov esi, ebx
mov ecx, edx
shr esi, cl
xor edi, edi
cmp r12, r14
jbe short loc_57EA7
mov edi, [r13-8]
loc_57EA7:
lea ecx, [rax+15h]
shl ebx, cl
mov ecx, edx
shr edi, cl
or edi, ebx
jmp short loc_57EFB
loc_57EB4:
xor edi, edi
cmp r12, r14
jbe short loc_57EC6
mov edi, [r13-8]
add r13, 0FFFFFFFFFFFFFFF8h
mov r12, r13
loc_57EC6:
mov edx, eax
add edx, 0FFFFFFF5h
jz short loc_57EF9
mov ecx, edx
shl ebx, cl
mov esi, 2Bh ; '+'
sub esi, eax
mov eax, edi
mov ecx, esi
shr eax, cl
xor r8d, r8d
cmp r12, r14
jbe short loc_57EEB
mov r8d, [r12-4]
loc_57EEB:
mov ecx, edx
shl edi, cl
mov ecx, esi
shr r8d, cl
or ebx, eax
or edi, r8d
loc_57EF9:
mov esi, ebx
loc_57EFB:
or esi, 3FF00000h
shl rsi, 20h
mov eax, edi
or rax, rsi
movq xmm0, rax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
double b2d(unsigned long long a1, int a2, _DWORD *a3)
{
unsigned long long v5; // r13
unsigned long long v6; // r12
unsigned int v7; // ebx
unsigned int v8; // eax
unsigned int v9; // esi
unsigned int v10; // edi
unsigned int v11; // edi
char v12; // dl
unsigned int v13; // ebx
char v14; // si
unsigned int v15; // eax
unsigned int v16; // r8d
double result; // xmm0_8
v5 = a1 + 4LL * a2;
v6 = v5 - 4;
v7 = *(_DWORD *)(v5 - 4);
v8 = hi0bits(v7);
*a3 = 32 - v8;
if ( v8 > 0xA )
{
v11 = 0;
if ( v6 > a1 )
{
v11 = *(_DWORD *)(v5 - 8);
v6 = v5 - 8;
}
v12 = v8 - 11;
if ( v8 != 11 )
{
v13 = v7 << v12;
v14 = 43 - v8;
v15 = v11 >> (43 - v8);
v16 = 0;
if ( v6 > a1 )
v16 = *(_DWORD *)(v6 - 4);
v7 = v15 | v13;
v11 = (v16 >> v14) | (v11 << v12);
}
v9 = v7;
}
else
{
v9 = v7 >> (11 - v8);
v10 = 0;
if ( v6 > a1 )
v10 = *(_DWORD *)(v5 - 8);
v11 = (v7 << (v8 + 21)) | (v10 >> (11 - v8));
}
*(_QWORD *)&result = ((unsigned long long)(v9 | 0x3FF00000) << 32) | v11;
return result;
}
|
b2d:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R14,RDI
MOVSXD RAX,ESI
LEA R13,[RDI + RAX*0x4]
LEA R12,[RDI + RAX*0x4]
ADD R12,-0x4
MOV EBX,dword ptr [R12]
MOV EDI,EBX
CALL 0x00157de6
MOV ECX,0x20
SUB ECX,EAX
MOV dword ptr [R15],ECX
CMP EAX,0xa
JA 0x00157eb4
MOV EDX,0xb
SUB EDX,EAX
MOV ESI,EBX
MOV ECX,EDX
SHR ESI,CL
XOR EDI,EDI
CMP R12,R14
JBE 0x00157ea7
MOV EDI,dword ptr [R13 + -0x8]
LAB_00157ea7:
LEA ECX,[RAX + 0x15]
SHL EBX,CL
MOV ECX,EDX
SHR EDI,CL
OR EDI,EBX
JMP 0x00157efb
LAB_00157eb4:
XOR EDI,EDI
CMP R12,R14
JBE 0x00157ec6
MOV EDI,dword ptr [R13 + -0x8]
ADD R13,-0x8
MOV R12,R13
LAB_00157ec6:
MOV EDX,EAX
ADD EDX,-0xb
JZ 0x00157ef9
MOV ECX,EDX
SHL EBX,CL
MOV ESI,0x2b
SUB ESI,EAX
MOV EAX,EDI
MOV ECX,ESI
SHR EAX,CL
XOR R8D,R8D
CMP R12,R14
JBE 0x00157eeb
MOV R8D,dword ptr [R12 + -0x4]
LAB_00157eeb:
MOV ECX,EDX
SHL EDI,CL
MOV ECX,ESI
SHR R8D,CL
OR EBX,EAX
OR EDI,R8D
LAB_00157ef9:
MOV ESI,EBX
LAB_00157efb:
OR ESI,0x3ff00000
SHL RSI,0x20
MOV EAX,EDI
OR RAX,RSI
MOVQ XMM0,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong b2d(uint *param_1,int param_2,int *param_3)
{
char cVar1;
uint uVar2;
long lVar3;
byte bVar4;
uint uVar5;
uint uVar6;
uint *puVar7;
lVar3 = (long)param_2;
puVar7 = param_1 + lVar3 + -1;
uVar5 = *puVar7;
uVar2 = hi0bits(uVar5);
*param_3 = 0x20 - uVar2;
cVar1 = (char)uVar2;
if (uVar2 < 0xb) {
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = param_1[lVar3 + -2];
}
uVar6 = uVar2 >> (0xbU - cVar1 & 0x1f) | uVar5 << (cVar1 + 0x15U & 0x1f);
uVar5 = uVar5 >> (0xbU - cVar1 & 0x1f);
}
else {
uVar6 = 0;
if (param_1 < puVar7) {
uVar6 = param_1[lVar3 + -2];
puVar7 = param_1 + lVar3 + -2;
}
if (uVar2 - 0xb != 0) {
bVar4 = (byte)(uVar2 - 0xb);
uVar2 = 0;
if (param_1 < puVar7) {
uVar2 = puVar7[-1];
}
uVar5 = uVar5 << (bVar4 & 0x1f) | uVar6 >> (0x2bU - cVar1 & 0x1f);
uVar6 = uVar6 << (bVar4 & 0x1f) | uVar2 >> (0x2bU - cVar1 & 0x1f);
}
}
return CONCAT44(uVar5,uVar6) | 0x3ff0000000000000;
}
|
|
9,594 |
SettingValue_InputFloat::layout() const
|
untodesu[P]voxelius/game/client/settings.cc
|
void SettingValue_InputFloat::layout(void) const
{
auto current_value = value->get_value();
if(ImGui::InputFloat(wid.c_str(), ¤t_value, 0.0f, 0.0f, format.c_str())) {
value->set_value(current_value);
}
layout_label();
layout_tooltip();
}
|
O1
|
cpp
|
SettingValue_InputFloat::layout() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
movss 0x8(%rax), %xmm0
leaq 0xc(%rsp), %rsi
movss %xmm0, (%rsi)
movq 0x78(%rdi), %rdi
movq 0x98(%rbx), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %ecx, %ecx
callq 0xd9521
testb %al, %al
je 0x6851a
movq 0xb8(%rbx), %r14
movss 0xc(%rsp), %xmm0
movss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
minss %xmm0, %xmm2
cmpltss %xmm1, %xmm0
movaps %xmm0, %xmm3
andnps %xmm2, %xmm3
andps %xmm1, %xmm0
orps %xmm3, %xmm0
movss %xmm0, 0x8(%r14)
cvtss2sd %xmm0, %xmm0
movq 0x1f2a6a(%rip), %rsi # 0x25af40
leaq 0x1749e6(%rip), %rcx # 0x1dcec3
leaq 0x10(%rsp), %r15
movl $0x3a, %edx
movq %r15, %rdi
movb $0x1, %al
callq 0x331e2
addq $0x18, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x26ac0
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x6851a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x268d0
movss 0x12da3a(%rip), %xmm1 # 0x195f5c
xorps %xmm0, %xmm0
callq 0x10f0da
movq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0xcc66c
movq %rbx, %rdi
callq 0x68138
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZNK23SettingValue_InputFloat6layoutEv:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
mov rax, [rdi+0B8h]
movss xmm0, dword ptr [rax+8]
lea rsi, [rsp+48h+var_3C]; char *
movss dword ptr [rsi], xmm0
mov rdi, [rdi+78h]; this
mov rdx, [rbx+98h]; float *
xorps xmm0, xmm0; float
xorps xmm1, xmm1; float
xor ecx, ecx; char *
call _ZN5ImGui10InputFloatEPKcPfffS1_i; ImGui::InputFloat(char const*,float *,float,float,char const*,int)
test al, al
jz loc_6851A
mov r14, [rbx+0B8h]
movss xmm0, dword ptr [rsp+48h+var_3C]
movss xmm1, dword ptr [r14+0Ch]
movss xmm2, dword ptr [r14+10h]
minss xmm2, xmm0
cmpltss xmm0, xmm1
movaps xmm3, xmm0
andnps xmm3, xmm2
andps xmm0, xmm1
orps xmm0, xmm3
movss dword ptr [r14+8], xmm0
cvtss2sd xmm0, xmm0
mov rsi, cs:vsnprintf_ptr
lea rcx, aAscentFDescent+21h; "%f"
lea r15, [rsp+48h+var_38]
mov edx, 3Ah ; ':'
mov rdi, r15
mov al, 1
call _ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPKS8_P13__va_list_tagEmSB_z; __gnu_cxx::__to_xstring<std::string,char>(int (*)(char *,ulong,char const*,__va_list_tag *),ulong,char const*,...)
add r14, 18h
mov rdi, r14
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; this
lea rax, [rsp+48h+var_28]
cmp rdi, rax
jz short loc_6851A
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6851A:
movss xmm1, cs:flt_195F5C; float
xorps xmm0, xmm0; float
call _ZN5ImGui8SameLineEff; ImGui::SameLine(float,float)
mov rdi, [rbx+30h]; this
xor esi, esi; char *
call _ZN5ImGui15TextUnformattedEPKcS1_; ImGui::TextUnformatted(char const*,char const*)
mov rdi, rbx; this
call _ZNK12SettingValue14layout_tooltipEv; SettingValue::layout_tooltip(void)
add rsp, 30h
pop rbx
pop r14
pop r15
retn
|
void SettingValue_InputFloat::layout(
SettingValue_InputFloat *this,
double a2,
double a3,
double a4,
double a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
int a13)
{
ImGui *v14; // rdi
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
_DWORD *v19; // r14
__m128 v20; // xmm1
__m128 v21; // xmm2
__m128 v22; // xmm0
__m128 v23; // xmm3
__m128 v24; // xmm0
const char *v25; // rdx
char v26; // [rsp+0h] [rbp-48h]
char v27[4]; // [rsp+Ch] [rbp-3Ch] BYREF
void *v28[2]; // [rsp+10h] [rbp-38h] BYREF
long long v29; // [rsp+20h] [rbp-28h] BYREF
*(_DWORD *)v27 = *(_DWORD *)(*((_QWORD *)this + 23) + 8LL);
v14 = (ImGui *)*((_QWORD *)this + 15);
if ( (unsigned __int8)ImGui::InputFloat(v14, v27, *((float **)this + 19), 0.0, 0.0, 0LL, a13) )
{
v19 = (_DWORD *)*((_QWORD *)this + 23);
v20 = (__m128)(unsigned int)v19[3];
v21 = (__m128)(unsigned int)v19[4];
v21.m128_f32[0] = fminf(v21.m128_f32[0], *(float *)v27);
v22 = _mm_cmplt_ss((__m128)*(unsigned int *)v27, v20);
v23 = _mm_andnot_ps(v22, v21);
v24 = _mm_or_ps(_mm_and_ps(v22, v20), v23);
v19[2] = v24.m128_i32[0];
*(double *)v24.m128_u64 = v24.m128_f32[0];
__gnu_cxx::__to_xstring<std::string,char>(
v28,
(long long ( *)(_BYTE *, long long, long long, _QWORD *))&vsnprintf,
58LL,
(long long)"%f",
v15,
v16,
v24,
v20,
v21,
v23,
v17,
v18,
a8,
a9,
v26);
std::string::operator=(v19 + 6, v28, *(double *)v24.m128_u64);
v14 = (ImGui *)v28[0];
if ( v28[0] != &v29 )
operator delete(v28[0], v29 + 1);
}
ImGui::SameLine(v14, 0.0, -1.0);
ImGui::TextUnformatted(*((ImGui **)this + 6), 0LL, v25);
SettingValue::layout_tooltip((ImGui **)this, 0LL);
}
|
layout:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOVSS XMM0,dword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xc]
MOVSS dword ptr [RSI],XMM0
MOV RDI,qword ptr [RDI + 0x78]
MOV RDX,qword ptr [RBX + 0x98]
XORPS XMM0,XMM0
XORPS XMM1,XMM1
XOR ECX,ECX
CALL 0x001d9521
TEST AL,AL
JZ 0x0016851a
MOV R14,qword ptr [RBX + 0xb8]
MOVSS XMM0,dword ptr [RSP + 0xc]
MOVSS XMM1,dword ptr [R14 + 0xc]
MOVSS XMM2,dword ptr [R14 + 0x10]
MINSS XMM2,XMM0
CMPLTSS XMM0,XMM1
MOVAPS XMM3,XMM0
ANDNPS XMM3,XMM2
ANDPS XMM0,XMM1
ORPS XMM0,XMM3
MOVSS dword ptr [R14 + 0x8],XMM0
CVTSS2SD XMM0,XMM0
MOV RSI,qword ptr [0x0035af40]
LEA RCX,[0x2dcec3]
LEA R15,[RSP + 0x10]
MOV EDX,0x3a
MOV RDI,R15
MOV AL,0x1
CALL 0x001331e2
ADD R14,0x18
MOV RDI,R14
MOV RSI,R15
CALL 0x00126ac0
MOV RDI,qword ptr [R15]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x0016851a
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001268d0
LAB_0016851a:
MOVSS XMM1,dword ptr [0x00295f5c]
XORPS XMM0,XMM0
CALL 0x0020f0da
MOV RDI,qword ptr [RBX + 0x30]
XOR ESI,ESI
CALL 0x001cc66c
MOV RDI,RBX
CALL 0x00168138
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* SettingValue_InputFloat::layout() const */
void __thiscall SettingValue_InputFloat::layout(SettingValue_InputFloat *this)
{
long lVar1;
char cVar2;
uint uVar3;
float fVar4;
float local_3c;
long *local_38 [2];
long local_28 [2];
local_3c = *(float *)(*(long *)(this + 0xb8) + 8);
cVar2 = ImGui::InputFloat(*(char **)(this + 0x78),&local_3c,0.0,0.0,*(char **)(this + 0x98),0);
if (cVar2 != '\0') {
lVar1 = *(long *)(this + 0xb8);
fVar4 = *(float *)(lVar1 + 0x10);
if (local_3c <= *(float *)(lVar1 + 0x10)) {
fVar4 = local_3c;
}
uVar3 = -(uint)(local_3c < *(float *)(lVar1 + 0xc));
fVar4 = (float)(uVar3 & (uint)*(float *)(lVar1 + 0xc) | ~uVar3 & (uint)fVar4);
*(float *)(lVar1 + 8) = fVar4;
__gnu_cxx::__to_xstring<std::__cxx11::string,char>
((_func_int_char_ptr_ulong_char_ptr___va_list_tag_ptr *)local_38,
(ulong)PTR_vsnprintf_0035af40,(char *)0x3a,(double)fVar4,"%f");
std::__cxx11::string::operator=((string *)(lVar1 + 0x18),(string *)local_38);
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
}
ImGui::SameLine(0.0,DAT_00295f5c);
ImGui::TextUnformatted(*(char **)(this + 0x30),(char *)0x0);
SettingValue::layout_tooltip((SettingValue *)this);
return;
}
|
|
9,595 |
char* fmt::v8::format_int::format_signed<int>(int)
|
aimrt_mujoco_sim/_deps/spdlog_lib-src/include/spdlog/fmt/bundled/format.h
|
auto format_signed(Int value) -> char* {
auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
bool negative = value < 0;
if (negative) abs_value = 0 - abs_value;
auto begin = format_unsigned(abs_value);
if (negative) *--begin = '-';
return begin;
}
|
O0
|
c
|
char* fmt::v8::format_int::format_signed<int>(int):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
setl %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0xe9704
xorl %eax, %eax
subq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe2d20
movq %rax, 0x10(%rsp)
testb $0x1, 0x1f(%rsp)
je 0xe9734
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x2d, -0x1(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
|
_ZN3fmt2v810format_int13format_signedIlEEPcT_:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_18], rax
cmp [rsp+38h+var_10], 0
setl al
and al, 1
mov [rsp+38h+var_19], al
test [rsp+38h+var_19], 1
jz short loc_E9704
xor eax, eax
sub rax, [rsp+38h+var_18]
mov [rsp+38h+var_18], rax
loc_E9704:
mov rdi, [rsp+38h+var_30]
mov rsi, [rsp+38h+var_18]
call _ZN3fmt2v810format_int15format_unsignedImEEPcT_; fmt::v8::format_int::format_unsigned<ulong>(ulong)
mov [rsp+38h+var_28], rax
test [rsp+38h+var_19], 1
jz short loc_E9734
mov rax, [rsp+38h+var_28]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+38h+var_28], rcx
mov byte ptr [rax-1], 2Dh ; '-'
loc_E9734:
mov rax, [rsp+38h+var_28]
add rsp, 38h
retn
|
_WORD * fmt::v8::format_int::format_signed<long>(long long a1, long long a2)
{
_WORD *v2; // rax
_WORD *v4; // [rsp+10h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-18h]
v5 = a2;
if ( a2 < 0 )
v5 = -a2;
v4 = fmt::v8::format_int::format_unsigned<unsigned long>(a1, (fmt::v8::detail *)v5);
if ( a2 < 0 )
{
v2 = v4;
v4 = (_WORD *)((char *)v4 - 1);
*((_BYTE *)v2 - 1) = 45;
}
return v4;
}
|
format_signed<long>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x28],0x0
SETL AL
AND AL,0x1
MOV byte ptr [RSP + 0x1f],AL
TEST byte ptr [RSP + 0x1f],0x1
JZ 0x001e9704
XOR EAX,EAX
SUB RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x20],RAX
LAB_001e9704:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001e2d20
MOV qword ptr [RSP + 0x10],RAX
TEST byte ptr [RSP + 0x1f],0x1
JZ 0x001e9734
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x10],RCX
MOV byte ptr [RAX + -0x1],0x2d
LAB_001e9734:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x38
RET
|
/* char* fmt::v8::format_int::format_signed<long>(long) */
char * __thiscall fmt::v8::format_int::format_signed<long>(format_int *this,long param_1)
{
char *pcVar1;
char *local_28;
ulong local_18;
local_18 = param_1;
if (param_1 < 0) {
local_18 = -param_1;
}
pcVar1 = format_unsigned<unsigned_long>(this,local_18);
local_28 = pcVar1;
if (param_1 < 0) {
local_28 = pcVar1 + -1;
pcVar1[-1] = '-';
}
return local_28;
}
|
|
9,596 |
maria_rtree_find_req
|
eloqsql/storage/maria/ma_rt_index.c
|
static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint32 search_flag,
uint nod_cmp_flag, my_off_t page_pos,
int level)
{
MARIA_SHARE *share= info->s;
uint nod_flag;
int res;
uchar *page_buf, *k, *last;
int key_data_length;
uint *saved_key= (uint*) (info->maria_rtree_recursion_state) + level;
MARIA_PAGE page;
my_bool buff_alloced;
alloc_on_stack(*info->stack_end_ptr, page_buf, buff_alloced,
keyinfo->block_length);
if (!page_buf)
{
my_errno= HA_ERR_OUT_OF_MEM;
return(-1);
}
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0))
goto err;
nod_flag= page.node;
key_data_length= keyinfo->keylength - share->base.rec_reflength;
if (info->maria_rtree_recursion_depth >= level)
{
k= page_buf + *saved_key;
}
else
{
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(&page);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_data_length, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
if (!(res= maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, k,
info->last_rkey_length, nod_cmp_flag)))
{
switch ((res= maria_rtree_find_req(info, keyinfo, search_flag,
nod_cmp_flag,
_ma_kpos(nod_flag, k),
level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key= (uint) (k - page_buf);
goto ok;
case 1: /* not found - continue searching */
info->maria_rtree_recursion_depth= level;
break;
default: /* error */
case -1:
goto err;
}
}
}
else
{
/* this is a leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, info->first_mbr_key,
k, info->last_rkey_length, search_flag))
{
uchar *after_key= rt_PAGE_NEXT_KEY(share, k, key_data_length, 0);
MARIA_KEY tmp_key;
/*
We don't need to set all MARIA_KEY elements here as
_ma_row_pos_from_key() only uses a few of them.
*/
tmp_key.keyinfo= keyinfo;
tmp_key.data= k;
tmp_key.data_length= key_data_length;
info->cur_row.lastpos= _ma_row_pos_from_key(&tmp_key);
info->last_key.data_length= key_data_length;
info->last_key.ref_length= share->base.rec_reflength;
info->last_key.flag= 0;
memcpy(info->last_key.data, k,
info->last_key.data_length + info->last_key.ref_length);
info->maria_rtree_recursion_depth= level;
*saved_key= (uint) (last - page_buf);
if (after_key < last)
{
uchar *keyread_buff= info->keyread_buff;
info->int_keypos= keyread_buff;
info->int_maxpos= keyread_buff + (last - after_key);
memcpy(keyread_buff, after_key, last - after_key);
info->keyread_buff_used= 0;
}
else
{
info->keyread_buff_used= 1;
}
res= 0;
goto ok;
}
}
}
info->cur_row.lastpos= HA_OFFSET_ERROR;
my_errno= HA_ERR_KEY_NOT_FOUND;
res= 1;
ok:
stack_alloc_free(page_buf, buff_alloced);
return res;
err:
stack_alloc_free(page_buf, buff_alloced);
info->cur_row.lastpos= HA_OFFSET_ERROR;
return -1;
}
|
O3
|
c
|
maria_rtree_find_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x58(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x6e0(%rdi), %r15
movzwl 0xa6(%rsi), %esi
leaq -0xa8(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x6ae09
cmpq $0x10000, %rax # imm = 0x10000
ja 0x6adef
cmpl $0x1000, %esi # imm = 0x1000
jb 0x6ae09
cmpq $0x8001, %rax # imm = 0x8001
jb 0x6ae09
movq %r15, -0x50(%rbp)
movq %rsp, %r13
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %r13
movq %r13, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x6ae2c
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fc99
testq %rax, %rax
je 0x6ae9f
movq %rax, %r13
movq %r15, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %r13
callq 0x58de6
addq $0x10, %rsp
testb %al, %al
je 0x6ae71
cmpb $0x0, -0x34(%rbp)
jne 0x6ae64
movq %r13, %rdi
callq 0x9fec6
movq $-0x1, 0x98(%rbx)
jmp 0x6aeaa
movslq -0x58(%rbp), %rcx
movl -0x80(%rbp), %r14d
cmpl %ecx, 0x6f0(%rbx)
movq %r13, -0x48(%rbp)
movq %rcx, -0x70(%rbp)
movq %r12, -0x60(%rbp)
jge 0x6aed3
movq -0x40(%rbp), %rax
movl 0x744(%rax), %eax
addq %r13, %rax
movl %r14d, %ecx
jmp 0x6aedd
callq 0xa1a0a
movl $0x80, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6b0ad
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x50(%rbp), %rax
movl (%rax,%rcx,4), %ecx
movq %r13, %rax
movl %ecx, %r15d
addq %rax, %r15
movl -0x88(%rbp), %r12d
addq -0x98(%rbp), %r12
cmpq %r12, %r15
jae 0x6af99
movq -0x60(%rbp), %rax
movzwl 0xaa(%rax), %eax
movq -0x40(%rbp), %rcx
subl 0x3e0(%rcx), %eax
movq -0x58(%rbp), %rcx
incl %ecx
movl %ecx, -0x64(%rbp)
movslq %eax, %r13
movq -0x60(%rbp), %rax
movq 0xc0(%rax), %rdi
movq 0x398(%rbx), %rsi
movl 0x630(%rbx), %ecx
movq %r15, %rdx
movl $0x400, %r8d # imm = 0x400
callq 0x6cf14
testl %r14d, %r14d
je 0x6af7e
movl %r14d, %ecx
testl %eax, %eax
jne 0x6af8c
movl %r14d, %edi
movq %r15, %rsi
callq 0x56df7
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movl -0x64(%rbp), %ecx
callq 0x6ad7b
cmpl $0x1, %eax
jne 0x6afd0
movq -0x58(%rbp), %rax
movl %eax, 0x6f0(%rbx)
movl %r14d, %ecx
jmp 0x6af8c
testl %eax, %eax
je 0x6afef
movq -0x40(%rbp), %rax
movl 0x3e0(%rax), %ecx
addq %r13, %r15
movl %ecx, %eax
addq %rax, %r15
cmpq %r12, %r15
jb 0x6af1b
movq $-0x1, 0x98(%rbx)
callq 0xa1a0a
movl $0x78, (%rax)
movl $0x1, %ebx
movq -0x48(%rbp), %r13
movl -0x34(%rbp), %eax
testb %al, %al
jne 0x6aeaf
movq %r13, %rdi
callq 0x9fec6
jmp 0x6aeaf
testl %eax, %eax
movq -0x48(%rbp), %r13
jne 0x6ae56
subl %r13d, %r15d
movq -0x50(%rbp), %rax
movq -0x70(%rbp), %rcx
movl %r15d, (%rax,%rcx,4)
xorl %ebx, %ebx
jmp 0x6afb8
movq -0x40(%rbp), %rcx
movl 0x3e0(%rcx), %r14d
addq %r15, %r14
addq %r13, %r14
leaq -0xc8(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, 0x8(%rdi)
movq %r15, (%rdi)
movl %r13d, 0x10(%rdi)
callq 0x56f5c
movq %rax, 0x98(%rbx)
movl %r13d, 0x210(%rbx)
movq -0x40(%rbp), %rax
movl 0x3e0(%rax), %edx
movl %edx, 0x214(%rbx)
movl $0x0, 0x218(%rbx)
movq 0x200(%rbx), %rdi
addl %r13d, %edx
movq %r15, %rsi
callq 0x29080
movq -0x58(%rbp), %rax
movl %eax, 0x6f0(%rbx)
movl %r12d, %eax
subl -0x48(%rbp), %eax
movq -0x50(%rbp), %rcx
movq -0x70(%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
movb $0x1, %al
cmpq %r12, %r14
jae 0x6b0a0
movq 0x380(%rbx), %rdi
movq %rdi, 0x3b0(%rbx)
subq %r14, %r12
leaq (%rdi,%r12), %rax
movq %rax, 0x3b8(%rbx)
movq %r14, %rsi
movq %r12, %rdx
callq 0x29080
xorl %eax, %eax
movb %al, 0x685(%rbx)
xorl %ebx, %ebx
jmp 0x6afb4
callq 0x29270
|
maria_rtree_find_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov [rbp+var_58], rcx
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_40], rax
mov r15, [rdi+6E0h]
movzx esi, word ptr [rsi+0A6h]
lea rcx, [rbp+var_A8]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_6AE09
cmp rax, offset stru_10000
ja short loc_6ADEF
cmp esi, 1000h
jb short loc_6AE09
cmp rax, 8001h
jb short loc_6AE09
loc_6ADEF:
mov [rbp+var_50], r15
mov r13, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub r13, rsi
mov rsp, r13
mov al, 1
mov [rbp+var_34], eax
jmp short loc_6AE2C
loc_6AE09:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_6AE9F
mov r13, rax
mov [rbp+var_50], r15
mov [rbp+var_34], 0
loc_6AE2C:
lea rdi, [rbp+var_A8]
mov rsi, rbx
mov rdx, r12
mov rcx, r14
xor r8d, r8d
mov r9d, 3
push 0
push r13
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_6AE71
loc_6AE56:
cmp byte ptr [rbp+var_34], 0
jnz short loc_6AE64
mov rdi, r13
call my_free
loc_6AE64:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
jmp short loc_6AEAA
loc_6AE71:
movsxd rcx, dword ptr [rbp+var_58]
mov r14d, [rbp+var_80]
cmp [rbx+6F0h], ecx
mov [rbp+var_48], r13
mov [rbp+var_70], rcx
mov [rbp+var_60], r12
jge short loc_6AED3
mov rax, [rbp+var_40]
mov eax, [rax+744h]
add rax, r13
mov ecx, r14d
jmp short loc_6AEDD
loc_6AE9F:
call _my_thread_var
mov dword ptr [rax], 80h
loc_6AEAA:
mov ebx, 0FFFFFFFFh
loc_6AEAF:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6B0AD
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6AED3:
mov rax, [rbp+var_50]
mov ecx, [rax+rcx*4]
mov rax, r13
loc_6AEDD:
mov r15d, ecx
add r15, rax
mov r12d, [rbp+var_88]
add r12, [rbp+var_98]
cmp r15, r12
jnb loc_6AF99
mov rax, [rbp+var_60]
movzx eax, word ptr [rax+0AAh]
mov rcx, [rbp+var_40]
sub eax, [rcx+3E0h]
mov rcx, [rbp+var_58]
inc ecx
mov [rbp+var_64], ecx
movsxd r13, eax
loc_6AF1B:
mov rax, [rbp+var_60]
mov rdi, [rax+0C0h]
mov rsi, [rbx+398h]
mov ecx, [rbx+630h]
mov rdx, r15
mov r8d, 400h
call maria_rtree_key_cmp
test r14d, r14d
jz short loc_6AF7E
mov ecx, r14d
test eax, eax
jnz short loc_6AF8C
mov edi, r14d
mov rsi, r15
call _ma_kpos
mov rdi, rbx
mov rsi, [rbp+var_60]
mov rdx, rax
mov ecx, [rbp+var_64]
call maria_rtree_find_req
cmp eax, 1
jnz short loc_6AFD0
mov rax, [rbp+var_58]
mov [rbx+6F0h], eax
mov ecx, r14d
jmp short loc_6AF8C
loc_6AF7E:
test eax, eax
jz short loc_6AFEF
mov rax, [rbp+var_40]
mov ecx, [rax+3E0h]
loc_6AF8C:
add r15, r13
mov eax, ecx
add r15, rax
cmp r15, r12
jb short loc_6AF1B
loc_6AF99:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov ebx, 1
loc_6AFB4:
mov r13, [rbp+var_48]
loc_6AFB8:
mov eax, [rbp+var_34]
test al, al
jnz loc_6AEAF
mov rdi, r13
call my_free
jmp loc_6AEAF
loc_6AFD0:
test eax, eax
mov r13, [rbp+var_48]
jnz loc_6AE56
sub r15d, r13d
mov rax, [rbp+var_50]
mov rcx, [rbp+var_70]
mov [rax+rcx*4], r15d
xor ebx, ebx
jmp short loc_6AFB8
loc_6AFEF:
mov rcx, [rbp+var_40]
mov r14d, [rcx+3E0h]
add r14, r15
add r14, r13
lea rdi, [rbp+var_C8]
mov rax, [rbp+var_60]
mov [rdi+8], rax
mov [rdi], r15
mov [rdi+10h], r13d
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov [rbx+210h], r13d
mov rax, [rbp+var_40]
mov edx, [rax+3E0h]
mov [rbx+214h], edx
mov dword ptr [rbx+218h], 0
mov rdi, [rbx+200h]
add edx, r13d
mov rsi, r15
call _memcpy
mov rax, [rbp+var_58]
mov [rbx+6F0h], eax
mov eax, r12d
sub eax, dword ptr [rbp+var_48]
mov rcx, [rbp+var_50]
mov rdx, [rbp+var_70]
mov [rcx+rdx*4], eax
mov al, 1
cmp r14, r12
jnb short loc_6B0A0
mov rdi, [rbx+380h]
mov [rbx+3B0h], rdi
sub r12, r14
lea rax, [rdi+r12]
mov [rbx+3B8h], rax
mov rsi, r14
mov rdx, r12
call _memcpy
xor eax, eax
loc_6B0A0:
mov [rbx+685h], al
xor ebx, ebx
jmp loc_6AFB4
loc_6B0AD:
call ___stack_chk_fail
|
long long maria_rtree_find_req(long long a1, long long a2, unsigned long long a3, long long a4)
{
long long v7; // r15
const char *v8; // rsi
unsigned long long v9; // rax
bool v10; // cc
unsigned long long v11; // rax
char *v12; // r13
long long v13; // rax
_QWORD *v14; // rdi
const char *v15; // rsi
unsigned int v16; // r14d
char *v17; // rax
unsigned int v18; // ecx
unsigned int v19; // ebx
unsigned long long v21; // r15
unsigned long long v22; // r12
int v23; // eax
long long v24; // r13
int v25; // eax
unsigned int v26; // ecx
long long v27; // rax
int req; // eax
unsigned long long v29; // r14
int v30; // edx
char v31; // al
long long v32; // rdi
unsigned long long v33; // r12
long long v35[2]; // [rsp+8h] [rbp-C8h] BYREF
int v36; // [rsp+18h] [rbp-B8h]
_QWORD v37[4]; // [rsp+28h] [rbp-A8h] BYREF
unsigned int v38; // [rsp+48h] [rbp-88h]
unsigned int v39; // [rsp+50h] [rbp-80h]
long long v40; // [rsp+60h] [rbp-70h]
unsigned int v41; // [rsp+6Ch] [rbp-64h]
long long v42; // [rsp+70h] [rbp-60h]
long long v43; // [rsp+78h] [rbp-58h]
long long v44; // [rsp+80h] [rbp-50h]
char *v45; // [rsp+88h] [rbp-48h]
long long v46; // [rsp+90h] [rbp-40h]
int v47; // [rsp+9Ch] [rbp-34h]
unsigned long long v48; // [rsp+A0h] [rbp-30h]
v43 = a4;
v48 = __readfsqword(0x28u);
v46 = *(_QWORD *)a1;
v7 = *(_QWORD *)(a1 + 1760);
v8 = (const char *)*(unsigned __int16 *)(a2 + 166);
v37[0] = v8;
v9 = **(_QWORD **)(a1 + 120) - (_QWORD)v37;
v10 = v9 <= (unsigned long long)v8;
v11 = v9 - (_QWORD)v8;
if ( v10 || v11 <= (unsigned long long)&stru_10000 && ((unsigned int)v8 < 0x1000 || v11 < 0x8001) )
{
v13 = my_malloc(0LL, v8, 65552LL);
if ( !v13 )
{
*(_DWORD *)my_thread_var(0LL, v8) = 128;
return (unsigned int)-1;
}
v12 = (char *)v13;
v44 = v7;
v47 = 0;
}
else
{
v44 = v7;
v12 = (char *)&v35[-1] - (((_DWORD)v8 + 15) & 0xFFFFFFF0);
LOBYTE(v11) = 1;
v47 = v11;
}
v14 = v37;
v15 = (const char *)a1;
if ( ma_fetch_keypage((long long)v37, a1, a2, a3, 0, 3, (long long)v12) )
{
LABEL_9:
if ( !(_BYTE)v47 )
my_free(v12);
*(_QWORD *)(a1 + 152) = -1LL;
return (unsigned int)-1;
}
v16 = v39;
v10 = *(_DWORD *)(a1 + 1776) < (int)v43;
v45 = v12;
v40 = (int)v43;
v42 = a2;
if ( v10 )
{
v17 = &v12[*(unsigned int *)(v46 + 1860)];
v18 = v39;
}
else
{
v18 = *(_DWORD *)(v44 + 4LL * (int)v43);
v17 = v12;
}
v21 = (unsigned long long)&v17[v18];
v22 = v37[2] + v38;
if ( v21 < v22 )
{
v23 = *(unsigned __int16 *)(v42 + 170) - *(_DWORD *)(v46 + 992);
v41 = v43 + 1;
v24 = v23;
do
{
v14 = *(_QWORD **)(v42 + 192);
v15 = *(const char **)(a1 + 920);
v25 = maria_rtree_key_cmp(v14, v15, v21, *(unsigned int *)(a1 + 1584), 1024LL);
if ( v16 )
{
v26 = v16;
if ( !v25 )
{
v27 = ma_kpos(v16, v21);
v14 = (_QWORD *)a1;
v15 = (const char *)v42;
req = maria_rtree_find_req(a1, v42, v27, v41);
if ( req != 1 )
{
v12 = v45;
if ( req )
goto LABEL_9;
*(_DWORD *)(v44 + 4 * v40) = v21 - (_DWORD)v45;
v19 = 0;
goto LABEL_29;
}
*(_DWORD *)(a1 + 1776) = v43;
v26 = v16;
}
}
else
{
if ( !v25 )
{
v29 = v24 + v21 + *(unsigned int *)(v46 + 992);
v35[1] = v42;
v35[0] = v21;
v36 = v24;
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key(v35);
*(_DWORD *)(a1 + 528) = v24;
v30 = *(_DWORD *)(v46 + 992);
*(_DWORD *)(a1 + 532) = v30;
*(_DWORD *)(a1 + 536) = 0;
memcpy(*(_QWORD *)(a1 + 512), v21, (unsigned int)(v24 + v30));
*(_DWORD *)(a1 + 1776) = v43;
*(_DWORD *)(v44 + 4 * v40) = v22 - (_DWORD)v45;
v31 = 1;
if ( v29 < v22 )
{
v32 = *(_QWORD *)(a1 + 896);
*(_QWORD *)(a1 + 944) = v32;
v33 = v22 - v29;
*(_QWORD *)(a1 + 952) = v32 + v33;
memcpy(v32, v29, v33);
v31 = 0;
}
*(_BYTE *)(a1 + 1669) = v31;
v19 = 0;
goto LABEL_28;
}
v26 = *(_DWORD *)(v46 + 992);
}
v21 += v26 + v24;
}
while ( v21 < v22 );
}
*(_QWORD *)(a1 + 152) = -1LL;
*(_DWORD *)my_thread_var(v14, v15) = 120;
v19 = 1;
LABEL_28:
v12 = v45;
LABEL_29:
if ( !(_BYTE)v47 )
my_free(v12);
return v19;
}
|
maria_rtree_find_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0x58],RCX
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x40],RAX
MOV R15,qword ptr [RDI + 0x6e0]
MOVZX ESI,word ptr [RSI + 0xa6]
LEA RCX,[RBP + -0xa8]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x0016ae09
CMP RAX,0x10000
JA 0x0016adef
CMP ESI,0x1000
JC 0x0016ae09
CMP RAX,0x8001
JC 0x0016ae09
LAB_0016adef:
MOV qword ptr [RBP + -0x50],R15
MOV R13,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB R13,RSI
MOV RSP,R13
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016ae2c
LAB_0016ae09:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fc99
TEST RAX,RAX
JZ 0x0016ae9f
MOV R13,RAX
MOV qword ptr [RBP + -0x50],R15
MOV dword ptr [RBP + -0x34],0x0
LAB_0016ae2c:
LEA RDI,[RBP + -0xa8]
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R14
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH R13
CALL 0x00158de6
ADD RSP,0x10
TEST AL,AL
JZ 0x0016ae71
LAB_0016ae56:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x0016ae64
MOV RDI,R13
CALL 0x0019fec6
LAB_0016ae64:
MOV qword ptr [RBX + 0x98],-0x1
JMP 0x0016aeaa
LAB_0016ae71:
MOVSXD RCX,dword ptr [RBP + -0x58]
MOV R14D,dword ptr [RBP + -0x80]
CMP dword ptr [RBX + 0x6f0],ECX
MOV qword ptr [RBP + -0x48],R13
MOV qword ptr [RBP + -0x70],RCX
MOV qword ptr [RBP + -0x60],R12
JGE 0x0016aed3
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x744]
ADD RAX,R13
MOV ECX,R14D
JMP 0x0016aedd
LAB_0016ae9f:
CALL 0x001a1a0a
MOV dword ptr [RAX],0x80
LAB_0016aeaa:
MOV EBX,0xffffffff
LAB_0016aeaf:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016b0ad
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016aed3:
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,R13
LAB_0016aedd:
MOV R15D,ECX
ADD R15,RAX
MOV R12D,dword ptr [RBP + -0x88]
ADD R12,qword ptr [RBP + -0x98]
CMP R15,R12
JNC 0x0016af99
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,word ptr [RAX + 0xaa]
MOV RCX,qword ptr [RBP + -0x40]
SUB EAX,dword ptr [RCX + 0x3e0]
MOV RCX,qword ptr [RBP + -0x58]
INC ECX
MOV dword ptr [RBP + -0x64],ECX
MOVSXD R13,EAX
LAB_0016af1b:
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RSI,qword ptr [RBX + 0x398]
MOV ECX,dword ptr [RBX + 0x630]
MOV RDX,R15
MOV R8D,0x400
CALL 0x0016cf14
TEST R14D,R14D
JZ 0x0016af7e
MOV ECX,R14D
TEST EAX,EAX
JNZ 0x0016af8c
MOV EDI,R14D
MOV RSI,R15
CALL 0x00156df7
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,RAX
MOV ECX,dword ptr [RBP + -0x64]
CALL 0x0016ad7b
CMP EAX,0x1
JNZ 0x0016afd0
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBX + 0x6f0],EAX
MOV ECX,R14D
JMP 0x0016af8c
LAB_0016af7e:
TEST EAX,EAX
JZ 0x0016afef
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX + 0x3e0]
LAB_0016af8c:
ADD R15,R13
MOV EAX,ECX
ADD R15,RAX
CMP R15,R12
JC 0x0016af1b
LAB_0016af99:
MOV qword ptr [RBX + 0x98],-0x1
CALL 0x001a1a0a
MOV dword ptr [RAX],0x78
MOV EBX,0x1
LAB_0016afb4:
MOV R13,qword ptr [RBP + -0x48]
LAB_0016afb8:
MOV EAX,dword ptr [RBP + -0x34]
TEST AL,AL
JNZ 0x0016aeaf
MOV RDI,R13
CALL 0x0019fec6
JMP 0x0016aeaf
LAB_0016afd0:
TEST EAX,EAX
MOV R13,qword ptr [RBP + -0x48]
JNZ 0x0016ae56
SUB R15D,R13D
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x70]
MOV dword ptr [RAX + RCX*0x4],R15D
XOR EBX,EBX
JMP 0x0016afb8
LAB_0016afef:
MOV RCX,qword ptr [RBP + -0x40]
MOV R14D,dword ptr [RCX + 0x3e0]
ADD R14,R15
ADD R14,R13
LEA RDI,[RBP + -0xc8]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RDI + 0x8],RAX
MOV qword ptr [RDI],R15
MOV dword ptr [RDI + 0x10],R13D
CALL 0x00156f5c
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0x210],R13D
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RAX + 0x3e0]
MOV dword ptr [RBX + 0x214],EDX
MOV dword ptr [RBX + 0x218],0x0
MOV RDI,qword ptr [RBX + 0x200]
ADD EDX,R13D
MOV RSI,R15
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBX + 0x6f0],EAX
MOV EAX,R12D
SUB EAX,dword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x70]
MOV dword ptr [RCX + RDX*0x4],EAX
MOV AL,0x1
CMP R14,R12
JNC 0x0016b0a0
MOV RDI,qword ptr [RBX + 0x380]
MOV qword ptr [RBX + 0x3b0],RDI
SUB R12,R14
LEA RAX,[RDI + R12*0x1]
MOV qword ptr [RBX + 0x3b8],RAX
MOV RSI,R14
MOV RDX,R12
CALL 0x00129080
XOR EAX,EAX
LAB_0016b0a0:
MOV byte ptr [RBX + 0x685],AL
XOR EBX,EBX
JMP 0x0016afb4
LAB_0016b0ad:
CALL 0x00129270
|
int8 maria_rtree_find_req(long *param_1,long param_2,int8 param_3,int8 param_4)
{
ushort uVar1;
uint uVar2;
void *pvVar3;
long lVar4;
char cVar5;
int iVar6;
int iVar7;
ulong uVar8;
int4 *puVar9;
long lVar10;
int8 uVar11;
int1 *puVar12;
int1 *puVar13;
int1 *puVar14;
int1 *puVar15;
long in_FS_OFFSET;
int1 auStack_d8 [8];
int1 *local_d0;
long local_c8;
int local_c0;
ulong local_b0 [2];
long local_a0;
uint local_90;
uint local_88;
long local_78;
int local_6c;
long local_68;
int8 local_60;
long local_58;
int1 *local_50;
long local_48;
int4 local_3c;
long local_38;
puVar12 = auStack_d8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = *param_1;
lVar10 = param_1[0xdc];
uVar1 = *(ushort *)(param_2 + 0xa6);
local_b0[0] = (ulong)uVar1;
uVar8 = (*(long *)param_1[0xf] - (long)local_b0) - local_b0[0];
local_60 = param_4;
if (((ulong)(*(long *)param_1[0xf] - (long)local_b0) < local_b0[0] || uVar8 == 0) ||
((uVar8 < 0x10001 && ((uVar1 < 0x1000 || (uVar8 < 0x8001)))))) {
puVar14 = (int1 *)my_malloc(0,local_b0[0],0x10010);
if (puVar14 != (int1 *)0x0) {
local_3c = 0;
puVar12 = auStack_d8;
goto LAB_0016ae2c;
}
puVar9 = (int4 *)_my_thread_var();
*puVar9 = 0x80;
}
else {
puVar14 = auStack_d8 + -(ulong)(uVar1 + 0xf & 0xfffffff0);
local_3c = (int4)CONCAT71((int7)(uVar8 >> 8),1);
puVar12 = puVar14;
LAB_0016ae2c:
local_58 = lVar10;
*(int8 *)(puVar12 + -8) = 0;
*(int1 **)(puVar12 + -0x10) = puVar14;
*(int8 *)(puVar12 + -0x18) = 0x16ae4e;
cVar5 = _ma_fetch_keypage(local_b0,param_1,param_2,param_3,0,3);
if (cVar5 == '\0') {
local_78 = (long)(int)local_60;
if ((int)param_1[0xde] < (int)local_60) {
puVar15 = puVar14 + *(uint *)(local_48 + 0x744);
uVar2 = local_88;
}
else {
uVar2 = *(uint *)(local_58 + local_78 * 4);
puVar15 = puVar14;
}
puVar15 = puVar15 + uVar2;
puVar13 = (int1 *)((ulong)local_90 + local_a0);
local_68 = param_2;
local_50 = puVar14;
if (puVar15 < puVar13) {
iVar6 = (uint)*(ushort *)(param_2 + 0xaa) - *(int *)(local_48 + 0x3e0);
local_6c = (int)local_60 + 1;
do {
uVar11 = *(int8 *)(local_68 + 0xc0);
lVar10 = param_1[0x73];
lVar4 = param_1[0xc6];
*(int8 *)(puVar12 + -8) = 0x16af41;
iVar7 = maria_rtree_key_cmp(uVar11,lVar10,puVar15,(int)lVar4,0x400);
if (local_88 == 0) {
if (iVar7 == 0) {
puVar14 = puVar15 + (long)iVar6 + (ulong)*(uint *)(local_48 + 0x3e0);
local_c8 = local_68;
local_d0 = puVar15;
local_c0 = iVar6;
*(int8 *)(puVar12 + -8) = 0x16b01b;
lVar10 = _ma_row_pos_from_key();
param_1[0x13] = lVar10;
*(int *)(param_1 + 0x42) = iVar6;
iVar7 = *(int *)(local_48 + 0x3e0);
*(int *)((long)param_1 + 0x214) = iVar7;
*(int4 *)(param_1 + 0x43) = 0;
pvVar3 = (void *)param_1[0x40];
*(int8 *)(puVar12 + -8) = 0x16b055;
memcpy(pvVar3,puVar15,(ulong)(uint)(iVar7 + iVar6));
*(int *)(param_1 + 0xde) = (int)local_60;
*(int *)(local_58 + local_78 * 4) = (int)puVar13 - (int)local_50;
if (puVar13 > puVar14) {
pvVar3 = (void *)param_1[0x70];
param_1[0x76] = (long)pvVar3;
param_1[0x77] = (long)pvVar3 + ((long)puVar13 - (long)puVar14);
*(int8 *)(puVar12 + -8) = 0x16b09e;
memcpy(pvVar3,puVar14,(long)puVar13 - (long)puVar14);
}
*(bool *)((long)param_1 + 0x685) = puVar13 <= puVar14;
uVar11 = 0;
goto LAB_0016afb8;
}
uVar8 = (ulong)*(uint *)(local_48 + 0x3e0);
}
else {
uVar8 = (ulong)local_88;
if (iVar7 == 0) {
*(int8 *)(puVar12 + -8) = 0x16af58;
uVar11 = _ma_kpos(local_88,puVar15);
lVar10 = local_68;
iVar7 = local_6c;
*(int8 *)(puVar12 + -8) = 0x16af6a;
iVar7 = maria_rtree_find_req(param_1,lVar10,uVar11,iVar7);
if (iVar7 != 1) {
puVar14 = local_50;
if (iVar7 != 0) goto LAB_0016ae56;
*(int *)(local_58 + local_78 * 4) = (int)puVar15 - (int)local_50;
uVar11 = 0;
goto LAB_0016afb8;
}
*(int *)(param_1 + 0xde) = (int)local_60;
uVar8 = (ulong)local_88;
}
}
puVar15 = puVar15 + uVar8 + (long)iVar6;
} while (puVar15 < puVar13);
}
param_1[0x13] = -1;
*(int8 *)(puVar12 + -8) = 0x16afa9;
puVar9 = (int4 *)_my_thread_var();
*puVar9 = 0x78;
uVar11 = 1;
LAB_0016afb8:
puVar14 = local_50;
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x16afcb;
my_free(puVar14);
}
goto LAB_0016aeaf;
}
LAB_0016ae56:
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x16ae64;
my_free(puVar14);
}
param_1[0x13] = -1;
}
uVar11 = 0xffffffff;
LAB_0016aeaf:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)(puVar12 + -8) = maria_rtree_find_next;
__stack_chk_fail();
}
return uVar11;
}
|
|
9,597 |
rpl_slave_state::truncate_hash()
|
eloqsql/sql/rpl_gtid.cc
|
void
rpl_slave_state::truncate_hash()
{
uint32 i;
for (i= 0; i < hash.records; ++i)
{
element *e= (element *)my_hash_element(&hash, i);
list_element *l= e->list;
list_element *next;
while (l)
{
next= l->next;
my_free(l);
l= next;
}
/* The element itself is freed by the hash element free function. */
}
my_hash_reset(&hash);
}
|
O0
|
cpp
|
rpl_slave_state::truncate_hash():
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpq 0x18(%rcx), %rax
jae 0xad6207
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x12ab070
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xad61fa
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12c7520
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xad61d5
jmp 0xad61fc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xad61ab
movq -0x30(%rbp), %rdi
callq 0x12a9e50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN15rpl_slave_state13truncate_hashEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov [rbp+var_C], 0
loc_AD61AB:
mov rcx, [rbp+var_30]
mov eax, [rbp+var_C]
cmp rax, [rcx+18h]
jnb short loc_AD6207
mov rdi, [rbp+var_30]
mov eax, [rbp+var_C]
mov esi, eax
call my_hash_element
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_20], rax
loc_AD61D5:
cmp [rbp+var_20], 0
jz short loc_AD61FA
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call my_free
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
jmp short loc_AD61D5
loc_AD61FA:
jmp short $+2
loc_AD61FC:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_AD61AB
loc_AD6207:
mov rdi, [rbp+var_30]
call my_hash_reset
add rsp, 30h
pop rbp
retn
|
long long rpl_slave_state::truncate_hash(rpl_slave_state *this)
{
_QWORD *v2; // [rsp+8h] [rbp-28h]
_QWORD *j; // [rsp+10h] [rbp-20h]
unsigned int i; // [rsp+24h] [rbp-Ch]
for ( i = 0; (unsigned long long)i < *((_QWORD *)this + 3); ++i )
{
for ( j = *(_QWORD **)my_hash_element(this, i); j; j = v2 )
{
v2 = (_QWORD *)*j;
my_free(j);
}
}
return my_hash_reset(this);
}
|
List:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x008dd990
ADD RSP,0x10
POP RBP
RET
|
/* List<partition_element>::List() */
void __thiscall List<partition_element>::List(List<partition_element> *this)
{
base_list::base_list((base_list *)this);
return;
}
|
|
9,598 |
mi_cmp_buffer
|
eloqsql/storage/myisam/mi_dynrec.c
|
static int _mi_cmp_buffer(File file, const uchar *buff, my_off_t filepos,
uint length)
{
uint next_length;
uchar temp_buff[IO_SIZE*2];
DBUG_ENTER("_mi_cmp_buffer");
next_length= IO_SIZE*2 - (uint) (filepos & (IO_SIZE-1));
while (length > IO_SIZE*2)
{
if (mysql_file_pread(file, temp_buff, next_length, filepos, MYF(MY_NABP)) ||
memcmp(buff, temp_buff, next_length))
goto err;
filepos+=next_length;
buff+=next_length;
length-= next_length;
next_length=IO_SIZE*2;
}
if (mysql_file_pread(file, temp_buff, length, filepos, MYF(MY_NABP)))
goto err;
DBUG_RETURN(memcmp(buff,temp_buff,length));
err:
DBUG_RETURN(1);
}
|
O0
|
c
|
mi_cmp_buffer:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp # imm = 0x2040
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x2018(%rbp)
movq %rsi, -0x2020(%rbp)
movq %rdx, -0x2028(%rbp)
movl %ecx, -0x202c(%rbp)
movq -0x2028(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movl %eax, %ecx
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movl %eax, -0x2030(%rbp)
cmpl $0x2000, -0x202c(%rbp) # imm = 0x2000
jbe 0xade6f
movl -0x2018(%rbp), %edx
leaq -0x2010(%rbp), %rcx
movl -0x2030(%rbp), %eax
movl %eax, %r8d
movq -0x2028(%rbp), %r9
leaq 0xaf30c(%rip), %rdi # 0x15d0ee
movl $0x67e, %esi # imm = 0x67E
movq $0x4, (%rsp)
callq 0xa9380
cmpq $0x0, %rax
jne 0xade1a
movq -0x2020(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl -0x2030(%rbp), %eax
movl %eax, %edx
callq 0x2a8c0
cmpl $0x0, %eax
je 0xade1f
jmp 0xaded2
movl -0x2030(%rbp), %eax
addq -0x2028(%rbp), %rax
movq %rax, -0x2028(%rbp)
movl -0x2030(%rbp), %ecx
movq -0x2020(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x2020(%rbp)
movl -0x2030(%rbp), %ecx
movl -0x202c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x202c(%rbp)
movl $0x2000, -0x2030(%rbp) # imm = 0x2000
jmp 0xaddae
movl -0x2018(%rbp), %edx
leaq -0x2010(%rbp), %rcx
movl -0x202c(%rbp), %eax
movl %eax, %r8d
movq -0x2028(%rbp), %r9
leaq 0xaf25b(%rip), %rdi # 0x15d0ee
movl $0x686, %esi # imm = 0x686
movq $0x4, (%rsp)
callq 0xa9380
cmpq $0x0, %rax
je 0xadead
jmp 0xaded2
jmp 0xadeaf
movq -0x2020(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movl -0x202c(%rbp), %eax
movl %eax, %edx
callq 0x2a8c0
movl %eax, -0x2014(%rbp)
jmp 0xadede
jmp 0xaded4
movl $0x1, -0x2014(%rbp)
movl -0x2014(%rbp), %eax
movl %eax, -0x2034(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xadf0b
movl -0x2034(%rbp), %eax
addq $0x2040, %rsp # imm = 0x2040
popq %rbp
retq
callq 0x2a270
|
_mi_cmp_buffer:
push rbp
mov rbp, rsp
sub rsp, 2040h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2018], edi
mov [rbp+var_2020], rsi
mov [rbp+var_2028], rdx
mov [rbp+var_202C], ecx
mov rax, [rbp+var_2028]
and rax, 0FFFh
mov ecx, eax
mov eax, 2000h
sub eax, ecx
mov [rbp+var_2030], eax
loc_ADDAE:
cmp [rbp+var_202C], 2000h
jbe loc_ADE6F
mov edx, [rbp+var_2018]
lea rcx, [rbp+var_2010]
mov eax, [rbp+var_2030]
mov r8d, eax
mov r9, [rbp+var_2028]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 67Eh
mov [rsp+2040h+var_2040], 4
call inline_mysql_file_pread_6
cmp rax, 0
jnz short loc_ADE1A
mov rdi, [rbp+var_2020]
lea rsi, [rbp+var_2010]
mov eax, [rbp+var_2030]
mov edx, eax
call _memcmp
cmp eax, 0
jz short loc_ADE1F
loc_ADE1A:
jmp loc_ADED2
loc_ADE1F:
mov eax, [rbp+var_2030]
add rax, [rbp+var_2028]
mov [rbp+var_2028], rax
mov ecx, [rbp+var_2030]
mov rax, [rbp+var_2020]
mov ecx, ecx
add rax, rcx
mov [rbp+var_2020], rax
mov ecx, [rbp+var_2030]
mov eax, [rbp+var_202C]
sub eax, ecx
mov [rbp+var_202C], eax
mov [rbp+var_2030], 2000h
jmp loc_ADDAE
loc_ADE6F:
mov edx, [rbp+var_2018]
lea rcx, [rbp+var_2010]
mov eax, [rbp+var_202C]
mov r8d, eax
mov r9, [rbp+var_2028]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 686h
mov [rsp+2040h+var_2040], 4
call inline_mysql_file_pread_6
cmp rax, 0
jz short loc_ADEAD
jmp short loc_ADED2
loc_ADEAD:
jmp short $+2
loc_ADEAF:
mov rdi, [rbp+var_2020]
lea rsi, [rbp+var_2010]
mov eax, [rbp+var_202C]
mov edx, eax
call _memcmp
mov [rbp+var_2014], eax
jmp short loc_ADEDE
loc_ADED2:
jmp short $+2
loc_ADED4:
mov [rbp+var_2014], 1
loc_ADEDE:
mov eax, [rbp+var_2014]
mov [rbp+var_2034], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_ADF0B
mov eax, [rbp+var_2034]
add rsp, 2040h
pop rbp
retn
loc_ADF0B:
call ___stack_chk_fail
|
long long mi_cmp_buffer(unsigned int a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v5; // [rsp+10h] [rbp-2030h]
long long v7; // [rsp+18h] [rbp-2028h]
_BYTE v10[8200]; // [rsp+30h] [rbp-2010h] BYREF
unsigned long long v11; // [rsp+2038h] [rbp-8h]
v11 = __readfsqword(0x28u);
v7 = a3;
v5 = 0x2000 - (a3 & 0xFFF);
while ( a4 > 0x2000 )
{
if ( inline_mysql_file_pread_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0x67Eu,
a1,
(long long)v10,
v5,
v7,
4LL)
|| (unsigned int)memcmp(a2, v10, v5) )
{
return 1;
}
v7 += v5;
a2 += v5;
a4 -= v5;
v5 = 0x2000;
}
if ( !inline_mysql_file_pread_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0x686u,
a1,
(long long)v10,
a4,
v7,
4LL) )
return (unsigned int)memcmp(a2, v10, a4);
return 1;
}
|
_mi_cmp_buffer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2040
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x2018],EDI
MOV qword ptr [RBP + -0x2020],RSI
MOV qword ptr [RBP + -0x2028],RDX
MOV dword ptr [RBP + -0x202c],ECX
MOV RAX,qword ptr [RBP + -0x2028]
AND RAX,0xfff
MOV ECX,EAX
MOV EAX,0x2000
SUB EAX,ECX
MOV dword ptr [RBP + -0x2030],EAX
LAB_001addae:
CMP dword ptr [RBP + -0x202c],0x2000
JBE 0x001ade6f
MOV EDX,dword ptr [RBP + -0x2018]
LEA RCX,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x2030]
MOV R8D,EAX
MOV R9,qword ptr [RBP + -0x2028]
LEA RDI,[0x25d0ee]
MOV ESI,0x67e
MOV qword ptr [RSP],0x4
CALL 0x001a9380
CMP RAX,0x0
JNZ 0x001ade1a
MOV RDI,qword ptr [RBP + -0x2020]
LEA RSI,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x2030]
MOV EDX,EAX
CALL 0x0012a8c0
CMP EAX,0x0
JZ 0x001ade1f
LAB_001ade1a:
JMP 0x001aded2
LAB_001ade1f:
MOV EAX,dword ptr [RBP + -0x2030]
ADD RAX,qword ptr [RBP + -0x2028]
MOV qword ptr [RBP + -0x2028],RAX
MOV ECX,dword ptr [RBP + -0x2030]
MOV RAX,qword ptr [RBP + -0x2020]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x2020],RAX
MOV ECX,dword ptr [RBP + -0x2030]
MOV EAX,dword ptr [RBP + -0x202c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x202c],EAX
MOV dword ptr [RBP + -0x2030],0x2000
JMP 0x001addae
LAB_001ade6f:
MOV EDX,dword ptr [RBP + -0x2018]
LEA RCX,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x202c]
MOV R8D,EAX
MOV R9,qword ptr [RBP + -0x2028]
LEA RDI,[0x25d0ee]
MOV ESI,0x686
MOV qword ptr [RSP],0x4
CALL 0x001a9380
CMP RAX,0x0
JZ 0x001adead
JMP 0x001aded2
LAB_001adead:
JMP 0x001adeaf
LAB_001adeaf:
MOV RDI,qword ptr [RBP + -0x2020]
LEA RSI,[RBP + -0x2010]
MOV EAX,dword ptr [RBP + -0x202c]
MOV EDX,EAX
CALL 0x0012a8c0
MOV dword ptr [RBP + -0x2014],EAX
JMP 0x001adede
LAB_001aded2:
JMP 0x001aded4
LAB_001aded4:
MOV dword ptr [RBP + -0x2014],0x1
LAB_001adede:
MOV EAX,dword ptr [RBP + -0x2014]
MOV dword ptr [RBP + -0x2034],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001adf0b
MOV EAX,dword ptr [RBP + -0x2034]
ADD RSP,0x2040
POP RBP
RET
LAB_001adf0b:
CALL 0x0012a270
|
int _mi_cmp_buffer(int4 param_1,void *param_2,long param_3,uint param_4)
{
int iVar1;
long lVar2;
long in_FS_OFFSET;
uint local_2038;
uint local_2034;
long local_2030;
void *local_2028;
int local_201c;
int1 local_2018 [8200];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2038 = 0x2000 - ((uint)param_3 & 0xfff);
local_2034 = param_4;
local_2030 = param_3;
local_2028 = param_2;
while (0x2000 < local_2034) {
lVar2 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0x67e,
param_1,local_2018,local_2038,local_2030,4);
if ((lVar2 != 0) || (iVar1 = memcmp(local_2028,local_2018,(ulong)local_2038), iVar1 != 0))
goto LAB_001aded2;
local_2030 = (ulong)local_2038 + local_2030;
local_2028 = (void *)((long)local_2028 + (ulong)local_2038);
local_2034 = local_2034 - local_2038;
local_2038 = 0x2000;
}
lVar2 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0x686,
param_1,local_2018,local_2034,local_2030,4);
if (lVar2 == 0) {
local_201c = memcmp(local_2028,local_2018,(ulong)local_2034);
}
else {
LAB_001aded2:
local_201c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_201c;
}
|
|
9,599 |
cmp
|
eloqsql/strings/dtoa.c
|
static int cmp(Bigint *a, Bigint *b)
{
ULong *xa, *xa0, *xb, *xb0;
int i, j;
i= a->wds;
j= b->wds;
if (i-= j)
return i;
xa0= a->p.x;
xa= xa0 + j;
xb0= b->p.x;
xb= xb0 + j;
for (;;)
{
if (*--xa != *--xb)
return *xa < *xb ? -1 : 1;
if (xa <= xa0)
break;
}
return 0;
}
|
O0
|
c
|
cmp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x7b84b
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b8e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x20(%rbp)
movl -0x4(%rax), %eax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
cmpl -0x4(%rcx), %eax
je 0x7b8cd
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7b8e2
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x7b8d9
jmp 0x7b8db
jmp 0x7b887
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
cmp:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_40], eax
mov ecx, [rbp+var_40]
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_7B84B
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
jmp loc_7B8E2
loc_7B84B:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_40]
shl rcx, 2
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movsxd rcx, [rbp+var_40]
shl rcx, 2
add rax, rcx
mov [rbp+var_30], rax
loc_7B887:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rcx
mov eax, [rax-4]
mov rcx, [rbp+var_30]
mov rdx, rcx
add rdx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_30], rdx
cmp eax, [rcx-4]
jz short loc_7B8CD
mov rax, [rbp+var_20]
mov edx, [rax]
mov rax, [rbp+var_30]
mov esi, [rax]
mov eax, 1
mov ecx, 0FFFFFFFFh
cmp edx, esi
cmovb eax, ecx
mov [rbp+var_4], eax
jmp short loc_7B8E2
loc_7B8CD:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
ja short loc_7B8D9
jmp short loc_7B8DB
loc_7B8D9:
jmp short loc_7B887
loc_7B8DB:
mov [rbp+var_4], 0
loc_7B8E2:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long cmp(long long a1, long long a2)
{
_DWORD *v2; // rax
_DWORD *v3; // rcx
unsigned int v4; // eax
int v6; // [rsp+0h] [rbp-40h]
_DWORD *v7; // [rsp+10h] [rbp-30h]
_DWORD *v8; // [rsp+20h] [rbp-20h]
v6 = *(_DWORD *)(a2 + 20);
if ( *(_DWORD *)(a1 + 20) == v6 )
{
v8 = (_DWORD *)(4LL * v6 + *(_QWORD *)a1);
v7 = (_DWORD *)(4LL * v6 + *(_QWORD *)a2);
while ( 1 )
{
v2 = v8--;
v3 = v7--;
if ( *(v2 - 1) != *(v3 - 1) )
break;
if ( (unsigned long long)v8 <= *(_QWORD *)a1 )
return 0;
}
v4 = 1;
if ( *v8 < *v7 )
return (unsigned int)-1;
return v4;
}
else
{
return (unsigned int)(*(_DWORD *)(a1 + 20) - v6);
}
}
|
cmp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x40],EAX
MOV ECX,dword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x0017b84b
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017b8e2
LAB_0017b84b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x40]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RCX,dword ptr [RBP + -0x40]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_0017b887:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x4
MOV qword ptr [RBP + -0x20],RCX
MOV EAX,dword ptr [RAX + -0x4]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,RCX
ADD RDX,-0x4
MOV qword ptr [RBP + -0x30],RDX
CMP EAX,dword ptr [RCX + -0x4]
JZ 0x0017b8cd
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RAX]
MOV EAX,0x1
MOV ECX,0xffffffff
CMP EDX,ESI
CMOVC EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017b8e2
LAB_0017b8cd:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x0017b8d9
JMP 0x0017b8db
LAB_0017b8d9:
JMP 0x0017b887
LAB_0017b8db:
MOV dword ptr [RBP + -0x4],0x0
LAB_0017b8e2:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int cmp(void *param_1,void *param_2)
{
int iVar1;
uint *puVar2;
uint *local_38;
uint *local_28;
int local_c;
iVar1 = *(int *)((long)param_2 + 0x14);
local_c = *(int *)((long)param_1 + 0x14) - iVar1;
if (local_c == 0) {
/* WARNING: Load size is inaccurate */
/* WARNING: Load size is inaccurate */
local_38 = (uint *)(*param_2 + (long)iVar1 * 4);
local_28 = *param_1 + iVar1;
do {
puVar2 = local_28 + -1;
if (local_28[-1] != local_38[-1]) {
if (local_38[-1] <= *puVar2) {
return 1;
}
return -1;
}
local_38 = local_38 + -1;
local_28 = puVar2;
} while (*param_1 < puVar2);
local_c = 0;
}
return local_c;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.